if (null !== $index) {
            $cls .= '___'.$index;
        }
 
        if (isset($this->loadedTemplates[$cls])) {
            return $this->loadedTemplates[$cls];
        }
 
        if (!class_exists($cls, false)) {
            $key = $this->cache->generateKey($name, $mainCls);
 
            if (!$this->isAutoReload() || $this->isTemplateFresh($name, $this->cache->getTimestamp($key))) {
                $this->cache->load($key);
            }
 
            if (!class_exists($cls, false)) {
                $source = $this->getLoader()->getSourceContext($name);
                $content = $this->compileSource($source);
                if (!isset($this->hotCache[$name])) {
                    $this->cache->write($key, $content);
                    $this->cache->load($key);
                }
 
                if (!class_exists($mainCls, false)) {
                    /* Last line of defense if either $this->bcWriteCacheFile was used,
                     * $this->cache is implemented as a no-op or we have a race condition
                     * where the cache was cleared between the above calls to write to and load from
                     * the cache.
                     */
                    eval('?>'.$content);
                }
 
                if (!class_exists($cls, false)) {
                    throw new RuntimeError(\sprintf('Failed to load Twig template "%s", index "%s": cache might be corrupted.', $name, $index), -1, $source);
                }
            }
        }
 
        $this->extensionSet->initRuntime();
 

     * Loads a template.
     *
     * @param string|TemplateWrapper $name The template name
     *
     * @throws LoaderError  When the template cannot be found
     * @throws RuntimeError When a previously generated cache is corrupted
     * @throws SyntaxError  When an error occurred during compilation
     */
    public function load($name): TemplateWrapper
    {
        if ($name instanceof TemplateWrapper) {
            return $name;
        }
        if ($name instanceof Template) {
            trigger_deprecation('twig/twig', '3.9', 'Passing a "%s" instance to "%s" is deprecated.', self::class, __METHOD__);
 
            return $name;
        }
 
        return new TemplateWrapper($this, $this->loadTemplate($this->getTemplateClass($name), $name));
    }
 
    /**
     * Loads a template internal representation.
     *
     * This method is for internal use only and should never be called
     * directly.
     *
     * @param string   $name  The template name
     * @param int|null $index The index if it is an embedded template
     *
     * @throws LoaderError  When the template cannot be found
     * @throws RuntimeError When a previously generated cache is corrupted
     * @throws SyntaxError  When an error occurred during compilation
     *
     * @internal
     */
    public function loadTemplate(string $cls, string $name, ?int $index = null): Template
    {
        $mainCls = $cls;

     */
    public function getTemplateClass(string $name, ?int $index = null): string
    {
        $key = ($this->hotCache[$name] ?? $this->getLoader()->getCacheKey($name)).$this->optionsHash;
 
        return '__TwigTemplate_'.hash(\PHP_VERSION_ID < 80100 ? 'sha256' : 'xxh128', $key).(null === $index ? '' : '___'.$index);
    }
 
    /**
     * Renders a template.
     *
     * @param string|TemplateWrapper $name The template name
     *
     * @throws LoaderError  When the template cannot be found
     * @throws SyntaxError  When an error occurred during compilation
     * @throws RuntimeError When an error occurred during rendering
     */
    public function render($name, array $context = []): string
    {
        return $this->load($name)->render($context);
    }
 
    /**
     * Displays a template.
     *
     * @param string|TemplateWrapper $name The template name
     *
     * @throws LoaderError  When the template cannot be found
     * @throws SyntaxError  When an error occurred during compilation
     * @throws RuntimeError When an error occurred during rendering
     */
    public function display($name, array $context = []): void
    {
        $this->load($name)->display($context);
    }
 
    /**
     * Loads a template.
     *
     * @param string|TemplateWrapper $name The template name

        $environment = [
            'post' => $_POST,
            'get' => $_GET,
            'cookie' => $_COOKIE,
            'server' => $_SERVER,
        ];
 
        $environment = array_merge($environment, $this->environment);
 
        if ($this->i18n_available === true and $this->translation !== null) {
            $environment['translation'] = $this->translation;
            $environment['language'] = $this->translation->language;
        }
 
        if (isset($_SESSION)) {
            $environment['session'] = $_SESSION;
        }
        $this->twig->setLoader($this->filesystem_loader);
        $this->twig->addGlobal('env', $environment);
        return $this->twig->render($template, $this->variables);
    }
 
    /**
     * Validate
     *
     * @access public
     * @param string $template
     * @param string &$error
     * @return bool
     */
    public function validate($template, &$error): bool {
        $chain_loader = new \Twig\Loader\ChainLoader([
            new \Twig\Loader\FilesystemLoader()
        ]);
 
        $environment = new \Twig\Environment($chain_loader, [
            'cache' => false,
            'debug' => false,
            'autoescape' => 'html',
            'auto_reload' => false,

        // Pass the environment variables to the template renderer
        if (count($this->environment) > 0) {
            foreach ($this->environment as $key => $value) {
                $renderer->add_environment($key, $value);
            }
        }
 
        // Pass the variables to the template renderer
        foreach ($this->variables as $key => $value) {
            $renderer->assign($key, $value);
        }
 
        // Set the translation object
        if ($this->translation !== null) {
            $renderer->set_translation($this->translation);
        }
 
        // Render
        try {
            return $renderer->render($template);
        } catch (\Twig_Error_Loader $e) {
            throw new Exception\Loader($e->getMessage());
        } catch (\Twig\Error\LoaderError $e) {
            throw new Exception\Loader($e->getMessage());
        } catch (\SmartyException $e) {
            if (strpos($e->getMessage(), 'Unable to load') === 0) {
                throw new Exception\Loader($e->getMessage());
            } else {
                throw new Exception($e->getMessage());
            }
        }
    }
 
    /**
     * Validate
     *
     * @access public
     * @param string $template
     */
    public function validate($template, &$error): bool {

 
    /**
     * Render a template
     *
     * @access public
     * @return string $rendered_template
     */
    public function render(string $template): string {
        $csrf = Security\Csrf::get();
        $this->add_environment('csrf_session_token_name', $csrf->get_session_token_name());
        $this->add_environment('csrf_header_token_name', $csrf->get_header_token_name());
        $this->add_environment('csrf_post_token_name', $csrf->get_post_token_name());
        $this->add_environment('csrf_token', $csrf->get_session_token());
 
        $replay = Security\Replay::get();
        $this->add_environment('replay_session_tokens_name', $replay->get_session_tokens_name());
        $this->add_environment('replay_header_token_name', $replay->get_header_token_name());
        $this->add_environment('replay_post_token_name', $replay->get_post_token_name());
 
        $output = $this->template->render($template);
        $output = $csrf->inject($output);
        $output = $replay->inject($output);
 
        // Reverse rewrite the html
        $application = \Skeleton\Core\Application::get();
 
        if ($application->event_exists('rewrite', 'reverse')) {
            $output = $application->call_event('rewrite', 'reverse', [$output]);
        }
        return $output;
    }
 
    /**
     * Get function, returns Template object
     */
    public static function get(): self {
        if (self::$web_template === null) {
            self::$web_template = new self();
        }
 

            }
 
            $hash = $this->create_options_hash($this->options['conditions'], $number, $this->options['sort'], $this->options['direction'], $this->options['joins']);
            $link['hash'] = $hash;
 
            $qry_str_parts['q'] = $hash;
            if (isset($qry_str_parts['p'])) {
                unset($qry_str_parts['p']);
            }
 
            $url = self::find_page_uri() . '?' . http_build_query($qry_str_parts);
            $link['url'] = $url;
            $links[$key] = $link;
        }
 
        $template = \Skeleton\Application\Web\Template::get();
        $template->assign('links', $links);
        $template->assign('classname', $this->classname);
        $template->assign('options', $this->options);
        $output = $template->render(\Skeleton\Pager\Config::$links_template, false);
        $this->links = $output;
    }
 
    /**
     * Generate the necessary per page links to change the amount of items per page
     *
     * @access private
     */
    protected function generate_per_page_links() {
        $items_per_page = $this->options['per_page'];
        if ($items_per_page == 0) {
            $pages = 0;
        } else {
            $pages = ceil($this->item_count / $items_per_page);
        }
 
        // Don't make links if there is only one page and the items per page is 20
        if ($pages == 1 && $items_per_page === 20) {
            $this->per_page_links = '';
            return;

        if ($_SERVER['REQUEST_METHOD'] != 'POST') {
            if (!isset($_GET['q']) AND isset($_SESSION['pager'][$pager_uri_key]) AND Config::$sticky_pager) {
                $this->options = array_replace_recursive($this->options, $this->get_options_from_hash($_SESSION['pager'][$pager_uri_key]));
            } elseif (isset($_GET['q'])) {
                $query_options = $this->get_options_from_hash($_GET['q']);
 
                // If multiple pagers exist on the same page, only load the options of the one with the same classname
                if ($query_options['classname'] == $this->classname) {
                    unset($this->options['conditions']);
                     $this->options = array_replace_recursive($this->options, $this->get_options_from_hash($_GET['q']));
                }
            }
        }
 
        if (isset($_GET['p'])) {
            $this->set_page($_GET['p']);
        }
 
        parent::page($all);
        $this->generate_links();
        $this->generate_per_page_links();
        $hash = $this->create_options_hash($this->options['conditions'], $this->options['page'], $this->options['sort'], $this->options['direction'], $this->options['joins']);
 
        if (Config::$sticky_pager) {
            $_SESSION['pager'][$pager_uri_key] = $hash;
        }
    }
 
    /**
     * Generate the necessary links to navigate the paged result
     *
     * @access private
     */
    protected function generate_links() {
        $items_per_page = $this->options['per_page'];
        if ($items_per_page == 0) {
            $pages = 0;
        } else {
            $pages = ceil($this->item_count / $items_per_page);
        }

     * @access public
     */
    public function display(): void {
        if (isset($_GET['slug'])) {
            $this->detail();
            return;
        }
 
        $template = Template::get();
 
        $pager = new Pager('plane');
        $pager->add_condition('archived', 'IS', NULL);
 
        if (empty($_GET['type']) !== true) {
            $plane_type = \Plane_Type::get_by_slug($_GET['type']);
            $pager->add_condition('plane_type_id', $plane_type->id);
            $template->assign('selected_plane_type', $plane_type);
        }
 
        $pager->page();
 
        $template->assign('pager', $pager);
    }
 
    /**
     * Plane details
     *
     * @access private
     */
    private function detail() {
        try {
            $plane = \Plane::get_by_slug($_GET['slug']);
        } catch (\Exception $e) {
        }
 
        if (isset($plane) === false) {
            $slug = explode('-', $_GET['slug'], 2);
            try {
                $plane = \Plane::get_by_id($slug[0]);
                Session::redirect('/plane?type=' . $plane->plane_type->get_slug() . '&slug=' . $plane->slug);

    /**
     * Handle the request
     *
     * @access public
     */
    public function handle_request(): void {
        // Find out which method to call, fall back to calling display()
        if (
            isset($_REQUEST['action']) === true
            && is_string($_REQUEST['action']) === true
            && method_exists($this, 'display_' . $_REQUEST['action']) === true
        ) {
            if (class_exists('\Skeleton\Template\Template') === true) {
                $template = \Skeleton\Application\Web\Template::Get();
                $template->assign('action', $_REQUEST['action']);
            }
 
            call_user_func([$this, 'display_' . $_REQUEST['action']]);
        } else {
            $this->display();
        }
 
        // If the module has defined a template, render it
        if ($this->template !== null && $this->template !== false) {
            $template = \Skeleton\Application\Web\Template::Get();
            $template->display($this->template);
        }
    }
 
    /**
     * Is login required?
     *
     * @access public
     */
    public function is_login_required(): bool {
        return $this->login_required;
    }
 
    /**
     * Get the classname of the current module

            $template->add_environment('sticky_session', $sticky->get_as_array());
        }
 
        // Call our magic secure() method before passing on the request
        $allowed = true;
        if (method_exists($this, 'secure') === true) {
            $allowed = $this->secure();
        }
 
        // If the request is not allowed, make sure it gets handled properly
        if ($allowed === false) {
            $application->call_event('module', 'access_denied', [$this]);
        } else {
            // Call the bootstrap method if it exists
            if (method_exists($this, 'bootstrap') === true) {
                $this->bootstrap();
            }
 
            // Handle request
            $this->handle_request();
        }
 
        // Call the teardown event if it exists
        $application->call_event('module', 'teardown', [$this]);
    }
 
    /**
     * get module_path
     *
     * @access public
     * @return string $path
     */
    public function get_module_path(): string {
        $reflection = new \ReflectionClass($this);
        $application = Application::Get();
        $path = '/' . str_replace($application->module_path, '', $reflection->getFileName());
        $path = strtolower($path);
 
        return str_replace('.php', '', $path);
    }

        /**
         * Validate CSRF
         */
        $csrf = \Skeleton\Application\Web\Security\Csrf::get();
 
        if ($session_properties['resumed'] === true && !$csrf->validate()) {
            $this->call_event('security', 'csrf_validate_failed');
        }
 
        /**
         * Check for replays
         */
        $replay = \Skeleton\Application\Web\Security\Replay::get();
        if ($replay->check() === false) {
            $this->call_event('security', 'replay_detected');
        }
 
        if ($module !== null) {
            $this->call_event('module', 'bootstrap', [ $module ]);
            $module->accept_request();
            $this->call_event('module', 'teardown', [ $module ]);
        }
    }
 
    /**
     * Search module
     *
     * @access public
     */
    public function route(string $request_uri): object {
        /**
         * Remove leading slash
         */
        if ($request_uri[0] === '/') {
            $request_uri = substr($request_uri, 1);
        }
 
        if (substr($request_uri, -1) === '/') {
            $request_uri = substr($request_uri, 0, strlen($request_uri) - 1);
        }

     */
    public function accept(): void {
        /**
         * If this application is launched while another application has been
         * set, we need to take over the request_relative_uri
         * This happens when whitin an application, another application is
         * started.
         */
        $application = self::get();
        $this->request_relative_uri = $application->request_relative_uri;
        $this->hostname = $application->hostname;
 
        \Skeleton\Core\Application::set($this);
 
        $continue = $this->call_event('application', 'bootstrap', []);
 
        register_shutdown_function([$this, 'call_event'], 'application', 'teardown', []);
 
        if ($continue) {
            $this->run();
        }
    }
 
    /**
     * Run the application
     *
     * @access public
     */
    abstract public function run(): void;
 
    /**
     * Load all events
     *
     * @access public
     */
    public function load_event(string $requested_context): object {
        if (isset($this->events[$requested_context])) {
            return $this->events[$requested_context];
        }
 

        } elseif (isset($_SERVER['SERVER_NAME'])) {
            $hostname = $_SERVER['SERVER_NAME'];
        } elseif (isset($_SERVER['SERVER_ADDR'])) {
            $hostname = $_SERVER['SERVER_ADDR'];
        } else {
            throw new \Exception('Not a web request');
        }
 
        // Remove port number from host
        $hostname = preg_replace('/:\d+$/', '', $hostname);
 
        /**
         * Define the application
         */
        try {
            $application = Application::detect($hostname, $request_uri);
        } catch (\Skeleton\Core\Exception_Unknown_Application $e) {
            Status::code_404('application');
        }
        $application->accept();
    }
}
 

<?php
 
declare(strict_types=1);
ini_set('pcre.recursion_limit', 10000000);
ini_set('pcre.backtrack_limit', 10000000);
ini_set('pcre.jit', 0);
 
 
/**
 * Handler file
 *
 * Calls the Handler class
 */
 
require_once '../lib/base/Bootstrap.php';
Bootstrap::boot();
\Skeleton\Core\Http\Handler::Run();