ContentObjectRenderer.php

Go to the documentation of this file.

<?php
 
/*
 * 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!
 */
 
namespace ‪TYPO3\CMS\Frontend\ContentObject;
 
use Doctrine\DBAL\DBALException;
use Doctrine\DBAL\Driver\Statement;
use Psr\Container\ContainerInterface;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;
use Symfony\Component\Mime\Address;
use ‪TYPO3\CMS\Core\Authentication\AbstractUserAuthentication;
use ‪TYPO3\CMS\Core\Cache\CacheManager;
use ‪TYPO3\CMS\Core\Configuration\Features;
use ‪TYPO3\CMS\Core\Context\Context;
use ‪TYPO3\CMS\Core\Context\LanguageAspect;
use ‪TYPO3\CMS\Core\Core\Environment;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\Query\Expression\ExpressionBuilder;
use ‪TYPO3\CMS\Core\Database\Query\QueryBuilder;
use ‪TYPO3\CMS\Core\Database\Query\QueryHelper;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\DeletedRestriction;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\DocumentTypeExclusionRestriction;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\FrontendRestrictionContainer;
use ‪TYPO3\CMS\Core\Domain\Repository\PageRepository;
use ‪TYPO3\CMS\Core\Html\HtmlParser;
use ‪TYPO3\CMS\Core\Html\SanitizerBuilderFactory;
use ‪TYPO3\CMS\Core\Html\SanitizerInitiator;
use ‪TYPO3\CMS\Core\Imaging\ImageManipulation\Area;
use ‪TYPO3\CMS\Core\Imaging\ImageManipulation\CropVariantCollection;
use ‪TYPO3\CMS\Core\LinkHandling\Exception\UnknownLinkHandlerException;
use ‪TYPO3\CMS\Core\LinkHandling\LinkService;
use ‪TYPO3\CMS\Core\Localization\Locales;
use ‪TYPO3\CMS\Core\Log\LogManager;
use ‪TYPO3\CMS\Core\Mail\MailMessage;
use ‪TYPO3\CMS\Core\Page\AssetCollector;
use ‪TYPO3\CMS\Core\Resource\Exception;
use ‪TYPO3\CMS\Core\Resource\Exception\InvalidPathException;
use ‪TYPO3\CMS\Core\Resource\Exception\ResourceDoesNotExistException;
use ‪TYPO3\CMS\Core\Resource\File;
use ‪TYPO3\CMS\Core\Resource\FileInterface;
use ‪TYPO3\CMS\Core\Resource\FileReference;
use ‪TYPO3\CMS\Core\Resource\ProcessedFile;
use ‪TYPO3\CMS\Core\Resource\ResourceFactory;
use ‪TYPO3\CMS\Core\Service\DependencyOrderingService;
use ‪TYPO3\CMS\Core\Service\FlexFormService;
use ‪TYPO3\CMS\Core\Service\MarkerBasedTemplateService;
use ‪TYPO3\CMS\Core\Site\SiteFinder;
use ‪TYPO3\CMS\Core\TimeTracker\TimeTracker;
use ‪TYPO3\CMS\Core\Type\BitSet;
use ‪TYPO3\CMS\Core\TypoScript\Parser\TypoScriptParser;
use ‪TYPO3\CMS\Core\TypoScript\TypoScriptService;
use ‪TYPO3\CMS\Core\Utility\ArrayUtility;
use ‪TYPO3\CMS\Core\Utility\DebugUtility;
use ‪TYPO3\CMS\Core\Utility\Exception\MissingArrayPathException;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\HttpUtility;
use ‪TYPO3\CMS\Core\Utility\MailUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Core\Utility\StringUtility;
use ‪TYPO3\CMS\Core\Versioning\VersionState;
use ‪TYPO3\CMS\Frontend\ContentObject\Exception\ContentRenderingException;
use ‪TYPO3\CMS\Frontend\ContentObject\Exception\ExceptionHandlerInterface;
use ‪TYPO3\CMS\Frontend\ContentObject\Exception\ProductionExceptionHandler;
use ‪TYPO3\CMS\Frontend\Controller\TypoScriptFrontendController;
use ‪TYPO3\CMS\Frontend\Http\UrlProcessorInterface;
use ‪TYPO3\CMS\Frontend\Imaging\GifBuilder;
use ‪TYPO3\CMS\Frontend\Page\PageLayoutResolver;
use ‪TYPO3\CMS\Frontend\Resource\FilePathSanitizer;
use ‪TYPO3\CMS\Frontend\Service\TypoLinkCodecService;
use ‪TYPO3\CMS\Frontend\Typolink\AbstractTypolinkBuilder;
use ‪TYPO3\CMS\Frontend\Typolink\UnableToLinkException;
use TYPO3\HtmlSanitizer\Builder\BuilderInterface;
 
class ‪ContentObjectRenderer implements LoggerAwareInterface
{
    use LoggerAwareTrait;
 
    protected ‪$container;
 
    public ‪$align = [
        'center',
        'right',
        'left'
    ];
 
    public ‪$stdWrapOrder = [
        'stdWrapPreProcess' => 'hook',
        // this is a placeholder for the first Hook
        'cacheRead' => 'hook',
        // this is a placeholder for checking if the content is available in cache
        'setContentToCurrent' => 'boolean',
        'setContentToCurrent.' => 'array',
        'addPageCacheTags' => 'string',
        'addPageCacheTags.' => 'array',
        'setCurrent' => 'string',
        'setCurrent.' => 'array',
        'lang.' => 'array',
        'data' => 'getText',
        'data.' => 'array',
        'field' => 'fieldName',
        'field.' => 'array',
        'current' => 'boolean',
        'current.' => 'array',
        'cObject' => 'cObject',
        'cObject.' => 'array',
        'numRows.' => 'array',
        'preUserFunc' => 'functionName',
        'stdWrapOverride' => 'hook',
        // this is a placeholder for the second Hook
        'override' => 'string',
        'override.' => 'array',
        'preIfEmptyListNum' => 'listNum',
        'preIfEmptyListNum.' => 'array',
        'ifNull' => 'string',
        'ifNull.' => 'array',
        'ifEmpty' => 'string',
        'ifEmpty.' => 'array',
        'ifBlank' => 'string',
        'ifBlank.' => 'array',
        'listNum' => 'listNum',
        'listNum.' => 'array',
        'trim' => 'boolean',
        'trim.' => 'array',
        'strPad.' => 'array',
        'stdWrap' => 'stdWrap',
        'stdWrap.' => 'array',
        'stdWrapProcess' => 'hook',
        // this is a placeholder for the third Hook
        'required' => 'boolean',
        'required.' => 'array',
        'if.' => 'array',
        'fieldRequired' => 'fieldName',
        'fieldRequired.' => 'array',
        'csConv' => 'string',
        'csConv.' => 'array',
        'parseFunc' => 'objectpath',
        'parseFunc.' => 'array',
        'HTMLparser' => 'boolean',
        'HTMLparser.' => 'array',
        'split.' => 'array',
        'replacement.' => 'array',
        'prioriCalc' => 'boolean',
        'prioriCalc.' => 'array',
        'char' => 'integer',
        'char.' => 'array',
        'intval' => 'boolean',
        'intval.' => 'array',
        'hash' => 'string',
        'hash.' => 'array',
        'round' => 'boolean',
        'round.' => 'array',
        'numberFormat.' => 'array',
        'expandList' => 'boolean',
        'expandList.' => 'array',
        'date' => 'dateconf',
        'date.' => 'array',
        'strtotime' => 'strtotimeconf',
        'strtotime.' => 'array',
        'strftime' => 'strftimeconf',
        'strftime.' => 'array',
        'age' => 'boolean',
        'age.' => 'array',
        'case' => 'case',
        'case.' => 'array',
        'bytes' => 'boolean',
        'bytes.' => 'array',
        'substring' => 'parameters',
        'substring.' => 'array',
        'cropHTML' => 'crop',
        'cropHTML.' => 'array',
        'stripHtml' => 'boolean',
        'stripHtml.' => 'array',
        'crop' => 'crop',
        'crop.' => 'array',
        'rawUrlEncode' => 'boolean',
        'rawUrlEncode.' => 'array',
        'htmlSpecialChars' => 'boolean',
        'htmlSpecialChars.' => 'array',
        'encodeForJavaScriptValue' => 'boolean',
        'encodeForJavaScriptValue.' => 'array',
        'doubleBrTag' => 'string',
        'doubleBrTag.' => 'array',
        'br' => 'boolean',
        'br.' => 'array',
        'brTag' => 'string',
        'brTag.' => 'array',
        'encapsLines.' => 'array',
        'keywords' => 'boolean',
        'keywords.' => 'array',
        'innerWrap' => 'wrap',
        'innerWrap.' => 'array',
        'innerWrap2' => 'wrap',
        'innerWrap2.' => 'array',
        'preCObject' => 'cObject',
        'preCObject.' => 'array',
        'postCObject' => 'cObject',
        'postCObject.' => 'array',
        'wrapAlign' => 'align',
        'wrapAlign.' => 'array',
        'typolink.' => 'array',
        'wrap' => 'wrap',
        'wrap.' => 'array',
        'noTrimWrap' => 'wrap',
        'noTrimWrap.' => 'array',
        'wrap2' => 'wrap',
        'wrap2.' => 'array',
        'dataWrap' => 'dataWrap',
        'dataWrap.' => 'array',
        'prepend' => 'cObject',
        'prepend.' => 'array',
        'append' => 'cObject',
        'append.' => 'array',
        'wrap3' => 'wrap',
        'wrap3.' => 'array',
        'orderedStdWrap' => 'stdWrap',
        'orderedStdWrap.' => 'array',
        'outerWrap' => 'wrap',
        'outerWrap.' => 'array',
        'insertData' => 'boolean',
        'insertData.' => 'array',
        'postUserFunc' => 'functionName',
        'postUserFuncInt' => 'functionName',
        'prefixComment' => 'string',
        'prefixComment.' => 'array',
        'editIcons' => 'string',
        'editIcons.' => 'array',
        'editPanel' => 'boolean',
        'editPanel.' => 'array',
        'htmlSanitize' => 'boolean',
        'htmlSanitize.' => 'array',
        'cacheStore' => 'hook',
        // this is a placeholder for storing the content in cache
        'stdWrapPostProcess' => 'hook',
        // this is a placeholder for the last Hook
        'debug' => 'boolean',
        'debug.' => 'array',
        'debugFunc' => 'boolean',
        'debugFunc.' => 'array',
        'debugData' => 'boolean',
        'debugData.' => 'array'
    ];
 
    protected ‪$contentObjectClassMap = [];
 
    public ‪$data = [];
 
    protected ‪$table = '';
 
    public ‪$oldData = [];
 
    public ‪$alternativeData = '';
 
    public ‪$parameters = [];
 
    public ‪$currentValKey = 'currentValue_kidjls9dksoje';
 
    public ‪$currentRecord = '';
 
    public ‪$currentRecordTotal = 0;
 
    public ‪$currentRecordNumber = 0;
 
    public ‪$parentRecordNumber = 0;
 
    public ‪$parentRecord = [];
 
    public ‪$checkPid_badDoktypeList = ‪PageRepository::DOKTYPE_RECYCLER;
 
    public ‪$lastTypoLinkUrl = '';
 
    public ‪$lastTypoLinkTarget = '';
 
    public ‪$lastTypoLinkLD = [];
 
    public ‪$recordRegister = [];
 
    protected ‪$cObjHookObjectsRegistry = [];
 
    public ‪$cObjHookObjectsArr = [];
 
    protected ‪$stdWrapHookObjects = [];
 
    protected ‪$getImgResourceHookObjects;
 
    protected ‪$currentFile;
 
    public ‪$doConvertToUserIntObject = false;
 
    protected ‪$userObjectType = false;
 
    protected ‪$stopRendering = [];
 
    protected ‪$stdWrapRecursionLevel = 0;
 
    protected ‪$typoScriptFrontendController;
 
    const ‪OBJECTTYPE_USER_INT = 1;
    const ‪OBJECTTYPE_USER = 2;
 
    public function ‪__construct(‪TypoScriptFrontendController ‪$typoScriptFrontendController = null, ContainerInterface ‪$container = null)
    {
        $this->typoScriptFrontendController = ‪$typoScriptFrontendController;
        $this->contentObjectClassMap = ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['ContentObjects'];
        $this->container = ‪$container;
    }
 
    public function ‪__sleep()
    {
        $vars = get_object_vars($this);
        unset($vars['typoScriptFrontendController'], $vars['logger'], $vars['container']);
        if ($this->currentFile instanceof ‪FileReference) {
            $this->currentFile = 'FileReference:' . $this->currentFile->getUid();
        } elseif ($this->currentFile instanceof File) {
            $this->currentFile = 'File:' . $this->currentFile->getIdentifier();
        } else {
            unset($vars['currentFile']);
        }
        return array_keys($vars);
    }
 
    public function ‪__wakeup()
    {
        if (isset(‪$GLOBALS['TSFE'])) {
            $this->typoScriptFrontendController = ‪$GLOBALS['TSFE'];
        }
        if ($this->currentFile !== null && is_string($this->currentFile)) {
            [$objectType, $identifier] = explode(':', $this->currentFile, 2);
            try {
                if ($objectType === 'File') {
                    $this->currentFile = GeneralUtility::makeInstance(ResourceFactory::class)->retrieveFileOrFolderObject($identifier);
                } elseif ($objectType === 'FileReference') {
                    $this->currentFile = GeneralUtility::makeInstance(ResourceFactory::class)->getFileReferenceObject($identifier);
                }
            } catch (‪ResourceDoesNotExistException $e) {
                $this->currentFile = null;
            }
        }
        $this->logger = GeneralUtility::makeInstance(LogManager::class)->getLogger(__CLASS__);
        $this->container = GeneralUtility::getContainer();
    }
 
    public function ‪setContentObjectClassMap(array ‪$contentObjectClassMap)
    {
        $this->contentObjectClassMap = ‪$contentObjectClassMap;
    }
 
    public function ‪registerContentObjectClass($className, $contentObjectName)
    {
        $this->contentObjectClassMap[$contentObjectName] = $className;
    }
 
