if (($level === E_DEPRECATED) && strpos($file, '/twig/') !== false) {
            if (str_contains($message, '#[\ReturnTypeWillChange]') || str_contains($message, 'Passing null to parameter')) {
                return true;
            }
        }
 
        $handler = $this->whoopsErrorHandler;
 
        if (!$this->registeredPatterns) {
            // Just forward to parent function is there aren't no registered patterns.
            return $handler($level, $message, $file, $line);
 
        }
 
        // If there are registered patterns, only handle errors if error matches one of the patterns.
        if ($level & error_reporting()) {
            foreach ($this->registeredPatterns as $entry) {
                $pathMatches = $file && preg_match($entry['pattern'], $file);
                if ($pathMatches) {
                    return $handler($level, $message, $file, $line);
                }
            }
        }
 
        // Propagate error to the next handler, allows error_get_last() to work on silenced errors.
        return false;
    }
 
    /**
     * Handles an exception, ultimately generating a Whoops error page.
     *
     * @param  \Throwable $exception
     * @return void
     */
    public function handleException($exception)
    {
        $handler = $this->whoopsExceptionHandler;
 
        // If there are registered patterns, only handle errors if error matches one of the patterns.
        if ($this->registeredPatterns) {

        if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
            return $file;
        }
 
        return false;
    }
}
 
/**
 * Scope isolated include.
 *
 * Prevents access to $this/self from included files.
 *
 * @param  string $file
 * @return void
 * @private
 */
function includeFile($file)
{
    include $file;
}
 

        if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
            return $file;
        }
 
        return false;
    }
}
 
/**
 * Scope isolated include.
 *
 * Prevents access to $this/self from included files.
 *
 * @param  string $file
 * @return void
 * @private
 */
function includeFile($file)
{
    include $file;
}
 

     */
    public function unregister()
    {
        spl_autoload_unregister(array($this, 'loadClass'));
 
        if (null !== $this->vendorDir) {
            unset(self::$registeredLoaders[$this->vendorDir]);
        }
    }
 
    /**
     * Loads the given class or interface.
     *
     * @param  string    $class The name of the class
     * @return true|null True if loaded, null otherwise
     */
    public function loadClass($class)
    {
        if ($file = $this->findFile($class)) {
            includeFile($file);
 
            return true;
        }
 
        return null;
    }
 
    /**
     * Finds the path to the file where the class is defined.
     *
     * @param string $class The name of the class
     *
     * @return string|false The path if found, false otherwise
     */
    public function findFile($class)
    {
        // class map lookup
        if (isset($this->classMap[$class])) {
            return $this->classMap[$class];
        }

 * @package   Gantry5
 * @author    RocketTheme http://www.rockettheme.com
 * @copyright Copyright (C) 2007 - 2022 RocketTheme, LLC
 * @license   Dual License: MIT or GNU/GPLv2 and later
 *
 * http://opensource.org/licenses/MIT
 * http://www.gnu.org/licenses/gpl-2.0.html
 *
 * Gantry Framework code that extends GPL code is considered GNU/GPLv2 and later
 */
 
namespace Gantry\Component\File;
 
use RocketTheme\Toolbox\File\YamlFile;
 
/**
 * Class CompiledYamlFile
 * @package Gantry\Component\File
 */
class CompiledYamlFile extends YamlFile
{
    use CompiledFile;
 
    static public $defaultCachePath;
    static public $defaultCaching = true;
 
    protected function __construct()
    {
        parent::__construct();
 
        $this->caching(static::$defaultCaching);
 
        if (static::$defaultCachePath) {
            $this->setCachePath(static::$defaultCachePath);
        }
    }
}
 

        if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
            return $file;
        }
 
        return false;
    }
}
 
/**
 * Scope isolated include.
 *
 * Prevents access to $this/self from included files.
 *
 * @param  string $file
 * @return void
 * @private
 */
