vendor/contao/core-bundle/src/Resources/contao/library/Contao/Template.php line 278

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of Contao.
  5.  *
  6.  * (c) Leo Feyer
  7.  *
  8.  * @license LGPL-3.0-or-later
  9.  */
  11. namespace Contao;
  13. use Contao\CoreBundle\Routing\ResponseContext\JsonLd\JsonLdManager;
  14. use Contao\Image\ImageInterface;
  15. use Contao\Image\PictureConfiguration;
  16. use MatthiasMullie\Minify\CSS;
  17. use MatthiasMullie\Minify\JS;
  18. use Spatie\SchemaOrg\Graph;
  19. use Symfony\Component\HttpFoundation\Response;
  20. use Symfony\Component\VarDumper\VarDumper;
  22. /**
  23.  * Parses and outputs template files
  24.  *
  25.  * The class supports loading template files, adding variables to them and then
  26.  * printing them to the screen. It functions as abstract parent class for the
  27.  * two core classes "BackendTemplate" and "FrontendTemplate".
  28.  *
  29.  * Usage:
  30.  *
  31.  *     $template = new BackendTemplate();
  32.  *     $template->name = 'Leo Feyer';
  33.  *     $template->output();
  34.  *
  35.  * @property string       $style
  36.  * @property array|string $cssID
  37.  * @property string       $class
  38.  * @property string       $inColumn
  39.  * @property string       $headline
  40.  * @property array        $hl
  41.  * @property string       $content
  42.  * @property string       $action
  43.  * @property string       $enforceTwoFactor
  44.  * @property string       $targetPath
  45.  * @property string       $message
  46.  * @property string       $href
  47.  * @property string       $twoFactor
  48.  * @property string       $explain
  49.  * @property string       $active
  50.  * @property string       $enableButton
  51.  * @property string       $disableButton
  52.  * @property boolean      $enable
  53.  * @property boolean      $isEnabled
  54.  * @property string       $secret
  55.  * @property string       $textCode
  56.  * @property string       $qrCode
  57.  * @property string       $scan
  58.  * @property string       $verify
  59.  * @property string       $verifyHelp
  60.  * @property boolean      $showBackupCodes
  61.  * @property array        $backupCodes
  62.  * @property boolean      $trustedDevicesEnabled
  63.  * @property array        $trustedDevices
  64.  * @property string       $currentDevice
  65.  */
  66. abstract class Template extends Controller
  67. {
  68.     use TemplateInheritance;
  70.     /**
  71.      * Output buffer
  72.      * @var string
  73.      */
  74.     protected $strBuffer;
  76.     /**
  77.      * Content type
  78.      * @var string
  79.      */
  80.     protected $strContentType;
  82.     /**
  83.      * Template data
  84.      * @var array
  85.      */
  86.     protected $arrData = array();
  88.     /**
  89.      * Valid JavaScipt types
  90.      * @var array
  91.      * @see http://www.w3.org/TR/html5/scripting-1.html#scriptingLanguages
  92.      */
  93.     protected static $validJavaScriptTypes = array
  94.     (
  95.         'application/ecmascript',
  96.         'application/javascript',
  97.         'application/x-ecmascript',
  98.         'application/x-javascript',
  99.         'text/ecmascript',
  100.         'text/javascript',
  101.         'text/javascript1.0',
  102.         'text/javascript1.1',
  103.         'text/javascript1.2',
  104.         'text/javascript1.3',
  105.         'text/javascript1.4',
  106.         'text/javascript1.5',
  107.         'text/jscript',
  108.         'text/livescript',
  109.         'text/x-ecmascript',
  110.         'text/x-javascript',
  111.     );
  113.     /**
  114.      * Create a new template object
  115.      *
  116.      * @param string $strTemplate    The template name
  117.      * @param string $strContentType The content type (defaults to "text/html")
  118.      */
  119.     public function __construct($strTemplate='', $strContentType='text/html')
  120.     {
  121.         parent::__construct();
  123.         $this->strTemplate = $strTemplate;
  124.         $this->strContentType = $strContentType;
  125.     }
  127.     /**
  128.      * Set an object property
  129.      *
  130.      * @param string $strKey   The property name
  131.      * @param mixed  $varValue The property value
  132.      */
  133.     public function __set($strKey, $varValue)
  134.     {
  135.         $this->arrData[$strKey] = $varValue;
  136.     }
  138.     /**
  139.      * Return an object property
  140.      *
  141.      * @param string $strKey The property name
  142.      *
  143.      * @return mixed The property value
  144.      */
  145.     public function __get($strKey)
  146.     {
  147.         if (isset($this->arrData[$strKey]))
  148.         {
  149.             if (\is_object($this->arrData[$strKey]) && \is_callable($this->arrData[$strKey]))
  150.             {
  151.                 return $this->arrData[$strKey]();
  152.             }
  154.             return $this->arrData[$strKey];
  155.         }
  157.         return parent::__get($strKey);
  158.     }
  160.     /**
  161.      * Execute a callable and return the result
  162.      *
  163.      * @param string $strKey    The name of the key
  164.      * @param array  $arrParams The parameters array
  165.      *
  166.      * @return mixed The callable return value
  167.      *
  168.      * @throws \InvalidArgumentException If the callable does not exist
  169.      */
  170.     public function __call($strKey, $arrParams)
  171.     {
  172.         if (!isset($this->arrData[$strKey]) || !\is_callable($this->arrData[$strKey]))
  173.         {
  174.             throw new \InvalidArgumentException("$strKey is not set or not a callable");
  175.         }
  177.         return ($this->arrData[$strKey])(...$arrParams);
  178.     }
  180.     /**
  181.      * Check whether a property is set
  182.      *
  183.      * @param string $strKey The property name
  184.      *
  185.      * @return boolean True if the property is set
  186.      */
  187.     public function __isset($strKey)
  188.     {
  189.         return isset($this->arrData[$strKey]);
  190.     }
  192.     /**
  193.      * Set the template data from an array
  194.      *
  195.      * @param array $arrData The data array
  196.      */
  197.     public function setData($arrData)
  198.     {
  199.         $this->arrData = $arrData;
  200.     }
  202.     /**
  203.      * Return the template data as array
  204.      *
  205.      * @return array The data array
  206.      */
  207.     public function getData()
  208.     {
  209.         return $this->arrData;
  210.     }
  212.     /**
  213.      * Set the template name
  214.      *
  215.      * @param string $strTemplate The template name
  216.      */
  217.     public function setName($strTemplate)
  218.     {
  219.         $this->strTemplate = $strTemplate;
  220.     }
  222.     /**
  223.      * Return the template name
  224.      *
  225.      * @return string The template name
  226.      */
  227.     public function getName()
  228.     {
  229.         return $this->strTemplate;
  230.     }
  232.     /**
  233.      * Set the output format
  234.      *
  235.      * @param string $strFormat The output format
  236.      */
  237.     public function setFormat($strFormat)
  238.     {
  239.         $this->strFormat = $strFormat;
  240.     }
  242.     /**
  243.      * Return the output format
  244.      *
  245.      * @return string The output format
  246.      */
  247.     public function getFormat()
  248.     {
  249.         return $this->strFormat;
  250.     }
  252.     /**
  253.      * Print all template variables to the screen using print_r
  254.      *
  255.      * @deprecated Deprecated since Contao 4.3, to be removed in Contao 5.
  256.      *             Use Template::dumpTemplateVars() instead.
  257.      */
  258.     public function showTemplateVars()
  259.     {
  260.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Template::showTemplateVars()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Template::dumpTemplateVars()" instead.');
  262.         $this->dumpTemplateVars();
  263.     }
  265.     /**
  266.      * Print all template variables to the screen using the Symfony VarDumper component
  267.      */
  268.     public function dumpTemplateVars()
  269.     {
  270.         VarDumper::dump($this->arrData);
  271.     }
  273.     /**
  274.      * Parse the template file and return it as string
  275.      *
  276.      * @return string The template markup
  277.      */
  278.     public function parse()
  279.     {
  280.         if (!$this->strTemplate)
  281.         {
  282.             return '';
  283.         }
  285.         // HOOK: add custom parse filters
  286.         if (isset($GLOBALS['TL_HOOKS']['parseTemplate']) && \is_array($GLOBALS['TL_HOOKS']['parseTemplate']))
  287.         {
  288.             foreach ($GLOBALS['TL_HOOKS']['parseTemplate'] as $callback)
  289.             {
  290.                 $this->import($callback[0]);
  291.                 $this->{$callback[0]}->{$callback[1]}($this);
  292.             }
  293.         }
  295.         return $this->inherit();
  296.     }
  298.     /**
  299.      * Parse the template file and print it to the screen
  300.      *
  301.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  302.      *             Use Template::getResponse() instead.
  303.      */
  304.     public function output()
  305.     {
  306.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Template::output()" has been deprecated and will no longer work in Contao 5.0. Use "Contao\Template::getResponse()" instead.');
  308.         $this->compile();
  310.         header('Content-Type: ' . $this->strContentType . '; charset=' . System::getContainer()->getParameter('kernel.charset'));
  312.         echo $this->strBuffer;
  313.     }
  315.     /**
  316.      * Return a response object
  317.      *
  318.      * @return Response The response object
  319.      */
  320.     public function getResponse()
  321.     {
  322.         $this->compile();
  324.         $response = new Response($this->strBuffer);
  325.         $response->headers->set('Content-Type', $this->strContentType);
  326.         $response->setCharset(System::getContainer()->getParameter('kernel.charset'));
  328.         return $response;
  329.     }
  331.     /**
  332.      * Return a route relative to the base URL
  333.      *
  334.      * @param string $strName   The route name
  335.      * @param array  $arrParams The route parameters
  336.      *
  337.      * @return string The route
  338.      */
  339.     public function route($strName, $arrParams=array())
  340.     {
  341.         $strUrl = System::getContainer()->get('router')->generate($strName, $arrParams);
  342.         $strUrl = substr($strUrl, \strlen(Environment::get('path')) + 1);
  344.         return StringUtil::ampersand($strUrl);
  345.     }
  347.     /**
  348.      * Return the preview route
  349.      *
  350.      * @param string $strName   The route name
  351.      * @param array  $arrParams The route parameters
  352.      *
  353.      * @return string The route
  354.      */
  355.     public function previewRoute($strName, $arrParams=array())
  356.     {
  357.         $container = System::getContainer();
  359.         if (!$previewScript = $container->getParameter('contao.preview_script'))
  360.         {
  361.             return $this->route($strName, $arrParams);
  362.         }
  364.         $router = $container->get('router');
  366.         $context = $router->getContext();
  367.         $context->setBaseUrl($previewScript);
  369.         $strUrl = $router->generate($strName, $arrParams);
  370.         $strUrl = substr($strUrl, \strlen(Environment::get('path')) + 1);
  372.         $context->setBaseUrl('');
  374.         return StringUtil::ampersand($strUrl);
  375.     }
  377.     /**
  378.      * Returns a translated message
  379.      *
  380.      * @param string $strId
  381.      * @param array  $arrParams
  382.      * @param string $strDomain
  383.      *
  384.      * @return string
  385.      */
  386.     public function trans($strId, array $arrParams=array(), $strDomain='contao_default')
  387.     {
  388.         return System::getContainer()->get('translator')->trans($strId, $arrParams, $strDomain);
  389.     }
  391.     /**
  392.      * Helper method to allow quick access in the Contao templates for safe raw (unencoded) output.
  393.      * It replaces (or optionally removes) Contao insert tags and removes all HTML.
  394.      *
  395.      * Be careful when using this. It must NOT be used within regular HTML when $value
  396.      * is uncontrolled user input. It's useful to ensure raw values within e.g. <code> examples
  397.      * or JSON-LD arrays.
  398.      */
  399.     public function rawPlainText(string $value, bool $removeInsertTags = false): string
  400.     {
  401.         return System::getContainer()->get('contao.string.html_decoder')->inputEncodedToPlainText($value, $removeInsertTags);
  402.     }
  404.     /**
  405.      * Helper method to allow quick access in the Contao templates for safe raw (unencoded) output.
  406.      *
  407.      * Compared to $this->rawPlainText() it adds new lines before and after block level HTML elements
  408.      * and only then removes the rest of the HTML tags.
  409.      *
  410.      * Be careful when using this. It must NOT be used within regular HTML when $value
  411.      * is uncontrolled user input. It's useful to ensure raw values within e.g. <code> examples
  412.      * or JSON-LD arrays.
  413.      */
  414.     public function rawHtmlToPlainText(string $value, bool $removeInsertTags = false): string
  415.     {
  416.         return System::getContainer()->get('contao.string.html_decoder')->htmlToPlainText($value, $removeInsertTags);
  417.     }
  419.     /**
  420.      * Adds schema.org JSON-LD data to the current response context
  421.      */
  422.     public function addSchemaOrg(array $jsonLd): void
  423.     {
  424.         $responseContext = System::getContainer()->get('contao.routing.response_context_accessor')->getResponseContext();
  426.         if (!$responseContext || !$responseContext->has(JsonLdManager::class))
  427.         {
  428.             return;
  429.         }
  431.         /** @var JsonLdManager $jsonLdManager */
  432.         $jsonLdManager = $responseContext->get(JsonLdManager::class);
  433.         $type = $jsonLdManager->createSchemaOrgTypeFromArray($jsonLd);
  435.         $jsonLdManager
  436.             ->getGraphForSchema(JsonLdManager::SCHEMA_ORG)
  437.             ->set($type, $jsonLd['identifier'] ?? Graph::IDENTIFIER_DEFAULT)
  438.         ;
  439.     }
  441.     /**
  442.      * Render a figure
  443.      *
  444.      * The provided configuration array is used to configure a FigureBuilder.
  445.      * If not explicitly set, the default template "image.html5" will be used
  446.      * to render the results. To use the core's default Twig template, pass
  447.      * "@ContaoCore/Image/Studio/figure.html.twig" as $template argument.
  448.      *
  449.      * @param int|string|FilesModel|ImageInterface       $from          Can be a FilesModel, an ImageInterface, a tl_files UUID/ID/path or a file system path
  450.      * @param int|string|array|PictureConfiguration|null $size          A picture size configuration or reference
  451.      * @param array<string, mixed>                       $configuration Configuration for the FigureBuilder
  452.      * @param string                                     $template      A Contao or Twig template
  453.      *
  454.      * @return string|null Returns null if the resource is invalid
  455.      */
  456.     public function figure($from, $size, $configuration = array(), $template = 'image')
  457.     {
  458.         return System::getContainer()->get('contao.image.studio.figure_renderer')->render($from, $size, $configuration, $template);
  459.     }
  461.     /**
  462.      * Returns an asset path
  463.      *
  464.      * @param string      $path
  465.      * @param string|null $packageName
  466.      *
  467.      * @return string
  468.      */
  469.     public function asset($path, $packageName = null)
  470.     {
  471.         $url = System::getContainer()->get('assets.packages')->getUrl($path, $packageName);
  473.         $basePath = '/';
  474.         $request = System::getContainer()->get('request_stack')->getMainRequest();
  476.         if ($request !== null)
  477.         {
  478.             $basePath = $request->getBasePath() . '/';
  479.         }
  481.         if (0 === strncmp($url, $basePath, \strlen($basePath)))
  482.         {
  483.             return substr($url, \strlen($basePath));
  484.         }
  486.         // Contao paths are relative to the <base> tag, so remove leading slashes
  487.         return $url;
  488.     }
  490.     /**
  491.      * Returns a container parameter
  492.      *
  493.      * @param string $strKey
  494.      *
  495.      * @return mixed
  496.      */
  497.     public function param($strKey)
  498.     {
  499.         return System::getContainer()->getParameter($strKey);
  500.     }
  502.     /**
  503.      * Compile the template
  504.      *
  505.      * @internal Do not call this method in your code. It will be made private in Contao 5.0.
  506.      */
  507.     protected function compile()
  508.     {
  509.         if (!$this->strBuffer)
  510.         {
  511.             $this->strBuffer = $this->parse();
  512.         }
  513.     }
  515.     /**
  516.      * Return the debug bar string
  517.      *
  518.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  519.      */
  520.     protected function getDebugBar()
  521.     {
  522.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Template::getDebugBar()" has been deprecated and will no longer work in Contao 5.0.');
  523.     }
  525.     /**
  526.      * Minify the HTML markup preserving pre, script, style and textarea tags
  527.      *
  528.      * @param string $strHtml The HTML markup
  529.      *
  530.      * @return string The minified HTML markup
  531.      */
  532.     public function minifyHtml($strHtml)
  533.     {
  534.         if (System::getContainer()->getParameter('kernel.debug'))
  535.         {
  536.             return $strHtml;
  537.         }
  539.         // Split the markup based on the tags that shall be preserved
  540.         $arrChunks = preg_split('@(</?pre[^>]*>)|(</?script[^>]*>)|(</?style[^>]*>)|( ?</?textarea[^>]*>)@i', $strHtml, -1, PREG_SPLIT_DELIM_CAPTURE|PREG_SPLIT_NO_EMPTY);
  542.         $strHtml = '';
  543.         $blnPreserveNext = false;
  544.         $blnOptimizeNext = false;
  545.         $strType = null;
  547.         // Check for valid JavaScript types (see #7927)
  548.         $isJavaScript = static function ($strChunk)
  549.         {
  550.             $typeMatch = array();
  552.             if (preg_match('/\stype\s*=\s*(?:(?J)(["\'])\s*(?<type>.*?)\s*\1|(?<type>[^\s>]+))/i', $strChunk, $typeMatch) && !\in_array(strtolower($typeMatch['type']), static::$validJavaScriptTypes))
  553.             {
  554.                 return false;
  555.             }
  557.             if (preg_match('/\slanguage\s*=\s*(?:(?J)(["\'])\s*(?<type>.*?)\s*\1|(?<type>[^\s>]+))/i', $strChunk, $typeMatch) && !\in_array('text/' . strtolower($typeMatch['type']), static::$validJavaScriptTypes))
  558.             {
  559.                 return false;
  560.             }
  562.             return true;
  563.         };
  565.         // Recombine the markup
  566.         foreach ($arrChunks as $strChunk)
  567.         {
  568.             if (strncasecmp($strChunk, '<pre', 4) === 0 || strncasecmp(ltrim($strChunk), '<textarea', 9) === 0)
  569.             {
  570.                 $blnPreserveNext = true;
  571.             }
  572.             elseif (strncasecmp($strChunk, '<script', 7) === 0)
  573.             {
  574.                 if ($isJavaScript($strChunk))
  575.                 {
  576.                     $blnOptimizeNext = true;
  577.                     $strType = 'js';
  578.                 }
  579.                 else
  580.                 {
  581.                     $blnPreserveNext = true;
  582.                 }
  583.             }
  584.             elseif (strncasecmp($strChunk, '<style', 6) === 0)
  585.             {
  586.                 $blnOptimizeNext = true;
  587.                 $strType = 'css';
  588.             }
  589.             elseif ($blnPreserveNext)
  590.             {
  591.                 $blnPreserveNext = false;
  592.             }
  593.             elseif ($blnOptimizeNext)
  594.             {
  595.                 $blnOptimizeNext = false;
  597.                 // Minify inline scripts
  598.                 if ($strType == 'js')
  599.                 {
  600.                     $objMinify = new JS();
  601.                     $objMinify->add($strChunk);
  602.                     $strChunk = $objMinify->minify();
  603.                 }
  604.                 elseif ($strType == 'css')
  605.                 {
  606.                     $objMinify = new CSS();
  607.                     $objMinify->add($strChunk);
  608.                     $strChunk = $objMinify->minify();
  609.                 }
  610.             }
  611.             else
  612.             {
  613.                 // Remove line indentations and trailing spaces
  614.                 $strChunk = str_replace("\r", '', $strChunk);
  615.                 $strChunk = preg_replace(array('/^[\t ]+/m', '/[\t ]+$/m', '/\n\n+/'), array('', '', "\n"), $strChunk);
  616.             }
  618.             $strHtml .= $strChunk;
  619.         }
  621.         return trim($strHtml);
  622.     }
  624.     /**
  625.      * Generate the markup for a style sheet tag
  626.      *
  627.      * @param string $href  The script path
  628.      * @param string $media The media type string
  629.      * @param mixed  $mtime The file mtime
  630.      *
  631.      * @return string The markup string
  632.      */
  633.     public static function generateStyleTag($href, $media=null, $mtime=false)
  634.     {
  635.         // Add the filemtime if not given and not an external file
  636.         if ($mtime === null && !preg_match('@^https?://@', $href))
  637.         {
  638.             $container = System::getContainer();
  639.             $projectDir = $container->getParameter('kernel.project_dir');
  641.             if (file_exists($projectDir . '/' . $href))
  642.             {
  643.                 $mtime = filemtime($projectDir . '/' . $href);
  644.             }
  645.             else
  646.             {
  647.                 $webDir = StringUtil::stripRootDir($container->getParameter('contao.web_dir'));
  649.                 // Handle public bundle resources in the contao.web_dir folder
  650.                 if (file_exists($projectDir . '/' . $webDir . '/' . $href))
  651.                 {
  652.                     $mtime = filemtime($projectDir . '/' . $webDir . '/' . $href);
  653.                 }
  654.             }
  655.         }
  657.         if ($mtime)
  658.         {
  659.             $href .= '?v=' . substr(md5($mtime), 0, 8);
  660.         }
  662.         return '<link rel="stylesheet" href="' . $href . '"' . (($media && $media != 'all') ? ' media="' . $media . '"' : '') . '>';
  663.     }
  665.     /**
  666.      * Generate the markup for inline CSS code
  667.      *
  668.      * @param string $script The CSS code
  669.      *
  670.      * @return string The markup string
  671.      */
  672.     public static function generateInlineStyle($script)
  673.     {
  674.         return '<style>' . $script . '</style>';
  675.     }
  677.     /**
  678.      * Generate the markup for a JavaScript tag
  679.      *
  680.      * @param string      $src            The script path
  681.      * @param boolean     $async          True to add the async attribute
  682.      * @param mixed       $mtime          The file mtime
  683.      * @param string|null $hash           An optional integrity hash
  684.      * @param string|null $crossorigin    An optional crossorigin attribute
  685.      * @param string|null $referrerpolicy An optional referrerpolicy attribute
  686.      *
  687.      * @return string The markup string
  688.      */
  689.     public static function generateScriptTag($src, $async=false, $mtime=false, $hash=null, $crossorigin=null, $referrerpolicy=null)
  690.     {
  691.         // Add the filemtime if not given and not an external file
  692.         if ($mtime === null && !preg_match('@^https?://@', $src))
  693.         {
  694.             $container = System::getContainer();
  695.             $projectDir = $container->getParameter('kernel.project_dir');
  697.             if (file_exists($projectDir . '/' . $src))
  698.             {
  699.                 $mtime = filemtime($projectDir . '/' . $src);
  700.             }
  701.             else
  702.             {
  703.                 $webDir = StringUtil::stripRootDir($container->getParameter('contao.web_dir'));
  705.                 // Handle public bundle resources in the contao.web_dir folder
  706.                 if (file_exists($projectDir . '/' . $webDir . '/' . $src))
  707.                 {
  708.                     $mtime = filemtime($projectDir . '/' . $webDir . '/' . $src);
  709.                 }
  710.             }
  711.         }
  713.         if ($mtime)
  714.         {
  715.             $src .= '?v=' . substr(md5($mtime), 0, 8);
  716.         }
  718.         return '<script src="' . $src . '"' . ($async ? ' async' : '') . ($hash ? ' integrity="' . $hash . '"' : '') . ($crossorigin ? ' crossorigin="' . $crossorigin . '"' : '') . ($referrerpolicy ? ' referrerpolicy="' . $referrerpolicy . '"' : '') . '></script>';
  719.     }
  721.     /**
  722.      * Generate the markup for an inline JavaScript
  723.      *
  724.      * @param string $script The JavaScript code
  725.      *
  726.      * @return string The markup string
  727.      */
  728.     public static function generateInlineScript($script)
  729.     {
  730.         return '<script>' . $script . '</script>';
  731.     }
  733.     /**
  734.      * Generate the markup for an RSS feed tag
  735.      *
  736.      * @param string $href   The script path
  737.      * @param string $format The feed format
  738.      * @param string $title  The feed title
  739.      *
  740.      * @return string The markup string
  741.      */
  742.     public static function generateFeedTag($href, $format, $title)
  743.     {
  744.         return '<link type="application/' . $format . '+xml" rel="alternate" href="' . $href . '" title="' . StringUtil::specialchars($title) . '">';
  745.     }
  747.     /**
  748.      * Flush the output buffers
  749.      *
  750.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  751.      */
  752.     public function flushAllData()
  753.     {
  754.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Template::flushAllData()" has been deprecated and will no longer work in Contao 5.0.');
  756.         if (\function_exists('fastcgi_finish_request'))
  757.         {
  758.             fastcgi_finish_request();
  759.         }
  760.         elseif (\PHP_SAPI !== 'cli')
  761.         {
  762.             $status = ob_get_status(true);
  763.             $level = \count($status);
  765.             while ($level-- > 0 && (!empty($status[$level]['del']) || (isset($status[$level]['flags']) && ($status[$level]['flags'] & PHP_OUTPUT_HANDLER_REMOVABLE) && ($status[$level]['flags'] & PHP_OUTPUT_HANDLER_FLUSHABLE))))
  766.             {
  767.                 ob_end_flush();
  768.             }
  770.             flush();
  771.         }
  772.     }
  773. }
  775. class_alias(Template::class, 'Template');