    public function ‪start(‪$data, ‪$table = '')
    {
        $this->data = ‪$data;
        $this->table = ‪$table;
        $this->currentRecord = ‪$table !== ''
            ? ‪$table . ':' . ($this->data['uid'] ?? '')
            : '';
        $this->parameters = [];
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['cObjTypeAndClass'] ?? [] as $classArr) {
            trigger_error('The hook $TYPO3_CONF_VARS[SC_OPTIONS][tslib/class.tslib_content.php][cObjTypeAndClass] for adding custom cObjects will be removed in TYPO3 v11.0. Use a custom cObject which you can register directly instead.', E_USER_DEPRECATED);
            $this->cObjHookObjectsRegistry[$classArr[0]] = $classArr[1];
        }
        $this->stdWrapHookObjects = [];
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['stdWrap'] ?? [] as $className) {
            $hookObject = GeneralUtility::makeInstance($className);
            if (!$hookObject instanceof ‪ContentObjectStdWrapHookInterface) {
                throw new \UnexpectedValueException($className . ' must implement interface ' . ContentObjectStdWrapHookInterface::class, 1195043965);
            }
            $this->stdWrapHookObjects[] = $hookObject;
        }
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['postInit'] ?? [] as $className) {
            $postInitializationProcessor = GeneralUtility::makeInstance($className);
            if (!$postInitializationProcessor instanceof ContentObjectPostInitHookInterface) {
                throw new \UnexpectedValueException($className . ' must implement interface ' . ContentObjectPostInitHookInterface::class, 1274563549);
            }
            $postInitializationProcessor->postProcessContentObjectInitialization($this);
        }
    }
 
    public function ‪getCurrentTable()
    {
        return ‪$this->table;
    }
 
    protected function ‪getGetImgResourceHookObjects()
    {
        if (!isset($this->getImgResourceHookObjects)) {
            $this->getImgResourceHookObjects = [];
            foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getImgResource'] ?? [] as $className) {
                $hookObject = GeneralUtility::makeInstance($className);
                if (!$hookObject instanceof ‪ContentObjectGetImageResourceHookInterface) {
                    throw new \UnexpectedValueException('$hookObject must implement interface ' . ContentObjectGetImageResourceHookInterface::class, 1218636383);
                }
                $this->getImgResourceHookObjects[] = $hookObject;
            }
        }
        return ‪$this->getImgResourceHookObjects;
    }
 
    public function ‪setParent(‪$data, ‪$currentRecord)
    {
        $this->parentRecord = [
            'data' => ‪$data,
            'currentRecord' => ‪$currentRecord
        ];
    }
 
    /***********************************************
     *
     * CONTENT_OBJ:
     *
     ***********************************************/
    public function ‪getCurrentVal()
    {
        return $this->data[‪$this->currentValKey];
    }
 
    public function ‪setCurrentVal($value)
    {
        $this->data[‪$this->currentValKey] = $value;
    }
 
    public function ‪cObjGet($setup, $addKey = '')
    {
        if (!is_array($setup)) {
            return '';
        }
        $sKeyArray = ‪ArrayUtility::filterAndSortByNumericKeys($setup);
        $content = '';
        foreach ($sKeyArray as $theKey) {
            $theValue = $setup[$theKey];
            if ((int)$theKey && strpos($theKey, '.') === false) {
                $conf = $setup[$theKey . '.'] ?? [];
                $content .= $this->‪cObjGetSingle($theValue, $conf, $addKey . $theKey);
            }
        }
        return $content;
    }
 
    public function ‪cObjGetSingle($name, $conf, $TSkey = '__')
    {
        $content = '';
        // Checking that the function is not called eternally. This is done by interrupting at a depth of 100
        $this->‪getTypoScriptFrontendController()->cObjectDepthCounter--;
        if ($this->‪getTypoScriptFrontendController()->cObjectDepthCounter > 0) {
            $timeTracker = $this->‪getTimeTracker();
            $name = trim($name);
            if ($timeTracker->LR) {
                $timeTracker->push($TSkey, $name);
            }
            // Checking if the COBJ is a reference to another object. (eg. name of 'some.object =< styles.something')
            if (isset($name[0]) && $name[0] === '<') {
                $key = trim(substr($name, 1));
                $cF = GeneralUtility::makeInstance(TypoScriptParser::class);
                // $name and $conf is loaded with the referenced values.
                $confOverride = is_array($conf) ? $conf : [];
                [$name, $conf] = $cF->getVal($key, $this->‪getTypoScriptFrontendController()->tmpl->setup);
                $conf = array_replace_recursive(is_array($conf) ? $conf : [], $confOverride);
                // Getting the cObject
                $timeTracker->incStackPointer();
                $content .= $this->‪cObjGetSingle($name, $conf, $key);
                $timeTracker->decStackPointer();
            } else {
                $hooked = false;
                // Application defined cObjects
                // @deprecated since TYPO3 v10.4 - will be removed in TYPO3 v11.0
                if (!empty($this->cObjHookObjectsRegistry[$name])) {
                    if (empty($this->cObjHookObjectsArr[$name])) {
                        $this->cObjHookObjectsArr[$name] = GeneralUtility::makeInstance($this->cObjHookObjectsRegistry[$name]);
                    }
                    $hookObj = $this->cObjHookObjectsArr[$name];
                    if (method_exists($hookObj, 'cObjGetSingleExt')) {
                        $content .= $hookObj->cObjGetSingleExt($name, $conf, $TSkey, $this);
                        $hooked = true;
                    }
                }
                if (!$hooked) {
                    $contentObject = $this->‪getContentObject($name);
                    if ($contentObject) {
                        $content .= $this->‪render($contentObject, $conf);
                    } else {
                        // Call hook functions for extra processing
                        if ($name) {
                            if (!empty(‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['cObjTypeAndClassDefault'])) {
                                trigger_error('The hook $TYPO3_CONF_VARS[SC_OPTIONS][tslib/class.tslib_content.php][cObjTypeAndClassDefault] for adding custom processing will be removed. Use a custom cObject which you can register directly instead.', E_USER_DEPRECATED);
                            }
                            foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['cObjTypeAndClassDefault'] ?? [] as $className) {
                                $hookObject = GeneralUtility::makeInstance($className);
                                if (!$hookObject instanceof ContentObjectGetSingleHookInterface) {
                                    throw new \UnexpectedValueException('$hookObject must implement interface ' . ContentObjectGetSingleHookInterface::class, 1195043731);
                                }
                                $content .= $hookObject->getSingleContentObject($name, (array)$conf, $TSkey, $this);
                            }
                        } else {
                            // Log error in AdminPanel
                            $warning = sprintf('Content Object "%s" does not exist', $name);
                            $timeTracker->setTSlogMessage($warning, 2);
                        }
                    }
                }
            }
            if ($timeTracker->LR) {
                $timeTracker->pull($content);
            }
        }
        // Increasing on exit...
        $this->‪getTypoScriptFrontendController()->cObjectDepthCounter++;
        return $content;
    }
 
    public function ‪getContentObject($name)
    {
        if (!isset($this->contentObjectClassMap[$name])) {
            return null;
        }
        $fullyQualifiedClassName = $this->contentObjectClassMap[$name];
        $contentObject = GeneralUtility::makeInstance($fullyQualifiedClassName, $this);
        if (!($contentObject instanceof AbstractContentObject)) {
            throw new ContentRenderingException(sprintf('Registered content object class name "%s" must be an instance of AbstractContentObject, but is not!', $fullyQualifiedClassName), 1422564295);
        }
        return $contentObject;
    }
 
    /********************************************
     *
     * Functions rendering content objects (cObjects)
     *
     ********************************************/
    public function ‪render(AbstractContentObject $contentObject, $configuration = [])
    {
        $content = '';
 
        // Evaluate possible cache and return
        $cacheConfiguration = $configuration['cache.'] ?? null;
        if ($cacheConfiguration !== null) {
            unset($configuration['cache.']);
            $cache = $this->‪getFromCache($cacheConfiguration);
            if ($cache !== false) {
                return $cache;
            }
        }
 
        // Render content
        try {
            $content .= $contentObject->render($configuration);
        } catch (ContentRenderingException $exception) {
            // Content rendering Exceptions indicate a critical problem which should not be
            // caught e.g. when something went wrong with Exception handling itself
            throw $exception;
        } catch (\Exception $exception) {
            $exceptionHandler = $this->‪createExceptionHandler($configuration);
            if ($exceptionHandler === null) {
                throw $exception;
            }
            $content = $exceptionHandler->handle($exception, $contentObject, $configuration);
        }
 
        // Store cache
        if ($cacheConfiguration !== null && !$this->‪getTypoScriptFrontendController()->no_cache) {
            $key = $this->‪calculateCacheKey($cacheConfiguration);
            if (!empty($key)) {
                $cacheFrontend = GeneralUtility::makeInstance(CacheManager::class)->getCache('hash');
                $tags = $this->‪calculateCacheTags($cacheConfiguration);
                $lifetime = $this->‪calculateCacheLifetime($cacheConfiguration);
                $cacheFrontend->set($key, $content, $tags, $lifetime);
            }
        }
 
        return $content;
    }
 
    protected function ‪createExceptionHandler($configuration = [])
    {
        $exceptionHandler = null;
        $exceptionHandlerClassName = $this->‪determineExceptionHandlerClassName($configuration);
        if (!empty($exceptionHandlerClassName)) {
            $exceptionHandler = GeneralUtility::makeInstance($exceptionHandlerClassName, $this->‪mergeExceptionHandlerConfiguration($configuration));
            if (!$exceptionHandler instanceof ‪ExceptionHandlerInterface) {
                throw new ‪ContentRenderingException('An exception handler was configured but the class does not exist or does not implement the ExceptionHandlerInterface', 1403653369);
            }
        }
 
        return $exceptionHandler;
    }
 
    protected function ‪determineExceptionHandlerClassName($configuration)
    {
        $exceptionHandlerClassName = null;
        $tsfe = $this->‪getTypoScriptFrontendController();
        if (!isset($tsfe->config['config']['contentObjectExceptionHandler'])) {
            if (‪Environment::getContext()->isProduction()) {
                $exceptionHandlerClassName = '1';
            }
        } else {
            $exceptionHandlerClassName = $tsfe->config['config']['contentObjectExceptionHandler'];
        }
 
        if (isset($configuration['exceptionHandler'])) {
            $exceptionHandlerClassName = $configuration['exceptionHandler'];
        }
 
        if ($exceptionHandlerClassName === '1') {
            $exceptionHandlerClassName = ProductionExceptionHandler::class;
        }
 
        return $exceptionHandlerClassName;
    }
 
    protected function ‪mergeExceptionHandlerConfiguration($configuration)
    {
        $exceptionHandlerConfiguration = [];
        $tsfe = $this->‪getTypoScriptFrontendController();
        if (!empty($tsfe->config['config']['contentObjectExceptionHandler.'])) {
            $exceptionHandlerConfiguration = $tsfe->config['config']['contentObjectExceptionHandler.'];
        }
        if (!empty($configuration['exceptionHandler.'])) {
            $exceptionHandlerConfiguration = array_replace_recursive($exceptionHandlerConfiguration, $configuration['exceptionHandler.']);
        }
 
        return $exceptionHandlerConfiguration;
    }
 
    public function ‪getUserObjectType()
    {
        return ‪$this->userObjectType;
    }
 
    public function ‪setUserObjectType(‪$userObjectType)
    {
        $this->userObjectType = ‪$userObjectType;
    }
 
    public function ‪convertToUserIntObject()
    {
        if ($this->userObjectType !== self::OBJECTTYPE_USER) {
            $this->‪getTimeTracker()->‪setTSlogMessage(self::class . '::convertToUserIntObject() is called in the wrong context or for the wrong object type', 2);
        } else {
            $this->doConvertToUserIntObject = true;
        }
    }
 
    /************************************
     *
     * Various helper functions for content objects:
     *
     ************************************/
    public function ‪readFlexformIntoConf($flexData, &$conf, $recursive = false)
    {
        if ($recursive === false && is_string($flexData)) {
            $flexData = ‪GeneralUtility::xml2array($flexData, 'T3');
        }
        if (is_array($flexData) && isset($flexData['data']['sDEF']['lDEF'])) {
            $flexData = $flexData['data']['sDEF']['lDEF'];
        }
        if (!is_array($flexData)) {
            return;
        }
        foreach ($flexData as $key => $value) {
            if (!is_array($value)) {
                continue;
            }
            if (isset($value['el'])) {
                if (is_array($value['el']) && !empty($value['el'])) {
                    foreach ($value['el'] as $ekey => $element) {
                        if (isset($element['vDEF'])) {
                            $conf[$ekey] = $element['vDEF'];
                        } else {
                            if (is_array($element)) {
                                $this->‪readFlexformIntoConf($element, $conf[$key][key($element)][$ekey], true);
                            } else {
                                $this->‪readFlexformIntoConf($element, $conf[$key][$ekey], true);
                            }
                        }
                    }
                } else {
                    $this->‪readFlexformIntoConf($value['el'], $conf[$key], true);
                }
            }
            if (isset($value['vDEF'])) {
                $conf[$key] = $value['vDEF'];
            }
        }
    }
 
    public function ‪getSlidePids($pidList, $pidConf)
    {
        // todo: phpstan states that $pidConf always exists and is not nullable. At the moment, this is a false positive
        //       as null can be passed into this method via $pidConf. As soon as more strict types are used, this isset
        //       check must be replaced with a more appropriate check like empty or count.
        $pidList = isset($pidConf) ? trim($this->‪stdWrap($pidList, $pidConf)) : trim($pidList);
        if ($pidList === '') {
            $pidList = 'this';
        }
        $tsfe = $this->‪getTypoScriptFrontendController();
        $listArr = null;
        if (trim($pidList)) {
            $listArr = ‪GeneralUtility::intExplode(',', str_replace('this', (string)$tsfe->contentPid, $pidList));
            $listArr = $this->‪checkPidArray($listArr);
        }
        $pidList = [];
        if (is_array($listArr) && !empty($listArr)) {
            foreach ($listArr as $uid) {
                $page = $tsfe->sys_page->getPage($uid);
                if (!$page['is_siteroot']) {
                    $pidList[] = $page['pid'];
                }
            }
        }
        return implode(',', $pidList);
    }
 
    public function ‪cImage($file, $conf)
    {
        trigger_error('cObj->cImage() will be removed in TYPO3 v11.0. This functionality is integrated into ImageContentObject now.', E_USER_DEPRECATED);
        $tsfe = $this->‪getTypoScriptFrontendController();
        $info = $this->‪getImgResource($file, $conf['file.']);
        $tsfe->lastImageInfo = $info;
        if (!is_array($info)) {
            return '';
        }
        if (is_file(‪Environment::getPublicPath() . '/' . $info['3'])) {
            $source = $tsfe->absRefPrefix . str_replace('%2F', '/', rawurlencode($info['3']));
        } else {
            $source = $info[3];
        }
        // Remove file objects for AssetCollector, as it only allows to store scalar values
        unset($info['originalFile'], $info['processedFile']);
        GeneralUtility::makeInstance(AssetCollector::class)->addMedia(
            $source,
            $info
        );
 
        $layoutKey = $this->‪stdWrap($conf['layoutKey'], $conf['layoutKey.']);
        $imageTagTemplate = $this->‪getImageTagTemplate($layoutKey, $conf);
        $sourceCollection = $this->‪getImageSourceCollection($layoutKey, $conf, $file);
 
        // This array is used to collect the image-refs on the page...
        $tsfe->imagesOnPage[] = $source;
        $altParam = $this->‪getAltParam($conf);
        $params = $this->‪stdWrapValue('params', $conf);
        if ($params !== '' && $params[0] !== ' ') {
            $params = ' ' . $params;
        }
 
        $imageTagValues = [
            'width' =>  (int)$info[0],
            'height' => (int)$info[1],
            'src' => htmlspecialchars($source),
            'params' => $params,
            'altParams' => $altParam,
            'border' =>  $this->‪getBorderAttr(' border="' . (int)$conf['border'] . '"'),
            'sourceCollection' => $sourceCollection,
            'selfClosingTagSlash' => !empty($tsfe->xhtmlDoctype) ? ' /' : '',
        ];
 
        $markerTemplateEngine = GeneralUtility::makeInstance(MarkerBasedTemplateService::class);
        $theValue = $markerTemplateEngine->substituteMarkerArray($imageTagTemplate, $imageTagValues, '###|###', true, true);
 
        $linkWrap = isset($conf['linkWrap.']) ? $this->‪stdWrap($conf['linkWrap'], $conf['linkWrap.']) : $conf['linkWrap'];
        if ($linkWrap) {
            $theValue = $this->‪linkWrap($theValue, $linkWrap);
        } elseif ($conf['imageLinkWrap']) {
            $originalFile = !empty($info['originalFile']) ? $info['originalFile'] : $info['origFile'];
            $theValue = $this->‪imageLinkWrap($theValue, $originalFile, $conf['imageLinkWrap.']);
        }
        $wrap = isset($conf['wrap.']) ? $this->‪stdWrap($conf['wrap'], $conf['wrap.']) : $conf['wrap'];
        if ((string)$wrap !== '') {
            $theValue = $this->‪wrap($theValue, $conf['wrap']);
        }
        return $theValue;
    }
 
    public function ‪getBorderAttr($borderAttr)
    {
        trigger_error('cObj->getBorderAttr() will be removed in TYPO3 v11.0. This functionality is integrated into ImageContentObject.', E_USER_DEPRECATED);
        $tsfe = $this->‪getTypoScriptFrontendController();
        $docType = $tsfe->xhtmlDoctype;
        if (
            $docType !== 'xhtml_strict' && $docType !== 'xhtml_11'
            && $tsfe->config['config']['doctype'] !== 'html5'
            && !$tsfe->config['config']['disableImgBorderAttr']
        ) {
            return $borderAttr;
        }
        return '';
    }
 
    public function ‪getImageTagTemplate($layoutKey, $conf)
    {
        trigger_error('cObj->getImageTagTemplate() will be removed in TYPO3 v11.0. This functionality is integrated into ImageContentObject.', E_USER_DEPRECATED);
        if ($layoutKey && isset($conf['layout.']) && isset($conf['layout.'][$layoutKey . '.'])) {
            $imageTagLayout = $this->‪stdWrap(
                $conf['layout.'][$layoutKey . '.']['element'] ?? '',
                $conf['layout.'][$layoutKey . '.']['element.'] ?? []
            );
        } else {
            $imageTagLayout = '<img src="###SRC###" width="###WIDTH###" height="###HEIGHT###" ###PARAMS### ###ALTPARAMS### ###BORDER######SELFCLOSINGTAGSLASH###>';
        }
        return $imageTagLayout;
    }
 
    public function ‪getImageSourceCollection($layoutKey, $conf, $file)
    {
        trigger_error('cObj->getImageSourceCollection() will be removed in TYPO3 v11.0. This functionality is integrated into ImageContentObject.', E_USER_DEPRECATED);
        $sourceCollection = '';
        if ($layoutKey
            && isset($conf['sourceCollection.']) && $conf['sourceCollection.']
            && (
                isset($conf['layout.'][$layoutKey . '.']['source']) && $conf['layout.'][$layoutKey . '.']['source']
                || isset($conf['layout.'][$layoutKey . '.']['source.']) && $conf['layout.'][$layoutKey . '.']['source.']
            )
        ) {
 
            // find active sourceCollection
            $activeSourceCollections = [];
            foreach ($conf['sourceCollection.'] as $sourceCollectionKey => $sourceCollectionConfiguration) {
                if (substr($sourceCollectionKey, -1) === '.') {
                    if (empty($sourceCollectionConfiguration['if.']) || $this->‪checkIf($sourceCollectionConfiguration['if.'])) {
                        $activeSourceCollections[] = $sourceCollectionConfiguration;
                    }
                }
            }
 
            // apply option split to configurations
            $tsfe = $this->‪getTypoScriptFrontendController();
            $typoScriptService = GeneralUtility::makeInstance(TypoScriptService::class);
            $srcLayoutOptionSplitted = $typoScriptService->explodeConfigurationForOptionSplit((array)$conf['layout.'][$layoutKey . '.'], count($activeSourceCollections));
 
            // render sources
            foreach ($activeSourceCollections as $key => $sourceConfiguration) {
                $sourceLayout = $this->‪stdWrap(
                    $srcLayoutOptionSplitted[$key]['source'] ?? '',
                    $srcLayoutOptionSplitted[$key]['source.'] ?? []
                );
 
                $sourceRenderConfiguration = [
                    'file' => $file,
                    'file.' => $conf['file.'] ?? null
                ];
 
                if (isset($sourceConfiguration['quality']) || isset($sourceConfiguration['quality.'])) {
                    $imageQuality = $sourceConfiguration['quality'] ?? '';
                    if (isset($sourceConfiguration['quality.'])) {
                        $imageQuality = $this->‪stdWrap($sourceConfiguration['quality'], $sourceConfiguration['quality.']);
                    }
                    if ($imageQuality) {
                        $sourceRenderConfiguration['file.']['params'] = '-quality ' . (int)$imageQuality;
                    }
                }
 
                if (isset($sourceConfiguration['pixelDensity'])) {
                    $pixelDensity = (int)$this->‪stdWrap(
                        $sourceConfiguration['pixelDensity'] ?? '',
                        $sourceConfiguration['pixelDensity.'] ?? []
                    );
                } else {
                    $pixelDensity = 1;
                }
                $dimensionKeys = ['width', 'height', 'maxW', 'minW', 'maxH', 'minH', 'maxWidth', 'maxHeight', 'XY'];
                foreach ($dimensionKeys as $dimensionKey) {
                    $dimension = $this->‪stdWrap(
                        $sourceConfiguration[$dimensionKey] ?? '',
                        $sourceConfiguration[$dimensionKey . '.'] ?? []
                    );
                    if (!$dimension) {
                        $dimension = $this->‪stdWrap(
                            $conf['file.'][$dimensionKey] ?? '',
                            $conf['file.'][$dimensionKey . '.'] ?? []
                        );
                    }
                    if ($dimension) {
                        if (strpos($dimension, 'c') !== false && ($dimensionKey === 'width' || $dimensionKey === 'height')) {
                            $dimensionParts = explode('c', $dimension, 2);
                            $dimension = ((int)$dimensionParts[0] * $pixelDensity) . 'c';
                            if ($dimensionParts[1]) {
                                $dimension .= $dimensionParts[1];
                            }
                        } elseif ($dimensionKey === 'XY') {
                            $dimensionParts = ‪GeneralUtility::intExplode(',', $dimension, false, 2);
                            $dimension = $dimensionParts[0] * $pixelDensity;
                            if ($dimensionParts[1]) {
                                $dimension .= ',' . $dimensionParts[1] * $pixelDensity;
                            }
                        } else {
                            $dimension = (int)$dimension * $pixelDensity;
                        }
                        $sourceRenderConfiguration['file.'][$dimensionKey] = $dimension;
                        // Remove the stdWrap properties for dimension as they have been processed already above.
                        unset($sourceRenderConfiguration['file.'][$dimensionKey . '.']);
                    }
                }
                $sourceInfo = $this->‪getImgResource($sourceRenderConfiguration['file'], $sourceRenderConfiguration['file.']);
                if ($sourceInfo) {
                    $sourceConfiguration['width'] = $sourceInfo[0];
                    $sourceConfiguration['height'] = $sourceInfo[1];
                    $urlPrefix = '';
                    if (parse_url($sourceInfo[3], PHP_URL_HOST) === null) {
                        $urlPrefix = $tsfe->absRefPrefix;
                    }
                    $sourceConfiguration['src'] = htmlspecialchars($urlPrefix . $sourceInfo[3]);
                    $sourceConfiguration['selfClosingTagSlash'] = !empty($tsfe->xhtmlDoctype) ? ' /' : '';
 
                    $markerTemplateEngine = GeneralUtility::makeInstance(MarkerBasedTemplateService::class);
                    $oneSourceCollection = $markerTemplateEngine->substituteMarkerArray($sourceLayout, $sourceConfiguration, '###|###', true, true);
 
                    foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getImageSourceCollection'] ?? [] as $className) {
                        $hookObject = GeneralUtility::makeInstance($className);
                        if (!$hookObject instanceof ‪ContentObjectOneSourceCollectionHookInterface) {
                            throw new \UnexpectedValueException(
                                '$hookObject must implement interface ' . ContentObjectOneSourceCollectionHookInterface::class,
                                1380007853
                            );
                        }
                        $oneSourceCollection = $hookObject->getOneSourceCollection((array)$sourceRenderConfiguration, (array)$sourceConfiguration, $oneSourceCollection, $this);
                    }
 
                    $sourceCollection .= $oneSourceCollection;
                }
            }
        }
        return $sourceCollection;
    }
 
    public function ‪imageLinkWrap($string, $imageFile, $conf)
    {
        $string = (string)$string;
        $enable = isset($conf['enable.']) ? $this->‪stdWrap($conf['enable'], $conf['enable.']) : $conf['enable'];
        if (!$enable) {
            return $string;
        }
        $content = (string)$this->‪typoLink($string, $conf['typolink.']);
        if (isset($conf['file.']) && is_scalar($imageFile)) {
            $imageFile = $this->‪stdWrap((string)$imageFile, $conf['file.']);
        }
 
        if ($imageFile instanceof File) {
            $file = $imageFile;
        } elseif ($imageFile instanceof FileReference) {
            $file = $imageFile->getOriginalFile();
        } else {
            if (‪MathUtility::canBeInterpretedAsInteger($imageFile)) {
                $file = GeneralUtility::makeInstance(ResourceFactory::class)->getFileObject((int)$imageFile);
            } else {
                $file = GeneralUtility::makeInstance(ResourceFactory::class)->getFileObjectFromCombinedIdentifier($imageFile);
            }
        }
 
        // Create imageFileLink if not created with typolink
        if ($content === $string && $file !== null) {
            $parameterNames = ['width', 'height', 'effects', 'bodyTag', 'title', 'wrap', 'crop'];
            ‪$parameters = [];
            $sample = isset($conf['sample.']) ? $this->‪stdWrap($conf['sample'], $conf['sample.']) : $conf['sample'];
            if ($sample) {
                ‪$parameters['sample'] = 1;
            }
            foreach ($parameterNames as $parameterName) {
                if (isset($conf[$parameterName . '.'])) {
                    $conf[$parameterName] = $this->‪stdWrap($conf[$parameterName], $conf[$parameterName . '.']);
                }
                if (isset($conf[$parameterName]) && $conf[$parameterName]) {
                    ‪$parameters[$parameterName] = $conf[$parameterName];
                }
            }
            $parametersEncoded = base64_encode((string)json_encode(‪$parameters));
            $hmac = GeneralUtility::hmac(implode('|', [$file->getUid(), $parametersEncoded]));
            $params = '&md5=' . $hmac;
            foreach (str_split($parametersEncoded, 64) as $index => $chunk) {
                $params .= '&parameters' . rawurlencode('[') . $index . rawurlencode(']') . '=' . rawurlencode($chunk);
            }
            $url = $this->‪getTypoScriptFrontendController()->absRefPrefix . 'index.php?eID=tx_cms_showpic&file=' . $file->getUid() . $params;
            $directImageLink = isset($conf['directImageLink.']) ? $this->‪stdWrap($conf['directImageLink'], $conf['directImageLink.']) : $conf['directImageLink'];
            if ($directImageLink) {
                $imgResourceConf = [
                    'file' => $imageFile,
                    'file.' => $conf
                ];
                $url = $this->‪cObjGetSingle('IMG_RESOURCE', $imgResourceConf);
                if (!$url) {
                    // If no imagemagick / gm is available
                    $url = $imageFile;
                }
            }
            // Create TARGET-attribute only if the right doctype is used
            $target = '';
            $xhtmlDocType = $this->‪getTypoScriptFrontendController()->xhtmlDoctype;
            if ($xhtmlDocType !== 'xhtml_strict' && $xhtmlDocType !== 'xhtml_11') {
                $target = isset($conf['target.'])
                    ? (string)$this->‪stdWrap($conf['target'], $conf['target.'])
                    : (string)$conf['target'];
                if ($target === '') {
                    $target = 'thePicture';
                }
            }
            $a1 = '';
            $a2 = '';
            $conf['JSwindow'] = isset($conf['JSwindow.']) ? $this->‪stdWrap($conf['JSwindow'], $conf['JSwindow.']) : $conf['JSwindow'];
            if ($conf['JSwindow']) {
                if ($conf['JSwindow.']['altUrl'] || $conf['JSwindow.']['altUrl.']) {
                    $altUrl = isset($conf['JSwindow.']['altUrl.']) ? $this->‪stdWrap($conf['JSwindow.']['altUrl'], $conf['JSwindow.']['altUrl.']) : $conf['JSwindow.']['altUrl'];
                    if ($altUrl) {
                        $url = $altUrl . ($conf['JSwindow.']['altUrl_noDefaultParams'] ? '' : '?file=' . rawurlencode($imageFile) . $params);
                    }
                }
 
                $processedFile = $file->process(‪ProcessedFile::CONTEXT_IMAGECROPSCALEMASK, $conf);
                $JSwindowExpand = isset($conf['JSwindow.']['expand.']) ? $this->‪stdWrap($conf['JSwindow.']['expand'], $conf['JSwindow.']['expand.']) : $conf['JSwindow.']['expand'];
                $offset = ‪GeneralUtility::intExplode(',', $JSwindowExpand . ',');
                $newWindow = isset($conf['JSwindow.']['newWindow.']) ? $this->‪stdWrap($conf['JSwindow.']['newWindow'], $conf['JSwindow.']['newWindow.']) : $conf['JSwindow.']['newWindow'];
                $params = [
                    'width' => ($processedFile->getProperty('width') + $offset[0]),
                    'height' => ($processedFile->getProperty('height') + $offset[1]),
                    'status' => '0',
                    'menubar' => '0'
                ];
                // params override existing parameters from above, or add more
                $windowParams = isset($conf['JSwindow.']['params.']) ? $this->‪stdWrap($conf['JSwindow.']['params'], $conf['JSwindow.']['params.']) : $conf['JSwindow.']['params'];
                $windowParams = explode(',', $windowParams);
                foreach ($windowParams as $windowParam) {
                    [$paramKey, $paramValue] = explode('=', $windowParam);
                    if ($paramValue !== '') {
                        $params[$paramKey] = $paramValue;
                    } else {
                        unset($params[$paramKey]);
                    }
                }
                $paramString = '';
                foreach ($params as $paramKey => $paramValue) {
                    $paramString .= htmlspecialchars((string)$paramKey) . '=' . htmlspecialchars((string)$paramValue) . ',';
                }
 
                $onClick = 'openPic('
                    . GeneralUtility::quoteJSvalue($this->‪getTypoScriptFrontendController()->baseUrlWrap($url)) . ','
                    . '\'' . ($newWindow ? md5($url) : 'thePicture') . '\','
                    . ‪GeneralUtility::quoteJSvalue(rtrim($paramString, ',')) . '); return false;';
                $a1 = '<a href="' . htmlspecialchars($url) . '"'
                    . ' onclick="' . htmlspecialchars($onClick) . '"'
                    . ($target !== '' ? ' target="' . htmlspecialchars($target) . '"' : '')
                    . $this->‪getTypoScriptFrontendController()->ATagParams . '>';
                $a2 = '</a>';
                $this->‪getTypoScriptFrontendController()->‪setJS('openPic');
            } else {
                $conf['linkParams.']['directImageLink'] = (bool)$conf['directImageLink'];
                $conf['linkParams.']['parameter'] = $url;
                $string = $this->‪typoLink($string, $conf['linkParams.']);
            }
            if (isset($conf['stdWrap.'])) {
                $string = $this->‪stdWrap($string, $conf['stdWrap.']);
            }
            $content = $a1 . $string . $a2;
        }
        return $content;
    }
 
    public function ‪lastChanged($tstamp)
    {
        $tstamp = (int)$tstamp;
        $tsfe = $this->‪getTypoScriptFrontendController();
        if ($tstamp > (int)$tsfe->register['SYS_LASTCHANGED']) {
            $tsfe->register['SYS_LASTCHANGED'] = $tstamp;
        }
    }
 
    public function ‪linkWrap($content, $wrap)
    {
        trigger_error('cObj->linkWrap() will be removed in TYPO3 v11.0. This functionality is integrated into ImageContentObject.', E_USER_DEPRECATED);
        $wrapArr = explode('|', $wrap);
        if (preg_match('/\\{([0-9]*)\\}/', $wrapArr[0], $reg)) {
            $uid = $this->‪getTypoScriptFrontendController()->tmpl->rootLine[$reg[1]]['uid'] ?? null;
            if ($uid) {
                $wrapArr[0] = str_replace($reg[0], $uid, $wrapArr[0]);
            }
        }
        return trim($wrapArr[0] ?? '') . $content . trim($wrapArr[1] ?? '');
    }
 
    public function ‪getAltParam($conf, $longDesc = true)
    {
        trigger_error('cObj->getAltParam() will be removed in TYPO3 v11.0. This functionality is integrated into ImageContentObject.', E_USER_DEPRECATED);
        $altText = isset($conf['altText.']) ? trim($this->‪stdWrap($conf['altText'], $conf['altText.'])) : trim($conf['altText']);
        $titleText = isset($conf['titleText.']) ? trim($this->‪stdWrap($conf['titleText'], $conf['titleText.'])) : trim($conf['titleText']);
        if (isset($conf['longdescURL.']) && $this->‪getTypoScriptFrontendController()->config['config']['doctype'] !== 'html5') {
            $longDescUrl = $this->‪typoLink_URL($conf['longdescURL.']);
        } else {
            $longDescUrl = trim($conf['longdescURL']);
        }
        $longDescUrl = strip_tags($longDescUrl);
 
        // "alt":
        $altParam = ' alt="' . htmlspecialchars($altText) . '"';
        // "title":
        $emptyTitleHandling = isset($conf['emptyTitleHandling.']) ? $this->‪stdWrap($conf['emptyTitleHandling'], $conf['emptyTitleHandling.']) : $conf['emptyTitleHandling'];
        // Choices: 'keepEmpty' | 'useAlt' | 'removeAttr'
        if ($titleText || $emptyTitleHandling === 'keepEmpty') {
            $altParam .= ' title="' . htmlspecialchars($titleText) . '"';
        } elseif (!$titleText && $emptyTitleHandling === 'useAlt') {
            $altParam .= ' title="' . htmlspecialchars($altText) . '"';
        }
        // "longDesc" URL
        if ($longDesc && !empty($longDescUrl)) {
            $altParam .= ' longdesc="' . htmlspecialchars($longDescUrl) . '"';
        }
        return $altParam;
    }
 
    public function ‪getATagParams($conf, $addGlobal = 1)
    {
        $aTagParams = '';
        if ($conf['ATagParams.'] ?? false) {
            $aTagParams = ' ' . $this->‪stdWrap($conf['ATagParams'], $conf['ATagParams.']);
        } elseif ($conf['ATagParams'] ?? false) {
            $aTagParams = ' ' . $conf['ATagParams'];
        }
        if ($addGlobal) {
            $aTagParams = ' ' . trim($this->‪getTypoScriptFrontendController()->ATagParams . $aTagParams);
        }
        // Extend params
        $_params = [
            'conf' => &$conf,
            'aTagParams' => &$aTagParams
        ];
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getATagParamsPostProc'] ?? [] as $className) {
            $processor = GeneralUtility::makeInstance($className);
            $aTagParams = $processor->process($_params, $this);
        }
 
        $aTagParams = trim($aTagParams);
        if (!empty($aTagParams)) {
            $aTagParams = ' ' . $aTagParams;
        }
 
        return $aTagParams;
    }
 
    public function ‪extLinkATagParams($URL, $TYPE)
    {
        $out = '';
        if (!empty(‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['extLinkATagParamsHandler'])) {
            trigger_error('The hook $TYPO3_CONF_VARS[SC_OPTIONS][tslib/class.tslib_content.php][extLinkATagParamsHandler] will be removed in TYPO3 v11.0. Use a custom LinkHandler instead.', E_USER_DEPRECATED);
            $extLinkATagParamsHandler = GeneralUtility::makeInstance(‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['extLinkATagParamsHandler']);
            if (method_exists($extLinkATagParamsHandler, 'main')) {
                $out .= trim($extLinkATagParamsHandler->main($URL, $TYPE, $this));
            }
        }
        return trim($out) ? ' ' . trim($out) : '';
    }
 
    /***********************************************
     *
     * HTML template processing functions
     *
     ***********************************************/
 
    public function ‪setCurrentFile($fileObject)
    {
        $this->currentFile = $fileObject;
    }
 
    public function ‪getCurrentFile()
    {
        return ‪$this->currentFile;
    }
 
    /***********************************************
     *
     * "stdWrap" + sub functions
     *
     ***********************************************/
    public function ‪stdWrap($content = '', $conf = [])
    {
        $content = (string)$content;
        // If there is any hook object, activate all of the process and override functions.
        // The hook interface ContentObjectStdWrapHookInterface takes care that all 4 methods exist.
        if ($this->stdWrapHookObjects) {
            $conf['stdWrapPreProcess'] = 1;
            $conf['stdWrapOverride'] = 1;
            $conf['stdWrapProcess'] = 1;
            $conf['stdWrapPostProcess'] = 1;
        }
 
        if (!is_array($conf) || !$conf) {
            return $content;
        }
 
        // Cache handling
        if (isset($conf['cache.']) && is_array($conf['cache.'])) {
            $conf['cache.']['key'] = $this->‪stdWrap($conf['cache.']['key'], $conf['cache.']['key.']);
            $conf['cache.']['tags'] = $this->‪stdWrap($conf['cache.']['tags'], $conf['cache.']['tags.']);
            $conf['cache.']['lifetime'] = $this->‪stdWrap($conf['cache.']['lifetime'], $conf['cache.']['lifetime.']);
            $conf['cacheRead'] = 1;
            $conf['cacheStore'] = 1;
        }
        // The configuration is sorted and filtered by intersection with the defined stdWrapOrder.
        $sortedConf = array_keys(array_intersect_key($this->stdWrapOrder, $conf));
        // Functions types that should not make use of nested stdWrap function calls to avoid conflicts with internal TypoScript used by these functions
        $stdWrapDisabledFunctionTypes = 'cObject,functionName,stdWrap';
        // Additional Array to check whether a function has already been executed
        $isExecuted = [];
        // Additional switch to make sure 'required', 'if' and 'fieldRequired'
        // will still stop rendering immediately in case they return FALSE
        $this->stdWrapRecursionLevel++;
        $this->stopRendering[‪$this->stdWrapRecursionLevel] = false;
        // execute each function in the predefined order
        foreach ($sortedConf as $stdWrapName) {
            // eliminate the second key of a pair 'key'|'key.' to make sure functions get called only once and check if rendering has been stopped
            if ((!isset($isExecuted[$stdWrapName]) || !$isExecuted[$stdWrapName]) && !$this->stopRendering[$this->stdWrapRecursionLevel]) {
                $functionName = rtrim($stdWrapName, '.');
                $functionProperties = $functionName . '.';
                $functionType = $this->stdWrapOrder[$functionName] ?? '';
                // If there is any code on the next level, check if it contains "official" stdWrap functions
                // if yes, execute them first - will make each function stdWrap aware
                // so additional stdWrap calls within the functions can be removed, since the result will be the same
                if (!empty($conf[$functionProperties]) && !GeneralUtility::inList($stdWrapDisabledFunctionTypes, $functionType)) {
                    if (array_intersect_key($this->stdWrapOrder, $conf[$functionProperties])) {
                        // Check if there's already content available before processing
                        // any ifEmpty or ifBlank stdWrap properties
                        if (($functionName === 'ifBlank' && $content !== '') ||
                            ($functionName === 'ifEmpty' && trim($content) !== '')) {
                            continue;
                        }
 
                        $conf[$functionName] = $this->‪stdWrap($conf[$functionName] ?? '', $conf[$functionProperties] ?? []);
                    }
                }
                // Check if key is still containing something, since it might have been changed by next level stdWrap before
                if ((isset($conf[$functionName]) || $conf[$functionProperties])
                    && ($functionType !== 'boolean' || $conf[$functionName])
                ) {
                    // Get just that part of $conf that is needed for the particular function
                    $singleConf = [
                        $functionName => $conf[$functionName] ?? null,
                        $functionProperties => $conf[$functionProperties] ?? null
                    ];
                    // Hand over the whole $conf array to the stdWrapHookObjects
                    if ($functionType === 'hook') {
                        $singleConf = $conf;
                    }
                    // Add both keys - with and without the dot - to the set of executed functions
                    $isExecuted[$functionName] = true;
                    $isExecuted[$functionProperties] = true;
                    // Call the function with the prefix stdWrap_ to make sure nobody can execute functions just by adding their name to the TS Array
                    $functionName = 'stdWrap_' . $functionName;
                    $content = $this->{$functionName}($content, $singleConf);
                } elseif ($functionType === 'boolean' && !$conf[$functionName]) {
                    $isExecuted[$functionName] = true;
                    $isExecuted[$functionProperties] = true;
                }
            }
        }
        unset($this->stopRendering[$this->stdWrapRecursionLevel]);
        $this->stdWrapRecursionLevel--;
 
        return $content;
    }
 
    public function ‪stdWrapValue($key, array $config, $defaultValue = '')
    {
        if (isset($config[$key])) {
            if (!isset($config[$key . '.'])) {
                return $config[$key];
            }
        } elseif (isset($config[$key . '.'])) {
            $config[$key] = '';
        } else {
            return $defaultValue;
        }
        $stdWrapped = $this->‪stdWrap($config[$key], $config[$key . '.']);
        return $stdWrapped ?: $defaultValue;
    }
 
    public function ‪stdWrap_stdWrapPreProcess($content = '', $conf = [])
    {
        foreach ($this->stdWrapHookObjects as $hookObject) {
            $content = $hookObject->stdWrapPreProcess($content, $conf, $this);
        }
        return $content;
    }
 
    public function ‪stdWrap_cacheRead($content = '', $conf = [])
    {
        if (!isset($conf['cache.'])) {
            return $content;
        }
        $result = $this->‪getFromCache($conf['cache.']);
        return $result === false ? $content : $result;
    }
 
    public function ‪stdWrap_addPageCacheTags($content = '', $conf = [])
    {
        $tags = isset($conf['addPageCacheTags.'])
            ? $this->‪stdWrap($conf['addPageCacheTags'], $conf['addPageCacheTags.'])
            : $conf['addPageCacheTags'];
        if (!empty($tags)) {
            $cacheTags = ‪GeneralUtility::trimExplode(',', $tags, true);
            $this->‪getTypoScriptFrontendController()->‪addCacheTags($cacheTags);
        }
        return $content;
    }
 
    public function ‪stdWrap_setContentToCurrent($content = '')
    {
        $this->data[‪$this->currentValKey] = $content;
        return $content;
    }
 
    public function ‪stdWrap_setCurrent($content = '', $conf = [])
    {
        $this->data[‪$this->currentValKey] = $conf['setCurrent'] ?? null;
        return $content;
    }
 
    public function ‪stdWrap_lang($content = '', $conf = [])
    {
        $currentLanguageCode = $this->‪getTypoScriptFrontendController()->‪getLanguage()->getTypo3Language();
        if (!$currentLanguageCode) {
            return $content;
        }
        if (isset($conf['lang.'][$currentLanguageCode])) {
            $content = $conf['lang.'][$currentLanguageCode];
        } else {
            // Check language dependencies
            ‪$locales = GeneralUtility::makeInstance(Locales::class);
            foreach (‪$locales->getLocaleDependencies($currentLanguageCode) as $languageCode) {
                if (isset($conf['lang.'][$languageCode])) {
                    $content = $conf['lang.'][$languageCode];
                    break;
                }
            }
        }
        return $content;
    }
 
    public function ‪stdWrap_data($content = '', $conf = [])
    {
        $content = $this->‪getData($conf['data'], is_array($this->alternativeData) ? $this->alternativeData : $this->data);
        // This must be unset directly after
        $this->alternativeData = '';
        return $content;
    }
 
    public function ‪stdWrap_field($content = '', $conf = [])
    {
        return $this->‪getFieldVal($conf['field']);
    }
 
    public function ‪stdWrap_current($content = '', $conf = [])
    {
        return $this->data[‪$this->currentValKey];
    }
 
    public function ‪stdWrap_cObject($content = '', $conf = [])
    {
        return $this->‪cObjGetSingle($conf['cObject'] ?? '', $conf['cObject.'] ?? [], '/stdWrap/.cObject');
    }
 
    public function ‪stdWrap_numRows($content = '', $conf = [])
    {
        return $this->‪numRows($conf['numRows.']);
    }
 
    public function ‪stdWrap_preUserFunc($content = '', $conf = [])
    {
        return $this->‪callUserFunction($conf['preUserFunc'], $conf['preUserFunc.'] ?? [], $content);
    }
 
    public function ‪stdWrap_stdWrapOverride($content = '', $conf = [])
    {
        foreach ($this->stdWrapHookObjects as $hookObject) {
            $content = $hookObject->stdWrapOverride($content, $conf, $this);
        }
        return $content;
    }
 
    public function ‪stdWrap_override($content = '', $conf = [])
    {
        if (trim($conf['override'] ?? false)) {
            $content = $conf['override'];
        }
        return $content;
    }
 
    public function ‪stdWrap_preIfEmptyListNum($content = '', $conf = [])
    {
        return $this->‪listNum($content, $conf['preIfEmptyListNum'] ?? null, $conf['preIfEmptyListNum.']['splitChar'] ?? null);
    }
 
    public function ‪stdWrap_ifNull($content = '', $conf = [])
    {
        return $content ?? $conf['ifNull'];
    }
 
    public function ‪stdWrap_ifEmpty($content = '', $conf = [])
    {
        if (!trim($content)) {
            $content = $conf['ifEmpty'];
        }
        return $content;
    }
 
    public function ‪stdWrap_ifBlank($content = '', $conf = [])
    {
        if (trim($content) === '') {
            $content = $conf['ifBlank'];
        }
        return $content;
    }
 
    public function ‪stdWrap_listNum($content = '', $conf = [])
    {
        return $this->‪listNum($content, $conf['listNum'] ?? null, $conf['listNum.']['splitChar'] ?? null);
    }
 
    public function ‪stdWrap_trim($content = '')
    {
        return trim($content);
    }
 
    public function ‪stdWrap_strPad($content = '', $conf = [])
    {
        // Must specify a length in conf for this to make sense
        $length = 0;
        // Padding with space is PHP-default
        $padWith = ' ';
        // Padding on the right side is PHP-default
        $padType = STR_PAD_RIGHT;
        if (!empty($conf['strPad.']['length'])) {
            $length = isset($conf['strPad.']['length.']) ? $this->‪stdWrap($conf['strPad.']['length'], $conf['strPad.']['length.']) : $conf['strPad.']['length'];
            $length = (int)$length;
        }
        if (isset($conf['strPad.']['padWith']) && (string)$conf['strPad.']['padWith'] !== '') {
            $padWith = isset($conf['strPad.']['padWith.']) ? $this->‪stdWrap($conf['strPad.']['padWith'], $conf['strPad.']['padWith.']) : $conf['strPad.']['padWith'];
        }
        if (!empty($conf['strPad.']['type'])) {
            $type = isset($conf['strPad.']['type.']) ? $this->‪stdWrap($conf['strPad.']['type'], $conf['strPad.']['type.']) : $conf['strPad.']['type'];
            if (strtolower($type) === 'left') {
                $padType = STR_PAD_LEFT;
            } elseif (strtolower($type) === 'both') {
                $padType = STR_PAD_BOTH;
            }
        }
        return ‪StringUtility::multibyteStringPad($content, $length, $padWith, $padType);
    }
 
    public function ‪stdWrap_stdWrap($content = '', $conf = [])
    {
        return $this->‪stdWrap($content, $conf['stdWrap.']);
    }
 
    public function ‪stdWrap_stdWrapProcess($content = '', $conf = [])
    {
        foreach ($this->stdWrapHookObjects as $hookObject) {
            $content = $hookObject->stdWrapProcess($content, $conf, $this);
        }
        return $content;
    }
 
    public function ‪stdWrap_required($content = '')
    {
        if ((string)$content === '') {
            $content = '';
            $this->stopRendering[‪$this->stdWrapRecursionLevel] = true;
        }
        return $content;
    }
 
    public function ‪stdWrap_if($content = '', $conf = [])
    {
        if (empty($conf['if.']) || $this->‪checkIf($conf['if.'])) {
            return $content;
        }
        $this->stopRendering[‪$this->stdWrapRecursionLevel] = true;
        return '';
    }
 
    public function ‪stdWrap_fieldRequired($content = '', $conf = [])
    {
        if (!trim($this->data[$conf['fieldRequired'] ?? null] ?? '')) {
            $content = '';
            $this->stopRendering[‪$this->stdWrapRecursionLevel] = true;
        }
        return $content;
    }
 
    public function ‪stdWrap_csConv($content = '', $conf = [])
    {
        if (!empty($conf['csConv'])) {
            ‪$output = mb_convert_encoding($content, 'utf-8', trim(strtolower($conf['csConv'])));
            return ‪$output !== false && ‪$output !== '' ? ‪$output : $content;
        }
        return $content;
    }
 
    public function ‪stdWrap_parseFunc($content = '', $conf = [])
    {
        return $this->‪parseFunc($content, $conf['parseFunc.'], $conf['parseFunc']);
    }
 
    public function ‪stdWrap_HTMLparser($content = '', $conf = [])
    {
        if (isset($conf['HTMLparser.']) && is_array($conf['HTMLparser.'])) {
            $content = $this->‪HTMLparser_TSbridge($content, $conf['HTMLparser.']);
        }
        return $content;
    }
 
    public function ‪stdWrap_split($content = '', $conf = [])
    {
        return $this->‪splitObj($content, $conf['split.']);
    }
 
    public function ‪stdWrap_replacement($content = '', $conf = [])
    {
        return $this->‪replacement($content, $conf['replacement.']);
    }
 
    public function ‪stdWrap_prioriCalc($content = '', $conf = [])
    {
        $content = ‪MathUtility::calculateWithParentheses($content);
        if (!empty($conf['prioriCalc']) && $conf['prioriCalc'] === 'intval') {
            $content = (int)$content;
        }
        return $content;
    }
 
    public function ‪stdWrap_char($content = '', $conf = [])
    {
        return chr((int)$conf['char']);
    }
 
    public function ‪stdWrap_intval($content = '')
    {
        return (int)$content;
    }
 
    public function ‪stdWrap_hash($content = '', array $conf = [])
    {
        $algorithm = isset($conf['hash.']) ? $this->‪stdWrap($conf['hash'], $conf['hash.']) : $conf['hash'];
        if (function_exists('hash') && in_array($algorithm, hash_algos())) {
            return hash($algorithm, $content);
        }
        // Non-existing hashing algorithm
        return '';
    }
 
    public function ‪stdWrap_round($content = '', $conf = [])
    {
        return $this->‪round($content, $conf['round.']);
    }
 
    public function ‪stdWrap_numberFormat($content = '', $conf = [])
    {
        return $this->‪numberFormat((float)$content, $conf['numberFormat.'] ?? []);
    }
 
    public function ‪stdWrap_expandList($content = '')
    {
        return GeneralUtility::expandList($content);
    }
 
    public function ‪stdWrap_date($content = '', $conf = [])
    {
        // Check for zero length string to mimic default case of date/gmdate.
        $content = (string)$content === '' ? ‪$GLOBALS['EXEC_TIME'] : (int)$content;
        $content = !empty($conf['date.']['GMT']) ? gmdate($conf['date'] ?? null, $content) : date($conf['date'] ?? null, $content);
        return $content;
    }
 
    public function ‪stdWrap_strftime($content = '', $conf = [])
    {
        // Check for zero length string to mimic default case of strtime/gmstrftime
        $content = (string)$content === '' ? ‪$GLOBALS['EXEC_TIME'] : (int)$content;
        $content = (isset($conf['strftime.']['GMT']) && $conf['strftime.']['GMT'])
            ? gmstrftime($conf['strftime'] ?? null, $content)
            : strftime($conf['strftime'] ?? null, $content);
        if (!empty($conf['strftime.']['charset'])) {
            ‪$output = mb_convert_encoding($content, 'utf-8', trim(strtolower($conf['strftime.']['charset'])));
            return ‪$output ?: $content;
        }
        return $content;
    }
 
    public function ‪stdWrap_strtotime($content = '', $conf = [])
    {
        if ($conf['strtotime'] !== '1') {
            $content .= ' ' . $conf['strtotime'];
        }
        return strtotime($content, ‪$GLOBALS['EXEC_TIME']);
    }
 
    public function ‪stdWrap_age($content = '', $conf = [])
    {
        return $this->‪calcAge((int)(‪$GLOBALS['EXEC_TIME'] ?? 0) - (int)$content, $conf['age'] ?? null);
    }
 
    public function ‪stdWrap_case($content = '', $conf = [])
    {
        return $this->‪HTMLcaseshift($content, $conf['case']);
    }
 
    public function ‪stdWrap_bytes($content = '', $conf = [])
    {
        return GeneralUtility::formatSize((int)$content, $conf['bytes.']['labels'], $conf['bytes.']['base']);
    }
 
    public function ‪stdWrap_substring($content = '', $conf = [])
    {
        return $this->‪substring($content, $conf['substring']);
    }
 
    public function ‪stdWrap_cropHTML($content = '', $conf = [])
    {
        return $this->‪cropHTML($content, $conf['cropHTML'] ?? '');
    }
 
    public function ‪stdWrap_stripHtml($content = '')
    {
        return strip_tags($content);
    }
 
    public function ‪stdWrap_crop($content = '', $conf = [])
    {
        return $this->‪crop($content, $conf['crop']);
    }
 
    public function ‪stdWrap_rawUrlEncode($content = '')
    {
        return rawurlencode($content);
    }
 
    public function ‪stdWrap_htmlSpecialChars($content = '', $conf = [])
    {
        if (!empty($conf['htmlSpecialChars.']['preserveEntities'])) {
            $content = htmlspecialchars($content, ENT_COMPAT, 'UTF-8', false);
        } else {
            $content = htmlspecialchars($content);
        }
        return $content;
    }
 
    public function ‪stdWrap_encodeForJavaScriptValue($content = '')
    {
        return GeneralUtility::quoteJSvalue($content);
    }
 
    public function ‪stdWrap_doubleBrTag($content = '', $conf = [])
    {
        return preg_replace('/\R{1,2}[\t\x20]*\R{1,2}/', $conf['doubleBrTag'] ?? null, $content);
    }
 
    public function ‪stdWrap_br($content = '')
    {
        return nl2br($content, !empty($this->‪getTypoScriptFrontendController()->xhtmlDoctype));
    }
 
    public function ‪stdWrap_brTag($content = '', $conf = [])
    {
        return str_replace(LF, $conf['brTag'] ?? null, $content);
    }
 
    public function ‪stdWrap_encapsLines($content = '', $conf = [])
    {
        return $this->‪encaps_lineSplit($content, $conf['encapsLines.']);
    }
 
    public function ‪stdWrap_keywords($content = '')
    {
        return $this->‪keywords($content);
    }
 
    public function ‪stdWrap_innerWrap($content = '', $conf = [])
    {
        return $this->‪wrap($content, $conf['innerWrap'] ?? null);
    }
 
    public function ‪stdWrap_innerWrap2($content = '', $conf = [])
    {
        return $this->‪wrap($content, $conf['innerWrap2'] ?? null);
    }
 
    public function ‪stdWrap_preCObject($content = '', $conf = [])
    {
        return $this->‪cObjGetSingle($conf['preCObject'], $conf['preCObject.'], '/stdWrap/.preCObject') . $content;
    }
 
    public function ‪stdWrap_postCObject($content = '', $conf = [])
    {
        return $content . $this->‪cObjGetSingle($conf['postCObject'], $conf['postCObject.'], '/stdWrap/.postCObject');
    }
 
    public function ‪stdWrap_wrapAlign($content = '', $conf = [])
    {
        $wrapAlign = trim($conf['wrapAlign'] ?? '');
        if ($wrapAlign) {
            $content = $this->‪wrap($content, '<div style="text-align:' . htmlspecialchars($wrapAlign) . ';">|</div>');
        }
        return $content;
    }
 
    public function ‪stdWrap_typolink($content = '', $conf = [])
    {
        return $this->‪typoLink($content, $conf['typolink.']);
    }
 
    public function ‪stdWrap_wrap($content = '', $conf = [])
    {
        return $this->‪wrap(
            $content,
            $conf['wrap'] ?? null,
            $conf['wrap.']['splitChar'] ?? '|'
        );
    }
 
    public function ‪stdWrap_noTrimWrap($content = '', $conf = [])
    {
        $splitChar = isset($conf['noTrimWrap.']['splitChar.'])
            ? $this->‪stdWrap($conf['noTrimWrap.']['splitChar'] ?? '', $conf['noTrimWrap.']['splitChar.'])
            : $conf['noTrimWrap.']['splitChar'] ?? '';
        if ($splitChar === null || $splitChar === '') {
            $splitChar = '|';
        }
        $content = $this->‪noTrimWrap(
            $content,
            $conf['noTrimWrap'],
            $splitChar
        );
        return $content;
    }
 
    public function ‪stdWrap_wrap2($content = '', $conf = [])
    {
        return $this->‪wrap(
            $content,
            $conf['wrap2'] ?? null,
            $conf['wrap2.']['splitChar'] ?? '|'
        );
    }
 
    public function ‪stdWrap_dataWrap($content = '', $conf = [])
    {
        return $this->‪dataWrap($content, $conf['dataWrap']);
    }
 
    public function ‪stdWrap_prepend($content = '', $conf = [])
    {
        return $this->‪cObjGetSingle($conf['prepend'], $conf['prepend.'], '/stdWrap/.prepend') . $content;
    }
 
    public function ‪stdWrap_append($content = '', $conf = [])
    {
        return $content . $this->‪cObjGetSingle($conf['append'], $conf['append.'], '/stdWrap/.append');
    }
 
    public function ‪stdWrap_wrap3($content = '', $conf = [])
    {
        return $this->‪wrap(
            $content,
            $conf['wrap3'] ?? null,
            $conf['wrap3.']['splitChar'] ?? '|'
        );
    }
 
    public function ‪stdWrap_orderedStdWrap($content = '', $conf = [])
    {
        $sortedKeysArray = ‪ArrayUtility::filterAndSortByNumericKeys($conf['orderedStdWrap.'], true);
        foreach ($sortedKeysArray as $key) {
            $content = $this->‪stdWrap($content, $conf['orderedStdWrap.'][$key . '.'] ?? null);
        }
        return $content;
    }
 
    public function ‪stdWrap_outerWrap($content = '', $conf = [])
    {
        return $this->‪wrap($content, $conf['outerWrap'] ?? null);
    }
 
    public function ‪stdWrap_insertData($content = '')
    {
        return $this->‪insertData($content);
    }
 
    public function ‪stdWrap_postUserFunc($content = '', $conf = [])
    {
        return $this->‪callUserFunction($conf['postUserFunc'], $conf['postUserFunc.'] ?? [], $content);
    }
 
    public function ‪stdWrap_postUserFuncInt($content = '', $conf = [])
    {
        $substKey = 'INT_SCRIPT.' . $this->‪getTypoScriptFrontendController()->‪uniqueHash();
        $this->‪getTypoScriptFrontendController()->config['INTincScript'][$substKey] = [
            'content' => $content,
            'postUserFunc' => $conf['postUserFuncInt'],
            'conf' => $conf['postUserFuncInt.'],
            'type' => 'POSTUSERFUNC',
            'cObj' => serialize($this)
        ];
        $content = '<!--' . $substKey . '-->';
        return $content;
    }
 
    public function ‪stdWrap_prefixComment($content = '', $conf = [])
    {
        if (
            (!isset($this->‪getTypoScriptFrontendController()->config['config']['disablePrefixComment']) || !$this->‪getTypoScriptFrontendController()->config['config']['disablePrefixComment'])
            && !empty($conf['prefixComment'])
        ) {
            $content = $this->‪prefixComment($conf['prefixComment'], [], $content);
        }
        return $content;
    }
 
    public function ‪stdWrap_editIcons($content = '', $conf = [])
    {
        if ($this->‪getTypoScriptFrontendController()->isBackendUserLoggedIn() && $conf['editIcons']) {
            if (!isset($conf['editIcons.']) || !is_array($conf['editIcons.'])) {
                $conf['editIcons.'] = [];
            }
            $content = $this->‪editIcons($content, $conf['editIcons'], $conf['editIcons.']);
        }
        return $content;
    }
 
    public function ‪stdWrap_editPanel($content = '', $conf = [])
    {
        if ($this->‪getTypoScriptFrontendController()->isBackendUserLoggedIn()) {
            $content = $this->‪editPanel($content, $conf['editPanel.']);
        }
        return $content;
    }
 
    public function ‪stdWrap_htmlSanitize(string $content = '', array $conf = []): string
    {
        $build = $conf['build'] ?? 'default';
        if (class_exists($build) && is_a($build, BuilderInterface::class, true)) {
            $builder = GeneralUtility::makeInstance($build);
        } else {
            $factory = GeneralUtility::makeInstance(SanitizerBuilderFactory::class);
            $builder = $factory->build($build);
        }
        $sanitizer = $builder->build();
        $initiator = $this->‪shallDebug()
            ? GeneralUtility::makeInstance(SanitizerInitiator::class, ‪DebugUtility::debugTrail())
            : null;
        return $sanitizer->sanitize($content, $initiator);
    }
 
    public function ‪stdWrap_cacheStore($content = '', $conf = [])
    {
        if (!isset($conf['cache.'])) {
            return $content;
        }
        $key = $this->‪calculateCacheKey($conf['cache.']);
        if (empty($key)) {
            return $content;
        }
        $cacheFrontend = GeneralUtility::makeInstance(CacheManager::class)->getCache('hash');
        $tags = $this->‪calculateCacheTags($conf['cache.']);
        $lifetime = $this->‪calculateCacheLifetime($conf['cache.']);
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['stdWrap_cacheStore'] ?? [] as $_funcRef) {
            $params = [
                'key' => $key,
                'content' => $content,
                'lifetime' => $lifetime,
                'tags' => $tags
            ];
            $ref = $this; // introduced for phpstan to not lose type information when passing $this into callUserFunction
            GeneralUtility::callUserFunction($_funcRef, $params, $ref);
        }
        $cacheFrontend->set($key, $content, $tags, $lifetime);
        return $content;
    }
 
    public function ‪stdWrap_stdWrapPostProcess($content = '', $conf = [])
    {
        foreach ($this->stdWrapHookObjects as $hookObject) {
            $content = $hookObject->stdWrapPostProcess($content, $conf, $this);
        }
        return $content;
    }
 
    public function ‪stdWrap_debug($content = '')
    {
        return '<pre>' . htmlspecialchars($content) . '</pre>';
    }
 
    public function ‪stdWrap_debugFunc($content = '', $conf = [])
    {
        ‪debug((int)$conf['debugFunc'] === 2 ? [$content] : $content);
        return $content;
    }
 
    public function ‪stdWrap_debugData($content = '')
    {
        ‪debug($this->data, '$cObj->data:');
        if (is_array($this->alternativeData)) {
            ‪debug($this->alternativeData, '$this->alternativeData');
        }
        return $content;
    }
 
    public function ‪numRows($conf)
    {
        $conf['select.']['selectFields'] = 'count(*)';
        $statement = $this->‪exec_getQuery($conf['table'], $conf['select.']);
 
        return (int)$statement->fetchColumn(0);
    }
 
    public function ‪listNum($content, $listNum, $char)
    {
        $char = $char ?: ',';
        if (‪MathUtility::canBeInterpretedAsInteger($char)) {
            $char = chr((int)$char);
        }
        $temp = explode($char, $content);
        if (empty($temp)) {
            return '';
        }
        $last = '' . (count($temp) - 1);
        // Take a random item if requested
        if ($listNum === 'rand') {
            $listNum = (string)random_int(0, count($temp) - 1);
        }
        $index = $this->‪calc(str_ireplace('last', $last, $listNum));
        return $temp[$index];
    }
 
    public function ‪checkIf($conf)
    {
        if (!is_array($conf)) {
            return true;
        }
        if (isset($conf['directReturn'])) {
            return (bool)$conf['directReturn'];
        }
        $flag = true;
        if (isset($conf['isNull.'])) {
            $isNull = $this->‪stdWrap('', $conf['isNull.']);
            if ($isNull !== null) {
                $flag = false;
            }
        }
        if (isset($conf['isTrue']) || isset($conf['isTrue.'])) {
            $isTrue = isset($conf['isTrue.']) ? trim($this->‪stdWrap($conf['isTrue'], $conf['isTrue.'])) : trim($conf['isTrue']);
            if (!$isTrue) {
                $flag = false;
            }
        }
        if (isset($conf['isFalse']) || isset($conf['isFalse.'])) {
            $isFalse = isset($conf['isFalse.']) ? trim($this->‪stdWrap($conf['isFalse'], $conf['isFalse.'])) : trim($conf['isFalse']);
            if ($isFalse) {
                $flag = false;
            }
        }
        if (isset($conf['isPositive']) || isset($conf['isPositive.'])) {
            $number = isset($conf['isPositive.']) ? $this->‪calc($this->‪stdWrap($conf['isPositive'], $conf['isPositive.'])) : $this->‪calc($conf['isPositive']);
            if ($number < 1) {
                $flag = false;
            }
        }
        if ($flag) {
            $value = isset($conf['value.'])
                ? trim($this->‪stdWrap($conf['value'] ?? '', $conf['value.']))
                : trim($conf['value'] ?? '');
            if (isset($conf['isGreaterThan']) || isset($conf['isGreaterThan.'])) {
                $number = isset($conf['isGreaterThan.']) ? trim($this->‪stdWrap($conf['isGreaterThan'], $conf['isGreaterThan.'])) : trim($conf['isGreaterThan']);
                if ($number <= $value) {
                    $flag = false;
                }
            }
            if (isset($conf['isLessThan']) || isset($conf['isLessThan.'])) {
                $number = isset($conf['isLessThan.']) ? trim($this->‪stdWrap($conf['isLessThan'], $conf['isLessThan.'])) : trim($conf['isLessThan']);
                if ($number >= $value) {
                    $flag = false;
                }
            }
            if (isset($conf['equals']) || isset($conf['equals.'])) {
                $number = isset($conf['equals.']) ? trim($this->‪stdWrap($conf['equals'], $conf['equals.'])) : trim($conf['equals']);
                if ($number != $value) {
                    $flag = false;
                }
            }
            if (isset($conf['isInList']) || isset($conf['isInList.'])) {
                $number = isset($conf['isInList.']) ? trim($this->‪stdWrap($conf['isInList'], $conf['isInList.'])) : trim($conf['isInList']);
                if (!GeneralUtility::inList($value, $number)) {
                    $flag = false;
                }
            }
            if (isset($conf['bitAnd']) || isset($conf['bitAnd.'])) {
                $number = (int)(isset($conf['bitAnd.']) ? trim($this->‪stdWrap($conf['bitAnd'], $conf['bitAnd.'])) : trim($conf['bitAnd']));
                if ((new BitSet($number))->get($value) === false) {
                    $flag = false;
                }
            }
        }
        if ($conf['negate'] ?? false) {
            $flag = !$flag;
        }
        return $flag;
    }
 
    public function ‪HTMLparser_TSbridge($theValue, $conf)
    {
        $htmlParser = GeneralUtility::makeInstance(HtmlParser::class);
        $htmlParserCfg = $htmlParser->HTMLparserConfig($conf);
        return $htmlParser->HTMLcleaner($theValue, $htmlParserCfg[0], $htmlParserCfg[1], $htmlParserCfg[2], $htmlParserCfg[3]);
    }
 
    public function ‪dataWrap($content, $wrap)
    {
        return $this->‪wrap($content, $this->‪insertData($wrap));
    }
 
    public function ‪insertData($str)
    {
        $inside = 0;
        $newVal = '';
        $pointer = 0;
        $totalLen = strlen($str);
        do {
            if (!$inside) {
                $len = strcspn(substr($str, $pointer), '{');
                $newVal .= substr($str, $pointer, $len);
                $inside = true;
                if (substr($str, $pointer + $len + 1, 1) === '#') {
                    $len2 = strcspn(substr($str, $pointer + $len), '}');
                    $newVal .= substr($str, $pointer + $len, $len2);
                    $len += $len2;
                    $inside = false;
                }
            } else {
                $len = strcspn(substr($str, $pointer), '}') + 1;
                $newVal .= $this->‪getData(substr($str, $pointer + 1, $len - 2), $this->data);
                $inside = false;
            }
            $pointer += $len;
        } while ($pointer < $totalLen);
        return $newVal;
    }
 
    public function ‪prefixComment($str, $conf, $content)
    {
        if (empty($str)) {
            return $content;
        }
        $parts = explode('|', $str);
        $indent = (int)$parts[0];
        $comment = htmlspecialchars($this->‪insertData($parts[1]));
        ‪$output = LF
            . str_pad('', $indent, "\t") . '<!-- ' . $comment . ' [begin] -->' . LF
            . str_pad('', $indent + 1, "\t") . $content . LF
            . str_pad('', $indent, "\t") . '<!-- ' . $comment . ' [end] -->' . LF
            . str_pad('', $indent + 1, "\t");
        return ‪$output;
    }
 
    public function ‪substring($content, $options)
    {
        $options = ‪GeneralUtility::intExplode(',', $options . ',');
        if ($options[1]) {
            return mb_substr($content, $options[0], $options[1], 'utf-8');
        }
        return mb_substr($content, $options[0], null, 'utf-8');
    }
 
    public function ‪crop($content, $options)
    {
        $options = explode('|', $options);
        $chars = (int)$options[0];
        $afterstring = trim($options[1] ?? '');
        $crop2space = trim($options[2] ?? '');
        if ($chars) {
            if (mb_strlen($content, 'utf-8') > abs($chars)) {
                $truncatePosition = false;
                if ($chars < 0) {
                    $content = mb_substr($content, $chars, null, 'utf-8');
                    if ($crop2space) {
                        $truncatePosition = strpos($content, ' ');
                    }
                    $content = $truncatePosition ? $afterstring . substr($content, $truncatePosition) : $afterstring . $content;
                } else {
                    $content = mb_substr($content, 0, $chars, 'utf-8');
                    if ($crop2space) {
                        $truncatePosition = strrpos($content, ' ');
                    }
                    $content = $truncatePosition ? substr($content, 0, $truncatePosition) . $afterstring : $content . $afterstring;
                }
            }
        }
        return $content;
    }
 
    public function ‪cropHTML($content, $options)
    {
        $options = explode('|', $options);
        $chars = (int)$options[0];
        $absChars = abs($chars);
        $replacementForEllipsis = trim($options[1] ?? '');
        $crop2space = trim($options[2] ?? '') === '1';
        // Split $content into an array(even items in the array are outside the tags, odd numbers are tag-blocks).
        $tags = 'a|abbr|address|area|article|aside|audio|b|bdi|bdo|blockquote|body|br|button|caption|cite|code|col|colgroup|data|datalist|dd|del|dfn|div|dl|dt|em|embed|fieldset|figcaption|figure|font|footer|form|h1|h2|h3|h4|h5|h6|header|hr|i|iframe|img|input|ins|kbd|keygen|label|legend|li|link|main|map|mark|meter|nav|object|ol|optgroup|option|output|p|param|pre|progress|q|rb|rp|rt|rtc|ruby|s|samp|section|select|small|source|span|strong|sub|sup|table|tbody|td|textarea|tfoot|th|thead|time|tr|track|u|ul|ut|var|video|wbr';
        $tagsRegEx = '
            (
                (?:
                    <!--.*?-->                  # a comment
                    |
                    <canvas[^>]*>.*?</canvas>   # a canvas tag
                    |
                    <script[^>]*>.*?</script>   # a script tag
                    |
                    <noscript[^>]*>.*?</noscript> # a noscript tag
                    |
                    <template[^>]*>.*?</template> # a template tag
                )
                |
                </?(?:' . $tags . ')+           # opening tag (\'<tag\') or closing tag (\'</tag\')
                (?:
                    (?:
                        (?:
                            \\s+\\w[\\w-]*      # EITHER spaces, followed by attribute names
                            (?:
                                \\s*=?\\s*      # equals
                                (?>
                                    ".*?"       # attribute values in double-quotes
                                    |
                                    \'.*?\'     # attribute values in single-quotes
                                    |
                                    [^\'">\\s]+ # plain attribute values
                                )
                            )?
                        )
                        |                       # OR a single dash (for TYPO3 link tag)
                        (?:
                            \\s+-
                        )
                    )+\\s*
                    |                           # OR only spaces
                    \\s*
                )
                /?>                             # closing the tag with \'>\' or \'/>\'
            )';
        $splittedContent = preg_split('%' . $tagsRegEx . '%xs', $content, -1, PREG_SPLIT_DELIM_CAPTURE);
        if ($splittedContent === false) {
            $this->logger->debug('Unable to split "' . $content . '" into tags.');
            $splittedContent = [];
        }
        // Reverse array if we are cropping from right.
        if ($chars < 0) {
            $splittedContent = array_reverse($splittedContent);
        }
        // Crop the text (chars of tag-blocks are not counted).
        $strLen = 0;
        // This is the offset of the content item which was cropped.
        $croppedOffset = null;
        $countSplittedContent = count($splittedContent);
        // @todo $maxCroppingLength of 962 was determined by hand as the highest
        //       value to not lead to internal error (Compilation failed: regular
        //       expression is too large ). Still questionable if we really can
        //       rely on a fixed value here, or better to say need to be understood
        //       why the value has to be this value to avoid regular expression
        //       compilation error.
        $maxCroppingLength = 962;
        for ($offset = 0; $offset < $countSplittedContent; $offset++) {
            if ($offset % 2 === 0) {
                $fullTempContent = $splittedContent[$offset];
                $thisStrLen = mb_strlen(html_entity_decode($fullTempContent, ENT_COMPAT, 'UTF-8'), 'utf-8');
                if ($strLen + $thisStrLen > $absChars) {
                    $tempProcessedContent = '';
                    $croppedOffset = $offset;
                    $cropPosition = $absChars - $strLen;
                    $cropEnd = ($cropPosition > $maxCroppingLength) ? $maxCroppingLength : $cropPosition;
                    $processed = 0;
                    // we need to crop in multiple steps to avoid regexp length compilation errors
                    do {
                        // remove already processed string part
                        $tempContent = mb_substr($fullTempContent, mb_strlen($tempProcessedContent));
                        $patternMatchEntityAsSingleChar = '(&[^&\\s;]{2,8};|.)';
                        $cropRegEx = $chars < 0 ? '#' . $patternMatchEntityAsSingleChar . '{0,' . ($cropEnd + 1) . '}$#uis' : '#^' . $patternMatchEntityAsSingleChar . '{0,' . ($cropEnd + 1) . '}#uis';
                        if (preg_match($cropRegEx, $tempContent, $croppedMatch)) {
                            $tempContentPlusOneCharacter = $croppedMatch[0];
                        } else {
                            $tempContentPlusOneCharacter = false;
                        }
                        $cropRegEx = $chars < 0 ? '#' . $patternMatchEntityAsSingleChar . '{0,' . $cropEnd . '}$#uis' : '#^' . $patternMatchEntityAsSingleChar . '{0,' . $cropEnd . '}#uis';
                        if (preg_match($cropRegEx, $tempContent, $croppedMatch)) {
                            $tempContent = $croppedMatch[0];
                            if ($crop2space && $tempContentPlusOneCharacter !== false) {
                                $cropRegEx = $chars < 0 ? '#(?<=\\s)' . $patternMatchEntityAsSingleChar . '{0,' . $cropEnd . '}$#uis' : '#^' . $patternMatchEntityAsSingleChar . '{0,' . $cropEnd . '}(?=\\s)#uis';
                                if (preg_match($cropRegEx, $tempContentPlusOneCharacter, $croppedMatch)) {
                                    $tempContent = $croppedMatch[0];
                                }
                            }
                        }
                        $tempProcessedContent .= $tempContent;
                        $processed += $cropEnd;
                        $cropEnd = ($processed + $maxCroppingLength > $cropPosition ? ($cropPosition - $processed) : $maxCroppingLength);
                    } while ($cropEnd > 0 && $cropEnd < $cropPosition);
                    $splittedContent[$offset] = $tempProcessedContent;
                    break;
                }
                $strLen += $thisStrLen;
            }
        }
        // Close cropped tags.
        $closingTags = [];
        if ($croppedOffset !== null) {
            $openingTagRegEx = '#^<(\\w+)(?:\\s|>)#';
            $closingTagRegEx = '#^</(\\w+)(?:\\s|>)#';
            for ($offset = $croppedOffset - 1; $offset >= 0; $offset = $offset - 2) {
                if (substr($splittedContent[$offset], -2) === '/>') {
                    // Ignore empty element tags (e.g. <br />).
                    continue;
                }
                preg_match($chars < 0 ? $closingTagRegEx : $openingTagRegEx, $splittedContent[$offset], $matches);
                $tagName = $matches[1] ?? null;
                if ($tagName !== null) {
                    // Seek for the closing (or opening) tag.
                    $countSplittedContent = count($splittedContent);
                    for ($seekingOffset = $offset + 2; $seekingOffset < $countSplittedContent; $seekingOffset = $seekingOffset + 2) {
                        preg_match($chars < 0 ? $openingTagRegEx : $closingTagRegEx, $splittedContent[$seekingOffset], $matches);
                        $seekingTagName = $matches[1] ?? null;
                        if ($tagName === $seekingTagName) {
                            // We found a matching tag.
                            // Add closing tag only if it occurs after the cropped content item.
                            if ($seekingOffset > $croppedOffset) {
                                $closingTags[] = $splittedContent[$seekingOffset];
                            }
                            break;
                        }
                    }
                }
            }
            // Drop the cropped items of the content array. The $closingTags will be added later on again.
            array_splice($splittedContent, $croppedOffset + 1);
        }
        $splittedContent = array_merge($splittedContent, [
            $croppedOffset !== null ? $replacementForEllipsis : ''
        ], $closingTags);
        // Reverse array once again if we are cropping from the end.
        if ($chars < 0) {
            $splittedContent = array_reverse($splittedContent);
        }
        return implode('', $splittedContent);
    }
 
    public function ‪calc($val)
    {
        $parts = GeneralUtility::splitCalc($val, '+-*/');
        $value = 0;
        foreach ($parts as $part) {
            $theVal = $part[1];
            $sign = $part[0];
            if ((string)(int)$theVal === (string)$theVal) {
                $theVal = (int)$theVal;
            } else {
                $theVal = 0;
            }
            if ($sign === '-') {
                $value -= $theVal;
            }
            if ($sign === '+') {
                $value += $theVal;
            }
            if ($sign === '/') {
                if ((int)$theVal) {
                    $value /= (int)$theVal;
                }
            }
            if ($sign === '*') {
                $value *= $theVal;
            }
        }
        return $value;
    }
 
    public function ‪splitObj($value, $conf)
    {
        $conf['token'] = isset($conf['token.']) ? $this->‪stdWrap($conf['token'], $conf['token.']) : $conf['token'];
        if ($conf['token'] === '') {
            return $value;
        }
        $valArr = explode($conf['token'], $value);
 
        // return value directly by returnKey. No further processing
        if (!empty($valArr) && (‪MathUtility::canBeInterpretedAsInteger($conf['returnKey'] ?? null) || ($conf['returnKey.'] ?? false))
        ) {
            $key = isset($conf['returnKey.']) ? (int)$this->‪stdWrap($conf['returnKey'], $conf['returnKey.']) : (int)$conf['returnKey'];
            return $valArr[$key] ?? '';
        }
 
        // return the amount of elements. No further processing
        if (!empty($valArr) && ($conf['returnCount'] || $conf['returnCount.'])) {
            $returnCount = isset($conf['returnCount.']) ? (bool)$this->‪stdWrap($conf['returnCount'], $conf['returnCount.']) : (bool)$conf['returnCount'];
            return $returnCount ? count($valArr) : 0;
        }
 
        // calculate splitCount
        $splitCount = count($valArr);
        $max = isset($conf['max.']) ? (int)$this->‪stdWrap($conf['max'], $conf['max.']) : (int)$conf['max'];
        if ($max && $splitCount > $max) {
            $splitCount = $max;
        }
        $min = isset($conf['min.']) ? (int)$this->‪stdWrap($conf['min'], $conf['min.']) : (int)$conf['min'];
        if ($min && $splitCount < $min) {
            $splitCount = $min;
        }
        $wrap = isset($conf['wrap.']) ? (string)$this->‪stdWrap($conf['wrap'], $conf['wrap.']) : (string)$conf['wrap'];
        $cObjNumSplitConf = isset($conf['cObjNum.']) ? (string)$this->‪stdWrap($conf['cObjNum'], $conf['cObjNum.']) : (string)$conf['cObjNum'];
        $splitArr = [];
        if ($wrap !== '' || $cObjNumSplitConf !== '') {
            $splitArr['wrap'] = $wrap;
            $splitArr['cObjNum'] = $cObjNumSplitConf;
            $splitArr = GeneralUtility::makeInstance(TypoScriptService::class)
                ->explodeConfigurationForOptionSplit($splitArr, $splitCount);
        }
        $content = '';
        for ($a = 0; $a < $splitCount; $a++) {
            $this->‪getTypoScriptFrontendController()->register['SPLIT_COUNT'] = $a;
            $value = '' . $valArr[$a];
            $this->data[‪$this->currentValKey] = $value;
            if ($splitArr[$a]['cObjNum']) {
                $objName = (int)$splitArr[$a]['cObjNum'];
                $value = isset($conf[$objName . '.'])
                    ? $this->‪stdWrap($this->‪cObjGet($conf[$objName . '.'], $objName . '.'), $conf[$objName . '.'])
                    : $this->‪cObjGet($conf[$objName . '.'], $objName . '.');
            }
            $wrap = isset($splitArr[$a]['wrap.']) ? $this->‪stdWrap($splitArr[$a]['wrap'], $splitArr[$a]['wrap.']) : $splitArr[$a]['wrap'];
            if ($wrap) {
                $value = $this->‪wrap($value, $wrap);
            }
            $content .= $value;
        }
        return $content;
    }
 
    protected function ‪replacement($content, array $configuration)
    {
        // Sorts actions in configuration by numeric index
        ksort($configuration, SORT_NUMERIC);
        foreach ($configuration as $index => $action) {
            // Checks whether we have a valid action and a numeric key ending with a dot ("10.")
            if (is_array($action) && substr($index, -1) === '.' && ‪MathUtility::canBeInterpretedAsInteger(substr($index, 0, -1))) {
                $content = $this->‪replacementSingle($content, $action);
            }
        }
        return $content;
    }
 
    protected function ‪replacementSingle($content, array $configuration)
    {
        if ((isset($configuration['search']) || isset($configuration['search.'])) && (isset($configuration['replace']) || isset($configuration['replace.']))) {
            // Gets the strings
            $search = isset($configuration['search.']) ? $this->‪stdWrap($configuration['search'], $configuration['search.']) : $configuration['search'];
            $replace = isset($configuration['replace.'])
                ? $this->‪stdWrap($configuration['replace'] ?? null, $configuration['replace.'])
                : $configuration['replace'] ?? null;
            $useRegularExpression = false;
            // Determines whether regular expression shall be used
            if (isset($configuration['useRegExp'])
                || (isset($configuration['useRegExp.']) && $configuration['useRegExp.'])
            ) {
                $useRegularExpression = isset($configuration['useRegExp.']) ? (bool)$this->‪stdWrap($configuration['useRegExp'], $configuration['useRegExp.']) : (bool)$configuration['useRegExp'];
            }
            $useOptionSplitReplace = false;
            // Determines whether replace-pattern uses option-split
            if (isset($configuration['useOptionSplitReplace']) || isset($configuration['useOptionSplitReplace.'])) {
                $useOptionSplitReplace = isset($configuration['useOptionSplitReplace.']) ? (bool)$this->‪stdWrap($configuration['useOptionSplitReplace'], $configuration['useOptionSplitReplace.']) : (bool)$configuration['useOptionSplitReplace'];
            }
 
            // Performs a replacement by preg_replace()
            if ($useRegularExpression) {
                // Get separator-character which precedes the string and separates search-string from the modifiers
                $separator = $search[0];
                $startModifiers = strrpos($search, $separator);
                if ($separator !== false && $startModifiers > 0) {
                    $modifiers = substr($search, $startModifiers + 1);
                    // remove "e" (eval-modifier), which would otherwise allow to run arbitrary PHP-code
                    $modifiers = str_replace('e', '', $modifiers);
                    $search = substr($search, 0, $startModifiers + 1) . $modifiers;
                }
                if ($useOptionSplitReplace) {
                    // init for replacement
                    $splitCount = preg_match_all($search, $content, $matches);
                    $typoScriptService = GeneralUtility::makeInstance(TypoScriptService::class);
                    $replaceArray = $typoScriptService->explodeConfigurationForOptionSplit([$replace], $splitCount);
                    $replaceCount = 0;
 
                    $replaceCallback = function ($match) use ($replaceArray, $search, &$replaceCount) {
                        $replaceCount++;
                        return preg_replace($search, $replaceArray[$replaceCount - 1][0], $match[0]);
                    };
                    $content = preg_replace_callback($search, $replaceCallback, $content);
                } else {
                    $content = preg_replace($search, $replace, $content);
                }
            } elseif ($useOptionSplitReplace) {
                // turn search-string into a preg-pattern
                $searchPreg = '#' . preg_quote($search, '#') . '#';
 
                // init for replacement
                $splitCount = preg_match_all($searchPreg, $content, $matches);
                $typoScriptService = GeneralUtility::makeInstance(TypoScriptService::class);
                $replaceArray = $typoScriptService->explodeConfigurationForOptionSplit([$replace], $splitCount);
                $replaceCount = 0;
 
                $replaceCallback = function () use ($replaceArray, &$replaceCount) {
                    $replaceCount++;
                    return $replaceArray[$replaceCount - 1][0];
                };
                $content = preg_replace_callback($searchPreg, $replaceCallback, $content);
            } else {
                $content = str_replace($search, $replace, $content);
            }
        }
        return $content;
    }
 
    protected function ‪round($content, array $conf = [])
    {
        $decimals = isset($conf['decimals.'])
            ? $this->‪stdWrap($conf['decimals'] ?? '', $conf['decimals.'])
            : ($conf['decimals'] ?? null);
        $type = isset($conf['roundType.'])
            ? $this->‪stdWrap($conf['roundType'] ?? '', $conf['roundType.'])
            : ($conf['roundType'] ?? null);
        $floatVal = (float)$content;
        switch ($type) {
            case 'ceil':
                $content = ceil($floatVal);
                break;
            case 'floor':
                $content = floor($floatVal);
                break;
            case 'round':
 
            default:
                $content = ‪round($floatVal, (int)$decimals);
        }
        return $content;
    }
 
    public function ‪numberFormat($content, $conf)
    {
        $decimals = isset($conf['decimals.'])
            ? (int)$this->‪stdWrap($conf['decimals'] ?? '', $conf['decimals.'])
            : (int)($conf['decimals'] ?? 0);
        $dec_point = isset($conf['dec_point.'])
            ? $this->‪stdWrap($conf['dec_point'] ?? '', $conf['dec_point.'])
            : ($conf['dec_point'] ?? null);
        $thousands_sep = isset($conf['thousands_sep.'])
            ? $this->‪stdWrap($conf['thousands_sep'] ?? '', $conf['thousands_sep.'])
            : ($conf['thousands_sep'] ?? null);
        return number_format((float)$content, $decimals, $dec_point, $thousands_sep);
    }
 
    public function ‪parseFunc($theValue, $conf, $ref = '')
    {
        // Fetch / merge reference, if any
        if ($ref) {
            $temp_conf = [
                'parseFunc' => $ref,
                'parseFunc.' => $conf
            ];
            $temp_conf = $this->‪mergeTSRef($temp_conf, 'parseFunc');
            $conf = $temp_conf['parseFunc.'];
        }
        // early return, no processing in case no configuration is given
        if (empty($conf)) {
            // @deprecated Invoking ContentObjectRenderer::parseFunc without any configuration will trigger an exception in TYPO3 v12.0
            trigger_error('Invoking ContentObjectRenderer::parseFunc without any configuration will trigger an exception in TYPO3 v12.0', E_USER_DEPRECATED);
            return $theValue;
        }
        // Handle HTML sanitizer invocation
        if (!isset($conf['htmlSanitize'])) {
            // @deprecated Property htmlSanitize was not defined, but will be mandatory in TYPO3 v12.0
            trigger_error('Property htmlSanitize was not defined, but will be mandatory in TYPO3 v12.0', E_USER_DEPRECATED);
            $features = GeneralUtility::makeInstance(Features::class);
            $conf['htmlSanitize'] = $features->isFeatureEnabled('security.frontend.htmlSanitizeParseFuncDefault');
        }
        $conf['htmlSanitize'] = (bool)$conf['htmlSanitize'];
 
        // Process:
        if ((string)($conf['externalBlocks'] ?? '') === '') {
            $result = $this->‪_parseFunc($theValue, $conf);
            if ($conf['htmlSanitize']) {
                $result = $this->‪stdWrap_htmlSanitize($result, $conf['htmlSanitize.'] ?? []);
            }
            return $result;
        }
        $tags = strtolower(implode(',', ‪GeneralUtility::trimExplode(',', $conf['externalBlocks'])));
        $htmlParser = GeneralUtility::makeInstance(HtmlParser::class);
        $parts = $htmlParser->splitIntoBlock($tags, $theValue);
        foreach ($parts as $k => $v) {
            if ($k % 2) {
                // font:
                $tagName = strtolower($htmlParser->getFirstTagName($v));
                $cfg = $conf['externalBlocks.'][$tagName . '.'];
                if ($cfg['stripNLprev'] || $cfg['stripNL']) {
                    $parts[$k - 1] = preg_replace('/' . CR . '?' . LF . '[ ]*$/', '', $parts[$k - 1]);
                }
                if ($cfg['stripNLnext'] || $cfg['stripNL']) {
                    $parts[$k + 1] = preg_replace('/^[ ]*' . CR . '?' . LF . '/', '', $parts[$k + 1]);
                }
            }
        }
        foreach ($parts as $k => $v) {
            if ($k % 2) {
                $tag = $htmlParser->getFirstTag($v);
                $tagName = strtolower($htmlParser->getFirstTagName($v));
                $cfg = $conf['externalBlocks.'][$tagName . '.'];
                if ($cfg['callRecursive']) {
                    $parts[$k] = $this->‪parseFunc($htmlParser->removeFirstAndLastTag($v), $conf);
                    if (!$cfg['callRecursive.']['dontWrapSelf']) {
                        if ($cfg['callRecursive.']['alternativeWrap']) {
                            $parts[$k] = $this->‪wrap($parts[$k], $cfg['callRecursive.']['alternativeWrap']);
                        } else {
                            if (is_array($cfg['callRecursive.']['tagStdWrap.'])) {
                                $tag = $this->‪stdWrap($tag, $cfg['callRecursive.']['tagStdWrap.']);
                            }
                            $parts[$k] = $tag . $parts[$k] . '</' . $tagName . '>';
                        }
                    }
                } elseif ($cfg['HTMLtableCells']) {
                    $rowParts = $htmlParser->splitIntoBlock('tr', $parts[$k]);
                    foreach ($rowParts as $kk => $vv) {
                        if ($kk % 2) {
                            $colParts = $htmlParser->splitIntoBlock('td,th', $vv);
                            $cc = 0;
                            foreach ($colParts as $kkk => $vvv) {
                                if ($kkk % 2) {
                                    $cc++;
                                    $tag = $htmlParser->getFirstTag($vvv);
                                    $tagName = strtolower($htmlParser->getFirstTagName($vvv));
                                    $colParts[$kkk] = $htmlParser->removeFirstAndLastTag($vvv);
                                    if ($cfg['HTMLtableCells.'][$cc . '.']['callRecursive'] || !isset($cfg['HTMLtableCells.'][$cc . '.']['callRecursive']) && $cfg['HTMLtableCells.']['default.']['callRecursive']) {
                                        if ($cfg['HTMLtableCells.']['addChr10BetweenParagraphs']) {
                                            $colParts[$kkk] = str_replace('</p><p>', '</p>' . LF . '<p>', $colParts[$kkk]);
                                        }
                                        $colParts[$kkk] = $this->‪parseFunc($colParts[$kkk], $conf);
                                    }
                                    $tagStdWrap = is_array($cfg['HTMLtableCells.'][$cc . '.']['tagStdWrap.'])
                                        ? $cfg['HTMLtableCells.'][$cc . '.']['tagStdWrap.']
                                        : $cfg['HTMLtableCells.']['default.']['tagStdWrap.'];
                                    if (is_array($tagStdWrap)) {
                                        $tag = $this->‪stdWrap($tag, $tagStdWrap);
                                    }
                                    $stdWrap = is_array($cfg['HTMLtableCells.'][$cc . '.']['stdWrap.'])
                                        ? $cfg['HTMLtableCells.'][$cc . '.']['stdWrap.']
                                        : $cfg['HTMLtableCells.']['default.']['stdWrap.'];
                                    if (is_array($stdWrap)) {
                                        $colParts[$kkk] = $this->‪stdWrap($colParts[$kkk], $stdWrap);
                                    }
                                    $colParts[$kkk] = $tag . $colParts[$kkk] . '</' . $tagName . '>';
                                }
                            }
                            $rowParts[$kk] = implode('', $colParts);
                        }
                    }
                    $parts[$k] = implode('', $rowParts);
                }
                if (is_array($cfg['stdWrap.'])) {
                    $parts[$k] = $this->‪stdWrap($parts[$k], $cfg['stdWrap.']);
                }
            } else {
                $parts[$k] = $this->‪_parseFunc($parts[$k], $conf);
            }
        }
        $result = implode('', $parts);
        if ($conf['htmlSanitize']) {
            $result = $this->‪stdWrap_htmlSanitize($result, $conf['htmlSanitize.'] ?? []);
        }
        return $result;
    }
 
    public function ‪_parseFunc($theValue, $conf)
    {
        if (!empty($conf['if.']) && !$this->‪checkIf($conf['if.'])) {
            return $theValue;
        }
        // Indicates that the data is from within a tag.
        $inside = false;
        // Pointer to the total string position
        $pointer = 0;
        // Loaded with the current typo-tag if any.
        $currentTag = null;
        $stripNL = 0;
        $contentAccum = [];
        $contentAccumP = 0;
        $allowTags = strtolower(str_replace(' ', '', $conf['allowTags'] ?? ''));
        $denyTags = strtolower(str_replace(' ', '', $conf['denyTags'] ?? ''));
        $totalLen = strlen($theValue);
        do {
            if (!$inside) {
                if ($currentTag === null) {
                    // These operations should only be performed on code outside the typotags...
                    // data: this checks that we enter tags ONLY if the first char in the tag is alphanumeric OR '/'
                    $len_p = 0;
                    $c = 100;
                    do {
                        $len = strcspn(substr($theValue, $pointer + $len_p), '<');
                        $len_p += $len + 1;
                        $endChar = ord(strtolower(substr($theValue, $pointer + $len_p, 1)));
                        $c--;
                    } while ($c > 0 && $endChar && ($endChar < 97 || $endChar > 122) && $endChar != 47);
                    $len = $len_p - 1;
                } else {
                    $len = $this->‪getContentLengthOfCurrentTag($theValue, $pointer, (string)$currentTag[0]);
                }
                // $data is the content until the next <tag-start or end is detected.
                // In case of a currentTag set, this would mean all data between the start- and end-tags
                ‪$data = substr($theValue, $pointer, $len);
                if (‪$data !== false) {
                    if ($stripNL) {
                        // If the previous tag was set to strip NewLines in the beginning of the next data-chunk.
                        ‪$data = preg_replace('/^[ ]*' . CR . '?' . LF . '/', '', ‪$data);
                        if (‪$data === null) {
                            $this->logger->debug('Stripping new lines failed for "' . ‪$data . '"');
                            ‪$data = '';
                        }
                    }
                    // These operations should only be performed on code outside the tags...
                    if (!is_array($currentTag)) {
                        // Constants
                        $tsfe = $this->‪getTypoScriptFrontendController();
                        $tmpConstants = $tsfe->tmpl->setup['constants.'] ?? null;
                        if (!empty($conf['constants']) && is_array($tmpConstants)) {
                            foreach ($tmpConstants as $key => $val) {
                                if (is_string($val)) {
                                    ‪$data = str_replace('###' . $key . '###', $val, ‪$data);
                                }
                            }
                        }
                        // Short
                        if (isset($conf['short.']) && is_array($conf['short.'])) {
                            $shortWords = $conf['short.'];
                            krsort($shortWords);
                            foreach ($shortWords as $key => $val) {
                                if (is_string($val)) {
                                    ‪$data = str_replace($key, $val, ‪$data);
                                }
                            }
                        }
                        // stdWrap
                        if (isset($conf['plainTextStdWrap.']) && is_array($conf['plainTextStdWrap.'])) {
                            ‪$data = $this->‪stdWrap($data, $conf['plainTextStdWrap.']);
                        }
                        // userFunc
                        if ($conf['userFunc'] ?? false) {
                            ‪$data = $this->‪callUserFunction($conf['userFunc'], $conf['userFunc.'] ?? [], ‪$data);
                        }
                        // Makelinks: (Before search-words as we need the links to be generated when searchwords go on...!)
                        if ($conf['makelinks'] ?? false) {
                            ‪$data = $this->‪http_makelinks($data, $conf['makelinks.']['http.']);
                            ‪$data = $this->‪mailto_makelinks($data, $conf['makelinks.']['mailto.'] ?? []);
                        }
                        // Search Words:
                        if ($tsfe->no_cache && $conf['sword'] && is_array($tsfe->sWordList) && $tsfe->sWordRegEx) {
                            $newstring = '';
                            do {
                                $pregSplitMode = 'i';
                                if (isset($tsfe->config['config']['sword_noMixedCase']) && !empty($tsfe->config['config']['sword_noMixedCase'])) {
                                    $pregSplitMode = '';
                                }
                                $pieces = preg_split('/' . $tsfe->sWordRegEx . '/' . $pregSplitMode, ‪$data, 2);
                                $newstring .= $pieces[0];
                                $match_len = strlen(‪$data) - (strlen($pieces[0]) + strlen($pieces[1]));
                                $inTag = false;
                                if (strpos($pieces[0], '<') !== false || strpos($pieces[0], '>') !== false) {
                                    // Returns TRUE, if a '<' is closer to the string-end than '>'.
                                    // This is the case if we're INSIDE a tag (that could have been
                                    // made by makelinks...) and we must secure, that the inside of a tag is
                                    // not marked up.
                                    $inTag = strrpos($pieces[0], '<') > strrpos($pieces[0], '>');
                                }
                                // The searchword:
                                $match = substr(‪$data, strlen($pieces[0]), $match_len);
                                if (trim($match) && strlen($match) > 1 && !$inTag) {
                                    $match = $this->‪wrap($match, $conf['sword']);
                                }
                                // Concatenate the Search Word again.
                                $newstring .= $match;
                                ‪$data = $pieces[1];
                            } while ($pieces[1]);
                            ‪$data = $newstring;
                        }
                    }
                    // Search for tags to process in current data and
                    // call this method recursively if found
                    if (strpos(‪$data, '<') !== false && isset($conf['tags.']) && is_array($conf['tags.'])) {
                        foreach ($conf['tags.'] as $tag => $tagConfig) {
                            // only match tag `a` in `<a href"...">` but not in `<abbr>`
                            if (preg_match('#<' . $tag . '[\s/>]#', ‪$data)) {
                                ‪$data = $this->‪_parseFunc($data, $conf);
                                break;
                            }
                        }
                    }
                    $contentAccum[$contentAccumP] = isset($contentAccum[$contentAccumP])
                        ? $contentAccum[$contentAccumP] . ‪$data
                        : ‪$data;
                }
                $inside = true;
            } else {
                // tags
                $len = strcspn(substr($theValue, $pointer), '>') + 1;
                ‪$data = substr($theValue, $pointer, $len);
                if (‪StringUtility::endsWith(‪$data, '/>') && strpos(‪$data, '<link ') !== 0) {
                    $tagContent = substr(‪$data, 1, -2);
                } else {
                    $tagContent = substr(‪$data, 1, -1);
                }
                $tag = explode(' ', trim($tagContent), 2);
                $tag[0] = strtolower($tag[0]);
                // end tag like </li>
                if ($tag[0][0] === '/') {
                    $tag[0] = substr($tag[0], 1);
                    $tag['out'] = 1;
                }
                if ($conf['tags.'][$tag[0]] ?? false) {
                    $treated = false;
                    $stripNL = false;
                    // in-tag
                    if (!$currentTag && (!isset($tag['out']) || !$tag['out'])) {
                        // $currentTag (array!) is the tag we are currently processing
                        $currentTag = $tag;
                        $contentAccumP++;
                        $treated = true;
                        // in-out-tag: img and other empty tags
                        if (preg_match('/^(area|base|br|col|hr|img|input|meta|param)$/i', (string)$tag[0])) {
                            $tag['out'] = 1;
                        }
                    }
                    // out-tag
                    if ($currentTag[0] === $tag[0] && isset($tag['out']) && $tag['out']) {
                        $theName = $conf['tags.'][$tag[0]];
                        $theConf = $conf['tags.'][$tag[0] . '.'];
                        // This flag indicates, that NL- (13-10-chars) should be stripped first and last.
                        $stripNL = (bool)($theConf['stripNL'] ?? false);
                        // This flag indicates, that this TypoTag section should NOT be included in the nonTypoTag content.
                        $breakOut = (bool)($theConf['breakoutTypoTagContent'] ?? false);
                        $this->parameters = [];
                        if (isset($currentTag[1])) {
                            // decode HTML entities in attributes, since they're processed
                            $params = GeneralUtility::get_tag_attributes((string)$currentTag[1], true);
                            if (is_array($params)) {
                                foreach ($params as $option => $val) {
                                    // contains non-encoded values
                                    $this->parameters[strtolower($option)] = $val;
                                }
                            }
                            $this->parameters['allParams'] = trim((string)$currentTag[1]);
                        }
                        // Removes NL in the beginning and end of the tag-content AND at the end of the currentTagBuffer.
                        // $stripNL depends on the configuration of the current tag
                        if ($stripNL) {
                            $contentAccum[$contentAccumP - 1] = preg_replace('/' . CR . '?' . LF . '[ ]*$/', '', $contentAccum[$contentAccumP - 1]);
                            $contentAccum[$contentAccumP] = preg_replace('/^[ ]*' . CR . '?' . LF . '/', '', $contentAccum[$contentAccumP]);
                            $contentAccum[$contentAccumP] = preg_replace('/' . CR . '?' . LF . '[ ]*$/', '', $contentAccum[$contentAccumP]);
                        }
                        $this->data[‪$this->currentValKey] = $contentAccum[$contentAccumP];
                        $newInput = $this->‪cObjGetSingle($theName, $theConf, '/parseFunc/.tags.' . $tag[0]);
                        // fetch the content object
                        $contentAccum[$contentAccumP] = $newInput;
                        $contentAccumP++;
                        // If the TypoTag section
                        if (!$breakOut) {
                            if (!isset($contentAccum[$contentAccumP - 2])) {
                                $contentAccum[$contentAccumP - 2] = '';
                            }
                            $contentAccum[$contentAccumP - 2] .= ($contentAccum[$contentAccumP - 1] ?? '') . ($contentAccum[$contentAccumP] ?? '');
                            unset($contentAccum[$contentAccumP]);
                            unset($contentAccum[$contentAccumP - 1]);
                            $contentAccumP -= 2;
                        }
                        $currentTag = null;
                        $treated = true;
                    }
                    // other tags
                    if (!$treated) {
                        $contentAccum[$contentAccumP] .= ‪$data;
                    }
                } else {
                    // If a tag was not a typo tag, then it is just added to the content
                    $stripNL = false;
                    if (GeneralUtility::inList($allowTags, (string)$tag[0]) ||
                        ($denyTags !== '*' && !GeneralUtility::inList($denyTags, (string)$tag[0]))) {
                        $contentAccum[$contentAccumP] = isset($contentAccum[$contentAccumP])
                            ? $contentAccum[$contentAccumP] . ‪$data
                            : ‪$data;
                    } else {
                        $contentAccum[$contentAccumP] = isset($contentAccum[$contentAccumP])
                            ? $contentAccum[$contentAccumP] . htmlspecialchars(‪$data)
                            : htmlspecialchars(‪$data);
                    }
                }
                $inside = false;
            }
            $pointer += $len;
        } while ($pointer < $totalLen);
        // Parsing nonTypoTag content (all even keys):
        reset($contentAccum);
        $contentAccumCount = count($contentAccum);
        for ($a = 0; $a < $contentAccumCount; $a++) {
            if ($a % 2 != 1) {
                // stdWrap
                if (isset($conf['nonTypoTagStdWrap.']) && is_array($conf['nonTypoTagStdWrap.'])) {
                    $contentAccum[$a] = $this->‪stdWrap((string)($contentAccum[$a] ?? ''), $conf['nonTypoTagStdWrap.']);
                }
                // userFunc
                if (!empty($conf['nonTypoTagUserFunc'])) {
                    $contentAccum[$a] = $this->‪callUserFunction($conf['nonTypoTagUserFunc'], $conf['nonTypoTagUserFunc.'] ?? [], (string)($contentAccum[$a] ?? ''));
                }
            }
        }
        return implode('', $contentAccum);
    }
 
    public function ‪encaps_lineSplit($theValue, $conf)
    {
        if ((string)$theValue === '') {
            return '';
        }
        $lParts = explode(LF, $theValue);
 
        // When the last element is an empty linebreak we need to remove it, otherwise we will have a duplicate empty line.
        $lastPartIndex = count($lParts) - 1;
        if ($lParts[$lastPartIndex] === '' && trim($lParts[$lastPartIndex - 1], CR) === '') {
            array_pop($lParts);
        }
 
        $encapTags = ‪GeneralUtility::trimExplode(',', strtolower($conf['encapsTagList']), true);
        $nonWrappedTag = $conf['nonWrappedTag'];
        $defaultAlign = isset($conf['defaultAlign.'])
            ? trim($this->‪stdWrap($conf['defaultAlign'] ?? '', $conf['defaultAlign.']))
            : trim($conf['defaultAlign'] ?? '');
 
        $str_content = '';
        foreach ($lParts as $k => $l) {
            $sameBeginEnd = 0;
            $emptyTag = false;
            $l = trim($l);
            $attrib = [];
            $nonWrapped = false;
            $tagName = '';
            if (isset($l[0]) && $l[0] === '<' && substr($l, -1) === '>') {
                $fwParts = explode('>', substr($l, 1), 2);
                [$tagName] = explode(' ', $fwParts[0], 2);
                if (!$fwParts[1]) {
                    if (substr($tagName, -1) === '/') {
                        $tagName = substr($tagName, 0, -1);
                    }
                    if (substr($fwParts[0], -1) === '/') {
                        $sameBeginEnd = 1;
                        $emptyTag = true;
                        // decode HTML entities, they're encoded later again
                        $attrib = GeneralUtility::get_tag_attributes('<' . substr($fwParts[0], 0, -1) . '>', true);
                    }
                } else {
                    $backParts = ‪GeneralUtility::revExplode('<', substr($fwParts[1], 0, -1), 2);
                    // decode HTML entities, they're encoded later again
                    $attrib = GeneralUtility::get_tag_attributes('<' . $fwParts[0] . '>', true);
                    $str_content = $backParts[0];
                    $sameBeginEnd = substr(strtolower($backParts[1]), 1, strlen($tagName)) === strtolower($tagName);
                }
            }
            if ($sameBeginEnd && in_array(strtolower($tagName), $encapTags)) {
                $uTagName = strtoupper($tagName);
                $uTagName = strtoupper($conf['remapTag.'][$uTagName] ?? $uTagName);
            } else {
                $uTagName = strtoupper($nonWrappedTag);
                // The line will be wrapped: $uTagName should not be an empty tag
                $emptyTag = false;
                $str_content = $lParts[$k];
                $nonWrapped = true;
                $attrib = [];
            }
            // Wrapping all inner-content:
            if (is_array($conf['innerStdWrap_all.'])) {
                $str_content = $this->‪stdWrap($str_content, $conf['innerStdWrap_all.']);
            }
            if ($uTagName) {
                // Setting common attributes
                if (isset($conf['addAttributes.'][$uTagName . '.']) && is_array($conf['addAttributes.'][$uTagName . '.'])) {
                    foreach ($conf['addAttributes.'][$uTagName . '.'] as $kk => $vv) {
                        if (!is_array($vv)) {
                            if ((string)$conf['addAttributes.'][$uTagName . '.'][$kk . '.']['setOnly'] === 'blank') {
                                if ((string)($attrib[$kk] ?? '') === '') {
                                    $attrib[$kk] = $vv;
                                }
                            } elseif ((string)$conf['addAttributes.'][$uTagName . '.'][$kk . '.']['setOnly'] === 'exists') {
                                if (!isset($attrib[$kk])) {
                                    $attrib[$kk] = $vv;
                                }
                            } else {
                                $attrib[$kk] = $vv;
                            }
                        }
                    }
                }
                // Wrapping all inner-content:
                if (isset($conf['encapsLinesStdWrap.'][$uTagName . '.']) && is_array($conf['encapsLinesStdWrap.'][$uTagName . '.'])) {
                    $str_content = $this->‪stdWrap($str_content, $conf['encapsLinesStdWrap.'][$uTagName . '.']);
                }
                // Default align
                if ((!isset($attrib['align']) || !$attrib['align']) && $defaultAlign) {
                    $attrib['align'] = $defaultAlign;
                }
                // implode (insecure) attributes, that's why `htmlspecialchars` is used here
                $params = GeneralUtility::implodeAttributes($attrib, true);
                if (!isset($conf['removeWrapping']) || !$conf['removeWrapping'] || ($emptyTag && $conf['removeWrapping.']['keepSingleTag'])) {
                    $selfClosingTagList = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
                    if ($emptyTag && in_array(strtolower($uTagName), $selfClosingTagList, true)) {
                        $str_content = '<' . strtolower($uTagName) . (trim($params) ? ' ' . trim($params) : '') . ' />';
                    } else {
                        $str_content = '<' . strtolower($uTagName) . (trim($params) ? ' ' . trim($params) : '') . '>' . $str_content . '</' . strtolower($uTagName) . '>';
                    }
                }
            }
            if ($nonWrapped && isset($conf['wrapNonWrappedLines']) && $conf['wrapNonWrappedLines']) {
                $str_content = $this->‪wrap($str_content, $conf['wrapNonWrappedLines']);
            }
            $lParts[$k] = $str_content;
        }
        return implode(LF, $lParts);
    }
 
    public function ‪http_makelinks(‪$data, $conf)
    {
        $parts = [];
        $aTagParams = $this->‪getATagParams($conf);
        $textstr = '';
        foreach (['http://', 'https://'] as $scheme) {
            $textpieces = explode($scheme, ‪$data);
            $pieces = count($textpieces);
            $textstr = $textpieces[0];
            for ($i = 1; $i < $pieces; $i++) {
                $len = strcspn($textpieces[$i], chr(32) . "\t" . CRLF);
                if (trim(substr($textstr, -1)) === '' && $len) {
                    $lastChar = substr($textpieces[$i], $len - 1, 1);
                    if (!preg_match('/[A-Za-z0-9\\/#_-]/', $lastChar)) {
                        $len--;
                    }
                    // Included '\/' 3/12
                    $parts[0] = substr($textpieces[$i], 0, $len);
                    $parts[1] = substr($textpieces[$i], $len);
                    $keep = $conf['keep'];
                    $linkParts = parse_url($scheme . $parts[0]);
                    $linktxt = '';
                    if (strpos($keep, 'scheme') !== false) {
                        $linktxt = $scheme;
                    }
                    $linktxt .= $linkParts['host'];
                    if (strpos($keep, 'path') !== false) {
                        $linktxt .= $linkParts['path'];
                        // Added $linkParts['query'] 3/12
                        if (strpos($keep, 'query') !== false && $linkParts['query']) {
                            $linktxt .= '?' . $linkParts['query'];
                        } elseif ($linkParts['path'] === '/') {
                            $linktxt = substr($linktxt, 0, -1);
                        }
                    }
                    if (isset($conf['extTarget'])) {
                        if (isset($conf['extTarget.'])) {
                            $target = $this->‪stdWrap($conf['extTarget'], $conf['extTarget.']);
                        } else {
                            $target = $conf['extTarget'];
                        }
                    } else {
                        $target = $this->‪getTypoScriptFrontendController()->extTarget;
                    }
 
                    // check for jump URLs or similar
                    $linkUrl = $this->‪processUrl(‪UrlProcessorInterface::CONTEXT_COMMON, $scheme . $parts[0], $conf) ?? '';
 
                    $res = '<a href="' . htmlspecialchars($linkUrl) . '"'
                        . ($target !== '' ? ' target="' . htmlspecialchars($target) . '"' : '')
                        . $aTagParams . $this->‪extLinkATagParams('http://' . $parts[0], 'url') . '>';
 
                    $wrap = isset($conf['wrap.']) ? $this->‪stdWrap($conf['wrap'], $conf['wrap.']) : $conf['wrap'];
                    if ((string)$conf['ATagBeforeWrap'] !== '') {
                        $res = $res . $this->‪wrap($linktxt, $wrap) . '</a>';
                    } else {
                        $res = $this->‪wrap($res . $linktxt . '</a>', $wrap);
                    }
                    $textstr .= $res . $parts[1];
                } else {
                    $textstr .= $scheme . $textpieces[$i];
                }
            }
            ‪$data = $textstr;
        }
        return $textstr;
    }
 
    public function ‪mailto_makelinks(‪$data, $conf)
    {
        $conf = (array)$conf;
        $parts = [];
        // http-split
        $aTagParams = $this->‪getATagParams($conf);
        $textpieces = explode('mailto:', ‪$data);
        $pieces = count($textpieces);
        $textstr = $textpieces[0];
        $tsfe = $this->‪getTypoScriptFrontendController();
        for ($i = 1; $i < $pieces; $i++) {
            $len = strcspn($textpieces[$i], chr(32) . "\t" . CRLF);
            if (trim(substr($textstr, -1)) === '' && $len) {
                $lastChar = substr($textpieces[$i], $len - 1, 1);
                if (!preg_match('/[A-Za-z0-9]/', $lastChar)) {
                    $len--;
                }
                $parts[0] = substr($textpieces[$i], 0, $len);
                $parts[1] = substr($textpieces[$i], $len);
                $linktxt = (string)preg_replace('/\\?.*/', '', $parts[0]);
                [$mailToUrl, $linktxt] = $this->‪getMailTo($parts[0], $linktxt);
                $mailToUrl = $tsfe->spamProtectEmailAddresses === 'ascii' ? $mailToUrl : htmlspecialchars($mailToUrl);
                $res = '<a href="' . $mailToUrl . '"' . $aTagParams . '>';
                $wrap = isset($conf['wrap.']) ? $this->‪stdWrap($conf['wrap'], $conf['wrap.']) : $conf['wrap'];
                if ((string)$conf['ATagBeforeWrap'] !== '') {
                    $res = $res . $this->‪wrap($linktxt, $wrap) . '</a>';
                } else {
                    $res = $this->‪wrap($res . $linktxt . '</a>', $wrap);
                }
                $textstr .= $res . $parts[1];
            } else {
                $textstr .= 'mailto:' . $textpieces[$i];
            }
        }
        return $textstr;
    }
 
    public function ‪getImgResource($file, $fileArray)
    {
        $importedFile = null;
        if (empty($file) && empty($fileArray)) {
            return null;
        }
        if (!is_array($fileArray)) {
            $fileArray = (array)$fileArray;
        }
        $imageResource = null;
        if ($file === 'GIFBUILDER') {
            $gifCreator = GeneralUtility::makeInstance(GifBuilder::class);
            $theImage = '';
            if (‪$GLOBALS['TYPO3_CONF_VARS']['GFX']['gdlib']) {
                $gifCreator->start($fileArray, $this->data);
                $theImage = $gifCreator->gifBuild();
            }
            $imageResource = $gifCreator->getImageDimensions($theImage);
            $imageResource['origFile'] = $theImage;
        } else {
            if ($file instanceof File) {
                $fileObject = $file;
            } elseif ($file instanceof FileReference) {
                $fileObject = $file->getOriginalFile();
            } else {
                try {
                    if (isset($fileArray['import.']) && $fileArray['import.']) {
                        $importedFile = trim($this->‪stdWrap('', $fileArray['import.']));
                        if (!empty($importedFile)) {
                            $file = $importedFile;
                        }
                    }
 
                    if (‪MathUtility::canBeInterpretedAsInteger($file)) {
                        $treatIdAsReference = isset($fileArray['treatIdAsReference.']) ? $this->‪stdWrap($fileArray['treatIdAsReference'], $fileArray['treatIdAsReference.']) : $fileArray['treatIdAsReference'];
                        if (!empty($treatIdAsReference)) {
                            $file = $this->‪getResourceFactory()->‪getFileReferenceObject($file);
                            $fileObject = $file->‪getOriginalFile();
                        } else {
                            $fileObject = $this->‪getResourceFactory()->‪getFileObject($file);
                        }
                    } elseif (preg_match('/^(0|[1-9][0-9]*):/', $file)) { // combined identifier
                        $fileObject = $this->‪getResourceFactory()->‪retrieveFileOrFolderObject($file);
                    } else {
                        if (isset($importedFile) && !empty($importedFile) && !empty($fileArray['import'])) {
                            $file = $fileArray['import'] . $file;
                        }
                        $fileObject = $this->‪getResourceFactory()->‪retrieveFileOrFolderObject($file);
                    }
                } catch (Exception $exception) {
                    $this->logger->warning('The image "' . $file . '" could not be found and won\'t be included in frontend output', ['exception' => $exception]);
                    return null;
                }
            }
            if ($fileObject instanceof File) {
                $processingConfiguration = [];
                $processingConfiguration['width'] = isset($fileArray['width.']) ? $this->‪stdWrap($fileArray['width'], $fileArray['width.']) : $fileArray['width'];
                $processingConfiguration['height'] = isset($fileArray['height.']) ? $this->‪stdWrap($fileArray['height'], $fileArray['height.']) : $fileArray['height'];
                $processingConfiguration['fileExtension'] = isset($fileArray['ext.']) ? $this->‪stdWrap($fileArray['ext'], $fileArray['ext.']) : $fileArray['ext'];
                $processingConfiguration['maxWidth'] = isset($fileArray['maxW.']) ? (int)$this->‪stdWrap($fileArray['maxW'], $fileArray['maxW.']) : (int)$fileArray['maxW'];
                $processingConfiguration['maxHeight'] = isset($fileArray['maxH.']) ? (int)$this->‪stdWrap($fileArray['maxH'], $fileArray['maxH.']) : (int)$fileArray['maxH'];
                $processingConfiguration['minWidth'] = isset($fileArray['minW.']) ? (int)$this->‪stdWrap($fileArray['minW'], $fileArray['minW.']) : (int)$fileArray['minW'];
                $processingConfiguration['minHeight'] = isset($fileArray['minH.']) ? (int)$this->‪stdWrap($fileArray['minH'], $fileArray['minH.']) : (int)$fileArray['minH'];
                $processingConfiguration['noScale'] = isset($fileArray['noScale.']) ? $this->‪stdWrap($fileArray['noScale'], $fileArray['noScale.']) : $fileArray['noScale'];
                $processingConfiguration['additionalParameters'] = isset($fileArray['params.']) ? $this->‪stdWrap($fileArray['params'], $fileArray['params.']) : $fileArray['params'];
                $processingConfiguration['frame'] = isset($fileArray['frame.']) ? (int)$this->‪stdWrap($fileArray['frame'], $fileArray['frame.']) : (int)$fileArray['frame'];
                if ($file instanceof FileReference) {
                    $processingConfiguration['crop'] = $this->‪getCropAreaFromFileReference($file, $fileArray);
                } else {
                    $processingConfiguration['crop'] = $this->‪getCropAreaFromFromTypoScriptSettings($fileObject, $fileArray);
                }
 
                // Possibility to cancel/force profile extraction
                // see $GLOBALS['TYPO3_CONF_VARS']['GFX']['processor_stripColorProfileCommand']
                if (isset($fileArray['stripProfile'])) {
                    $processingConfiguration['stripProfile'] = $fileArray['stripProfile'];
                }
                // Check if we can handle this type of file for editing
                if ($fileObject->isImage()) {
                    $maskArray = $fileArray['m.'];
                    // Must render mask images and include in hash-calculating
                    // - otherwise we cannot be sure the filename is unique for the setup!
                    if (is_array($maskArray)) {
                        $mask = $this->‪getImgResource($maskArray['mask'], $maskArray['mask.']);
                        $bgImg = $this->‪getImgResource($maskArray['bgImg'], $maskArray['bgImg.']);
                        $bottomImg = $this->‪getImgResource($maskArray['bottomImg'], $maskArray['bottomImg.']);
                        $bottomImg_mask = $this->‪getImgResource($maskArray['bottomImg_mask'], $maskArray['bottomImg_mask.']);
 
                        $processingConfiguration['maskImages']['maskImage'] = $mask['processedFile'];
                        $processingConfiguration['maskImages']['backgroundImage'] = $bgImg['processedFile'];
                        $processingConfiguration['maskImages']['maskBottomImage'] = $bottomImg['processedFile'];
                        $processingConfiguration['maskImages']['maskBottomImageMask'] = $bottomImg_mask['processedFile'];
                    }
                    $processedFileObject = $fileObject->process(‪ProcessedFile::CONTEXT_IMAGECROPSCALEMASK, $processingConfiguration);
                    if ($processedFileObject->isProcessed()) {
                        $imageResource = [
                            0 => (int)$processedFileObject->getProperty('width'),
                            1 => (int)$processedFileObject->getProperty('height'),
                            2 => $processedFileObject->getExtension(),
                            3 => $processedFileObject->getPublicUrl(),
                            'origFile' => $fileObject->getPublicUrl(),
                            'origFile_mtime' => $fileObject->getModificationTime(),
                            // This is needed by \TYPO3\CMS\Frontend\Imaging\GifBuilder,
                            // in order for the setup-array to create a unique filename hash.
                            'originalFile' => $fileObject,
                            'processedFile' => $processedFileObject
                        ];
                    }
                }
            }
        }
        // If image was processed by GIFBUILDER:
        // ($imageResource indicates that it was processed the regular way)
        if (!isset($imageResource)) {
            try {
                $theImage = GeneralUtility::makeInstance(FilePathSanitizer::class)->sanitize((string)$file);
                $info = GeneralUtility::makeInstance(GifBuilder::class)->imageMagickConvert($theImage, 'WEB');
                $info['origFile'] = $theImage;
                // This is needed by \TYPO3\CMS\Frontend\Imaging\GifBuilder, ln 100ff in order for the setup-array to create a unique filename hash.
                $info['origFile_mtime'] = @filemtime($theImage);
                $imageResource = $info;
            } catch (Exception $e) {
                // do nothing in case the file path is invalid
            }
        }
        // Hook 'getImgResource': Post-processing of image resources
        if (isset($imageResource)) {
            foreach ($this->‪getGetImgResourceHookObjects() as $hookObject) {
                $imageResource = $hookObject->getImgResourcePostProcess($file, (array)$fileArray, $imageResource, $this);
            }
        }
        return $imageResource;
    }
 
    protected function ‪getCropAreaFromFileReference(FileReference $fileReference, array $fileArray)
    {
        // Use cropping area from file reference if nothing is configured in TypoScript.
        if (!isset($fileArray['crop']) && !isset($fileArray['crop.'])) {
            // Set crop variant from TypoScript settings. If not set, use default.
            $cropVariant = $fileArray['cropVariant'] ?? 'default';
            $fileCropArea = $this->‪createCropAreaFromJsonString((string)$fileReference->getProperty('crop'), $cropVariant);
            return $fileCropArea->isEmpty() ? null : $fileCropArea->makeAbsoluteBasedOnFile($fileReference);
        }
 
        return $this->‪getCropAreaFromFromTypoScriptSettings($fileReference, $fileArray);
    }
 
    protected function ‪getCropAreaFromFromTypoScriptSettings(FileInterface $file, array $fileArray)
    {
        $cropArea = null;
        // Resolve TypoScript configured cropping.
        $cropSettings = isset($fileArray['crop.'])
            ? $this->‪stdWrap($fileArray['crop'], $fileArray['crop.'])
            : ($fileArray['crop'] ?? null);
 
        if (is_string($cropSettings)) {
            // Set crop variant from TypoScript settings. If not set, use default.
            $cropVariant = $fileArray['cropVariant'] ?? 'default';
            // Get cropArea from CropVariantCollection, if cropSettings is a valid json.
            // CropVariantCollection::create does json_decode.
            $jsonCropArea = $this->‪createCropAreaFromJsonString($cropSettings, $cropVariant);
            $cropArea = $jsonCropArea->isEmpty() ? null : $jsonCropArea->makeAbsoluteBasedOnFile($file);
 
            // Cropping is configured in TypoScript in the following way: file.crop = 50,50,100,100
            if ($jsonCropArea->isEmpty() && preg_match('/^[0-9]+,[0-9]+,[0-9]+,[0-9]+$/', $cropSettings)) {
                $cropSettings = explode(',', $cropSettings);
                if (count($cropSettings) === 4) {
                    $stringCropArea = GeneralUtility::makeInstance(
                        Area::class,
                        ...$cropSettings
                    );
                    $cropArea = $stringCropArea->isEmpty() ? null : $stringCropArea;
                }
            }
        }
 
        return $cropArea;
    }
 
    protected function ‪createCropAreaFromJsonString(string $cropSettings, string $cropVariant): Area
    {
        return ‪CropVariantCollection::create($cropSettings)->‪getCropArea($cropVariant);
    }
 
    /***********************************************
     *
     * Data retrieval etc.
     *
     ***********************************************/
    public function ‪getFieldVal($field)
    {
        if (strpos($field, '//') === false) {
            return $this->data[trim($field)] ?? null;
        }
        $sections = ‪GeneralUtility::trimExplode('//', $field, true);
        foreach ($sections as $k) {
            if ((string)$this->data[$k] !== '') {
                return $this->data[$k];
            }
        }
 
        return '';
    }
 
    public function ‪getData($string, $fieldArray = null)
    {
        $tsfe = $this->‪getTypoScriptFrontendController();
        if (!is_array($fieldArray)) {
            $fieldArray = $tsfe->page;
        }
        $retVal = '';
        $sections = explode('//', $string);
        foreach ($sections as $secKey => $secVal) {
            if ($retVal) {
                break;
            }
            $parts = explode(':', $secVal, 2);
            $type = strtolower(trim($parts[0]));
            $typesWithOutParameters = ['level', 'date', 'current', 'pagelayout'];
            $key = trim($parts[1] ?? '');
            if (($key != '') || in_array($type, $typesWithOutParameters)) {
                switch ($type) {
                    case 'gp':
                        // Merge GET and POST and get $key out of the merged array
                        $getPostArray = GeneralUtility::_GET();
                        ‪ArrayUtility::mergeRecursiveWithOverrule($getPostArray, GeneralUtility::_POST());
                        $retVal = $this->‪getGlobal($key, $getPostArray);
                        break;
                    case 'tsfe':
                        $retVal = $this->‪getGlobal('TSFE|' . $key);
                        break;
                    case 'getenv':
                        $retVal = getenv($key);
                        break;
                    case 'getindpenv':
                        $retVal = $this->‪getEnvironmentVariable($key);
                        break;
                    case 'field':
                        $retVal = $this->‪getGlobal($key, $fieldArray);
                        break;
                    case 'file':
                        $retVal = $this->‪getFileDataKey($key);
                        break;
                    case 'parameters':
                        $retVal = $this->parameters[$key];
                        break;
                    case 'register':
                        $retVal = $tsfe->register[$key] ?? null;
                        break;
                    case 'global':
                        $retVal = $this->‪getGlobal($key);
                        break;
                    case 'level':
                        $retVal = count($tsfe->tmpl->rootLine) - 1;
                        break;
                    case 'leveltitle':
                        $keyParts = ‪GeneralUtility::trimExplode(',', $key);
                        $pointer = (int)($keyParts[0] ?? 0);
                        $slide = (string)($keyParts[1] ?? '');
 
                        $numericKey = $this->‪getKey($pointer, $tsfe->tmpl->rootLine);
                        $retVal = $this->‪rootLineValue($numericKey, 'title', strtolower($slide) === 'slide');
                        break;
                    case 'levelmedia':
                        $keyParts = ‪GeneralUtility::trimExplode(',', $key);
                        $pointer = (int)($keyParts[0] ?? 0);
                        $slide = (string)($keyParts[1] ?? '');
 
                        $numericKey = $this->‪getKey($pointer, $tsfe->tmpl->rootLine);
                        $retVal = $this->‪rootLineValue($numericKey, 'media', strtolower($slide) === 'slide');
                        break;
                    case 'leveluid':
                        $numericKey = $this->‪getKey((int)$key, $tsfe->tmpl->rootLine);
                        $retVal = $this->‪rootLineValue($numericKey, 'uid');
                        break;
                    case 'levelfield':
                        $keyParts = ‪GeneralUtility::trimExplode(',', $key);
                        $pointer = (int)($keyParts[0] ?? 0);
                        $field = (string)($keyParts[1] ?? '');
                        $slide = (string)($keyParts[2] ?? '');
 
                        $numericKey = $this->‪getKey($pointer, $tsfe->tmpl->rootLine);
                        $retVal = $this->‪rootLineValue($numericKey, $field, strtolower($slide) === 'slide');
                        break;
                    case 'fullrootline':
                        $keyParts = ‪GeneralUtility::trimExplode(',', $key);
                        $pointer = (int)($keyParts[0] ?? 0);
                        $field = (string)($keyParts[1] ?? '');
                        $slide = (string)($keyParts[2] ?? '');
 
                        $fullKey = (int)($pointer - count($tsfe->tmpl->rootLine) + count($tsfe->rootLine));
                        if ($fullKey >= 0) {
                            $retVal = $this->‪rootLineValue($fullKey, $field, stristr($slide, 'slide') !== false, $tsfe->rootLine);
                        }
                        break;
                    case 'date':
                        if (!$key) {
                            $key = 'd/m Y';
                        }
                        $retVal = date($key, ‪$GLOBALS['EXEC_TIME']);
                        break;
                    case 'page':
                        $retVal = $tsfe->page[$key];
                        break;
                    case 'pagelayout':
                        $retVal = GeneralUtility::makeInstance(PageLayoutResolver::class)
                            ->getLayoutForPage($tsfe->page, $tsfe->rootLine);
                        break;
                    case 'current':
                        $retVal = $this->data[‪$this->currentValKey] ?? null;
                        break;
                    case 'db':
                        $selectParts = ‪GeneralUtility::trimExplode(':', $key);
                        $db_rec = $tsfe->sys_page->getRawRecord($selectParts[0], $selectParts[1]);
                        if (is_array($db_rec) && $selectParts[2]) {
                            $retVal = $db_rec[$selectParts[2]];
                        }
                        break;
                    case 'lll':
                        $retVal = $tsfe->sL('LLL:' . $key);
                        break;
                    case 'path':
                        try {
                            $retVal = GeneralUtility::makeInstance(FilePathSanitizer::class)->sanitize($key);
                        } catch (Exception $e) {
                            // do nothing in case the file path is invalid
                            $retVal = null;
                        }
                        break;
                    case 'cobj':
                        switch ($key) {
                            case 'parentRecordNumber':
                                $retVal = ‪$this->parentRecordNumber;
                                break;
                        }
                        break;
                    case 'debug':
                        switch ($key) {
                            case 'rootLine':
                                $retVal = ‪DebugUtility::viewArray($tsfe->tmpl->rootLine);
                                break;
                            case 'fullRootLine':
                                $retVal = ‪DebugUtility::viewArray($tsfe->rootLine);
                                break;
                            case 'data':
                                $retVal = ‪DebugUtility::viewArray($this->data);
                                break;
                            case 'register':
                                $retVal = ‪DebugUtility::viewArray($tsfe->register);
                                break;
                            case 'page':
                                $retVal = ‪DebugUtility::viewArray($tsfe->page);
                                break;
                        }
                        break;
                    case 'flexform':
                        $keyParts = ‪GeneralUtility::trimExplode(':', $key, true);
                        if (count($keyParts) === 2 && isset($this->data[$keyParts[0]])) {
                            $flexFormContent = $this->data[$keyParts[0]];
                            if (!empty($flexFormContent)) {
                                $flexFormService = GeneralUtility::makeInstance(FlexFormService::class);
                                $flexFormKey = str_replace('.', '|', $keyParts[1]);
                                $settings = $flexFormService->convertFlexFormContentToArray($flexFormContent);
                                $retVal = $this->‪getGlobal($flexFormKey, $settings);
                            }
                        }
                        break;
                    case 'session':
                        $keyParts = ‪GeneralUtility::trimExplode('|', $key, true);
                        $sessionKey = array_shift($keyParts);
                        $retVal = $this->‪getTypoScriptFrontendController()->fe_user->getSessionData($sessionKey);
                        foreach ($keyParts as $keyPart) {
                            if (is_object($retVal)) {
                                $retVal = $retVal->{$keyPart};
                            } elseif (is_array($retVal)) {
                                $retVal = $retVal[$keyPart];
                            } else {
                                $retVal = '';
                                break;
                            }
                        }
                        if (!is_scalar($retVal)) {
                            $retVal = '';
                        }
                        break;
                    case 'context':
                        $context = GeneralUtility::makeInstance(Context::class);
                        [$aspectName, $propertyName] = ‪GeneralUtility::trimExplode(':', $key, true, 2);
                        $retVal = $context->getPropertyFromAspect($aspectName, $propertyName, '');
                        if (is_array($retVal)) {
                            $retVal = implode(',', $retVal);
                        }
                        if (!is_scalar($retVal)) {
                            $retVal = '';
                        }
                        break;
                    case 'site':
                        $site = $this->‪getTypoScriptFrontendController()->‪getSite();
                        if ($key === 'identifier') {
                            $retVal = $site->getIdentifier();
                        } elseif ($key === 'base') {
                            $retVal = $site->getBase();
                        } else {
                            try {
                                $retVal = ‪ArrayUtility::getValueByPath($site->getConfiguration(), $key, '.');
                            } catch (MissingArrayPathException $exception) {
                                $this->logger->notice(sprintf('Configuration "%s" is not defined for site "%s"', $key, $site->getIdentifier()), ['exception' => $exception]);
                            }
                        }
                        break;
                    case 'sitelanguage':
                        $siteLanguage = $this->‪getTypoScriptFrontendController()->‪getLanguage();
                        $config = $siteLanguage->toArray();
                        if (isset($config[$key])) {
                            $retVal = $config[$key];
                        }
                        break;
                }
            }
 
            foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getData'] ?? [] as $className) {
                $hookObject = GeneralUtility::makeInstance($className);
                if (!$hookObject instanceof ContentObjectGetDataHookInterface) {
                    throw new \UnexpectedValueException('$hookObject must implement interface ' . ContentObjectGetDataHookInterface::class, 1195044480);
                }
                $ref = $this; // introduced for phpstan to not lose type information when passing $this into callUserFunction
                $retVal = $hookObject->getDataExtension($string, $fieldArray, $secVal, $retVal, $ref);
            }
        }
        return $retVal;
    }
 
    protected function getFileDataKey($key)
    {
        [$fileUidOrCurrentKeyword, $requestedFileInformationKey] = ‪GeneralUtility::trimExplode(':', $key, false, 3);
        try {
            if ($fileUidOrCurrentKeyword === 'current') {
                $fileObject = $this->getCurrentFile();
            } elseif (‪MathUtility::canBeInterpretedAsInteger($fileUidOrCurrentKeyword)) {
                $fileFactory = GeneralUtility::makeInstance(ResourceFactory::class);
                $fileObject = $fileFactory->getFileObject($fileUidOrCurrentKeyword);
            } else {
                $fileObject = null;
            }
        } catch (Exception $exception) {
            $this->logger->warning('The file "' . $fileUidOrCurrentKeyword . '" could not be found and won\'t be included in frontend output', ['exception' => $exception]);
            $fileObject = null;
        }
 
        if ($fileObject instanceof FileInterface) {
            // All properties of the \TYPO3\CMS\Core\Resource\FileInterface are available here:
            switch ($requestedFileInformationKey) {
                case 'name':
                    return $fileObject->getName();
                case 'uid':
                    if (method_exists($fileObject, 'getUid')) {
                        return $fileObject->getUid();
                    }
                    return 0;
                case 'originalUid':
                    if ($fileObject instanceof FileReference) {
                        return $fileObject->getOriginalFile()->getUid();
                    }
                    return null;
                case 'size':
                    return $fileObject->getSize();
                case 'sha1':
                    return $fileObject->getSha1();
                case 'extension':
                    return $fileObject->getExtension();
                case 'mimetype':
                    return $fileObject->getMimeType();
                case 'contents':
                    return $fileObject->getContents();
                case 'publicUrl':
                    return $fileObject->getPublicUrl();
                default:
                    // Generic alternative here
                    return $fileObject->getProperty($requestedFileInformationKey);
            }
        } else {
            // @todo fail silently as is common in tslib_content
            return 'Error: no file object';
        }
    }
 
    public function rootLineValue($key, $field, $slideBack = false, $altRootLine = '')
    {
        $rootLine = is_array($altRootLine) ? $altRootLine : $this->getTypoScriptFrontendController()->tmpl->rootLine;
        if (!$slideBack) {
            return $rootLine[$key][$field];
        }
        for ($a = $key; $a >= 0; $a--) {
            $val = $rootLine[$a][$field];
            if ($val) {
                return $val;
            }
        }
 
        return '';
    }
 
    public function getGlobal($keyString, $source = null)
    {
        $keys = explode('|', $keyString);
        $numberOfLevels = count($keys);
        $rootKey = trim($keys[0]);
        $value = isset($source) ? $source[$rootKey] : ‪$GLOBALS[$rootKey];
        for ($i = 1; $i < $numberOfLevels && isset($value); $i++) {
            $currentKey = trim($keys[$i]);
            if (is_object($value)) {
                $value = $value->{$currentKey};
            } elseif (is_array($value)) {
                $value = $value[$currentKey];
            } else {
                $value = '';
                break;
            }
        }
        if (!is_scalar($value)) {
            $value = '';
        }
        return $value;
    }
 
    public function getKey($key, $arr)
    {
        $key = (int)$key;
        if (is_array($arr)) {
            if ($key < 0) {
                $key = count($arr) + $key;
            }
            if ($key < 0) {
                $key = 0;
            }
        }
        return $key;
    }
 
    /***********************************************
     *
     * Link functions (typolink)
     *
     ***********************************************/
    protected function resolveMixedLinkParameter($linkText, $mixedLinkParameter, &$configuration = [])
    {
        $linkParameter = null;
 
        // Link parameter value = first part
        $linkParameterParts = GeneralUtility::makeInstance(TypoLinkCodecService::class)->decode($mixedLinkParameter);
 
        // Check for link-handler keyword
        $linkHandlerExploded = explode(':', $linkParameterParts['url'], 2);
        $linkHandlerKeyword = (string)($linkHandlerExploded[0] ?? '');
        $linkHandlerValue = (string)($linkHandlerExploded[1] ?? '');
        if (!empty(‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['typolinkLinkHandler'][$linkHandlerKeyword])
            && $linkHandlerValue !== ''
        ) {
            trigger_error('The hook $TYPO3_CONF_VARS[SC_OPTIONS][tslib/class.tslib_content.php][typolinkLinkHandler] will be removed in TYPO3 v11.0. Use a custom LinkHandler instead. The used link handler keyword was: ' . $linkHandlerKeyword, E_USER_DEPRECATED);
            $linkHandlerObj = GeneralUtility::makeInstance(‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['typolinkLinkHandler'][$linkHandlerKeyword]);
            if (method_exists($linkHandlerObj, 'main')) {
                return $linkHandlerObj->main($linkText, $configuration, $linkHandlerKeyword, $linkHandlerValue, $mixedLinkParameter, $this);
            }
        }
 
        if (in_array(strtolower((string)preg_replace('#\s|[[:cntrl:]]#', '', $linkHandlerKeyword)), ['javascript', 'data'], true)) {
            // Disallow insecure scheme's like javascript: or data:
            return $linkText;
        }
        $linkParameter = $linkParameterParts['url'];
 
        // additional parameters that need to be set
        if ($linkParameterParts['additionalParams'] !== '') {
            $forceParams = $linkParameterParts['additionalParams'];
            // params value
            $configuration['additionalParams'] .= $forceParams[0] === '&' ? $forceParams : '&' . $forceParams;
        }
 
        return [
            'href'   => $linkParameter,
            'target' => $linkParameterParts['target'],
            'class'  => $linkParameterParts['class'],
            'title'  => $linkParameterParts['title']
        ];
    }
 
    public function typoLink($linkText, $conf)
    {
        $linkText = (string)$linkText;
        $tsfe = $this->getTypoScriptFrontendController();
 
        $linkParameter = trim(
            (isset($conf['parameter.']))
            ? $this->stdWrap($conf['parameter'] ?? '', $conf['parameter.'])
            : ($conf['parameter'] ?? '')
        );
        $this->lastTypoLinkUrl = '';
        $this->lastTypoLinkTarget = '';
 
        $resolvedLinkParameters = $this->resolveMixedLinkParameter($linkText, $linkParameter, $conf);
        // check if the link handler hook has resolved the link completely already
        if (!is_array($resolvedLinkParameters)) {
            return $resolvedLinkParameters;
        }
        $linkParameter = $resolvedLinkParameters['href'];
        $target = $resolvedLinkParameters['target'];
        $title = $resolvedLinkParameters['title'];
 
        if (!$linkParameter) {
            return $this->resolveAnchorLink($linkText, $conf ?? []);
        }
 
        // Detecting kind of link and resolve all necessary parameters
        $linkService = GeneralUtility::makeInstance(LinkService::class);
        try {
            $linkDetails = $linkService->resolve($linkParameter);
        } catch (UnknownLinkHandlerException | InvalidPathException $exception) {
            $this->logger->warning('The link could not be generated', ['exception' => $exception]);
            return $linkText;
        }
 
        $linkDetails['typoLinkParameter'] = $linkParameter;
        if (isset($linkDetails['type']) && isset(‪$GLOBALS['TYPO3_CONF_VARS']['FE']['typolinkBuilder'][$linkDetails['type']])) {
            $linkBuilder = GeneralUtility::makeInstance(
                ‪$GLOBALS['TYPO3_CONF_VARS']['FE']['typolinkBuilder'][$linkDetails['type']],
                $this,
                $tsfe
            );
            try {
                [$this->lastTypoLinkUrl, $linkText, $target] = $linkBuilder->build($linkDetails, $linkText, $target, $conf);
                $this->lastTypoLinkTarget = htmlspecialchars($target);
                $this->lastTypoLinkLD['target'] = htmlspecialchars($target);
                $this->lastTypoLinkLD['totalUrl'] = $this->lastTypoLinkUrl;
            } catch (UnableToLinkException $e) {
                $this->logger->debug(sprintf('Unable to link "%s": %s', $e->getLinkText(), $e->getMessage()), ['exception' => $e]);
 
                // Only return the link text directly
                return $e->getLinkText();
            }
        } elseif (isset($linkDetails['url'])) {
            $this->lastTypoLinkUrl = $linkDetails['url'];
            $this->lastTypoLinkTarget = htmlspecialchars($target);
            $this->lastTypoLinkLD['target'] = htmlspecialchars($target);
            $this->lastTypoLinkLD['totalUrl'] = $this->lastTypoLinkUrl;
        } else {
            return $linkText;
        }
 
        // We need to backup the URL because ATagParams might call typolink again and change the last URL.
        $url = $this->lastTypoLinkUrl;
        $finalTagParts = [
            'aTagParams' => $this->getATagParams($conf) . $this->extLinkATagParams($this->lastTypoLinkUrl, $linkDetails['type']),
            'url'        => $url,
            'TYPE'       => $linkDetails['type']
        ];
 
        // Ensure "href" is not in the list of aTagParams to avoid double tags, usually happens within buggy parseFunc settings
        if (!empty($finalTagParts['aTagParams'])) {
            $aTagParams = GeneralUtility::get_tag_attributes($finalTagParts['aTagParams'], true);
            if (isset($aTagParams['href'])) {
                unset($aTagParams['href']);
                $finalTagParts['aTagParams'] = GeneralUtility::implodeAttributes($aTagParams, true);
            }
        }
 
        // Building the final <a href=".."> tag
        $tagAttributes = [];
 
        // Title attribute
        if (empty($title)) {
            $title = $conf['title'] ?? '';
            if (isset($conf['title.']) && is_array($conf['title.'])) {
                $title = $this->stdWrap($title, $conf['title.']);
            }
        }
 
        // Check, if the target is coded as a JS open window link:
        $JSwindowParts = [];
        $JSwindowParams = '';
        if ($target && preg_match('/^([0-9]+)x([0-9]+)(:(.*)|.*)$/', $target, $JSwindowParts)) {
            // Take all pre-configured and inserted parameters and compile parameter list, including width+height:
            $JSwindow_tempParamsArr = GeneralUtility::trimExplode(',', strtolower(($conf['JSwindow_params'] ?? '') . ',' . ($JSwindowParts[4] ?? '')), true);
            $JSwindow_paramsArr = [];
            $target = $conf['target'] ?? 'FEopenLink';
            foreach ($JSwindow_tempParamsArr as $JSv) {
                [$JSp, $JSv] = explode('=', $JSv, 2);
                // If the target is set as JS param, this is extracted
                if ($JSp === 'target') {
                    $target = $JSv;
                } else {
                    $JSwindow_paramsArr[$JSp] = $JSp . '=' . $JSv;
                }
            }
            // Add width/height:
            $JSwindow_paramsArr['width'] = 'width=' . $JSwindowParts[1];
            $JSwindow_paramsArr['height'] = 'height=' . $JSwindowParts[2];
            // Imploding into string:
            $JSwindowParams = implode(',', $JSwindow_paramsArr);
        }
 
        if (!$JSwindowParams && $linkDetails['type'] === LinkService::TYPE_EMAIL && $tsfe->spamProtectEmailAddresses === 'ascii') {
            $tagAttributes['href'] = $finalTagParts['url'];
        } else {
            $tagAttributes['href'] = htmlspecialchars($finalTagParts['url']);
        }
        if (!empty($title)) {
            $tagAttributes['title'] = htmlspecialchars($title);
        }
 
        // Target attribute
        if (!empty($target)) {
            $tagAttributes['target'] = htmlspecialchars($target);
        }
        if ($JSwindowParams && in_array($tsfe->xhtmlDoctype, ['xhtml_strict', 'xhtml_11'], true)) {
            // Create TARGET-attribute only if the right doctype is used
            unset($tagAttributes['target']);
        }
 
        if ($JSwindowParams) {
            $onClick = 'openPic(' . GeneralUtility::quoteJSvalue($tsfe->baseUrlWrap($finalTagParts['url']))
                . ',' . GeneralUtility::quoteJSvalue($target) . ','
                . GeneralUtility::quoteJSvalue($JSwindowParams)
                . ');return false;';
            $tagAttributes['onclick'] = htmlspecialchars($onClick);
            GeneralUtility::makeInstance(AssetCollector::class)->addInlineJavaScript('openPic', 'function openPic(url, winName, winParams) { var theWindow = window.open(url, winName, winParams); if (theWindow) { theWindow.focus(); } }');
        }
 
        if (!empty($resolvedLinkParameters['class'])) {
            $tagAttributes['class'] = htmlspecialchars($resolvedLinkParameters['class']);
        }
 
        // Prevent trouble with double and missing spaces between attributes and merge params before implode
        // (skip decoding HTML entities, since `$tagAttributes` are expected to be encoded already)
        $finalTagAttributes = array_merge($tagAttributes, GeneralUtility::get_tag_attributes($finalTagParts['aTagParams']));
        $finalTagAttributes = $this->addSecurityRelValues($finalTagAttributes, $target, $tagAttributes['href']);
        $finalAnchorTag = '<a ' . GeneralUtility::implodeAttributes($finalTagAttributes) . '>';
 
        // kept for backwards-compatibility in hooks
        $finalTagParts['targetParams'] = !empty($tagAttributes['target']) ? ' target="' . $tagAttributes['target'] . '"' : '';
        $this->lastTypoLinkTarget = $target;
 
        // Call user function:
        if ($conf['userFunc'] ?? false) {
            $finalTagParts['TAG'] = $finalAnchorTag;
            $finalAnchorTag = $this->callUserFunction($conf['userFunc'], $conf['userFunc.'] ?? [], $finalTagParts);
        }
 
        // Hook: Call post processing function for link rendering:
        $_params = [
            'conf' => &$conf,
            'linktxt' => &$linkText,
            'finalTag' => &$finalAnchorTag,
            'finalTagParts' => &$finalTagParts,
            'linkDetails' => &$linkDetails,
            'tagAttributes' => &$finalTagAttributes
        ];
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['typoLink_PostProc'] ?? [] as $_funcRef) {
            $ref = $this; // introduced for phpstan to not lose type information when passing $this into callUserFunction
            GeneralUtility::callUserFunction($_funcRef, $_params, $ref);
        }
 
        // If flag "returnLastTypoLinkUrl" set, then just return the latest URL made:
        if ($conf['returnLast'] ?? false) {
            switch ($conf['returnLast']) {
                case 'url':
                    return $this->lastTypoLinkUrl;
                case 'target':
                    return $this->lastTypoLinkTarget;
            }
        }
 
        $wrap = isset($conf['wrap.'])
            ? $this->stdWrap($conf['wrap'] ?? '', $conf['wrap.'])
            : $conf['wrap'] ?? '';
 
        if ($conf['ATagBeforeWrap'] ?? false) {
            return $finalAnchorTag . $this->wrap($linkText, $wrap) . '</a>';
        }
        return $this->wrap($finalAnchorTag . $linkText . '</a>', $wrap);
    }
 
    protected function addSecurityRelValues(array $tagAttributes, ?string $target, string $url): array
    {
        $relAttribute = 'noreferrer';
        if (in_array($target, ['', null, '_self', '_parent', '_top'], true) || $this->isInternalUrl($url)) {
            return $tagAttributes;
        }
 
        if (!isset($tagAttributes['rel'])) {
            $tagAttributes['rel'] = $relAttribute;
            return $tagAttributes;
        }
 
        $tagAttributes['rel'] = implode(' ', array_unique(array_merge(
            GeneralUtility::trimExplode(' ', $relAttribute),
            GeneralUtility::trimExplode(' ', $tagAttributes['rel'])
        )));
 
        return $tagAttributes;
    }
 
    protected function isInternalUrl(string $url): bool
    {
        $cache = GeneralUtility::makeInstance(CacheManager::class)->getCache('runtime');
        $parsedUrl = parse_url($url);
        $foundDomains = 0;
        if (!isset($parsedUrl['host'])) {
            return true;
        }
 
        $cacheIdentifier = sha1('isInternalDomain' . $parsedUrl['host']);
 
        if ($cache->has($cacheIdentifier) === false) {
            foreach (GeneralUtility::makeInstance(SiteFinder::class)->getAllSites() as $site) {
                if ($site->getBase()->getHost() === $parsedUrl['host']) {
                    ++$foundDomains;
                    break;
                }
 
                if ($site->getBase()->getHost() === '' && GeneralUtility::isOnCurrentHost($url)) {
                    ++$foundDomains;
                    break;
                }
            }
 
            $cache->set($cacheIdentifier, $foundDomains > 0);
        }
 
        return (bool)$cache->get($cacheIdentifier);
    }
 
    public function typoLink_URL($conf)
    {
        $this->typoLink('|', $conf);
        return $this->lastTypoLinkUrl;
    }
 
    public function getTypoLink($label, $params, $urlParameters = [], $target = '')
    {
        $conf = [];
        $conf['parameter'] = $params;
        if ($target) {
            $conf['target'] = $target;
            $conf['extTarget'] = $target;
            $conf['fileTarget'] = $target;
        }
        if (is_array($urlParameters)) {
            if (!empty($urlParameters)) {
                $conf['additionalParams'] .= HttpUtility::buildQueryString($urlParameters, '&');
            }
        } else {
            $conf['additionalParams'] .= $urlParameters;
        }
        $out = $this->typoLink($label, $conf);
        return $out;
    }
 
    public function getUrlToCurrentLocation($addQueryString = true)
    {
        $conf = [];
        $conf['parameter'] = $this->getTypoScriptFrontendController()->id . ',' . $this->getTypoScriptFrontendController()->type;
        if ($addQueryString) {
            $conf['addQueryString'] = '1';
            $linkVars = implode(',', array_keys(GeneralUtility::explodeUrl2Array($this->getTypoScriptFrontendController()->linkVars)));
            $conf['addQueryString.'] = [
                'method' => 'GET',
                'exclude' => 'id,type,cHash' . ($linkVars ? ',' . $linkVars : '')
            ];
        }
 
        return $this->typoLink_URL($conf);
    }
 
    public function getTypoLink_URL($params, $urlParameters = [], $target = '')
    {
        $this->getTypoLink('', $params, $urlParameters, $target);
        return $this->lastTypoLinkUrl;
    }
 
    protected function processUrl($context, $url, $typolinkConfiguration = [])
    {
        $urlProcessors = ‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['urlProcessing']['urlProcessors'] ?? [];
        if (empty($urlProcessors)) {
            return $url;
        }
 
        foreach ($urlProcessors as $identifier => $configuration) {
            if (empty($configuration) || !is_array($configuration)) {
                throw new \RuntimeException('Missing configuration for URI processor "' . $identifier . '".', 1442050529);
            }
            if (!is_string($configuration['processor']) || empty($configuration['processor']) || !class_exists($configuration['processor']) || !is_subclass_of($configuration['processor'], UrlProcessorInterface::class)) {
                throw new \RuntimeException('The URI processor "' . $identifier . '" defines an invalid provider. Ensure the class exists and implements the "' . UrlProcessorInterface::class . '".', 1442050579);
            }
        }
 
        $orderedProcessors = GeneralUtility::makeInstance(DependencyOrderingService::class)->orderByDependencies($urlProcessors);
        $keepProcessing = true;
 
        foreach ($orderedProcessors as $configuration) {
            $urlProcessor = GeneralUtility::makeInstance($configuration['processor']);
            $url = $urlProcessor->process($context, $url, $typolinkConfiguration, $this, $keepProcessing);
            if (!$keepProcessing) {
                break;
            }
        }
 
        return $url;
    }
 
    public function getMailTo($mailAddress, $linktxt)
    {
        $mailAddress = (string)$mailAddress;
        if ((string)$linktxt === '') {
            $linktxt = htmlspecialchars($mailAddress);
        }
 
        $originalMailToUrl = 'mailto:' . $mailAddress;
        $mailToUrl = $this->processUrl(UrlProcessorInterface::CONTEXT_MAIL, $originalMailToUrl);
 
        // no processing happened, therefore, the default processing kicks in
        if ($mailToUrl === $originalMailToUrl) {
            $tsfe = $this->getTypoScriptFrontendController();
            if ($tsfe->spamProtectEmailAddresses) {
                $mailToUrl = $this->‪encryptEmail($mailToUrl, $tsfe->spamProtectEmailAddresses);
                if ($tsfe->spamProtectEmailAddresses !== 'ascii') {
                    $encodedForJsAndHref = rawurlencode(GeneralUtility::quoteJSvalue($mailToUrl));
                    $mailToUrl = 'javascript:linkTo_UnCryptMailto(' . $encodedForJsAndHref . ');';
                }
                $atLabel = trim($tsfe->config['config']['spamProtectEmailAddresses_atSubst']) ?: '(at)';
                $spamProtectedMailAddress = str_replace('@', $atLabel, htmlspecialchars($mailAddress));
                if ($tsfe->config['config']['spamProtectEmailAddresses_lastDotSubst']) {
                    $lastDotLabel = trim($tsfe->config['config']['spamProtectEmailAddresses_lastDotSubst']);
                    $lastDotLabel = $lastDotLabel ?: '(dot)';
                    $spamProtectedMailAddress = preg_replace('/\\.([^\\.]+)$/', $lastDotLabel . '$1', $spamProtectedMailAddress);
                    if ($spamProtectedMailAddress === null) {
                        $this->logger->debug('Error replacing the last dot in email address "' . $spamProtectedMailAddress . '"');
                        $spamProtectedMailAddress = '';
                    }
                }
                $linktxt = str_ireplace($mailAddress, $spamProtectedMailAddress, $linktxt);
            }
        }
 
        return [$mailToUrl, $linktxt];
    }
 
    protected function encryptEmail(string $string, $type): string
    {
        $out = '';
        // obfuscates using the decimal HTML entity references for each character
        if ($type === 'ascii') {
            foreach (preg_split('//u', $string, -1, PREG_SPLIT_NO_EMPTY) as $char) {
                $out .= '&#' . mb_ord($char) . ';';
            }
        } else {
            // like str_rot13() but with a variable offset and a wider character range
            $len = strlen($string);
            $offset = (int)$type;
            for ($i = 0; $i < $len; $i++) {
                $charValue = ord($string[$i]);
                // 0-9 . , - + / :
                if ($charValue >= 43 && $charValue <= 58) {
                    $out .= $this->encryptCharcode($charValue, 43, 58, $offset);
                } elseif ($charValue >= 64 && $charValue <= 90) {
                    // A-Z @
                    $out .= $this->encryptCharcode($charValue, 64, 90, $offset);
                } elseif ($charValue >= 97 && $charValue <= 122) {
                    // a-z
                    $out .= $this->encryptCharcode($charValue, 97, 122, $offset);
                } else {
                    $out .= $string[$i];
                }
            }
        }
        return $out;
    }
 
    protected function encryptCharcode($n, $start, $end, $offset)
    {
        $n = $n + $offset;
        if ($offset > 0 && $n > $end) {
            $n = $start + ($n - $end - 1);
        } elseif ($offset < 0 && $n < $start) {
            $n = $end - ($start - $n - 1);
        }
        return chr($n);
    }
 
    public function getQueryArguments($conf, $overruleQueryArguments = [], $forceOverruleArguments = false)
    {
        $exclude = [];
        $method = (string)($conf['method'] ?? '');
        if ($method === 'POST') {
            trigger_error('Assigning typolink.addQueryString.method = POST is not supported anymore since TYPO3 v10.0.', E_USER_WARNING);
            return '';
        }
        if ($method === 'GET,POST' || $method === 'POST,GET') {
            trigger_error('Assigning typolink.addQueryString.method = GET,POST or POST,GET is not supported anymore since TYPO3 v10.0 - falling back to GET.', E_USER_WARNING);
            $method = 'GET';
        }
        if ($method === 'GET') {
            $currentQueryArray = GeneralUtility::_GET();
        } else {
            $currentQueryArray = [];
            parse_str($this->getEnvironmentVariable('QUERY_STRING'), $currentQueryArray);
        }
        if ($conf['exclude'] ?? false) {
            $excludeString = str_replace(',', '&', $conf['exclude']);
            $excludedQueryParts = [];
            parse_str($excludeString, $excludedQueryParts);
            // never repeat id
            $exclude['id'] = 0;
            $newQueryArray = ArrayUtility::arrayDiffKeyRecursive($currentQueryArray, $excludedQueryParts);
        } else {
            $newQueryArray = $currentQueryArray;
        }
        ArrayUtility::mergeRecursiveWithOverrule($newQueryArray, $overruleQueryArguments, $forceOverruleArguments);
        return HttpUtility::buildQueryString($newQueryArray, '&');
    }
 
    /***********************************************
     *
     * Miscellaneous functions, stand alone
     *
     ***********************************************/
    public function wrap($content, $wrap, $char = '|')
    {
        if ($wrap) {
            $wrapArr = explode($char, $wrap);
            $content = trim($wrapArr[0] ?? '') . $content . trim($wrapArr[1] ?? '');
        }
        return $content;
    }
 
    public function noTrimWrap($content, $wrap, $char = '|')
    {
        if ($wrap) {
            // expects to be wrapped with (at least) 3 characters (before, middle, after)
            // anything else is not taken into account
            $wrapArr = explode($char, $wrap, 4);
            $content = $wrapArr[1] . $content . $wrapArr[2];
        }
        return $content;
    }
 
    public function callUserFunction($funcName, $conf, $content)
    {
        // Split parts
        $parts = explode('->', $funcName);
        if (count($parts) === 2) {
            // Check whether PHP class is available
            if (class_exists($parts[0])) {
                if ($this->container && $this->container->has($parts[0])) {
                    $classObj = $this->container->get($parts[0]);
                } else {
                    $classObj = GeneralUtility::makeInstance($parts[0]);
                }
                $methodName = (string)$parts[1];
                $callable = [$classObj, $methodName];
                if (is_object($classObj) && method_exists($classObj, $parts[1]) && is_callable($callable)) {
                    $classObj->cObj = $this;
                    $content = call_user_func_array($callable, [
                        $content,
                        $conf
                    ]);
                } else {
                    $this->getTimeTracker()->setTSlogMessage('Method "' . $parts[1] . '" did not exist in class "' . $parts[0] . '"', 3);
                }
            } else {
                $this->getTimeTracker()->setTSlogMessage('Class "' . $parts[0] . '" did not exist', 3);
            }
        } elseif (function_exists($funcName)) {
            $content = $funcName($content, $conf);
        } else {
            $this->getTimeTracker()->setTSlogMessage('Function "' . $funcName . '" did not exist', 3);
        }
        return $content;
    }
 
    public function keywords($content)
    {
        $listArr = preg_split('/[,;' . LF . ']/', $content);
        if ($listArr === false) {
            return '';
        }
        foreach ($listArr as $k => $v) {
            $listArr[$k] = trim($v);
        }
        return implode(',', $listArr);
    }
 
    public function caseshift($theValue, $case)
    {
        switch (strtolower($case)) {
            case 'upper':
                $theValue = mb_strtoupper($theValue, 'utf-8');
                break;
            case 'lower':
                $theValue = mb_strtolower($theValue, 'utf-8');
                break;
            case 'capitalize':
                $theValue = mb_convert_case($theValue, MB_CASE_TITLE, 'utf-8');
                break;
            case 'ucfirst':
                $firstChar = mb_substr($theValue, 0, 1, 'utf-8');
                $firstChar = mb_strtoupper($firstChar, 'utf-8');
                $remainder = mb_substr($theValue, 1, null, 'utf-8');
                $theValue = $firstChar . $remainder;
                break;
            case 'lcfirst':
                $firstChar = mb_substr($theValue, 0, 1, 'utf-8');
                $firstChar = mb_strtolower($firstChar, 'utf-8');
                $remainder = mb_substr($theValue, 1, null, 'utf-8');
                $theValue = $firstChar . $remainder;
                break;
            case 'uppercamelcase':
                $theValue = GeneralUtility::underscoredToUpperCamelCase($theValue);
                break;
            case 'lowercamelcase':
                $theValue = GeneralUtility::underscoredToLowerCamelCase($theValue);
                break;
        }
        return $theValue;
    }
 
    public function HTMLcaseshift($theValue, $case)
    {
        $inside = 0;
        $newVal = '';
        $pointer = 0;
        $totalLen = strlen($theValue);
        do {
            if (!$inside) {
                $len = strcspn(substr($theValue, $pointer), '<');
                $newVal .= $this->caseshift(substr($theValue, $pointer, $len), $case);
                $inside = 1;
            } else {
                $len = strcspn(substr($theValue, $pointer), '>') + 1;
                $newVal .= substr($theValue, $pointer, $len);
                $inside = 0;
            }
            $pointer += $len;
        } while ($pointer < $totalLen);
        return $newVal;
    }
 
    public function calcAge($seconds, $labels)
    {
        if (MathUtility::canBeInterpretedAsInteger($labels)) {
            $labels = ' min| hrs| days| yrs| min| hour| day| year';
        } else {
            $labels = str_replace('"', '', $labels);
        }
        $labelArr = explode('|', $labels);
        if (count($labelArr) === 4) {
            $labelArr = array_merge($labelArr, $labelArr);
        }
        $absSeconds = abs($seconds);
        $sign = $seconds > 0 ? 1 : -1;
        if ($absSeconds < 3600) {
            $val = round($absSeconds / 60);
            $seconds = $sign * $val . ($val == 1 ? $labelArr[4] : $labelArr[0]);
        } elseif ($absSeconds < 24 * 3600) {
            $val = round($absSeconds / 3600);
            $seconds = $sign * $val . ($val == 1 ? $labelArr[5] : $labelArr[1]);
        } elseif ($absSeconds < 365 * 24 * 3600) {
            $val = round($absSeconds / (24 * 3600));
            $seconds = $sign * $val . ($val == 1 ? $labelArr[6] : $labelArr[2]);
        } else {
            $val = round($absSeconds / (365 * 24 * 3600));
            $seconds = $sign * $val . ($val == 1 ? ($labelArr[7] ?? null) : ($labelArr[3] ?? null));
        }
        return $seconds;
    }
 
    public function sendNotifyEmail($message, $recipients, $cc, $senderAddress, $senderName = '', $replyTo = '')
    {
        trigger_error('ContentObjectRenderer::sendNotifyEmail is deprecated and will be removed in TYPO3 v11. Consider using the mail API directly.', E_USER_DEPRECATED);
        $mail = GeneralUtility::makeInstance(MailMessage::class);
        $senderName = trim($senderName);
        $senderAddress = trim($senderAddress);
        if ($senderAddress !== '') {
            $mail->from(new Address($senderAddress, $senderName));
        }
        $parsedReplyTo = MailUtility::parseAddresses($replyTo);
        if (!empty($parsedReplyTo)) {
            $mail->replyTo($parsedReplyTo);
        }
        $message = trim($message);
        if ($message !== '') {
            // First line is subject
            $messageParts = explode(LF, $message, 2);
            $subject = trim($messageParts[0]);
            $plainMessage = trim($messageParts[1]);
            $parsedRecipients = MailUtility::parseAddresses($recipients);
            if (!empty($parsedRecipients)) {
                $mail->to(...$parsedRecipients)
                    ->subject($subject)
                    ->text($plainMessage);
                $mail->send();
            }
            $parsedCc = MailUtility::parseAddresses($cc);
            if (!empty($parsedCc)) {
                $from = $mail->getFrom();
                $mail = GeneralUtility::makeInstance(MailMessage::class);
                if (!empty($parsedReplyTo)) {
                    $mail->replyTo($parsedReplyTo);
                }
                $mail->from($from)
                    ->to(...$parsedCc)
                    ->subject($subject)
                    ->text($plainMessage);
                $mail->send();
            }
            return true;
        }
        return false;
    }
 
    public function mergeTSRef($confArr, $prop)
    {
        if ($confArr[$prop][0] === '<') {
            $key = trim(substr($confArr[$prop], 1));
            $cF = GeneralUtility::makeInstance(TypoScriptParser::class);
            // $name and $conf is loaded with the referenced values.
            $old_conf = $confArr[$prop . '.'];
            [, $conf] = $cF->getVal($key, $this->getTypoScriptFrontendController()->tmpl->setup);
            if (is_array($old_conf) && !empty($old_conf)) {
                $conf = is_array($conf) ? array_replace_recursive($conf, $old_conf) : $old_conf;
            }
            $confArr[$prop . '.'] = $conf;
        }
        return $confArr;
    }
 
    /***********************************************
     *
     * Database functions, making of queries
     *
     ***********************************************/
    public function getTreeList($id, $depth, $begin = 0, $dontCheckEnableFields = false, $addSelectFields = '', $moreWhereClauses = '', array $prevId_array = [], $recursionLevel = 0)
    {
        $id = (int)$id;
        if (!$id) {
            return '';
        }
 
        // Init vars:
        $allFields = 'uid,hidden,starttime,endtime,fe_group,extendToSubpages,doktype,php_tree_stop,mount_pid,mount_pid_ol,t3ver_state,l10n_parent' . $addSelectFields;
        $depth = (int)$depth;
        $begin = (int)$begin;
        $theList = [];
        $addId = 0;
        $requestHash = '';
 
        // First level, check id (second level, this is done BEFORE the recursive call)
        $tsfe = $this->getTypoScriptFrontendController();
        if (!$recursionLevel) {
            // Check tree list cache
            // First, create the hash for this request - not sure yet whether we need all these parameters though
            $parameters = [
                $id,
                $depth,
                $begin,
                $dontCheckEnableFields,
                $addSelectFields,
                $moreWhereClauses,
                $prevId_array,
                GeneralUtility::makeInstance(Context::class)->getPropertyFromAspect('frontend.user', 'groupIds', [0, -1])
            ];
            $requestHash = md5(serialize($parameters));
            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                ->getQueryBuilderForTable('cache_treelist');
            $cacheEntry = $queryBuilder->select('treelist')
                ->from('cache_treelist')
                ->where(
                    $queryBuilder->expr()->eq(
                        'md5hash',
                        $queryBuilder->createNamedParameter($requestHash, \PDO::PARAM_STR)
                    ),
                    $queryBuilder->expr()->orX(
                        $queryBuilder->expr()->gt(
                            'expires',
                            $queryBuilder->createNamedParameter(‪$GLOBALS['EXEC_TIME'], \PDO::PARAM_INT)
                        ),
                        $queryBuilder->expr()->eq('expires', $queryBuilder->createNamedParameter(0, \PDO::PARAM_INT))
                    )
                )
                ->setMaxResults(1)
                ->execute()
                ->fetch();
 
            if (is_array($cacheEntry)) {
                // Cache hit
                return $cacheEntry['treelist'];
            }
            // If Id less than zero it means we should add the real id to list:
            if ($id < 0) {
                $addId = $id = abs($id);
            }
            // Check start page:
            if ($tsfe->sys_page->getRawRecord('pages', $id, 'uid')) {
                // Find mount point if any:
                $mount_info = $tsfe->sys_page->getMountPointInfo($id);
                if (is_array($mount_info)) {
                    $id = $mount_info['mount_pid'];
                    // In Overlay mode, use the mounted page uid as added ID!:
                    if ($addId && $mount_info['overlay']) {
                        $addId = $id;
                    }
                }
            } else {
                // Return blank if the start page was NOT found at all!
                return '';
            }
        }
        // Add this ID to the array of IDs
        if ($begin <= 0) {
            $prevId_array[] = $id;
        }
        // Select sublevel:
        if ($depth > 0) {
            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('pages');
            $queryBuilder->getRestrictions()
                ->removeAll()
                ->add(GeneralUtility::makeInstance(DeletedRestriction::class));
            $queryBuilder->select(...GeneralUtility::trimExplode(',', $allFields, true))
                ->from('pages')
                ->where(
                    $queryBuilder->expr()->eq(
                        'pid',
                        $queryBuilder->createNamedParameter($id, \PDO::PARAM_INT)
                    ),
                    // tree is only built by language=0 pages
                    $queryBuilder->expr()->eq('sys_language_uid', 0)
                )
                ->orderBy('sorting');
 
            if (!empty($moreWhereClauses)) {
                $queryBuilder->andWhere(QueryHelper::stripLogicalOperatorPrefix($moreWhereClauses));
            }
 
            $result = $queryBuilder->execute();
            while ($row = $result->fetch()) {
                $versionState = VersionState::cast($row['t3ver_state']);
                $tsfe->sys_page->versionOL('pages', $row);
                if ($row === false
                    || (int)$row['doktype'] === PageRepository::DOKTYPE_RECYCLER
                    || (int)$row['doktype'] === PageRepository::DOKTYPE_BE_USER_SECTION
                    || $versionState->indicatesPlaceholder()
                ) {
                    // falsy row means Overlay prevents access to this page.
                    // Doing this after the overlay to make sure changes
                    // in the overlay are respected.
                    // However, we do not process pages below of and
                    // including of type recycler and BE user section
                    continue;
                }
                // Find mount point if any:
                $next_id = $row['uid'];
                $mount_info = $tsfe->sys_page->getMountPointInfo($next_id, $row);
                // Overlay mode:
                if (is_array($mount_info) && $mount_info['overlay']) {
                    $next_id = $mount_info['mount_pid'];
                    $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                        ->getQueryBuilderForTable('pages');
                    $queryBuilder->getRestrictions()
                        ->removeAll()
                        ->add(GeneralUtility::makeInstance(DeletedRestriction::class));
                    $queryBuilder->select(...GeneralUtility::trimExplode(',', $allFields, true))
                        ->from('pages')
                        ->where(
                            $queryBuilder->expr()->eq(
                                'uid',
                                $queryBuilder->createNamedParameter($next_id, \PDO::PARAM_INT)
                            )
                        )
                        ->orderBy('sorting')
                        ->setMaxResults(1);
 
                    if (!empty($moreWhereClauses)) {
                        $queryBuilder->andWhere(QueryHelper::stripLogicalOperatorPrefix($moreWhereClauses));
                    }
 
                    $row = $queryBuilder->execute()->fetch();
                    $tsfe->sys_page->versionOL('pages', $row);
                    if ((int)$row['doktype'] === PageRepository::DOKTYPE_RECYCLER
                        || (int)$row['doktype'] === PageRepository::DOKTYPE_BE_USER_SECTION
                        || $versionState->indicatesPlaceholder()
                    ) {
                        // Doing this after the overlay to make sure
                        // changes in the overlay are respected.
                        // see above
                        continue;
                    }
                }
                // Add record:
                if ($dontCheckEnableFields || $tsfe->checkPagerecordForIncludeSection($row)) {
                    // Add ID to list:
                    if ($begin <= 0) {
                        if ($dontCheckEnableFields || $tsfe->checkEnableFields($row)) {
                            $theList[] = $next_id;
                        }
                    }
                    // Next level:
                    if ($depth > 1 && !$row['php_tree_stop']) {
                        // Normal mode:
                        if (is_array($mount_info) && !$mount_info['overlay']) {
                            $next_id = $mount_info['mount_pid'];
                        }
                        // Call recursively, if the id is not in prevID_array:
                        if (!in_array($next_id, $prevId_array)) {
                            $theList = array_merge(
                                GeneralUtility::intExplode(
                                    ',',
                                    $this->getTreeList(
                                        $next_id,
                                        $depth - 1,
                                        $begin - 1,
                                        $dontCheckEnableFields,
                                        $addSelectFields,
                                        $moreWhereClauses,
                                        $prevId_array,
                                        $recursionLevel + 1
                                    ),
                                    true
                                ),
                                $theList
                            );
                        }
                    }
                }
            }
        }
        // If first run, check if the ID should be returned:
        if (!$recursionLevel) {
            if ($addId) {
                if ($begin > 0) {
                    $theList[] = 0;
                } else {
                    $theList[] = $addId;
                }
            }
 
            $cacheEntry = [
                'md5hash' => $requestHash,
                'pid' => $id,
                'treelist' => implode(',', $theList),
                'tstamp' => ‪$GLOBALS['EXEC_TIME'],
            ];
 
            // Only add to cache if not logged into TYPO3 Backend
            if (!$this->getFrontendBackendUser() instanceof ‪AbstractUserAuthentication) {
                $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable('cache_treelist');
                try {
                    $connection->transactional(function ($connection) use ($cacheEntry) {
                        $connection->insert('cache_treelist', $cacheEntry);
                    });
                } catch (\Throwable $e) {
                }
            }
        }
 
        return implode(',', $theList);
    }
 
    public function searchWhere($searchWords, $searchFieldList, $searchTable)
    {
        if (!$searchWords) {
            return '';
        }
 
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable($searchTable);
 
        $prefixTableName = $searchTable ? $searchTable . '.' : '';
 
        $where = $queryBuilder->expr()->andX();
        $searchFields = explode(',', $searchFieldList);
        $searchWords = preg_split('/[ ,]/', $searchWords);
        foreach ($searchWords as $searchWord) {
            $searchWord = trim($searchWord);
            if (strlen($searchWord) < 3) {
                continue;
            }
            $searchWordConstraint = $queryBuilder->expr()->orX();
            $searchWord = $queryBuilder->escapeLikeWildcards($searchWord);
            foreach ($searchFields as $field) {
                $searchWordConstraint->add(
                    $queryBuilder->expr()->like($prefixTableName . $field, $queryBuilder->quote('%' . $searchWord . '%'))
                );
            }
 
            if ($searchWordConstraint->count()) {
                $where->add($searchWordConstraint);
            }
        }
 
        if ((string)$where === '') {
            return '';
        }
 
        return ' AND (' . (string)$where . ')';
    }
 
    public function exec_getQuery($table, $conf)
    {
        $statement = $this->getQuery($table, $conf);
        $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($table);
 
        return $connection->executeQuery($statement);
    }
 
    public function getRecords($tableName, array $queryConfiguration)
    {
        $records = [];
 
        $statement = $this->exec_getQuery($tableName, $queryConfiguration);
 
        $tsfe = $this->getTypoScriptFrontendController();
        while ($row = $statement->fetch()) {
            // Versioning preview:
            $tsfe->sys_page->versionOL($tableName, $row, true);
 
            // Language overlay:
            if (is_array($row)) {
                $row = $tsfe->sys_page->getLanguageOverlay($tableName, $row);
            }
 
            // Might be unset in the language overlay
            if (is_array($row)) {
                $records[] = $row;
            }
        }
 
        return $records;
    }
 
    public function getQuery($table, $conf, $returnQueryArray = false)
    {
        // Resolve stdWrap in these properties first
        $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($table);
        $properties = [
            'pidInList',
            'uidInList',
            'languageField',
            'selectFields',
            'max',
            'begin',
            'groupBy',
            'orderBy',
            'join',
            'leftjoin',
            'rightjoin',
            'recursive',
            'where'
        ];
        foreach ($properties as $property) {
            $conf[$property] = trim(
                isset($conf[$property . '.'])
                    ? $this->stdWrap($conf[$property], $conf[$property . '.'])
                    : $conf[$property]
            );
            if ($conf[$property] === '') {
                unset($conf[$property]);
            } elseif (in_array($property, ['languageField', 'selectFields', 'join', 'leftjoin', 'rightjoin', 'where'], true)) {
                $conf[$property] = QueryHelper::quoteDatabaseIdentifiers($connection, $conf[$property]);
            }
            if (isset($conf[$property . '.'])) {
                // stdWrapping already done, so remove the sub-array
                unset($conf[$property . '.']);
            }
        }
        // Handle PDO-style named parameter markers first
        $queryMarkers = $this->getQueryMarkers($table, $conf);
        // Replace the markers in the non-stdWrap properties
        foreach ($queryMarkers as $marker => $markerValue) {
            $properties = [
                'uidInList',
                'selectFields',
                'where',
                'max',
                'begin',
                'groupBy',
                'orderBy',
                'join',
                'leftjoin',
                'rightjoin'
            ];
            foreach ($properties as $property) {
                if ($conf[$property]) {
                    $conf[$property] = str_replace('###' . $marker . '###', $markerValue, $conf[$property]);
                }
            }
        }
 
        // Construct WHERE clause:
        // Handle recursive function for the pidInList
        if (isset($conf['recursive'])) {
            $conf['recursive'] = (int)$conf['recursive'];
            if ($conf['recursive'] > 0) {
                $pidList = GeneralUtility::trimExplode(',', $conf['pidInList'], true);
                array_walk($pidList, function (&$storagePid) {
                    if ($storagePid === 'this') {
                        $storagePid = $this->getTypoScriptFrontendController()->id;
                    }
                    if ($storagePid > 0) {
                        $storagePid = -$storagePid;
                    }
                });
                $expandedPidList = [];
                foreach ($pidList as $value) {
                    // Implementation of getTreeList allows to pass the id negative to include
                    // it into the result otherwise only childpages are returned
                    $expandedPidList = array_merge(
                        GeneralUtility::intExplode(',', $this->getTreeList((int)$value, (int)($conf['recursive'] ?? 0))),
                        $expandedPidList
                    );
                }
                $conf['pidInList'] = implode(',', $expandedPidList);
            }
        }
        if ((string)$conf['pidInList'] === '') {
            $conf['pidInList'] = 'this';
        }
 
        $queryParts = $this->getQueryConstraints($table, $conf);
 
        $queryBuilder = $connection->createQueryBuilder();
        // @todo Check against getQueryConstraints, can probably use FrontendRestrictions
        // @todo here and remove enableFields there.
        $queryBuilder->getRestrictions()->removeAll();
        $queryBuilder->select('*')->from($table);
 
        if ($queryParts['where']) {
            $queryBuilder->where($queryParts['where']);
        }
 
        if ($queryParts['groupBy']) {
            $queryBuilder->groupBy(...$queryParts['groupBy']);
        }
 
        if (is_array($queryParts['orderBy'])) {
            foreach ($queryParts['orderBy'] as $orderBy) {
                $queryBuilder->addOrderBy(...$orderBy);
            }
        }
 
        // Fields:
        if ($conf['selectFields']) {
            $queryBuilder->selectLiteral($this->sanitizeSelectPart($conf['selectFields'], $table));
        }
 
        // Setting LIMIT:
        $error = false;
        if ($conf['max'] || $conf['begin']) {
            // Finding the total number of records, if used:
            if (strpos(strtolower($conf['begin'] . $conf['max']), 'total') !== false) {
                $countQueryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($table);
                $countQueryBuilder->getRestrictions()->removeAll();
                $countQueryBuilder->count('*')
                    ->from($table)
                    ->where($queryParts['where']);
 
                if ($queryParts['groupBy']) {
                    $countQueryBuilder->groupBy(...$queryParts['groupBy']);
                }
 
                try {
                    $count = $countQueryBuilder->execute()->fetchColumn(0);
                    $conf['max'] = str_ireplace('total', $count, $conf['max']);
                    $conf['begin'] = str_ireplace('total', $count, $conf['begin']);
                } catch (DBALException $e) {
                    $this->getTimeTracker()->setTSlogMessage($e->getPrevious()->getMessage());
                    $error = true;
                }
            }
 
            if (!$error) {
                $conf['begin'] = MathUtility::forceIntegerInRange((int)ceil($this->calc($conf['begin'])), 0);
                $conf['max'] = MathUtility::forceIntegerInRange((int)ceil($this->calc($conf['max'])), 0);
                if ($conf['begin'] > 0) {
                    $queryBuilder->setFirstResult($conf['begin']);
                }
                $queryBuilder->setMaxResults($conf['max'] ?: 100000);
            }
        }
 
        if (!$error) {
            // Setting up tablejoins:
            if ($conf['join']) {
                $joinParts = QueryHelper::parseJoin($conf['join']);
                $queryBuilder->join(
                    $table,
                    $joinParts['tableName'],
                    $joinParts['tableAlias'],
                    $joinParts['joinCondition']
                );
            } elseif ($conf['leftjoin']) {
                $joinParts = QueryHelper::parseJoin($conf['leftjoin']);
                $queryBuilder->leftJoin(
                    $table,
                    $joinParts['tableName'],
                    $joinParts['tableAlias'],
                    $joinParts['joinCondition']
                );
            } elseif ($conf['rightjoin']) {
                $joinParts = QueryHelper::parseJoin($conf['rightjoin']);
                $queryBuilder->rightJoin(
                    $table,
                    $joinParts['tableName'],
                    $joinParts['tableAlias'],
                    $joinParts['joinCondition']
                );
            }
 
            // Convert the QueryBuilder object into a SQL statement.
            $query = $queryBuilder->getSQL();
 
            // Replace the markers in the queryParts to handle stdWrap enabled properties
            foreach ($queryMarkers as $marker => $markerValue) {
                // @todo Ugly hack that needs to be cleaned up, with the current architecture
                // @todo for exec_Query / getQuery it's the best we can do.
                $query = str_replace('###' . $marker . '###', $markerValue, $query);
                foreach ($queryParts as $queryPartKey => &$queryPartValue) {
                    $queryPartValue = str_replace('###' . $marker . '###', $markerValue, $queryPartValue);
                }
                unset($queryPartValue);
            }
 
            return $returnQueryArray ? $this->getQueryArray($queryBuilder) : $query;
        }
 
        return '';
    }
 
    protected function getQueryArray(QueryBuilder $queryBuilder)
    {
        $fromClauses = [];
        $knownAliases = [];
        $queryParts = [];
 
        // Loop through all FROM clauses
        foreach ($queryBuilder->getQueryPart('from') as $from) {
            if ($from['alias'] === null) {
                $tableSql = $from['table'];
                $tableReference = $from['table'];
            } else {
                $tableSql = $from['table'] . ' ' . $from['alias'];
                $tableReference = $from['alias'];
            }
 
            $knownAliases[$tableReference] = true;
 
            $fromClauses[$tableReference] = $tableSql . $this->‪getQueryArrayJoinHelper(
                $tableReference,
                $queryBuilder->getQueryPart('join'),
                $knownAliases
            );
        }
 
        $queryParts['SELECT'] = implode(', ', $queryBuilder->getQueryPart('select'));
        $queryParts['FROM'] = implode(', ', $fromClauses);
        $queryParts['WHERE'] = (string)$queryBuilder->getQueryPart('where') ?: '';
        $queryParts['GROUPBY'] = implode(', ', $queryBuilder->getQueryPart('groupBy'));
        $queryParts['ORDERBY'] = implode(', ', $queryBuilder->getQueryPart('orderBy'));
        if ($queryBuilder->getFirstResult() > 0) {
            $queryParts['LIMIT'] = $queryBuilder->getFirstResult() . ',' . $queryBuilder->getMaxResults();
        } elseif ($queryBuilder->getMaxResults() > 0) {
            $queryParts['LIMIT'] = $queryBuilder->getMaxResults();
        }
 
        return $queryParts;
    }
 
    protected function getQueryArrayJoinHelper(string $fromAlias, array $joinParts, array &$knownAliases): string
    {
        $sql = '';
 
        if (isset($joinParts['join'][$fromAlias])) {
            foreach ($joinParts['join'][$fromAlias] as $join) {
                if (array_key_exists($join['joinAlias'], $knownAliases)) {
                    throw new \RuntimeException(
                        'Non unique join alias: "' . $join['joinAlias'] . '" found.',
                        1472748872
                    );
                }
                $sql .= ' ' . strtoupper($join['joinType'])
                    . ' JOIN ' . $join['joinTable'] . ' ' . $join['joinAlias']
                    . ' ON ' . ((string)$join['joinCondition']);
                $knownAliases[$join['joinAlias']] = true;
            }
 
            foreach ($joinParts['join'][$fromAlias] as $join) {
                $sql .= $this->getQueryArrayJoinHelper($join['joinAlias'], $joinParts, $knownAliases);
            }
        }
 
        return $sql;
    }
    protected function getQueryConstraints(string $table, array $conf): array
    {
        // Init:
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($table);
        $expressionBuilder = $queryBuilder->expr();
        $tsfe = $this->getTypoScriptFrontendController();
        $constraints = [];
        $pid_uid_flag = 0;
        $enableFieldsIgnore = [];
        $queryParts = [
            'where' => null,
            'groupBy' => null,
            'orderBy' => null,
        ];
 
        $isInWorkspace = GeneralUtility::makeInstance(Context::class)->getPropertyFromAspect('workspace', 'isOffline');
        $considerMovePlaceholders = (
            $isInWorkspace && $table !== 'pages'
            && !empty(‪$GLOBALS['TCA'][$table]['ctrl']['versioningWS'])
        );
 
        if (trim($conf['uidInList'])) {
            $listArr = GeneralUtility::intExplode(',', str_replace('this', (string)$tsfe->contentPid, $conf['uidInList']));
 
            // If move placeholder shall be considered, select via t3ver_move_id
            if ($considerMovePlaceholders) {
                $constraints[] = (string)$expressionBuilder->orX(
                    $expressionBuilder->in($table . '.uid', $listArr),
                    $expressionBuilder->andX(
                        $expressionBuilder->eq(
                            $table . '.t3ver_state',
                            (int)(string)VersionState::cast(VersionState::MOVE_PLACEHOLDER)
                        ),
                        $expressionBuilder->in($table . '.t3ver_move_id', $listArr)
                    )
                );
            } else {
                $constraints[] = (string)$expressionBuilder->in($table . '.uid', $listArr);
            }
            $pid_uid_flag++;
        }
 
        // Static_* tables are allowed to be fetched from root page
        if (strpos($table, 'static_') === 0) {
            $pid_uid_flag++;
        }
 
        if (trim($conf['pidInList'])) {
            $listArr = GeneralUtility::intExplode(',', str_replace('this', (string)$tsfe->contentPid, $conf['pidInList']));
            // Removes all pages which are not visible for the user!
            $listArr = $this->checkPidArray($listArr);
            if (GeneralUtility::inList($conf['pidInList'], 'root')) {
                $listArr[] = 0;
            }
            if (GeneralUtility::inList($conf['pidInList'], '-1')) {
                $listArr[] = -1;
                $enableFieldsIgnore['pid'] = true;
            }
            if (!empty($listArr)) {
                $constraints[] = $expressionBuilder->in($table . '.pid', array_map('intval', $listArr));
                $pid_uid_flag++;
            } else {
                // If not uid and not pid then uid is set to 0 - which results in nothing!!
                $pid_uid_flag = 0;
            }
        }
 
        // If not uid and not pid then uid is set to 0 - which results in nothing!!
        if (!$pid_uid_flag) {
            $constraints[] = $expressionBuilder->eq($table . '.uid', 0);
        }
 
        $where = isset($conf['where.']) ? trim($this->stdWrap($conf['where'], $conf['where.'])) : trim($conf['where']);
        if ($where) {
            $constraints[] = QueryHelper::stripLogicalOperatorPrefix($where);
        }
 
        // Check if the default language should be fetched (= doing overlays), or if only the records of a language should be fetched
        // but only do this for TCA tables that have languages enabled
        $languageConstraint = $this->getLanguageRestriction($expressionBuilder, $table, $conf, GeneralUtility::makeInstance(Context::class));
        if ($languageConstraint !== null) {
            $constraints[] = $languageConstraint;
        }
 
        // Enablefields
        if ($table === 'pages') {
            $constraints[] = QueryHelper::stripLogicalOperatorPrefix($tsfe->sys_page->where_hid_del);
            $constraints[] = QueryHelper::stripLogicalOperatorPrefix($tsfe->sys_page->where_groupAccess);
        } else {
            $constraints[] = QueryHelper::stripLogicalOperatorPrefix($tsfe->sys_page->enableFields($table, -1, $enableFieldsIgnore));
        }
 
        // MAKE WHERE:
        if (count($constraints) !== 0) {
            $queryParts['where'] = $expressionBuilder->andX(...$constraints);
        }
        // GROUP BY
        if (trim($conf['groupBy'])) {
            $groupBy = isset($conf['groupBy.'])
                ? trim($this->stdWrap($conf['groupBy'], $conf['groupBy.']))
                : trim($conf['groupBy']);
            $queryParts['groupBy'] = QueryHelper::parseGroupBy($groupBy);
        }
 
        // ORDER BY
        if (trim($conf['orderBy'])) {
            $orderByString = isset($conf['orderBy.'])
                ? trim($this->stdWrap($conf['orderBy'], $conf['orderBy.']))
                : trim($conf['orderBy']);
 
            $queryParts['orderBy'] = QueryHelper::parseOrderBy($orderByString);
        }
 
        // Return result:
        return $queryParts;
    }
 
    protected function getLanguageRestriction(‪ExpressionBuilder $expressionBuilder, string $table, array $conf, ‪Context $context)
    {
        $languageField = '';
        $localizationParentField = ‪$GLOBALS['TCA'][$table]['ctrl']['transOrigPointerField'] ?? null;
        // Check if the table is translatable, and set the language field by default from the TCA information
        if (!empty($conf['languageField']) || !isset($conf['languageField'])) {
            if (isset($conf['languageField']) && !empty(‪$GLOBALS['TCA'][$table]['columns'][$conf['languageField']])) {
                $languageField = $conf['languageField'];
            } elseif (!empty(‪$GLOBALS['TCA'][$table]['ctrl']['languageField']) && !empty($localizationParentField)) {
                $languageField = $table . '.' . ‪$GLOBALS['TCA'][$table]['ctrl']['languageField'];
            }
        }
 
        // No language restriction enabled explicitly or available via TCA
        if (empty($languageField)) {
            return null;
        }
 
        $languageAspect = $context->‪getAspect('language');
        if ($languageAspect->doOverlays() && !empty($localizationParentField)) {
            // Sys language content is set to zero/-1 - and it is expected that whatever routine processes the output will
            // OVERLAY the records with localized versions!
            $languageQuery = $expressionBuilder->‪in($languageField, [0, -1]);
            // Use this option to include records that don't have a default language counterpart ("free mode")
            // (originalpointerfield is 0 and the language field contains the requested language)
            if (isset($conf['includeRecordsWithoutDefaultTranslation']) || $conf['includeRecordsWithoutDefaultTranslation.']) {
                $includeRecordsWithoutDefaultTranslation = isset($conf['includeRecordsWithoutDefaultTranslation.']) ?
                    $this->stdWrap($conf['includeRecordsWithoutDefaultTranslation'], $conf['includeRecordsWithoutDefaultTranslation.']) : $conf['includeRecordsWithoutDefaultTranslation'];
                $includeRecordsWithoutDefaultTranslation = trim($includeRecordsWithoutDefaultTranslation) !== '';
            } else {
                // Option was not explicitly set, check what's in for the language overlay type.
                $includeRecordsWithoutDefaultTranslation = $languageAspect->getOverlayType() === $languageAspect::OVERLAYS_ON_WITH_FLOATING;
            }
            if ($includeRecordsWithoutDefaultTranslation) {
                $languageQuery = $expressionBuilder->‪orX(
                    $languageQuery,
                    $expressionBuilder->‪andX(
                        $expressionBuilder->‪eq($table . '.' . $localizationParentField, 0),
                        $expressionBuilder->‪eq($languageField, $languageAspect->getContentId())
                    )
                );
            }
            return $languageQuery;
        }
        // No overlays = only fetch records given for the requested language and "all languages"
        return $expressionBuilder->‪in($languageField, [$languageAspect->getContentId(), -1]);
    }
 
    protected function sanitizeSelectPart($selectPart, $table)
    {
        $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($table);
 
        // Pattern matching parts
        $matchStart = '/(^\\s*|,\\s*|' . $table . '\\.)';
        $matchEnd = '(\\s*,|\\s*$)/';
        $necessaryFields = ['uid', 'pid'];
        $wsFields = ['t3ver_state'];
        if (isset(‪$GLOBALS['TCA'][$table]) && !preg_match($matchStart . '\\*' . $matchEnd, $selectPart) && !preg_match('/(count|max|min|avg|sum)\\([^\\)]+\\)|distinct/i', $selectPart)) {
            foreach ($necessaryFields as $field) {
                $match = $matchStart . $field . $matchEnd;
                if (!preg_match($match, $selectPart)) {
                    $selectPart .= ', ' . $connection->quoteIdentifier($table . '.' . $field) . ' AS ' . $connection->quoteIdentifier($field);
                }
            }
            if (‪$GLOBALS['TCA'][$table]['ctrl']['versioningWS']) {
                foreach ($wsFields as $field) {
                    $match = $matchStart . $field . $matchEnd;
                    if (!preg_match($match, $selectPart)) {
                        $selectPart .= ', ' . $connection->quoteIdentifier($table . '.' . $field) . ' AS ' . $connection->quoteIdentifier($field);
                    }
                }
            }
        }
        return $selectPart;
    }
 
    public function checkPidArray($pageIds)
    {
        if (!is_array($pageIds) || empty($pageIds)) {
            return [];
        }
        $restrictionContainer = GeneralUtility::makeInstance(FrontendRestrictionContainer::class);
        $restrictionContainer->add(GeneralUtility::makeInstance(
            DocumentTypeExclusionRestriction::class,
            GeneralUtility::intExplode(',', (string)$this->checkPid_badDoktypeList, true)
        ));
        return $this->getTypoScriptFrontendController()->sys_page->filterAccessiblePageIds($pageIds, $restrictionContainer);
    }
 
    public function getQueryMarkers($table, $conf)
    {
        if (!is_array($conf['markers.'])) {
            return [];
        }
        // Parse markers and prepare their values
        $connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable($table);
        $markerValues = [];
        foreach ($conf['markers.'] as $dottedMarker => $dummy) {
            $marker = rtrim($dottedMarker, '.');
            if ($dottedMarker != $marker . '.') {
                continue;
            }
            // Parse definition
            $tempValue = isset($conf['markers.'][$dottedMarker])
                ? $this->stdWrap($conf['markers.'][$dottedMarker]['value'], $conf['markers.'][$dottedMarker])
                : $conf['markers.'][$dottedMarker]['value'];
            // Quote/escape if needed
            if (is_numeric($tempValue)) {
                if ((int)$tempValue == $tempValue) {
                    // Handle integer
                    $markerValues[$marker] = (int)$tempValue;
                } else {
                    // Handle float
                    $markerValues[$marker] = (float)$tempValue;
                }
            } elseif ($tempValue === null) {
                // It represents NULL
                $markerValues[$marker] = 'NULL';
            } elseif (!empty($conf['markers.'][$dottedMarker]['commaSeparatedList'])) {
                // See if it is really a comma separated list of values
                $explodeValues = GeneralUtility::trimExplode(',', $tempValue);
                if (count($explodeValues) > 1) {
                    // Handle each element of list separately
                    $tempArray = [];
                    foreach ($explodeValues as $listValue) {
                        if (is_numeric($listValue)) {
                            if ((int)$listValue == $listValue) {
                                $tempArray[] = (int)$listValue;
                            } else {
                                $tempArray[] = (float)$listValue;
                            }
                        } else {
                            // If quoted, remove quotes before
                            // escaping.
                            if (preg_match('/^\'([^\']*)\'$/', $listValue, $matches)) {
                                $listValue = $matches[1];
                            } elseif (preg_match('/^\\"([^\\"]*)\\"$/', $listValue, $matches)) {
                                $listValue = $matches[1];
                            }
                            $tempArray[] = $connection->quote($listValue);
                        }
                    }
                    $markerValues[$marker] = implode(',', $tempArray);
                } else {
                    // Handle remaining values as string
                    $markerValues[$marker] = $connection->quote($tempValue);
                }
            } else {
                // Handle remaining values as string
                $markerValues[$marker] = $connection->quote($tempValue);
            }
        }
        return $markerValues;
    }
 
    /***********************************************
     *
     * Frontend editing functions
     *
     ***********************************************/
    public function editPanel($content, $conf, $currentRecord = '', $dataArray = [])
    {
        if (!$this->getTypoScriptFrontendController()->isBackendUserLoggedIn()) {
            return $content;
        }
        if (!$this->getTypoScriptFrontendController()->displayEditIcons) {
            return $content;
        }
 
        if (!$currentRecord) {
            $currentRecord = $this->currentRecord;
        }
        if (empty($dataArray)) {
            $dataArray = $this->data;
        }
 
        if ($conf['newRecordFromTable']) {
            $currentRecord = $conf['newRecordFromTable'] . ':NEW';
            $conf['allow'] = 'new';
            $checkEditAccessInternals = false;
        } else {
            $checkEditAccessInternals = true;
        }
        [$table, $uid] = explode(':', $currentRecord);
        // Page ID for new records, 0 if not specified
        $newRecordPid = (int)$conf['newRecordInPid'];
        $newUid = null;
        if (!$conf['onlyCurrentPid'] || $dataArray['pid'] == $this->getTypoScriptFrontendController()->id) {
            if ($table === 'pages') {
                $newUid = $uid;
            } else {
                if ($conf['newRecordFromTable']) {
                    $newUid = $this->getTypoScriptFrontendController()->id;
                    if ($newRecordPid) {
                        $newUid = $newRecordPid;
                    }
                } else {
                    $newUid = -1 * $uid;
                }
            }
        }
        if ($table && $this->getFrontendBackendUser()->allowedToEdit($table, $dataArray, $conf, $checkEditAccessInternals) && $this->getFrontendBackendUser()->allowedToEditLanguage($table, $dataArray)) {
            $editClass = ‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['typo3/classes/class.frontendedit.php']['edit'];
            if ($editClass) {
                $edit = GeneralUtility::makeInstance($editClass);
                $allowedActions = $this->getFrontendBackendUser()->getAllowedEditActions($table, $conf, $dataArray['pid']);
                $content = $edit->editPanel($content, $conf, $currentRecord, $dataArray, $table, $allowedActions, $newUid, []);
            }
        }
        return $content;
    }
 
    public function editIcons($content, $params, array $conf = [], $currentRecord = '', $dataArray = [], $addUrlParamStr = '')
    {
        if (!$this->getTypoScriptFrontendController()->isBackendUserLoggedIn()) {
            return $content;
        }
        if (!$this->getTypoScriptFrontendController()->displayFieldEditIcons) {
            return $content;
        }
        if (!$currentRecord) {
            $currentRecord = $this->currentRecord;
        }
        if (empty($dataArray)) {
            $dataArray = $this->data;
        }
        // Check incoming params:
        [$currentRecordTable, $currentRecordUID] = explode(':', $currentRecord);
        [$fieldList, $table] = array_reverse(GeneralUtility::trimExplode(':', $params, true));
        // Reverse the array because table is optional
        if (!$table) {
            $table = $currentRecordTable;
        } elseif ($table != $currentRecordTable) {
            // If the table is set as the first parameter, and does not match the table of the current record, then just return.
            return $content;
        }
 
        $editUid = $dataArray['_LOCALIZED_UID'] ?: $currentRecordUID;
        // Edit icons imply that the editing action is generally allowed, assuming page and content element permissions permit it.
        if (!array_key_exists('allow', $conf)) {
            $conf['allow'] = 'edit';
        }
        if ($table && $this->getFrontendBackendUser()->allowedToEdit($table, $dataArray, $conf, true) && $fieldList && $this->getFrontendBackendUser()->allowedToEditLanguage($table, $dataArray)) {
            $editClass = ‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['typo3/classes/class.frontendedit.php']['edit'];
            if ($editClass) {
                $edit = GeneralUtility::makeInstance($editClass);
                $content = $edit->editIcons($content, $params, $conf, $currentRecord, $dataArray, $addUrlParamStr, $table, $editUid, $fieldList);
            }
        }
        return $content;
    }
 
    public function isDisabled($table, $row)
    {
        $tsfe = $this->getTypoScriptFrontendController();
        $enablecolumns = ‪$GLOBALS['TCA'][$table]['ctrl']['enablecolumns'];
        return $enablecolumns['disabled'] && $row[$enablecolumns['disabled']]
            || $enablecolumns['fe_group'] && $tsfe->simUserGroup && (int)$row[$enablecolumns['fe_group']] === (int)$tsfe->simUserGroup
            || $enablecolumns['starttime'] && $row[$enablecolumns['starttime']] > ‪$GLOBALS['EXEC_TIME']
            || $enablecolumns['endtime'] && $row[$enablecolumns['endtime']] && $row[$enablecolumns['endtime']] < ‪$GLOBALS['EXEC_TIME'];
    }
 
    protected function getResourceFactory()
    {
        return GeneralUtility::makeInstance(ResourceFactory::class);
    }
 
    protected function getEnvironmentVariable($key)
    {
        return GeneralUtility::getIndpEnv($key);
    }
 
    protected function getFromCache(array $configuration)
    {
        $content = false;
 
        if ($this->getTypoScriptFrontendController()->no_cache) {
            return $content;
        }
        $cacheKey = $this->calculateCacheKey($configuration);
        if (!empty($cacheKey)) {
            $cacheFrontend = GeneralUtility::makeInstance(CacheManager::class)
                ->getCache('hash');
            $content = $cacheFrontend->get($cacheKey);
        }
        return $content;
    }
 
    protected function calculateCacheLifetime(array $configuration)
    {
        $lifetimeConfiguration = $configuration['lifetime'] ?? '';
        $lifetimeConfiguration = isset($configuration['lifetime.'])
            ? $this->stdWrap($lifetimeConfiguration, $configuration['lifetime.'])
            : $lifetimeConfiguration;
 
        $lifetime = null; // default lifetime
        if (strtolower($lifetimeConfiguration) === 'unlimited') {
            $lifetime = 0; // unlimited
        } elseif ($lifetimeConfiguration > 0) {
            $lifetime = (int)$lifetimeConfiguration; // lifetime in seconds
        }
        return $lifetime;
    }
 
    protected function calculateCacheTags(array $configuration)
    {
        $tags = $configuration['tags'] ?? '';
        $tags = isset($configuration['tags.'])
            ? $this->stdWrap($tags, $configuration['tags.'])
            : $tags;
        return empty($tags) ? [] : GeneralUtility::trimExplode(',', $tags);
    }
 
    protected function calculateCacheKey(array $configuration)
    {
        $key = $configuration['key'] ?? '';
        return isset($configuration['key.'])
            ? $this->stdWrap($key, $configuration['key.'])
            : $key;
    }
 
    protected function getFrontendBackendUser()
    {
        return ‪$GLOBALS['BE_USER'];
    }
 
    protected function getTimeTracker()
    {
        return GeneralUtility::makeInstance(TimeTracker::class);
    }
 
    protected function getTypoScriptFrontendController()
    {
        return $this->typoScriptFrontendController ?: ‪$GLOBALS['TSFE'];
    }
 
    protected function resolveAnchorLink(string $linkText, array $conf): string
    {
        $anchorTag = '<a ' . $this->getATagParams($conf) . '>';
        $aTagParams = GeneralUtility::get_tag_attributes($anchorTag);
        // If it looks like a anchor tag, render it anyway
        if (isset($aTagParams['id']) || isset($aTagParams['name'])) {
            return $anchorTag . $linkText . '</a>';
        }
        // Otherwise just return the link text
        return $linkText;
    }
 
    protected function getContentLengthOfCurrentTag(string $theValue, int $pointer, string $currentTag): int
    {
        $tempContent = strtolower(substr($theValue, $pointer));
        $startTag = '<' . $currentTag;
        $endTag = '</' . $currentTag . '>';
        $offsetCount = 0;
 
        // Take care for nested tags
        do {
            $nextMatchingEndTagPosition = strpos($tempContent, $endTag);
            // only match tag `a` in `<a href"...">` but not in `<abbr>`
            $nextSameTypeTagPosition = preg_match(
                '#' . $startTag . '[\s/>]#',
                $tempContent,
                $nextSameStartTagMatches,
                PREG_OFFSET_CAPTURE
            ) ? $nextSameStartTagMatches[0][1] : false;
 
            // filter out nested tag contents to help getting the correct closing tag
            if ($nextMatchingEndTagPosition !== false && $nextSameTypeTagPosition !== false && $nextSameTypeTagPosition < $nextMatchingEndTagPosition) {
                $lastOpeningTagStartPosition = (int)strrpos(substr($tempContent, 0, $nextMatchingEndTagPosition), $startTag);
                $closingTagEndPosition = $nextMatchingEndTagPosition + strlen($endTag);
                $offsetCount += $closingTagEndPosition - $lastOpeningTagStartPosition;
 
                // replace content from latest tag start to latest tag end
                $tempContent = substr($tempContent, 0, $lastOpeningTagStartPosition) . substr($tempContent, $closingTagEndPosition);
            }
        } while (
            ($nextMatchingEndTagPosition !== false && $nextSameTypeTagPosition !== false) &&
            $nextSameTypeTagPosition < $nextMatchingEndTagPosition
        );
 
        // if no closing tag is found we use length of the whole content
        $endingOffset = strlen($tempContent);
        if ($nextMatchingEndTagPosition !== false) {
            $endingOffset = $nextMatchingEndTagPosition + $offsetCount;
        }
 
        return $endingOffset;
    }
 
    protected function shallDebug(): bool
    {
        $tsfe = $this->getTypoScriptFrontendController();
        if ($tsfe !== null && isset($tsfe->config['config']['debug'])) {
            return (bool)($tsfe->config['config']['debug']);
        }
        return !empty(‪$GLOBALS['TYPO3_CONF_VARS']['FE']['debug']);
    }
}