9.5/_template_service_8php_source.html

<?php

namespace ‪TYPO3\CMS\Core\TypoScript;


/*

 * This file is part of the TYPO3 CMS project.

 *

 * It is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, either version 2

 * of the License, or any later version.

 *

 * For the full copyright and license information, please read the

 * LICENSE.txt file that was distributed with this source code.

 *

 * The TYPO3 project - inspiring people to share!

 */


use ‪TYPO3\CMS\Backend\Utility\BackendUtility;

use ‪TYPO3\CMS\Core\Cache\CacheManager;

use ‪TYPO3\CMS\Core\Compatibility\PublicMethodDeprecationTrait;

use ‪TYPO3\CMS\Core\Compatibility\PublicPropertyDeprecationTrait;

use ‪TYPO3\CMS\Core\Context\Context;

use ‪TYPO3\CMS\Core\Database\Connection;

use ‪TYPO3\CMS\Core\Database\ConnectionPool;

use ‪TYPO3\CMS\Core\Database\Query\Restriction\AbstractRestrictionContainer;

use ‪TYPO3\CMS\Core\Database\Query\Restriction\DefaultRestrictionContainer;

use ‪TYPO3\CMS\Core\Database\Query\Restriction\DeletedRestriction;

use ‪TYPO3\CMS\Core\Database\Query\Restriction\HiddenRestriction;

use TYPO3\CMS\Core\Package\PackageManager;

use ‪TYPO3\CMS\Core\Resource\Exception\FileDoesNotExistException;

use ‪TYPO3\CMS\Core\Resource\Exception\InvalidFileException;

use ‪TYPO3\CMS\Core\Resource\Exception\InvalidFileNameException;

use ‪TYPO3\CMS\Core\Resource\Exception\InvalidPathException;

use ‪TYPO3\CMS\Core\TimeTracker\TimeTracker;

use ‪TYPO3\CMS\Core\Utility\ArrayUtility;

use ‪TYPO3\CMS\Core\Utility\ExtensionManagementUtility;

use ‪TYPO3\CMS\Core\Utility\GeneralUtility;

use ‪TYPO3\CMS\Core\Utility\HttpUtility;

use ‪TYPO3\CMS\Core\Utility\MathUtility;

use ‪TYPO3\CMS\Frontend\Configuration\TypoScript\ConditionMatching\ConditionMatcher;

use ‪TYPO3\CMS\Frontend\Controller\TypoScriptFrontendController;

use ‪TYPO3\CMS\Frontend\Page\PageRepository;

use ‪TYPO3\CMS\Frontend\Resource\FilePathSanitizer;


class ‪TemplateService

{

    use ‪PublicPropertyDeprecationTrait;

    use ‪PublicMethodDeprecationTrait;


    protected ‪$deprecatedPublicProperties = [

        'matchAll' => 'Using $matchAll of class TemplateService from the outside is discouraged, as this variable is only used for internal storage.',

        'whereClause' => 'Using $whereClause of class TemplateService is discouraged, as this has been superseded by Doctrine DBAL API.',

        'debug' => 'Using $debug of class TemplateService is discouraged, as this option has no effect anymore.',

        'allowedPaths' => 'Using $allowedPaths of class TemplateService from the outside is discouraged, as this variable is only used for internal storage.',

        'simulationHiddenOrTime' => 'Using $simulationHiddenOrTime of class TemplateService is discouraged, as this has been superseeded by Doctrine DBAL API.',

        'nextLevel' => 'Using $nextLevel of class TemplateService from the outside is discouraged, as this variable is only used for internal storage.',

        'rootId' => 'Using $rootId of class TemplateService from the outside is discouraged, use TemplateService->getRootId() instead.',

        'absoluteRootLine' => 'Using $absoluteRootLine of class TemplateService from the outside is discouraged, as this variable is only used for internal storage.',

        'outermostRootlineIndexWithTemplate' => 'Using $outermostRootlineIndexWithTemplate of class TemplateService from the outside is discouraged, as this variable is only used for internal storage.',

        'rowSum' => 'Using $rowSum of class TemplateService from the outside is discouraged, as this variable is only used for internal storage.',

        'sitetitle' => 'Using $sitetitle of class TemplateService from the outside is discouraged, as this variable is only used for internal storage.',

        'sectionsMatch' => 'Using $sectionsMatch of class TemplateService from the outside is discouraged, as this variable is only used for internal storage.',

        'frames' => 'Using $frames of class TemplateService from the outside is discouraged, as this variable is only used for internal storage.',

        'MPmap' => 'Using $MPmap of class TemplateService from the outside is discouraged, as this variable is only used for internal storage.',

        'fileCache' => 'Using $fileCache of class TemplateService from the outside is discouraged, the property will be removed in TYPO3 v10.0.',

    ];


    protected ‪$deprecatedPublicMethods = [

        'prependStaticExtra' => 'Using prependStaticExtra() of class TemplateService from the outside is discouraged, as this method is only meant to be used internally.',

        'versionOL' => 'Using versionOL() of class TemplateService from the outside is discouraged, as this method is only meant to be used internally.',

        'processIncludes' => 'Using processIncludes() of class TemplateService from the outside is discouraged, as this method is only meant to be used internally.',

        'mergeConstantsFromPageTSconfig' => 'Using mergeConstantsFromPageTSconfig() of class TemplateService from the outside is discouraged, as this method is only meant to be used internally.',

        'flattenSetup' => 'Using flattenSetup() of class TemplateService from the outside is discouraged, as this method is only meant to be used internally.',

        'substituteConstants' => 'Using substituteConstants() of class TemplateService from the outside is discouraged, as this method is only meant to be used internally.',

    ];


    protected ‪$verbose = false;


    public ‪$tt_track = true;


    public ‪$forceTemplateParsing = false;


    public ‪$matchAlternative = [];


    protected ‪$matchAll = false;


    public ‪$ext_constants_BRP = 0;


    public ‪$ext_config_BRP = 0;


    public ‪$ext_regLinenumbers = false;


    public ‪$ext_regComments = false;


    protected ‪$whereClause = '';


    protected ‪$debug = false;


    protected ‪$allowedPaths = [];


    protected ‪$simulationHiddenOrTime = 0;


    public ‪$loaded = false;


    public ‪$setup = [];


    public ‪$flatSetup = [];


    public ‪$config = [];


    public ‪$constants = [];


    protected ‪$templateIncludePaths = [];


    public ‪$hierarchyInfo = [];


    protected ‪$hierarchyInfoToRoot = [];


    protected ‪$nextLevel = 0;


    protected ‪$rootId;


    public ‪$rootLine;


    protected ‪$absoluteRootLine;


    protected ‪$outermostRootlineIndexWithTemplate = 0;


    protected ‪$rowSum;


    protected ‪$sitetitle = '';


    public ‪$sections;


    protected ‪$sectionsMatch;


    public ‪$clearList_const = [];


    public ‪$clearList_setup = [];


    public ‪$parserErrors = [];


    public ‪$setup_constants = [];


    protected ‪$fileCache = [];


    protected ‪$frames = [];


    protected ‪$MPmap = '';


    protected ‪$extensionStaticsProcessed = false;


    protected ‪$processExtensionStatics = false;


    protected ‪$isDefaultTypoScriptAdded = false;


