TemplateService.php

Go to the documentation of this file.

<?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);
    }
}