function includeFile($file)
{
    include $file;
}
 

     */
    public function unregister()
    {
        spl_autoload_unregister(array($this, 'loadClass'));
 
        if (null !== $this->vendorDir) {
            unset(self::$registeredLoaders[$this->vendorDir]);
        }
    }
 
    /**
     * Loads the given class or interface.
     *
     * @param  string    $class The name of the class
     * @return true|null True if loaded, null otherwise
     */
    public function loadClass($class)
    {
        if ($file = $this->findFile($class)) {
            includeFile($file);
 
            return true;
        }
 
        return null;
    }
 
    /**
     * Finds the path to the file where the class is defined.
     *
     * @param string $class The name of the class
     *
     * @return string|false The path if found, false otherwise
     */
    public function findFile($class)
    {
        // class map lookup
        if (isset($this->classMap[$class])) {
            return $this->classMap[$class];
        }

    protected function init()
    {
        $gantry = static::gantry();
        $gantry['streams']->register();
 
        // Only add error service if development or debug mode has been enabled or user is admin.
        if (!$gantry['global']->get('production', 0) || $gantry->debug() || $gantry->admin()) {
            $gantry->register(new ErrorServiceProvider);
        }
 
        // Initialize theme cache stream.
        $cachePath = $this->getCachePath();
 
        Folder::create($cachePath);
 
        /** @var UniformResourceLocator $locator */
        $locator = $gantry['locator'];
        $locator->addPath('gantry-cache', 'theme', [$cachePath], true, true);
 
        CompiledYamlFile::$defaultCachePath = $locator->findResource('gantry-cache://theme/compiled/yaml', true, true);
        CompiledYamlFile::$defaultCaching = $gantry['global']->get('compile_yaml', 1);
    }
 
    /**
     * Set twig lookup paths to the loader.
     *
     * @param LoaderInterface $loader
     * @return FilesystemLoader|null
     * @internal
     */
    protected function setTwigLoaderPaths(LoaderInterface $loader)
    {
        if ($loader instanceof ChainLoader) {
            $new = new FilesystemLoader();
            $loader->addLoader($new);
            $loader = $new;
        } elseif (!($loader instanceof FilesystemLoader)) {
            return null;
        }
 

     * @param array $context
     * @return array
     */
    public function getContext(array $context)
    {
        $gantry = static::gantry();
 
        $context = parent::getContext($context);
        $context['site'] = $gantry['site'];
        $context['joomla'] = $gantry['platform'];
 
        return $context;
    }
 
    /**
     * @see AbstractTheme::init()
     */
    protected function init()
    {
        parent::init();
 
        $gantry = Gantry::instance();
 
        /** @var UniformResourceLocator $locator */
        $locator = $gantry['locator'];
 
        /** @var CMSApplication $application */
        $application = Factory::getApplication();
        $language = $application->getLanguage();
 
        // FIXME: Do not hardcode this file.
        $language->load('files_gantry5_nucleus', JPATH_SITE);
 
        if ($application->isClient('site')) {
            // Load our custom positions file as frontend requires the strings to be there.
            $filename = $locator("gantry-theme://language/en-GB/en-GB.tpl_{$this->name}_positions.ini");
 
            if ($filename) {
                $language->load("tpl_{$this->name}_positions", \dirname(\dirname(\dirname($filename))), 'en-GB');
            }

 
    /** @var Environment|null */
    protected $renderer;
 
    /**
     * Construct theme object.
     *
     * @param string $path
     * @param string $name
     */
    public function __construct($path, $name = null)
    {
        if (!is_dir($path)) {
            throw new \LogicException('Theme not found!');
        }
 
        $this->name = $name ?: Gantry::basename($path);
        $this->path = $path;
 
        $this->init();
    }
 
    /**
     * Get context for render().
     *
     * @param array $context
     * @return array
     */
    public function getContext(array $context)
    {
        $context['theme'] = $this;
 
        return $context;
    }
 
    /**
     * Define twig environment.
     *
     * @param Environment $twig
     * @param LoaderInterface $loader

/**
 * Define the template.
 */
class GantryTheme extends Theme {}
 
// Initialize theme stream.
/** @var \Gantry\Framework\Platform $platform */
$platform = $gantry['platform'];
$platform->set(
    'streams.gantry-theme.prefixes',
    ['' => [
        "gantry-themes://{$gantry['theme.name']}/custom",
        "gantry-themes://{$gantry['theme.name']}",
        "gantry-themes://{$gantry['theme.name']}/common"
    ]]
);
 
// Define Gantry services.
$gantry['theme'] = static function ($c)  {
    return new GantryTheme($c['theme.path'], $c['theme.name']);
};
 

    {
        if (!isset($this->keys[$id])) {
            throw new UnknownIdentifierException($id);
        }
 
        if (
            isset($this->raw[$id])
            || !\is_object($this->values[$id])
            || isset($this->protected[$this->values[$id]])
            || !\method_exists($this->values[$id], '__invoke')
        ) {
            return $this->values[$id];
        }
 
        if (isset($this->factories[$this->values[$id]])) {
            return $this->values[$id]($this);
        }
 
        $raw = $this->values[$id];
        $val = $this->values[$id] = $raw($this);
        $this->raw[$id] = $raw;
 
        $this->frozen[$id] = true;
 
        return $val;
    }
 
    /**
     * Checks if a parameter or an object is set.
     *
     * @param string $id The unique identifier for the parameter or object
     *
     * @return bool
     */
    #[\ReturnTypeWillChange]
    public function offsetExists($id)
    {
        return isset($this->keys[$id]);
    }
 

 
defined('_JEXEC') or die;
 
use Gantry\Framework\Platform;
use Gantry\Framework\Theme;
use Joomla\CMS\Factory;
 
// Bootstrap Gantry framework or fail gracefully (inside included file).
$className = __DIR__ . '/custom/includes/gantry.php';
if (!is_file($className)) {
    $className = __DIR__ . '/includes/gantry.php';
}
$gantry = include $className;
 
/** @var Platform $joomla */
$joomla = $gantry['platform'];
$joomla->document = $this;
 
/** @var Theme $theme */
$theme = $gantry['theme'];
$app = Factory::getApplication();
 
$context = array(
    'errorcode' => isset($this->error) ? $this->error->getCode() : null,
    'error' => isset($this->error) ? $this->error->getMessage() : null,
    'debug' => $app->get('debug_lang', '0') == '1' || $app->get('debug', '0') == '1',
    'backtrace' => $this->debug ? $this->renderBacktrace() : null
);
 
// Reset used outline configuration.
unset($gantry['configuration']);
 
// Render the page.
echo $theme
    ->setLayout('_error', true)
    ->render('error.html.twig', $context);
 

     *
     * @param   string  $directory  The name of the template
     * @param   string  $filename   The actual filename
     *
     * @return  string  The contents of the template
     *
     * @since   1.7.0
     */
    protected function _loadTemplate($directory, $filename)
    {
        $contents = '';
 
        // Check to see if we have a valid template file
        if (is_file($directory . '/' . $filename)) {
            // Store the file path
            $this->_file = $directory . '/' . $filename;
 
            // Get the file content
            ob_start();
            require $directory . '/' . $filename;
            $contents = ob_get_contents();
            ob_end_clean();
        }
 
        return $contents;
    }
 
    /**
     * Fetch the template, and initialise the params
     *
     * @param   array  $params  Parameters to determine the template
     *
     * @return  HtmlDocument instance of $this to allow chaining
     *
     * @since   1.7.0
     */
    protected function _fetchTemplate($params = [])
    {
        // Check
        $directory = $params['directory'] ?? 'templates';

                }
            }
        }
 
        // Load the language file for the template
        $lang = CmsFactory::getLanguage();
 
        // 1.5 or core then 1.6
        $lang->load('tpl_' . $template, JPATH_BASE)
            || ($inherits !== '' && $lang->load('tpl_' . $inherits, JPATH_BASE))
            || $lang->load('tpl_' . $template, $directory . '/' . $template)
            || ($inherits !== '' && $lang->load('tpl_' . $inherits, $directory . '/' . $inherits));
 
        // Assign the variables
        $this->baseurl  = Uri::base(true);
        $this->params   = $params['params'] ?? new Registry();
        $this->template = $template;
 
        // Load
        $this->_template = $this->_loadTemplate($baseDir, $file);
 
        return $this;
    }
 
    /**
     * Parse a document template
     *
     * @return  HtmlDocument  instance of $this to allow chaining
     *
     * @since   1.7.0
     */
    protected function _parseTemplate()
    {
        $matches = [];
 
        if (preg_match_all('#<jdoc:include\ type="([^"]+)"(.*)\/>#iU', $this->_template, $matches)) {
            $messages            = [];
            $template_tags_first = [];
            $template_tags_last  = [];
 

        $name  = $options['name'] ?? '';
        $title = $options['title'] ?? '';
 
        parent::$_buffer[$type][$name][$title] = $content;
 
        return $this;
    }
 
    /**
     * Parses the template and populates the buffer
     *
     * @param   array  $params  Parameters for fetching the template
     *
     * @return  HtmlDocument instance of $this to allow chaining
     *
     * @since   1.7.0
     */
    public function parse($params = [])
    {
        return $this->_fetchTemplate($params)->_parseTemplate();
    }
 
    /**
     * Outputs the template to the browser.
     *
     * @param   boolean  $caching  If true, cache the output
     * @param   array    $params   Associative array of attributes
     *
     * @return  string The rendered data
     *
     * @since   1.7.0
     */
    public function render($caching = false, $params = [])
    {
        $this->_caching = $caching;
 
        if (empty($this->_template)) {
            $this->parse($params);
        }
 

    {
        return $this->_fetchTemplate($params)->_parseTemplate();
    }
 
    /**
     * Outputs the template to the browser.
     *
     * @param   boolean  $caching  If true, cache the output
     * @param   array    $params   Associative array of attributes
     *
     * @return  string The rendered data
     *
     * @since   1.7.0
     */
    public function render($caching = false, $params = [])
    {
        $this->_caching = $caching;
 
        if (empty($this->_template)) {
            $this->parse($params);
        }
 
        if (\array_key_exists('csp_nonce', $params) && $params['csp_nonce'] !== null) {
            $this->cspNonce = $params['csp_nonce'];
        }
 
        $data = $this->_renderTemplate();
        parent::render($caching, $params);
 
        return $data;
    }
 
    /**
     * Count the modules in the given position
     *
     * @param   string   $positionName     The position to use
     * @param   boolean  $withContentOnly  Count only a modules which actually has a content
     *
     * @return  integer  Number of modules found
     *

 
        if ($status < 400 || $status > 599) {
            $status = 500;
        }
 
        $errorReporting = CmsFactory::getApplication()->get('error_reporting');
 
        if ($errorReporting === "development" || $errorReporting === "maximum") {
            $status .= ' ' . str_replace("\n", ' ', $this->_error->getMessage());
        }
 
        CmsFactory::getApplication()->setHeader('status', $status);
 
        // Set variables
        $this->debug = $params['debug'] ?? false;
        $this->error = $this->_error;
 
        $params['file'] = 'error.php';
 
        return parent::render($cache, $params);
    }
 
    /**
     * Render the backtrace
     *
     * @return  string  The contents of the backtrace
     *
     * @since   1.7.0
     */
    public function renderBacktrace()
    {
        // If no error object is set return null
        if (!isset($this->_error)) {
            return;
        }
 
        // The back trace
        $backtrace = $this->_error->getTrace();
 
        // Add the position of the actual file

 
        // Push the error object into the document
        $this->getDocument()->setError($error);
 
        // Add registry file for the template asset
        $wa = $this->getDocument()->getWebAssetManager()->getRegistry();
 
        $wa->addTemplateRegistryFile($template->template, $app->getClientId());
 
        if (!empty($template->parent)) {
            $wa->addTemplateRegistryFile($template->parent, $app->getClientId());
        }
 
        if (ob_get_contents()) {
            ob_end_clean();
        }
 
        $this->getDocument()->setTitle(Text::_('Error') . ': ' . $error->getCode());
 
        return $this->getDocument()->render(
            false,
            [
                'template'         => $template->template,
                'directory'        => JPATH_THEMES,
                'debug'            => JDEBUG,
                'csp_nonce'        => $app->get('csp_nonce'),
                'templateInherits' => $template->parent,
                'params'           => $template->params,
            ]
        );
    }
}
 

             * Lastly, if all else fails, we default onto the HTML format to at least render something
             */
            if (Factory::$document) {
                $format = Factory::$document->getType();
            } else {
                $format = $app->getInput()->getString('format', 'html');
            }
 
            try {
                $renderer = AbstractRenderer::getRenderer($format);
            } catch (\InvalidArgumentException $e) {
                // Default to the HTML renderer
                $renderer = AbstractRenderer::getRenderer('html');
            }
 
            // Reset the document object in the factory, this gives us a clean slate and lets everything render properly
            Factory::$document = $renderer->getDocument();
            Factory::getApplication()->loadDocument(Factory::$document);
 
            $data = $renderer->render($error);
 
            // If nothing was rendered, just use the message from the Exception
            if (empty($data)) {
                $data = $error->getMessage();
            }
 
            if ($isCli) {
                echo $data;
            } else {
                /** @var CMSApplication $app */
 
                // Do not allow cache
                $app->allowCache(false);
 
                $app->setBody($data);
            }
 
            // This return is needed to ensure the test suite does not trigger the non-Exception handling below
            return;
        } catch (\Throwable $errorRendererError) {

            }
        }
 
        // Always return false, this will tell PHP to handle the error internally
        return false;
    }
 
    /**
     * Handles exceptions: logs errors and renders error page.
     *
     * @param   \Exception|\Throwable  $error  An Exception or Throwable (PHP 7+) object for which to render the error page.
     *
     * @return  void
     *
     * @since   3.10.0
     */
    public static function handleException(\Throwable $error)
    {
        static::logException($error);
        static::render($error);
    }
 
    /**
     * Render the error page based on an exception.
     *
     * @param   \Throwable  $error  An Exception or Throwable (PHP 7+) object for which to render the error page.
     *
     * @return  void
     *
     * @since   3.0
     */
    public static function render(\Throwable $error)
    {
        try {
            $app = Factory::getApplication();
 
            // Flag if we are on cli
            $isCli = $app->isClient('cli');
 
            // If site is offline and it's a 404 error, just go to index (to see offline message, instead of 404)

                $this->compress();
 
                // Trigger the onAfterCompress event.
                $this->triggerEvent('onAfterCompress');
            }
        } catch (\Throwable $throwable) {
            /** @var ErrorEvent $event */
            $event = AbstractEvent::create(
                'onError',
                [
                    'subject'     => $throwable,
                    'eventClass'  => ErrorEvent::class,
                    'application' => $this,
                ]
            );
 
            // Trigger the onError event.
            $this->triggerEvent('onError', $event);
 
            ExceptionHandler::handleException($event->getError());
        }
 
        // Trigger the onBeforeRespond event.
        $this->getDispatcher()->dispatch('onBeforeRespond');
 
        // Send the application response.
        $this->respond();
 
        // Trigger the onAfterRespond event.
        $this->getDispatcher()->dispatch('onAfterRespond');
    }
 
    /**
     * Check if the user is required to reset their password.
     *
     * If the user is required to reset their password will be redirected to the page that manage the password reset.
     *
     * @param   string  $option  The option that manage the password reset
     * @param   string  $view    The view that manage the password reset
     * @param   string  $layout  The layout of the view that manage the password reset

     * @return  array
     *
     * @since   1.5
     * @throws  \Exception
     */
    public function parse(&$uri, $setVars = false)
    {
        // Do the preprocess stage of the URL parse process
        $this->processParseRules($uri, self::PROCESS_BEFORE);
 
        // Do the main stage of the URL parse process
        $this->processParseRules($uri);
 
        // Do the postprocess stage of the URL parse process
        $this->processParseRules($uri, self::PROCESS_AFTER);
 
        // Check if all parts of the URL have been parsed.
        // Otherwise we have an invalid URL
        if (\strlen($uri->getPath()) > 0) {
            throw new RouteNotFoundException(Text::_('JERROR_PAGE_NOT_FOUND'));
        }
 
        if ($setVars) {
            $this->setVars($uri->getQuery(true));
 
            return $this->getVars();
        }
 
        return $uri->getQuery(true);
    }
 
    /**
     * Function to convert an internal URI to a route
     *
     * @param   string|array|Uri  $url  The internal URL or an associative array
     *
     * @return  Uri  The absolute search engine friendly URL object
     *
     * @since   1.5
     */

    /**
     * Route the application.
     *
     * Routing is the process of examining the request environment to determine which
     * component should receive the request. The component optional parameters
     * are then set in the request object to be processed when the application is being
     * dispatched.
     *
     * @return  void
     *
     * @since   3.2
     */
    protected function route()
    {
        // Get the full request URI.
        $uri = clone Uri::getInstance();
 
        // It is not possible to inject the SiteRouter as it requires a SiteApplication
        // and we would end in an infinite loop
        $result = $this->getContainer()->get(SiteRouter::class)->parse($uri, true);
 
        $active = $this->getMenu()->getActive();
 
        if (
            $active !== null
            && $active->type === 'alias'
            && $active->getParams()->get('alias_redirect')
            && \in_array($this->input->getMethod(), ['GET', 'HEAD'], true)
        ) {
            $item = $this->getMenu()->getItem($active->getParams()->get('aliasoptions'));
 
            if ($item !== null) {
                $oldUri = clone Uri::getInstance();
 
                if ($oldUri->getVar('Itemid') == $active->id) {
                    $oldUri->setVar('Itemid', $item->id);
                }
 
                $base             = Uri::base(true);
                $oldPath          = StringHelper::strtolower(substr($oldUri->getPath(), \strlen($base) + 1));

        $this->triggerEvent('onAfterDispatch');
    }
 
    /**
     * Method to run the Web application routines.
     *
     * @return  void
     *
     * @since   3.2
     */
    protected function doExecute()
    {
        // Initialise the application
        $this->initialiseApp();
 
        // Mark afterInitialise in the profiler.
        JDEBUG ? $this->profiler->mark('afterInitialise') : null;
 
        // Route the application
        $this->route();
 
        // Mark afterRoute in the profiler.
        JDEBUG ? $this->profiler->mark('afterRoute') : null;
 
        if (!$this->isHandlingMultiFactorAuthentication()) {
            /*
             * Check if the user is required to reset their password
             *
             * Before $this->route(); "option" and "view" can't be safely read using:
             * $this->input->getCmd('option'); or $this->input->getCmd('view');
             * ex: due of the sef urls
             */
            $this->checkUserRequireReset('com_users', 'profile', 'edit', 'com_users/profile.save,com_users/profile.apply,com_users/user.logout');
        }
 
        // Dispatch the application
        $this->dispatch();
 
        // Mark afterDispatch in the profiler.
        JDEBUG ? $this->profiler->mark('afterDispatch') : null;

            throw new \RuntimeException('Invalid input, aborting application.');
        }
    }
 
    /**
     * Execute the application.
     *
     * @return  void
     *
     * @since   3.2
     */
    public function execute()
    {
        try {
            $this->sanityCheckSystemVariables();
            $this->setupLogging();
            $this->createExtensionNamespaceMap();
 
            // Perform application routines.
            $this->doExecute();
 
            // If we have an application document object, render it.
            if ($this->document instanceof \Joomla\CMS\Document\Document) {
                // Render the application output.
                $this->render();
            }
 
            // If gzip compression is enabled in configuration and the server is compliant, compress the output.
            if ($this->get('gzip') && !ini_get('zlib.output_compression') && ini_get('output_handler') !== 'ob_gzhandler') {
                $this->compress();
 
                // Trigger the onAfterCompress event.
                $this->triggerEvent('onAfterCompress');
            }
        } catch (\Throwable $throwable) {
            /** @var ErrorEvent $event */
            $event = AbstractEvent::create(
                'onError',
                [
                    'subject'     => $throwable,

 *
 * In addition to aliasing "common" service keys, we also create aliases for the PHP classes to ensure autowiring objects
 * is supported.  This includes aliases for aliased class names, and the keys for aliased class names should be considered
 * deprecated to be removed when the class name alias is removed as well.
 */
$container->alias('session.web', 'session.web.site')
    ->alias('session', 'session.web.site')
    ->alias('JSession', 'session.web.site')
    ->alias(\Joomla\CMS\Session\Session::class, 'session.web.site')
    ->alias(\Joomla\Session\Session::class, 'session.web.site')
    ->alias(\Joomla\Session\SessionInterface::class, 'session.web.site');
 
// Instantiate the application.
$app = $container->get(\Joomla\CMS\Application\SiteApplication::class);
 
// Set the application as global app
\Joomla\CMS\Factory::$application = $app;
 
// Execute the application.
$app->execute();
 

define('JOOMLA_MINIMUM_PHP', '7.2.5');
 
if (version_compare(PHP_VERSION, JOOMLA_MINIMUM_PHP, '<')) {
    die(
        str_replace(
            '{{phpversion}}',
            JOOMLA_MINIMUM_PHP,
            file_get_contents(dirname(__FILE__) . '/templates/system/incompatible.html')
        )
    );
}
 
/**
 * Constant that is checked in included files to prevent direct access.
 * define() is used rather than "const" to not error for PHP 5.2 and lower
 */
define('_JEXEC', 1);
 
// Run the application - All executable code should be triggered through this file
require_once dirname(__FILE__) . '/includes/app.php';