    protected ‪$processIncludesHasBeenRun = false;


    protected ‪$queryBuilderRestrictions;


    protected ‪$context;


    protected ‪$packageManager;


    public function ‪__construct(‪Context ‪$context = null, PackageManager ‪$packageManager = null)

    {

        $this->context = ‪$context ?? GeneralUtility::makeInstance(Context::class);

        $this->packageManager = ‪$packageManager ?? GeneralUtility::makeInstance(PackageManager::class);

        $this->‪initializeDatabaseQueryRestrictions();

        if ($this->context->getPropertyFromAspect('visibility', 'includeHiddenContent', false) || ‪$GLOBALS['SIM_ACCESS_TIME'] !== ‪$GLOBALS['ACCESS_TIME']) {

            // Set the simulation flag, if simulation is detected!

            $this->simulationHiddenOrTime = 1;

        }


        // Sets the paths from where TypoScript resources are allowed to be used:

        $this->allowedPaths = [

            ‪$GLOBALS['TYPO3_CONF_VARS']['BE']['fileadminDir'],

            // fileadmin/ path

            'uploads/',

            'typo3temp/',

            TYPO3_mainDir . 'ext/',

            TYPO3_mainDir . 'sysext/',

            'typo3conf/ext/'

        ];

        if (‪$GLOBALS['TYPO3_CONF_VARS']['FE']['addAllowedPaths']) {

            $pathArr = GeneralUtility::trimExplode(',', ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['addAllowedPaths'], true);

            foreach ($pathArr as $p) {

                // Once checked for path, but as this may run from typo3/mod/web/ts/ dir, that'll not work!! So the paths ar uncritically included here.

                $this->allowedPaths[] = $p;

            }

        }


        $this->tt_track = $this->verbose = (bool)$this->context->getPropertyFromAspect('backend.user', 'isLoggedIn', false);

    }


    public function ‪getProcessExtensionStatics()

    {

        return ‪$this->processExtensionStatics;

    }


    public function ‪setProcessExtensionStatics(‪$processExtensionStatics)

    {

        $this->processExtensionStatics = (bool)‪$processExtensionStatics;

    }


    public function ‪setVerbose(‪$verbose)

    {

        $this->verbose = (bool)‪$verbose;

    }


    public function ‪init()

    {

        trigger_error('TemplateService->init() will be removed in TYPO3 v10.0, __construct() does the job.', E_USER_DEPRECATED);

        $this->‪initializeDatabaseQueryRestrictions();

        if ($this->context->getPropertyFromAspect('visibility', 'includeHiddenContent', false) || ‪$GLOBALS['SIM_ACCESS_TIME'] !== ‪$GLOBALS['ACCESS_TIME']) {

            // Set the simulation flag, if simulation is detected!

            $this->simulationHiddenOrTime = 1;

        }


        // Sets the paths from where TypoScript resources are allowed to be used:

        $this->allowedPaths = [

            ‪$GLOBALS['TYPO3_CONF_VARS']['BE']['fileadminDir'],

            // fileadmin/ path

            'uploads/',

            'typo3temp/',

            TYPO3_mainDir . 'ext/',

            TYPO3_mainDir . 'sysext/',

            'typo3conf/ext/'

        ];

        if (‪$GLOBALS['TYPO3_CONF_VARS']['FE']['addAllowedPaths']) {

            $pathArr = GeneralUtility::trimExplode(',', ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['addAllowedPaths'], true);

            foreach ($pathArr as $p) {

                // Once checked for path, but as this may run from typo3/mod/web/ts/ dir, that'll not work!! So the paths ar uncritically included here.

                $this->allowedPaths[] = $p;

            }

        }

    }


    protected function ‪initializeDatabaseQueryRestrictions()

    {

        $includeHiddenRecords = $this->context->getPropertyFromAspect('visibility', 'includeHiddenContent', false);

        // $this->whereClause is used only to select templates from sys_template.

        // $GLOBALS['SIM_ACCESS_TIME'] is used so that we're able to simulate a later time as a test...

        $this->whereClause = 'AND deleted=0 ';

        if (!$includeHiddenRecords) {

            $this->whereClause .= 'AND hidden=0 ';

        }

        $this->whereClause .= 'AND (starttime<=' . ‪$GLOBALS['SIM_ACCESS_TIME'] . ') AND (endtime=0 OR endtime>' . ‪$GLOBALS['SIM_ACCESS_TIME'] . ')';


        // set up the query builder restrictions

        $this->queryBuilderRestrictions = GeneralUtility::makeInstance(DefaultRestrictionContainer::class);


        if ($includeHiddenRecords) {

            $this->queryBuilderRestrictions->removeByType(HiddenRestriction::class);

        }

    }


    public function ‪getCurrentPageData()

    {

        return GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_pagesection')->get((int)$this->‪getTypoScriptFrontendController()->id . '_' . GeneralUtility::md5int($this->‪getTypoScriptFrontendController()->MP));

    }


    public function ‪matching($cc)

    {

        if (is_array($cc['all'])) {

            $matchObj = GeneralUtility::makeInstance(ConditionMatcher::class);

            $matchObj->setRootline((array)$cc['rootLine']);

            ‪$sectionsMatch = [];

            foreach ($cc['all'] as $key => $pre) {

                if ($matchObj->match($pre)) {

                    ‪$sectionsMatch[$key] = $pre;

                }

            }

            $cc['match'] = ‪$sectionsMatch;

        }

        return $cc;

    }


    public function ‪start($theRootLine)

    {

        if (is_array($theRootLine)) {

            $constantsData = [];

            $setupData = [];

            $cacheIdentifier = '';

            // Flag that indicates that the existing data in cache_pagesection

            // could be used (this is the case if $TSFE->all is set, and the

            // rowSum still matches). Based on this we decide if cache_pagesection

            // needs to be updated...

            $isCached = false;

            $this->‪runThroughTemplates($theRootLine);

            if ($this->‪getTypoScriptFrontendController()->all) {

                $cc = $this->‪getTypoScriptFrontendController()->all;

                // The two rowSums must NOT be different from each other - which they will be if start/endtime or hidden has changed!

                if (serialize($this->rowSum) !== serialize($cc['rowSum'])) {

                    unset($cc);

                } else {

                    // If $TSFE->all contains valid data, we don't need to update cache_pagesection (because this data was fetched from there already)

                    if (serialize($this->rootLine) === serialize($cc['rootLine'])) {

                        $isCached = true;

                    }

                    // When the data is serialized below (ROWSUM hash), it must not contain the rootline by concept. So this must be removed (and added again later)...

                    unset($cc['rootLine']);

                }

            }

            // This is about getting the hash string which is used to fetch the cached TypoScript template.

            // If there was some cached currentPageData ($cc) then that's good (it gives us the hash).

            if (isset($cc) && is_array($cc)) {

                // If currentPageData was actually there, we match the result (if this wasn't done already in $TSFE->getFromCache()...)

                if (!$cc['match']) {

                    // @todo check if this can ever be the case - otherwise remove

                    $cc = $this->‪matching($cc);

                    ksort($cc);

                }

                $cacheIdentifier = md5(serialize($cc));

            } else {

                // If currentPageData was not there, we first find $rowSum (freshly generated). After that we try to see, if it is stored with a list of all conditions. If so we match the result.

                $rowSumHash = md5('ROWSUM:' . serialize($this->rowSum));

                $result = $this->‪getCacheEntry($rowSumHash);

                if (is_array($result)) {

                    $cc = [];

                    $cc['all'] = $result;

                    $cc['rowSum'] = ‪$this->rowSum;

                    $cc = $this->‪matching($cc);

                    ksort($cc);

                    $cacheIdentifier = md5(serialize($cc));

                }

            }

            if ($cacheIdentifier) {

                // Get TypoScript setup array

                $cachedData = $this->‪getCacheEntry($cacheIdentifier);

                if (is_array($cachedData)) {

                    $constantsData = $cachedData['constants'];

                    $setupData = $cachedData['setup'];

                }

            }

            if (!empty($setupData) && !$this->forceTemplateParsing) {

                // TypoScript constants + setup are found in the cache

                $this->setup_constants = $constantsData;

                $this->setup = $setupData;

                if ($this->tt_track) {

                    $this->‪getTimeTracker()->‪setTSlogMessage('Using cached TS template data');

                }

            } else {

                if ($this->tt_track) {

                    $this->‪getTimeTracker()->‪setTSlogMessage('Not using any cached TS data');

                }


                // Make configuration

                $this->‪generateConfig();

                // This stores the template hash thing

                $cc = [];

                // All sections in the template at this point is found

                $cc['all'] = ‪$this->sections;

                // The line of templates is collected

                $cc['rowSum'] = ‪$this->rowSum;

                $cc = $this->‪matching($cc);

                ksort($cc);

                $cacheIdentifier = md5(serialize($cc));

                // This stores the data.

                $this->‪setCacheEntry($cacheIdentifier, ['constants' => $this->setup_constants, 'setup' => $this->setup], 'TS_TEMPLATE');

                if ($this->tt_track) {

                    $this->‪getTimeTracker()->‪setTSlogMessage('TS template size, serialized: ' . strlen(serialize($this->setup)) . ' bytes');

                }

                $rowSumHash = md5('ROWSUM:' . serialize($this->rowSum));

                $this->‪setCacheEntry($rowSumHash, $cc['all'], 'TMPL_CONDITIONS_ALL');

            }

            // Add rootLine

            $cc['rootLine'] = ‪$this->rootLine;

            ksort($cc);

            // Make global and save

            $this->‪getTypoScriptFrontendController()->all = $cc;

            // Matching must be executed for every request, so this must never be part of the pagesection cache!

            unset($cc['match']);

            if (!$isCached && !$this->simulationHiddenOrTime && !$this->‪getTypoScriptFrontendController()->no_cache) {

                // Only save the data if we're not simulating by hidden/starttime/endtime

                $mpvarHash = GeneralUtility::md5int($this->‪getTypoScriptFrontendController()->MP);

                $pageSectionCache = GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_pagesection');

                $pageSectionCache->set((int)$this->‪getTypoScriptFrontendController()->id . '_' . $mpvarHash, $cc, [

                    'pageId_' . (int)$this->‪getTypoScriptFrontendController()->id,

                    'mpvarHash_' . $mpvarHash

                ]);

            }

            // If everything OK.

            if ($this->rootId && $this->rootLine && $this->setup) {

                $this->loaded = true;

            }

        }

    }


    /*******************************************************************

     *

     * Fetching TypoScript code text for the Template Hierarchy

     *

     *******************************************************************/

    public function ‪runThroughTemplates($theRootLine, $start_template_uid = 0)

    {

        $this->constants = [];

        $this->config = [];

        $this->rowSum = [];

        $this->hierarchyInfoToRoot = [];

        $this->absoluteRootLine = $theRootLine;

        $this->isDefaultTypoScriptAdded = false;


        reset($this->absoluteRootLine);

        $c = count($this->absoluteRootLine);

        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('sys_template');

        for ($a = 0; $a < $c; $a++) {

            // If some template loaded before has set a template-id for the next level, then load this template first!

            if ($this->nextLevel) {

                $queryBuilder->setRestrictions($this->queryBuilderRestrictions);

                $queryResult = $queryBuilder

                    ->select('*')

                    ->from('sys_template')

                    ->where(

                        $queryBuilder->expr()->eq(

                            'uid',

                            $queryBuilder->createNamedParameter($this->nextLevel, \PDO::PARAM_INT)

                        )

                    )

                    ->execute();

                $this->nextLevel = 0;

                if ($row = $queryResult->fetch()) {

                    $this->‪versionOL($row);

                    if (is_array($row)) {

                        $this->‪processTemplate($row, 'sys_' . $row['uid'], $this->absoluteRootLine[$a]['uid'], 'sys_' . $row['uid']);

                        $this->outermostRootlineIndexWithTemplate = $a;

                    }

                }

            }


            $where = [

                $queryBuilder->expr()->eq(

                    'pid',

                    $queryBuilder->createNamedParameter($this->absoluteRootLine[$a]['uid'], \PDO::PARAM_INT)

                )

            ];

            // If first loop AND there is set an alternative template uid, use that

            if ($a === $c - 1 && $start_template_uid) {

                $where[] = $queryBuilder->expr()->eq(

                    'uid',

                    $queryBuilder->createNamedParameter($start_template_uid, \PDO::PARAM_INT)

                );

            }

            $queryBuilder->setRestrictions($this->queryBuilderRestrictions);

            $queryResult = $queryBuilder

                ->select('*')

                ->from('sys_template')

                ->where(...$where)

                ->orderBy('root', 'DESC')

                ->addOrderBy('sorting')

                ->setMaxResults(1)

                ->execute();

            if ($row = $queryResult->fetch()) {

                $this->‪versionOL($row);

                if (is_array($row)) {

                    $this->‪processTemplate($row, 'sys_' . $row['uid'], $this->absoluteRootLine[$a]['uid'], 'sys_' . $row['uid']);

                    $this->outermostRootlineIndexWithTemplate = $a;

                }

            }

            $this->rootLine[] = $this->absoluteRootLine[$a];

        }


        // Hook into the default TypoScript to add custom typoscript logic

        $hookParameters = [

            'extensionStaticsProcessed' => &‪$this->extensionStaticsProcessed,

            'isDefaultTypoScriptAdded'  => &‪$this->isDefaultTypoScriptAdded,

            'absoluteRootLine' => &‪$this->absoluteRootLine,

            'rootLine'         => &‪$this->rootLine,

            'startTemplateUid' => $start_template_uid,

        ];

        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['Core/TypoScript/TemplateService']['runThroughTemplatesPostProcessing'] ?? [] as $listener) {

            GeneralUtility::callUserFunction($listener, $hookParameters, $this);

        }


        // Process extension static files if not done yet, but explicitly requested

        if (!$this->extensionStaticsProcessed && $this->processExtensionStatics) {

            $this->‪addExtensionStatics('sys_0', 'sys_0', 0);

        }


        // Add the global default TypoScript from the TYPO3_CONF_VARS

        $this->‪addDefaultTypoScript();


        $this->‪processIncludes();

    }


    public function ‪processTemplate($row, $idList, $pid, $templateID = '', $templateParent = '', $includePath = '')

    {

        // Adding basic template record information to rowSum array

        $this->rowSum[] = [$row['uid'] ?? null, $row['title'] ?? null, $row['tstamp'] ?? null];

        // Processing "Clear"-flags

        $clConst = 0;

        $clConf = 0;

        if (!empty($row['clear'])) {

            $clConst = $row['clear'] & 1;

            $clConf = $row['clear'] & 2;

            if ($clConst) {

                // Keep amount of items to stay in sync with $this->templateIncludePaths so processIncludes() does not break

                foreach ($this->constants as &$constantConfiguration) {

                    $constantConfiguration = '';

                }

                unset($constantConfiguration);

                $this->clearList_const = [];

            }

            if ($clConf) {

                // Keep amount of items to stay in sync with $this->templateIncludePaths so processIncludes() does not break

                foreach ($this->config as &$configConfiguration) {

                    $configConfiguration = '';

                }

                unset($configConfiguration);

                $this->hierarchyInfoToRoot = [];

                $this->clearList_setup = [];

            }

        }

        // Include files (from extensions) (#1/2)

        // NORMAL inclusion, The EXACT same code is found below the basedOn inclusion!!!

        if (!isset($row['includeStaticAfterBasedOn']) || !$row['includeStaticAfterBasedOn']) {

            $this->‪includeStaticTypoScriptSources($idList, $templateID, $pid, $row);

        }

        // Include "Based On" sys_templates:

        // 'basedOn' is a list of templates to include

        if (trim($row['basedOn'] ?? '')) {

            // Normal Operation, which is to include the "based-on" sys_templates,

            // if they are not already included, and maintaining the sorting of the templates

            $basedOnIds = GeneralUtility::intExplode(',', $row['basedOn'], true);

            // skip template if it's already included

            foreach ($basedOnIds as $key => $basedOnId) {

                if (GeneralUtility::inList($idList, 'sys_' . $basedOnId)) {

                    unset($basedOnIds[$key]);

                }

            }

            if (!empty($basedOnIds)) {

                $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('sys_template');

                $queryBuilder->setRestrictions($this->queryBuilderRestrictions);

                $queryResult = $queryBuilder

                    ->select('*')

                    ->from('sys_template')

                    ->where(

                        $queryBuilder->expr()->in(

                            'uid',

                            $queryBuilder->createNamedParameter($basedOnIds, Connection::PARAM_INT_ARRAY)

                        )

                    )

                    ->execute();

                // make it an associative array with the UID as key

                $subTemplates = [];

                while ($rowItem = $queryResult->fetch()) {

                    $subTemplates[(int)$rowItem['uid']] = $rowItem;

                }

                // Traversing list again to ensure the sorting of the templates

                foreach ($basedOnIds as $id) {

                    if (is_array($subTemplates[$id])) {

                        $this->‪versionOL($subTemplates[$id]);

                        $this->‪processTemplate($subTemplates[$id], $idList . ',sys_' . $id, $pid, 'sys_' . $id, $templateID);

                    }

                }

            }

        }

        // Include files (from extensions) (#2/2)

        if (!empty($row['includeStaticAfterBasedOn'])) {

            $this->‪includeStaticTypoScriptSources($idList, $templateID, $pid, $row);

        }

        // Creating hierarchy information; Used by backend analysis tools

        $this->hierarchyInfo[] = ($this->hierarchyInfoToRoot[] = [

            'root' => trim($row['root'] ?? ''),

            'next' => $row['nextLevel'] ?? null,

            'clConst' => $clConst,

            'clConf' => $clConf,

            'templateID' => $templateID,

            'templateParent' => $templateParent,

            'title' => $row['title'],

            'uid' => $row['uid'],

            'pid' => $row['pid'] ?? null,

            'configLines' => substr_count($row['config'], LF) + 1

        ]);

        // Adding the content of the fields constants (Constants) and config (Setup)

        $this->constants[] = $row['constants'];

        $this->config[] = $row['config'];

        $this->templateIncludePaths[] = $includePath;

        // For backend analysis (Template Analyzer) provide the order of added constants/config template IDs

        $this->clearList_const[] = $templateID;

        $this->clearList_setup[] = $templateID;

        if (trim($row['sitetitle'] ?? null)) {

            $this->sitetitle = $row['sitetitle'];

        }

        // If the template record is a Rootlevel record, set the flag and clear the template rootLine (so it starts over from this point)

        if (trim($row['root'] ?? null)) {

            $this->rootId = $pid;

            $this->rootLine = [];

        }

        // If a template is set to be active on the next level set this internal value to point to this UID. (See runThroughTemplates())

        if ($row['nextLevel'] ?? null) {

            $this->nextLevel = $row['nextLevel'];

        } else {

            $this->nextLevel = 0;

        }

    }


    public function ‪updateRootlineData($fullRootLine)

    {

        if (!is_array($this->rootLine) || empty($this->rootLine)) {

            return;

        }


        $fullRootLineByUid = [];

        foreach ($fullRootLine as $rootLineData) {

            $fullRootLineByUid[$rootLineData['uid']] = $rootLineData;

        }


        foreach ($this->rootLine as $level => $dataArray) {

            $currentUid = $dataArray['uid'];


            if (!array_key_exists($currentUid, $fullRootLineByUid)) {

                throw new \RuntimeException(sprintf('The full rootLine does not contain data for the page with the uid %d that is contained in the template rootline.', $currentUid), 1370419654);

            }


            $this->rootLine[$level] = $fullRootLineByUid[$currentUid];

        }

    }


    public function ‪includeStaticTypoScriptSources($idList, $templateID, $pid, $row)

    {

        // Call function for link rendering:

        $_params = [

            'idList' => &$idList,

            'templateId' => &$templateID,

            'pid' => &$pid,

            'row' => &$row

        ];

        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tstemplate.php']['includeStaticTypoScriptSources'] ?? [] as $_funcRef) {

            GeneralUtility::callUserFunction($_funcRef, $_params, $this);

        }

        // If "Include before all static templates if root-flag is set" is set:

        $staticFileMode = $row['static_file_mode'] ?? null;

        if ($staticFileMode == 3 && strpos($templateID, 'sys_') === 0 && $row['root']) {

            $this->‪addExtensionStatics($idList, $templateID, $pid);

        }

        // Static Template Files (Text files from extensions): include_static_file is a list of static files to include (from extensions)

        if (trim($row['include_static_file'] ?? '')) {

            $include_static_fileArr = GeneralUtility::trimExplode(',', $row['include_static_file'], true);

            // Traversing list

            foreach ($include_static_fileArr as $ISF_file) {

                if (strpos($ISF_file, 'EXT:') === 0) {

                    list($ISF_extKey, $ISF_localPath) = explode('/', substr($ISF_file, 4), 2);

                    if ((string)$ISF_extKey !== '' && ‪ExtensionManagementUtility::isLoaded($ISF_extKey) && (string)$ISF_localPath !== '') {

                        $ISF_localPath = rtrim($ISF_localPath, '/') . '/';

                        $ISF_filePath = ‪ExtensionManagementUtility::extPath($ISF_extKey) . $ISF_localPath;

                        if (@is_dir($ISF_filePath)) {

                            $mExtKey = str_replace('_', '', $ISF_extKey . '/' . $ISF_localPath);

                            $subrow = [

                                'constants' => $this->‪getTypoScriptSourceFileContent($ISF_filePath, 'constants'),

                                'config' => $this->‪getTypoScriptSourceFileContent($ISF_filePath, 'setup'),

                                'include_static' => @file_exists($ISF_filePath . 'include_static.txt') ? implode(',', array_unique(GeneralUtility::intExplode(',', file_get_contents($ISF_filePath . 'include_static.txt')))) : '',

                                'include_static_file' => @file_exists($ISF_filePath . 'include_static_file.txt') ? implode(',', array_unique(explode(',', file_get_contents($ISF_filePath . 'include_static_file.txt')))) : '',

                                'title' => $ISF_file,

                                'uid' => $mExtKey

                            ];

                            $subrow = $this->‪prependStaticExtra($subrow);

                            $this->‪processTemplate($subrow, $idList . ',ext_' . $mExtKey, $pid, 'ext_' . $mExtKey, $templateID, $ISF_filePath);

                        }

                    }

                }

            }

        }

        // If "Default (include before if root flag is set)" is set OR

        // "Always include before this template record" AND root-flag are set

        if ($staticFileMode == 1 || $staticFileMode == 0 && strpos($templateID, 'sys_') === 0 && $row['root']) {

            $this->‪addExtensionStatics($idList, $templateID, $pid);

        }

        // Include Static Template Records after all other TypoScript has been included.

        $_params = [

            'idList' => &$idList,

            'templateId' => &$templateID,

            'pid' => &$pid,

            'row' => &$row

        ];

        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tstemplate.php']['includeStaticTypoScriptSourcesAtEnd'] ?? [] as $_funcRef) {

            GeneralUtility::callUserFunction($_funcRef, $_params, $this);

        }

    }


    protected function ‪getTypoScriptSourceFileContent($filePath, $baseName)

    {

        $extensions = ['.typoscript', '.ts', '.txt'];

        foreach ($extensions as $extension) {

            $fileName = $filePath . $baseName . $extension;

            if (@file_exists($fileName)) {

                return file_get_contents($fileName);

            }

        }

        return '';

    }


    public function ‪addExtensionStatics($idList, $templateID, $pid)

    {

        $this->extensionStaticsProcessed = true;


        foreach ($this->packageManager->getActivePackages() as $package) {

            $extKey = $package->getPackageKey();

            $packagePath = $package->getPackagePath();

            $filesToCheck = [

                'ext_typoscript_constants.txt',

                'ext_typoscript_constants.typoscript',

                'ext_typoscript_setup.txt',

                'ext_typoscript_setup.typoscript',

            ];

            $files = [];

            $hasExtensionStatics = false;

            foreach ($filesToCheck as $file) {

                $path = $packagePath . $file;

                if (@file_exists($path)) {

                    $files[$file] = $path;

                    $hasExtensionStatics = true;

                } else {

                    $files[$file] = null;

                }

            }


            if ($hasExtensionStatics) {

                $mExtKey = str_replace('_', '', $extKey);

                ‪$constants = '';

                ‪$config = '';


                if (!empty($files['ext_typoscript_constants.typoscript'])) {

                    ‪$constants = @file_get_contents($files['ext_typoscript_constants.typoscript']);

                } elseif (!empty($files['ext_typoscript_constants.txt'])) {

                    ‪$constants = @file_get_contents($files['ext_typoscript_constants.txt']);

                }


                if (!empty($files['ext_typoscript_setup.typoscript'])) {

                    ‪$config = @file_get_contents($files['ext_typoscript_setup.typoscript']);

                } elseif (!empty($files['ext_typoscript_setup.txt'])) {

                    ‪$config = @file_get_contents($files['ext_typoscript_setup.txt']);

                }


                $this->‪processTemplate(

                    $this->‪prependStaticExtra([

                        'constants' => ‪$constants,

                        'config' => ‪$config,

                        'title' => $extKey,

                        'uid' => $mExtKey

                    ]),

                    $idList . ',ext_' . $mExtKey,

                    $pid,

                    'ext_' . $mExtKey,

                    $templateID,

                    $packagePath

                );

            }

        }

    }


    protected function ‪prependStaticExtra($subrow)

    {

        // the identifier can be "43" if coming from "static template" extension or a path like "cssstyledcontent/static/"

        $identifier = $subrow['uid'];

        $subrow['config'] .= ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_setup.'][$identifier] ?? null;

        $subrow['constants'] .= ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_constants.'][$identifier] ?? null;

        // if this is a template of type "default content rendering", also see if other extensions have added their TypoScript that should be included after the content definitions

        if (in_array($identifier, ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['contentRenderingTemplates'], true)) {

            $subrow['config'] .= ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_setup.']['defaultContentRendering'];

            $subrow['constants'] .= ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_constants.']['defaultContentRendering'];

        }

        return $subrow;

    }


    protected function ‪versionOL(&$row)

    {

        // Distinguish frontend and backend call:

        // To do the fronted call a full frontend is required, just checking for

        // TYPO3_MODE === 'FE' is not enough. This could otherwise lead to fatals in

        // eId scripts that run in frontend scope, but do not have a full blown frontend.

        if (is_object($this->‪getTypoScriptFrontendController()) && property_exists($this->‪getTypoScriptFrontendController(), 'sys_page') && method_exists($this->‪getTypoScriptFrontendController()->sys_page, 'versionOL')) {

            // Frontend

            $this->‪getTypoScriptFrontendController()->sys_page->versionOL('sys_template', $row);

        } else {

            // Backend

            ‪BackendUtility::workspaceOL('sys_template', $row);

        }

    }


    /*******************************************************************

     *

     * Parsing TypoScript code text from Template Records into PHP array

     *

     *******************************************************************/

    public function ‪generateConfig()

    {

        // Add default TS for all code types

        $this->‪addDefaultTypoScript();


        // Parse the TypoScript code text for include-instructions!

        $this->‪processIncludes();

        // These vars are also set lateron...

        $this->setup['sitetitle'] = ‪$this->sitetitle;

        // ****************************

        // Parse TypoScript Constants

        // ****************************

        // Initialize parser and match-condition classes:

        ‪$constants = GeneralUtility::makeInstance(Parser\TypoScriptParser::class);

        ‪$constants->breakPointLN = (int)$this->ext_constants_BRP;

        ‪$constants->setup = $this->‪mergeConstantsFromPageTSconfig([]);

        $matchObj = GeneralUtility::makeInstance(ConditionMatcher::class);

        $matchObj->setSimulateMatchConditions($this->matchAlternative);

        $matchObj->setSimulateMatchResult((bool)$this->matchAll);

        // Traverse constants text fields and parse them

        foreach ($this->constants as $str) {

            ‪$constants->parse($str, $matchObj);

        }

        // Read out parse errors if any

        $this->parserErrors['constants'] = ‪$constants->errors;

        // Then flatten the structure from a multi-dim array to a single dim array with all constants listed as key/value pairs (ready for substitution)

        $this->flatSetup = [];

        $this->‪flattenSetup(‪$constants->setup, '');

        // ***********************************************

        // Parse TypoScript Setup (here called "config")

        // ***********************************************

        // Initialize parser and match-condition classes:

        ‪$config = GeneralUtility::makeInstance(Parser\TypoScriptParser::class);

        ‪$config->breakPointLN = (int)$this->ext_config_BRP;

        ‪$config->regLinenumbers = ‪$this->ext_regLinenumbers;

        ‪$config->regComments = ‪$this->ext_regComments;

        ‪$config->setup = ‪$this->setup;

        // Transfer information about conditions found in "Constants" and which of them returned TRUE.

        ‪$config->sections = ‪$constants->sections;

        ‪$config->sectionsMatch = ‪$constants->sectionsMatch;

        // Traverse setup text fields and concatenate them into one, single string separated by a [GLOBAL] condition

        $all = '';

        foreach ($this->config as $str) {

            $all .= '

[GLOBAL]

' . $str;

        }

        // Substitute constants in the Setup code:

        if ($this->tt_track) {

            $this->‪getTimeTracker()->‪push('Substitute Constants (' . count($this->flatSetup) . ')');

        }

        $all = $this->‪substituteConstants($all);

        if ($this->tt_track) {

            $this->‪getTimeTracker()->‪pull();

        }


        // Searching for possible unsubstituted constants left (only for information)

        if ($this->verbose) {

            if (preg_match_all('/\\{\\$.[^}]*\\}/', $all, $constantList) > 0) {

                if ($this->tt_track) {

                    $this->‪getTimeTracker()->‪setTSlogMessage(implode(', ', $constantList[0]) . ': Constants may remain un-substituted!!', 2);

                }

            }

        }


        // Logging the textual size of the TypoScript Setup field text with all constants substituted:

        if ($this->tt_track) {

            $this->‪getTimeTracker()->‪setTSlogMessage('TypoScript template size as textfile: ' . strlen($all) . ' bytes');

        }

        // Finally parse the Setup field TypoScript code (where constants are now substituted)

        ‪$config->parse($all, $matchObj);

        // Read out parse errors if any

        $this->parserErrors['config'] = ‪$config->errors;

        // Transfer the TypoScript array from the parser object to the internal $this->setup array:

        $this->setup = ‪$config->setup;

        // Do the same for the constants

        $this->setup_constants = ‪$constants->setup;

        // ****************************************************************

        // Final processing of the $this->setup TypoScript Template array

        // Basically: This is unsetting/setting of certain reserved keys.

        // ****************************************************************

        // These vars are already set after 'processTemplate', but because $config->setup overrides them (in the line above!), we set them again. They are not changed compared to the value they had in the top of the page!

        unset($this->setup['sitetitle']);

        unset($this->setup['sitetitle.']);

        $this->setup['sitetitle'] = ‪$this->sitetitle;

        // Unsetting some vars...

        unset($this->setup['types.']);

        unset($this->setup['types']);

        if (is_array($this->setup)) {

            foreach ($this->setup as $key => $value) {

                if ($value === 'PAGE') {

                    // Set the typeNum of the current page object:

                    if (isset($this->setup[$key . '.']['typeNum'])) {

                        $typeNum = $this->setup[$key . '.']['typeNum'];

                        $this->setup['types.'][$typeNum] = $key;

                    } elseif (!isset($this->setup['types.'][0]) || !$this->setup['types.'][0]) {

                        $this->setup['types.'][0] = $key;

                    }

                }

            }

        }

        unset($this->setup['temp.']);

        unset(‪$constants);

        // Storing the conditions found/matched information:

        $this->sections = ‪$config->sections;

        $this->sectionsMatch = ‪$config->sectionsMatch;

    }


    protected function ‪processIncludes()

    {

        if ($this->processIncludesHasBeenRun) {

            return;

        }


        $paths = ‪$this->templateIncludePaths;

        $files = [];

        foreach ($this->constants as &$value) {

            $includeData = ‪Parser\TypoScriptParser::checkIncludeLines($value, 1, true, array_shift($paths));

            $files = array_merge($files, $includeData['files']);

            $value = $includeData['typoscript'];

        }

        unset($value);

        $paths = ‪$this->templateIncludePaths;

        foreach ($this->config as &$value) {

            $includeData = ‪Parser\TypoScriptParser::checkIncludeLines($value, 1, true, array_shift($paths));

            $files = array_merge($files, $includeData['files']);

            $value = $includeData['typoscript'];

        }

        unset($value);


        if (!empty($files)) {

            $files = array_unique($files);

            foreach ($files as $file) {

                $this->rowSum[] = [$file, filemtime($file)];

            }

        }


        $this->processIncludesHasBeenRun = true;

    }


    protected function ‪mergeConstantsFromPageTSconfig($constArray)

    {

        $TSdataArray = [];

        // Setting default configuration:

        $TSdataArray[] = ‪$GLOBALS['TYPO3_CONF_VARS']['BE']['defaultPageTSconfig'];

        for ($a = 0; $a <= ‪$this->outermostRootlineIndexWithTemplate; $a++) {

            if (trim($this->absoluteRootLine[$a]['tsconfig_includes'])) {

                $includeTsConfigFileList = GeneralUtility::trimExplode(

                    ',',

                    $this->absoluteRootLine[$a]['tsconfig_includes'],

                    true

                );


                $TSdataArray = $this->‪mergeConstantsFromIncludedTsConfigFiles($includeTsConfigFileList, $TSdataArray);

            }

            $TSdataArray[] = $this->absoluteRootLine[$a]['TSconfig'];

        }

        // Parsing the user TS (or getting from cache)

        $TSdataArray = ‪Parser\TypoScriptParser::checkIncludeLines_array($TSdataArray);

        $userTS = implode(LF . '[GLOBAL]' . LF, $TSdataArray);

        $parseObj = GeneralUtility::makeInstance(Parser\TypoScriptParser::class);

        $parseObj->parse($userTS);

        if (is_array($parseObj->setup['TSFE.']['constants.'])) {

            ‪ArrayUtility::mergeRecursiveWithOverrule($constArray, $parseObj->setup['TSFE.']['constants.']);

        }


        return $constArray;

    }


    protected function ‪mergeConstantsFromIncludedTsConfigFiles($filesToInclude, $TSdataArray)

    {

        foreach ($filesToInclude as $key => $file) {

            if (strpos($file, 'EXT:') !== 0) {

                continue;

            }


            list($extensionKey, $filePath) = explode('/', substr($file, 4), 2);


            if ((string)$extensionKey === '' || !‪ExtensionManagementUtility::isLoaded($extensionKey)) {

                continue;

            }

            if ((string)$filePath == '') {

                continue;

            }


            $tsConfigFile = ‪ExtensionManagementUtility::extPath($extensionKey) . $filePath;

            if (file_exists($tsConfigFile)) {

                $TSdataArray[] = file_get_contents($tsConfigFile);

            }

        }


        return $TSdataArray;

    }


    protected function ‪flattenSetup($setupArray, $prefix)

    {

        if (is_array($setupArray)) {

            foreach ($setupArray as $key => $val) {

                if (is_array($val)) {

                    $this->‪flattenSetup($val, $prefix . $key);

                } else {

                    $this->flatSetup[$prefix . $key] = $val;

                }

            }

        }

    }


    protected function ‪substituteConstants($all)

    {

        if ($this->tt_track) {

            $this->‪getTimeTracker()->‪setTSlogMessage('Constants to substitute: ' . count($this->flatSetup));

        }

        $noChange = false;

        // Recursive substitution of constants (up to 10 nested levels)

        for ($i = 0; $i < 10 && !$noChange; $i++) {

            $old_all = $all;

            $all = preg_replace_callback('/\\{\\$(.[^}]*)\\}/', [$this, 'substituteConstantsCallBack'], $all);

            if ($old_all == $all) {

                $noChange = true;

            }

        }

        return $all;

    }


    public function ‪substituteConstantsCallBack($matches)

    {

        // Replace {$CONST} if found in $this->flatSetup, else leave unchanged

        return isset($this->flatSetup[$matches[1]]) && !is_array($this->flatSetup[$matches[1]]) ? $this->flatSetup[$matches[1]] : $matches[0];

    }


    /*******************************************************************

     *

     * Various API functions, used from elsewhere in the frontend classes

     *

     *******************************************************************/


    public function ‪getFileName($fileFromSetup)

    {

        trigger_error('TemplateService->getFileName() will be removed in TYPO3 v10.0. Use FilePathSanitizer->sanitize() of EXT:frontend instead.', E_USER_DEPRECATED);

        try {

            $file = GeneralUtility::makeInstance(FilePathSanitizer::class)->sanitize((string)$fileFromSetup);

            $hash = md5($file);

            if (!isset($this->fileCache[$hash])) {

                $this->fileCache[$hash] = $file;

            }

            return $file;

        } catch (‪InvalidFileNameException $e) {

            // Empty file name

        } catch (‪InvalidPathException $e) {

            if ($this->tt_track) {

                $this->‪getTimeTracker()->‪setTSlogMessage('File path "' . $fileFromSetup . '" contained illegal string "../"!', 3);

            }

        } catch (‪FileDoesNotExistException $e) {

            if ($this->tt_track) {

                $this->‪getTimeTracker()->‪setTSlogMessage('File "' . $fileFromSetup . '" was not found!', 3);

            }

        } catch (InvalidFileException $e) {

            if ($this->tt_track) {

                $this->‪getTimeTracker()->‪setTSlogMessage('"' . $fileFromSetup . '" was not located in the allowed paths: (' . implode(',', $this->allowedPaths) . ')', 3);

            }

        }

        return null;

    }


    public function ‪printTitle($pageTitle, $noTitle = false, $showTitleFirst = false, $pageTitleSeparator = '')

    {

        trigger_error('TemplateService->printTitle() will be removed in TYPO3 v10.0. Title tag generation has been moved into $TSFE itself, re-implement this method if you need to, otherwise use TSFE->generatePageTitle() for full usage.', E_USER_DEPRECATED);

        $siteTitle = trim($this->setup['sitetitle']);

        $pageTitle = $noTitle ? '' : $pageTitle;

        if ($showTitleFirst) {

            $temp = $siteTitle;

            $siteTitle = $pageTitle;

            $pageTitle = $temp;

        }

        // only show a separator if there are both site title and page title

        if ($pageTitle === '' || $siteTitle === '') {

            $pageTitleSeparator = '';

        } elseif (empty($pageTitleSeparator)) {

            // use the default separator if non given

            $pageTitleSeparator = ': ';

        }

        return $siteTitle . $pageTitleSeparator . $pageTitle;

    }


    public function ‪getRootlineLevel($list)

    {

        $idx = 0;

        foreach ($this->rootLine as $page) {

            if (GeneralUtility::inList($list, $page['uid'])) {

                return $idx;

            }

            $idx++;

        }

        return false;

    }


    public function ‪getRootId(): int

    {

        return (int)‪$this->rootId;

    }


    /*******************************************************************

     *

     * Functions for creating links

     *

     *******************************************************************/

    public function ‪linkData($page, $oTarget, $no_cache, $_ = null, $overrideArray = null, $addParams = '', $typeOverride = '', $targetDomain = '')

    {

        trigger_error('Creating URLs to pages is now encapsulated into PageLinkBuilder, and should be used in the future. TemplateService->linkData() will be removed in TYPO3 v10.0.', E_USER_DEPRECATED);

        $LD = [];

        // Overriding some fields in the page record and still preserves the values by adding them as parameters. Little strange function.

        if (is_array($overrideArray)) {

            foreach ($overrideArray as $theKey => $theNewVal) {

                $addParams .= '&real_' . $theKey . '=' . rawurlencode($page[$theKey]);

                $page[$theKey] = $theNewVal;

            }

        }

        // Adding Mount Points, "&MP=", parameter for the current page if any is set:

        if (!strstr($addParams, '&MP=')) {

            // Looking for hardcoded defaults:

            if (trim($this->‪getTypoScriptFrontendController()->MP_defaults[$page['uid']])) {

                $addParams .= '&MP=' . rawurlencode(trim($this->‪getTypoScriptFrontendController()->MP_defaults[$page['uid']]));

            } elseif ($this->‪getTypoScriptFrontendController()->config['config']['MP_mapRootPoints']) {

                // Else look in automatically created map:

                $m = $this->‪getFromMPmap($page['uid']);

                if ($m) {

                    $addParams .= '&MP=' . rawurlencode($m);

                }

            }

        }

        // Setting ID/alias:

        $script = 'index.php';

        if ($page['alias']) {

            $LD['url'] = $script . '?id=' . rawurlencode($page['alias']);

        } else {

            $LD['url'] = $script . '?id=' . $page['uid'];

        }

        // Setting target

        $LD['target'] = trim($page['target']) ?: $oTarget;

        // typeNum

        $typeNum = $this->setup[$LD['target'] . '.']['typeNum'];

        if (!‪MathUtility::canBeInterpretedAsInteger($typeOverride) && (int)$this->‪getTypoScriptFrontendController()->config['config']['forceTypeValue']) {

            $typeOverride = (int)$this->‪getTypoScriptFrontendController()->config['config']['forceTypeValue'];

        }

        if ((string)$typeOverride !== '') {

            $typeNum = $typeOverride;

        }

        // Override...

        if ($typeNum) {

            $LD['type'] = '&type=' . (int)$typeNum;

        } else {

            $LD['type'] = '';

        }

        // Preserving the type number.

        $LD['orig_type'] = $LD['type'];

        // noCache

        $LD['no_cache'] = $no_cache ? '&no_cache=1' : '';

        // linkVars

        if ($addParams) {

            $LD['linkVars'] = ‪HttpUtility::buildQueryString(GeneralUtility::explodeUrl2Array($this->‪getTypoScriptFrontendController()->linkVars . $addParams), '&');

        } else {

            $LD['linkVars'] = $this->‪getTypoScriptFrontendController()->linkVars;

        }

        // Add absRefPrefix if exists.

        $LD['url'] = $this->‪getTypoScriptFrontendController()->absRefPrefix . $LD['url'];

        // If the special key 'sectionIndex_uid' (added 'manually' in tslib/menu.php to the page-record) is set, then the link jumps directly to a section on the page.

        $LD['sectionIndex'] = $page['sectionIndex_uid'] ? '#c' . $page['sectionIndex_uid'] : '';

        // Compile the normal total url

        $LD['totalURL'] = rtrim($LD['url'] . $LD['type'] . $LD['no_cache'] . $LD['linkVars'] . $this->‪getTypoScriptFrontendController()->getMethodUrlIdToken, '?') . $LD['sectionIndex'];

        // Call post processing function for link rendering:

        $_params = [

            'LD' => &$LD,

            'args' => ['page' => $page, 'oTarget' => $oTarget, 'no_cache' => $no_cache, 'script' => $script, 'overrideArray' => $overrideArray, 'addParams' => $addParams, 'typeOverride' => $typeOverride, 'targetDomain' => $targetDomain],

            'typeNum' => $typeNum

        ];

        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tstemplate.php']['linkData-PostProc'] ?? [] as $_funcRef) {

            GeneralUtility::callUserFunction($_funcRef, $_params, $this);

        }

        // Return the LD-array

        return $LD;

    }


    public function ‪getFromMPmap($pageId = 0)

    {

        trigger_error('Getting a mount point parameter for a page is now built into PageLinkBuilder, and should be used in the future. TemplateService->getFromMPmap() will be removed in TYPO3 v10.0.', E_USER_DEPRECATED);

        // Create map if not found already:

        if (!is_array($this->MPmap)) {

            $this->MPmap = [];

            $rootPoints = GeneralUtility::trimExplode(',', strtolower($this->‪getTypoScriptFrontendController()->config['config']['MP_mapRootPoints']), true);

            // Traverse rootpoints:

            foreach ($rootPoints as $p) {

                $initMParray = [];

                if ($p === 'root') {

                    $p = $this->rootLine[0]['uid'];

                    if ($this->rootLine[0]['_MOUNT_OL'] && $this->rootLine[0]['_MP_PARAM']) {

                        $initMParray[] = $this->rootLine[0]['_MP_PARAM'];

                    }

                }

                $this->‪initMPmap_create($p, $initMParray);

            }

        }

        // Finding MP var for Page ID:

        if ($pageId) {

            if (is_array($this->MPmap[$pageId]) && !empty($this->MPmap[$pageId])) {

                return implode(',', $this->MPmap[$pageId]);

            }

        }

        return '';

    }


    public function ‪initMPmap_create($id, $MP_array = [], $level = 0)

    {

        trigger_error('Building a mount point parameter map is now built into PageLinkBuilder, and should be used in the future. TemplateService->initMPmap_creat() will be removed in TYPO3 v10.0.', E_USER_DEPRECATED);

        $id = (int)$id;

        if ($id <= 0) {

            return;

        }

        // First level, check id

        if (!$level) {

            // Find mount point if any:

            $mount_info = $this->‪getTypoScriptFrontendController()->sys_page->getMountPointInfo($id);

            // Overlay mode:

            if (is_array($mount_info) && $mount_info['overlay']) {

                $MP_array[] = $mount_info['MPvar'];

                $id = $mount_info['mount_pid'];

            }

            // Set mapping information for this level:

            $this->MPmap[$id] = $MP_array;

            // Normal mode:

            if (is_array($mount_info) && !$mount_info['overlay']) {

                $MP_array[] = $mount_info['MPvar'];

                $id = $mount_info['mount_pid'];

            }

        }

        if ($id && $level < 20) {

            $nextLevelAcc = [];

            // Select and traverse current level pages:

            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('pages');

            $queryBuilder->getRestrictions()

                ->removeAll()

                ->add(GeneralUtility::makeInstance(DeletedRestriction::class));

            $queryResult = $queryBuilder

                ->select('uid', 'pid', 'doktype', 'mount_pid', 'mount_pid_ol')

                ->from('pages')

                ->where(

                    $queryBuilder->expr()->eq(

                        'pid',

                        $queryBuilder->createNamedParameter($id, \PDO::PARAM_INT)

                    ),

                    $queryBuilder->expr()->neq(

                        'doktype',

                        $queryBuilder->createNamedParameter(‪PageRepository::DOKTYPE_RECYCLER, \PDO::PARAM_INT)

                    ),

                    $queryBuilder->expr()->neq(

                        'doktype',

                        $queryBuilder->createNamedParameter(‪PageRepository::DOKTYPE_BE_USER_SECTION, \PDO::PARAM_INT)

                    )

                )->execute();

            while ($row = $queryResult->fetch()) {

                // Find mount point if any:

                $next_id = $row['uid'];

                $next_MP_array = $MP_array;

                $mount_info = $this->‪getTypoScriptFrontendController()->sys_page->getMountPointInfo($next_id, $row);

                // Overlay mode:

                if (is_array($mount_info) && $mount_info['overlay']) {

                    $next_MP_array[] = $mount_info['MPvar'];

                    $next_id = $mount_info['mount_pid'];

                }

                if (!isset($this->MPmap[$next_id])) {

                    // Set mapping information for this level:

                    $this->MPmap[$next_id] = $next_MP_array;

                    // Normal mode:

                    if (is_array($mount_info) && !$mount_info['overlay']) {

                        $next_MP_array[] = $mount_info['MPvar'];

                        $next_id = $mount_info['mount_pid'];

                    }

                    // Register recursive call

                    // (have to do it this way since ALL of the current level should be registered BEFORE the sublevel at any time)

                    $nextLevelAcc[] = [$next_id, $next_MP_array];

                }

            }

            // Call recursively, if any:

            foreach ($nextLevelAcc as $pSet) {

                $this->‪initMPmap_create($pSet[0], $pSet[1], $level + 1);

            }

        }

    }


    protected function ‪addDefaultTypoScript()

    {

        // Add default TS for all code types, if not done already

        if (!$this->isDefaultTypoScriptAdded) {

            // adding default setup and constants

            // defaultTypoScript_setup is *very* unlikely to be empty

            // the count of elements in ->constants, ->config and ->templateIncludePaths have to be in sync

            array_unshift($this->constants, (string)‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_constants']);

            array_unshift($this->config, (string)‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_setup']);

            array_unshift($this->templateIncludePaths, '');

            // prepare a proper entry to hierachyInfo (used by TemplateAnalyzer in BE)

            $rootTemplateId = $this->hierarchyInfo[count($this->hierarchyInfo) - 1]['templateID'] ?? null;

            $defaultTemplateInfo = [

                'root' => '',

                'next' => '',

                'clConst' => '',

                'clConf' => '',

                'templateID' => '_defaultTypoScript_',

                'templateParent' => $rootTemplateId,

                'title' => 'SYS:TYPO3_CONF_VARS:FE:defaultTypoScript',

                'uid' => '_defaultTypoScript_',

                'pid' => '',

                'configLines' => substr_count((string)‪$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_setup'], LF) + 1

            ];

            // push info to information arrays used in BE by TemplateTools (Analyzer)

            array_unshift($this->clearList_const, $defaultTemplateInfo['uid']);

            array_unshift($this->clearList_setup, $defaultTemplateInfo['uid']);

            array_unshift($this->hierarchyInfo, $defaultTemplateInfo);

            $this->isDefaultTypoScriptAdded = true;

        }

    }


    protected function ‪getTypoScriptFrontendController()

    {

        return ‪$GLOBALS['TSFE'];

    }


    protected function ‪getTimeTracker()

    {

        return GeneralUtility::makeInstance(TimeTracker::class);

    }


    protected function ‪getCacheEntry($identifier)

    {

        return GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_hash')->get($identifier);

    }


    protected function ‪setCacheEntry($identifier, $data, $tag)

    {

        GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_hash')->set($identifier, $data, ['ident_' . $tag], 0);

    }

}