ContentObjectRenderer.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Frontend\ContentObject;

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

use TYPO3\CMS\Core\Cache\CacheManager;
use TYPO3\CMS\Core\FrontendEditing\FrontendEditingController;
use TYPO3\CMS\Core\Html\HtmlParser;
use TYPO3\CMS\Core\Log\LogManager;
use TYPO3\CMS\Core\Mail\MailMessage;
use TYPO3\CMS\Core\Resource\Exception;
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\Folder;
use TYPO3\CMS\Core\Resource\ProcessedFile;
use TYPO3\CMS\Core\Resource\ResourceFactory;
use TYPO3\CMS\Core\Service\DependencyOrderingService;
use TYPO3\CMS\Core\Service\MarkerBasedTemplateService;
use TYPO3\CMS\Core\TypoScript\Parser\TypoScriptParser;
use TYPO3\CMS\Core\TypoScript\TemplateService;
use TYPO3\CMS\Core\Utility\ArrayUtility;
use TYPO3\CMS\Core\Utility\DebugUtility;
use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
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\CacheHashCalculator;
use TYPO3\CMS\Frontend\Page\PageRepository;
use TYPO3\CMS\Frontend\Service\TypoLinkCodecService;

class ContentObjectRenderer
{
    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',
        'filelist' => 'dir',
        'filelist.' => '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',
        'removeBadHTML' => 'boolean',
        'removeBadHTML.' => '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',
        'fontTag' => 'wrap',
        'fontTag.' => 'array',
        'addParams.' => 'array',
        'textStyle.' => 'array',
        'tableStyle.' => 'array',
        'filelink.' => 'array',
        'preCObject' => 'cObject',
        'preCObject.' => 'array',
        'postCObject' => 'cObject',
        'postCObject.' => 'array',
        'wrapAlign' => 'align',
        'wrapAlign.' => 'array',
        'typolink.' => 'array',
        'TCAselectItem.' => 'array',
        'space' => 'space',
        'space.' => 'array',
        'spaceBefore' => 'int',
        'spaceBefore.' => 'array',
        'spaceAfter' => 'int',
        'spaceAfter.' => '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',
        'offsetWrap' => 'space',
        'offsetWrap.' => 'array',
        'postUserFunc' => 'functionName',
        'postUserFuncInt' => 'functionName',
        'prefixComment' => 'string',
        'prefixComment.' => 'array',
        'editIcons' => 'string',
        'editIcons.' => 'array',
        'editPanel' => 'boolean',
        'editPanel.' => '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 $image_compression = [
        10 => [
            'params' => '',
            'ext' => 'gif'
        ],
        11 => [
            'params' => '-colors 128',
            'ext' => 'gif'
        ],
        12 => [
            'params' => '-colors 64',
            'ext' => 'gif'
        ],
        13 => [
            'params' => '-colors 32',
            'ext' => 'gif'
        ],
        14 => [
            'params' => '-colors 16',
            'ext' => 'gif'
        ],
        15 => [
            'params' => '-colors 8',
            'ext' => 'gif'
        ],
        20 => [
            'params' => '-quality 100',
            'ext' => 'jpg'
        ],
        21 => [
            'params' => '-quality 90',
            'ext' => 'jpg'
        ],
        22 => [
            'params' => '-quality 80',
            'ext' => 'jpg'
        ],
        23 => [
            'params' => '-quality 70',
            'ext' => 'jpg'
        ],
        24 => [
            'params' => '-quality 60',
            'ext' => 'jpg'
        ],
        25 => [
            'params' => '-quality 50',
            'ext' => 'jpg'
        ],
        26 => [
            'params' => '-quality 40',
            'ext' => 'jpg'
        ],
        27 => [
            'params' => '-quality 30',
            'ext' => 'jpg'
        ],
        28 => [
            'params' => '-quality 20',
            'ext' => 'jpg'
        ],
        30 => [
            'params' => '-colors 256',
            'ext' => 'png'
        ],
        31 => [
            'params' => '-colors 128',
            'ext' => 'png'
        ],
        32 => [
            'params' => '-colors 64',
            'ext' => 'png'
        ],
        33 => [
            'params' => '-colors 32',
            'ext' => 'png'
        ],
        34 => [
            'params' => '-colors 16',
            'ext' => 'png'
        ],
        35 => [
            'params' => '-colors 8',
            'ext' => 'png'
        ],
        39 => [
            'params' => '',
            'ext' => 'png'
        ]
    ];

    public $image_effects = [
        1 => '-rotate 90',
        2 => '-rotate 270',
        3 => '-rotate 180',
        10 => '-colorspace GRAY',
        11 => '-sharpen 70',
        20 => '-normalize',
        23 => '-contrast',
        25 => '-gamma 1.3',
        26 => '-gamma 0.8'
    ];

    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 $INT_include = 0;

    public $checkPid_cache = [];

    public $checkPid_badDoktypeList = '255';

    public $lastTypoLinkUrl = '';

    public $lastTypoLinkTarget = '';

    public $lastTypoLinkLD = [];

    public $substMarkerCache = [];

    public $recordRegister = [];

    protected $cObjHookObjectsRegistry = [];

    public $cObjHookObjectsArr = [];

    protected $stdWrapHookObjects = [];

    protected $getImgResourceHookObjects;

    protected $currentFile = null;

    public $doConvertToUserIntObject = false;

    protected $userObjectType = false;

    protected $stopRendering = [];

    protected $stdWrapRecursionLevel = 0;

    protected $typoScriptFrontendController;

    protected $templateService;

    const OBJECTTYPE_USER_INT = 1;
    const OBJECTTYPE_USER = 2;

    public function __construct(TypoScriptFrontendController $typoScriptFrontendController = null)
    {
        $this->typoScriptFrontendController = $typoScriptFrontendController;
        $this->contentObjectClassMap = $GLOBALS['TYPO3_CONF_VARS']['FE']['ContentObjects'];
        $this->templateService = GeneralUtility::makeInstance(MarkerBasedTemplateService::class);
    }

    public function __sleep()
    {
        $vars = get_object_vars($this);
        unset($vars['typoScriptFrontendController']);
        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)) {
            list($objectType, $identifier) = explode(':', $this->currentFile, 2);
            try {
                if ($objectType === 'File') {
                    $this->currentFile = ResourceFactory::getInstance()->retrieveFileOrFolderObject($identifier);
                } elseif ($objectType === 'FileReference') {
                    $this->currentFile = ResourceFactory::getInstance()->getFileReferenceObject($identifier);
                }
            } catch (ResourceDoesNotExistException $e) {
                $this->currentFile = null;
            }
        }
    }

    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 = [];
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['cObjTypeAndClass'])) {
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['cObjTypeAndClass'] as $classArr) {
                $this->cObjHookObjectsRegistry[$classArr[0]] = $classArr[1];
            }
        }
        $this->stdWrapHookObjects = [];
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['stdWrap'])) {
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['stdWrap'] as $classData) {
                $hookObject = GeneralUtility::getUserObj($classData);
                if (!$hookObject instanceof ContentObjectStdWrapHookInterface) {
                    throw new \UnexpectedValueException($classData . ' must implement interface ' . ContentObjectStdWrapHookInterface::class, 1195043965);
                }
                $this->stdWrapHookObjects[] = $hookObject;
            }
        }
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['postInit'])) {
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['postInit'] as $classData) {
                $postInitializationProcessor = GeneralUtility::getUserObj($classData);
                if (!$postInitializationProcessor instanceof ContentObjectPostInitHookInterface) {
                    throw new \UnexpectedValueException($classData . ' must implement interface ' . ContentObjectPostInitHookInterface::class, 1274563549);
                }
                $postInitializationProcessor->postProcessContentObjectInitialization($this);
            }
        }
    }

    public function getCurrentTable()
    {
        return $this->table;
    }

    protected function getGetImgResourceHookObjects()
    {
        if (!isset($this->getImgResourceHookObjects)) {
            $this->getImgResourceHookObjects = [];
            if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getImgResource'])) {
                foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getImgResource'] as $classData) {
                    $hookObject = GeneralUtility::getUserObj($classData);
                    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 = TemplateService::sortedKeyList($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 'blabla.blabla = < styles.something')
            if ($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 : [];
                list($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
                if (!empty($this->cObjHookObjectsRegistry[$name])) {
                    if (empty($this->cObjHookObjectsArr[$name])) {
                        $this->cObjHookObjectsArr[$name] = GeneralUtility::getUserObj($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 && is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['cObjTypeAndClassDefault'])) {
                            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['cObjTypeAndClassDefault'] as $classData) {
                                $hookObject = GeneralUtility::getUserObj($classData);
                                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 = isset($configuration['cache.']) ? $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;
            } else {
                $content = $exceptionHandler->handle($exception, $contentObject, $configuration);
            }
        }

        // Store cache
        if ($cacheConfiguration !== null) {
            $key = $this->calculateCacheKey($cacheConfiguration);
            if (!empty($key)) {
                $cacheFrontend = GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_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 (GeneralUtility::getApplicationContext()->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 FLOWPLAYER($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('FLOWPLAYER'), $conf);
    }

    public function TEXT($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('TEXT'), $conf);
    }

    public function CLEARGIF($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('CLEARGIF'), $conf);
    }

    public function COBJ_ARRAY($conf, $ext = '')
    {
        GeneralUtility::logDeprecatedFunction();
        if ($ext === 'INT') {
            return $this->render($this->getContentObject('COA_INT'), $conf);
        } else {
            return $this->render($this->getContentObject('COA'), $conf);
        }
    }

    public function USER($conf, $ext = '')
    {
        GeneralUtility::logDeprecatedFunction();
        if ($ext === 'INT') {
            return $this->render($this->getContentObject('USER_INT'), $conf);
        } else {
            return $this->render($this->getContentObject('USER'), $conf);
        }
    }

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

    public function FILE($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('FILE'), $conf);
    }

    public function FILES($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('FILES'), $conf);
    }

    public function IMAGE($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('IMAGE'), $conf);
    }

    public function IMG_RESOURCE($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('IMG_RESOURCE'), $conf);
    }

    public function IMGTEXT($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('IMGTEXT'), $conf);
    }

    public function CONTENT($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('CONTENT'), $conf);
    }

    public function RECORDS($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('RECORDS'), $conf);
    }

    public function HMENU($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('HMENU'), $conf);
    }

    public function CTABLE($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('CTABLE'), $conf);
    }

    public function OTABLE($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('OTABLE'), $conf);
    }

    public function COLUMNS($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('COLUMNS'), $conf);
    }

    public function HRULER($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('HRULER'), $conf);
    }

    public function CASEFUNC($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('CASE'), $conf);
    }

    public function LOAD_REGISTER($conf, $name)
    {
        GeneralUtility::logDeprecatedFunction();
        if ($name === 'RESTORE_REGISTER') {
            return $this->render($this->getContentObject('RESTORE_REGISTER'), $conf);
        } else {
            return $this->render($this->getContentObject('LOAD_REGISTER'), $conf);
        }
    }

    public function FORM($conf, $formData = '')
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('FORM'), $conf);
    }

    public function SEARCHRESULT($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('SEARCHRESULT'), $conf);
    }

    public function TEMPLATE($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('TEMPLATE'), $conf);
    }

    protected function FLUIDTEMPLATE(array $conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('FLUIDTEMPLATE'), $conf);
    }

    public function MULTIMEDIA($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('MULTIMEDIA'), $conf);
    }

    public function MEDIA($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('MEDIA'), $conf);
    }

    public function SWFOBJECT($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('SWFOBJECT'), $conf);
    }

    public function QTOBJECT($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('QTOBJECT'), $conf);
    }

    public function SVG($conf)
    {
        GeneralUtility::logDeprecatedFunction();
        return $this->render($this->getContentObject('SVG'), $conf);
    }

    /************************************
     *
     * 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)
    {
        $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', $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)
    {
        $tsfe = $this->getTypoScriptFrontendController();
        $info = $this->getImgResource($file, $conf['file.']);
        $tsfe->lastImageInfo = $info;
        if (!is_array($info)) {
            return '';
        }
        if (is_file(PATH_site . $info['3'])) {
            $source = $tsfe->absRefPrefix . GeneralUtility::rawUrlEncodeFP($info['3']);
        } else {
            $source = $info[3];
        }

        $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) ? ' /' : ''),
        ];

        $theValue = $this->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)
    {
        $tsfe = $this->getTypoScriptFrontendController();
        $docType = $tsfe->xhtmlDoctype;
        if (
            $docType !== 'xhtml_strict' && $docType !== 'xhtml_11' && $docType !== 'xhtml_2'
            && $tsfe->config['config']['doctype'] !== 'html5'
            && !$tsfe->config['config']['disableImgBorderAttr']
        ) {
            return $borderAttr;
        }
        return '';
    }

    public function getImageTagTemplate($layoutKey, $conf)
    {
        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)
    {
        $sourceCollection = '';
        if ($layoutKey && $conf['sourceCollection.'] && ($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();
            $srcLayoutOptionSplitted = $tsfe->tmpl->splitConfArray($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.']
                ];

                if (isset($sourceConfiguration['quality']) || isset($sourceConfiguration['quality.'])) {
                    $imageQuality = isset($sourceConfiguration['quality']) ? $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'];
                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 (strstr($dimension, 'c') !== false && ($dimensionKey === 'width' || $dimensionKey === 'height')) {
                            $dimensionParts = explode('c', $dimension, 2);
                            $dimension = ((int)$dimensionParts[0] * $pixelDensity) . 'c';
                            if ($dimensionParts[1]) {
                                $dimension .= $dimensionParts[1];
                            }
                        } 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) ? ' /' : '';

                    $oneSourceCollection = $this->substituteMarkerArray($sourceLayout, $sourceConfiguration, '###|###', true, true);

                    if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getImageSourceCollection'])) {
                        foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getImageSourceCollection'] as $classData) {
                            $hookObject = GeneralUtility::getUserObj($classData);
                            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.'])) {
            $imageFile = $this->stdWrap($imageFile, $conf['file.']);
        }

        if ($imageFile instanceof File) {
            $file = $imageFile;
        } elseif ($imageFile instanceof FileReference) {
            $file = $imageFile->getOriginalFile();
        } else {
            if (MathUtility::canBeInterpretedAsInteger($imageFile)) {
                $file = ResourceFactory::getInstance()->getFileObject((int)$imageFile);
            } else {
                $file = ResourceFactory::getInstance()->getFileObjectFromCombinedIdentifier($imageFile);
            }
        }

        // Create imageFileLink if not created with typolink
        if ($content === $string) {
            $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(serialize($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' && $xhtmlDocType !== 'xhtml_2') {
                $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('Image.CropScaleMask', $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'];
                $onClick = 'openPic('
                    . GeneralUtility::quoteJSvalue($this->getTypoScriptFrontendController()->baseUrlWrap($url)) . ','
                    . '\'' . ($newWindow ? md5($url) : 'thePicture') . '\','
                    . GeneralUtility::quoteJSvalue('width=' . ($processedFile->getProperty('width') + $offset[0])
                        . ',height=' . ($processedFile->getProperty('height') + $offset[1]) . ',status=0,menubar=0')
                    . '); 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.']['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 fileResource($fName, $addParams = 'alt="" title=""')
    {
        $tsfe = $this->getTypoScriptFrontendController();
        $incFile = $tsfe->tmpl->getFileName($fName);
        if ($incFile && file_exists($incFile)) {
            $fileInfo = GeneralUtility::split_fileref($incFile);
            $extension = $fileInfo['fileext'];
            if ($extension === 'jpg' || $extension === 'jpeg' || $extension === 'gif' || $extension === 'png') {
                $imgFile = $incFile;
                $imgInfo = @getimagesize($imgFile);
                return '<img src="' . htmlspecialchars($tsfe->absRefPrefix . $imgFile) . '" width="' . (int)$imgInfo[0] . '" height="' . (int)$imgInfo[1] . '"' . $this->getBorderAttr(' border="0"') . ' ' . $addParams . ' />';
            } elseif (filesize($incFile) < 1024 * 1024) {
                return $tsfe->tmpl->fileContent($incFile);
            }
        }
        return '';
    }

    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)
    {
        $wrapArr = explode('|', $wrap);
        if (preg_match('/\\{([0-9]*)\\}/', $wrapArr[0], $reg)) {
            if ($uid = $this->getTypoScriptFrontendController()->tmpl->rootLine[$reg[1]]['uid']) {
                $wrapArr[0] = str_replace($reg[0], $uid, $wrapArr[0]);
            }
        }
        return trim($wrapArr[0]) . $content . trim($wrapArr[1]);
    }

    public function getAltParam($conf, $longDesc = true)
    {
        $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 cleanFormName($name)
    {
        GeneralUtility::logDeprecatedFunction();
        // Turn data[x][y] into data:x:y:
        $name = preg_replace('/\\[|\\]\\[?/', ':', trim($name));
        // Remove illegal chars like _
        return preg_replace('#[^:a-zA-Z0-9]#', '', $name);
    }

    public function getATagParams($conf, $addGlobal = 1)
    {
        $aTagParams = '';
        if ($conf['ATagParams.']) {
            $aTagParams = ' ' . $this->stdWrap($conf['ATagParams'], $conf['ATagParams.']);
        } elseif ($conf['ATagParams']) {
            $aTagParams = ' ' . $conf['ATagParams'];
        }
        if ($addGlobal) {
            $aTagParams = ' ' . trim($this->getTypoScriptFrontendController()->ATagParams . $aTagParams);
        }
        // Extend params
        if (isset($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getATagParamsPostProc']) && is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getATagParamsPostProc'])) {
            $_params = [
                'conf' => &$conf,
                'aTagParams' => &$aTagParams
            ];
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getATagParamsPostProc'] as $objRef) {
                $processor =& GeneralUtility::getUserObj($objRef);
                $aTagParams = $processor->process($_params, $this);
            }
        }

        $aTagParams = trim($aTagParams);
        if (!empty($aTagParams)) {
            $aTagParams = ' ' . $aTagParams;
        }

        return $aTagParams;
    }

    public function extLinkATagParams($URL, $TYPE)
    {
        $out = '';
        if ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['extLinkATagParamsHandler']) {
            $extLinkATagParamsHandler = GeneralUtility::getUserObj($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 getSubpart($content, $marker)
    {
        return $this->templateService->getSubpart($content, $marker);
    }

    public function substituteSubpart($content, $marker, $subpartContent, $recursive = 1)
    {
        return $this->templateService->substituteSubpart($content, $marker, $subpartContent, $recursive);
    }

    public function substituteSubpartArray($content, array $subpartsContent)
    {
        return $this->templateService->substituteSubpartArray($content, $subpartsContent);
    }

    public function substituteMarker($content, $marker, $markContent)
    {
        return $this->templateService->substituteMarker($content, $marker, $markContent);
    }

    public function substituteMarkerArrayCached($content, array $markContentArray = null, array $subpartContentArray = null, array $wrappedSubpartContentArray = null)
    {
        $timeTracker = $this->getTimeTracker();
        $timeTracker->push('substituteMarkerArrayCached');
        // If not arrays then set them
        if (is_null($markContentArray)) {
            // Plain markers
            $markContentArray = [];
        }
        if (is_null($subpartContentArray)) {
            // Subparts being directly substituted
            $subpartContentArray = [];
        }
        if (is_null($wrappedSubpartContentArray)) {
            // Subparts being wrapped
            $wrappedSubpartContentArray = [];
        }
        // Finding keys and check hash:
        $sPkeys = array_keys($subpartContentArray);
        $wPkeys = array_keys($wrappedSubpartContentArray);
        $keysToReplace = array_merge(array_keys($markContentArray), $sPkeys, $wPkeys);
        if (empty($keysToReplace)) {
            $timeTracker->pull();
            return $content;
        }
        asort($keysToReplace);
        $storeKey = md5('substituteMarkerArrayCached_storeKey:' . serialize([$content, $keysToReplace]));
        if ($this->substMarkerCache[$storeKey]) {
            $storeArr = $this->substMarkerCache[$storeKey];
            $timeTracker->setTSlogMessage('Cached', 0);
        } else {
            $storeArrDat = $this->getTypoScriptFrontendController()->sys_page->getHash($storeKey);
            if (is_array($storeArrDat)) {
                $storeArr = $storeArrDat;
                // Setting cache:
                $this->substMarkerCache[$storeKey] = $storeArr;
                $timeTracker->setTSlogMessage('Cached from DB', 0);
            } else {
                // Finding subparts and substituting them with the subpart as a marker
                foreach ($sPkeys as $sPK) {
                    $content = $this->substituteSubpart($content, $sPK, $sPK);
                }
                // Finding subparts and wrapping them with markers
                foreach ($wPkeys as $wPK) {
                    $content = $this->substituteSubpart($content, $wPK, [
                        $wPK,
                        $wPK
                    ]);
                }

                $storeArr = [];
                // search all markers in the content
                $result = preg_match_all('/###([^#](?:[^#]*+|#{1,2}[^#])+)###/', $content, $markersInContent);
                if ($result !== false && !empty($markersInContent[1])) {
                    $keysToReplaceFlipped = array_flip($keysToReplace);
                    $regexKeys = [];
                    $wrappedKeys = [];
                    // Traverse keys and quote them for reg ex.
                    foreach ($markersInContent[1] as $key) {
                        if (isset($keysToReplaceFlipped['###' . $key . '###'])) {
                            $regexKeys[] = preg_quote($key, '/');
                            $wrappedKeys[] = '###' . $key . '###';
                        }
                    }
                    $regex = '/###(?:' . implode('|', $regexKeys) . ')###/';
                    $storeArr['c'] = preg_split($regex, $content); // contains all content parts around markers
                    $storeArr['k'] = $wrappedKeys; // contains all markers incl. ###
                    // Setting cache:
                    $this->substMarkerCache[$storeKey] = $storeArr;
                    // Storing the cached data:
                    $this->getTypoScriptFrontendController()->sys_page->storeHash($storeKey, $storeArr, 'substMarkArrayCached');
                }
                $timeTracker->setTSlogMessage('Parsing', 0);
            }
        }
        if (!empty($storeArr['k']) && is_array($storeArr['k'])) {
            // Substitution/Merging:
            // Merging content types together, resetting
            $valueArr = array_merge($markContentArray, $subpartContentArray, $wrappedSubpartContentArray);
            $wSCA_reg = [];
            $content = '';
            // Traversing the keyList array and merging the static and dynamic content
            foreach ($storeArr['k'] as $n => $keyN) {
                // add content before marker
                $content .= $storeArr['c'][$n];
                if (!is_array($valueArr[$keyN])) {
                    // fetch marker replacement from $markContentArray or $subpartContentArray
                    $content .= $valueArr[$keyN];
                } else {
                    if (!isset($wSCA_reg[$keyN])) {
                        $wSCA_reg[$keyN] = 0;
                    }
                    // fetch marker replacement from $wrappedSubpartContentArray
                    $content .= $valueArr[$keyN][$wSCA_reg[$keyN] % 2];
                    $wSCA_reg[$keyN]++;
                }
            }
            // add remaining content
            $content .= $storeArr['c'][count($storeArr['k'])];
        }
        $timeTracker->pull();
        return $content;
    }

    public function substituteMarkerArray($content, array $markContentArray, $wrap = '', $uppercase = false, $deleteUnused = false)
    {
        return $this->templateService->substituteMarkerArray($content, $markContentArray, $wrap, $uppercase, $deleteUnused);
    }

    public function substituteMarkerInObject(&$tree, array $markContentArray)
    {
        if (is_array($tree)) {
            foreach ($tree as $key => $value) {
                $this->substituteMarkerInObject($tree[$key], $markContentArray);
            }
        } else {
            $tree = $this->substituteMarkerArray($tree, $markContentArray);
        }
        return $tree;
    }

    public function substituteMarkerAndSubpartArrayRecursive($content, array $markersAndSubparts, $wrap = '', $uppercase = false, $deleteUnused = false)
    {
        return $this->templateService->substituteMarkerAndSubpartArrayRecursive($content, $markersAndSubparts, $wrap, $uppercase, $deleteUnused);
    }

    public function fillInMarkerArray(array $markContentArray, array $row, $fieldList = '', $nl2br = true, $prefix = 'FIELD_', $HSC = false)
    {
        $tsfe = $this->getTypoScriptFrontendController();
        if ($fieldList) {
            $fArr = GeneralUtility::trimExplode(',', $fieldList, true);
            foreach ($fArr as $field) {
                $markContentArray['###' . $prefix . $field . '###'] = $nl2br ? nl2br($row[$field], !empty($tsfe->xhtmlDoctype)) : $row[$field];
            }
        } else {
            if (is_array($row)) {
                foreach ($row as $field => $value) {
                    if (!MathUtility::canBeInterpretedAsInteger($field)) {
                        if ($HSC) {
                            $value = htmlspecialchars($value);
                        }
                        $markContentArray['###' . $prefix . $field . '###'] = $nl2br ? nl2br($value, !empty($tsfe->xhtmlDoctype)) : $value;
                    }
                }
            }
        }
        return $markContentArray;
    }

    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 (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;
        }
        // Check, which of the available stdWrap functions is needed for the current conf Array
        // and keep only those but still in the same order
        $sortedConf = 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 => $functionType) {
            // 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 (!$isExecuted[$stdWrapName] && !$this->stopRendering[$this->stdWrapRecursionLevel]) {
                $functionName = rtrim($stdWrapName, '.');
                $functionProperties = $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
                // exception: the recursive stdWrap function and cObject will still be using their own stdWrap call, since it modifies the content and not a property
                if ($functionName !== 'stdWrap' && !empty($conf[$functionProperties]) && !GeneralUtility::inList($stdWrapDisabledFunctionTypes, $functionType)) {
                    if (array_intersect_key($this->stdWrapOrder, $conf[$functionProperties])) {
                        $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],
                        $functionProperties => $conf[$functionProperties]
                    ];
                    // In this special case 'spaceBefore' and 'spaceAfter' need additional stuff from 'space.''
                    if ($functionName === 'spaceBefore' || $functionName === 'spaceAfter') {
                        $singleConf['space.'] = $conf['space.'];
                    }
                    // 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'];
        return $content;
    }

    public function stdWrap_lang($content = '', $conf = [])
    {
        $tsfe = $this->getTypoScriptFrontendController();
        if (isset($conf['lang.']) && $tsfe->config['config']['language'] && isset($conf['lang.'][$tsfe->config['config']['language']])) {
            $content = $conf['lang.'][$tsfe->config['config']['language']];
        }
        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_filelist($content = '', $conf = [])
    {
        return $this->filelist($conf['filelist']);
    }

    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'])) {
            $content = $conf['override'];
        }
        return $content;
    }

    public function stdWrap_preIfEmptyListNum($content = '', $conf = [])
    {
        return $this->listNum($content, $conf['preIfEmptyListNum'], $conf['preIfEmptyListNum.']['splitChar']);
    }

    public function stdWrap_ifNull($content = '', $conf = [])
    {
        return $content !== null ? $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'], $conf['listNum.']['splitChar']);
    }

    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 str_pad($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']])) {
            $content = '';
            $this->stopRendering[$this->stdWrapRecursionLevel] = true;
        }
        return $content;
    }

    public function stdWrap_csConv($content = '', $conf = [])
    {
        return $this->getTypoScriptFrontendController()->csConv($content, $conf['csConv']);
    }

    public function stdWrap_parseFunc($content = '', $conf = [])
    {
        return $this->parseFunc($content, $conf['parseFunc.'], $conf['parseFunc']);
    }

    public function stdWrap_HTMLparser($content = '', $conf = [])
    {
        if (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 ($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($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 = $conf['date.']['GMT'] ? gmdate($conf['date'], $content) : date($conf['date'], $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 = $conf['strftime.']['GMT'] ? gmstrftime($conf['strftime'], $content) : strftime($conf['strftime'], $content);
        $tsfe = $this->getTypoScriptFrontendController();
        $tmp_charset = $conf['strftime.']['charset'] ? $conf['strftime.']['charset'] : $tsfe->localeCharset;
        if ($tmp_charset) {
            $content = $tsfe->csConv($content, $tmp_charset);
        }
        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'] - (int)$content, $conf['age']);
    }

    public function stdWrap_case($content = '', $conf = [])
    {
        return $this->HTMLcaseshift($content, $conf['case']);
    }

    public function stdWrap_bytes($content = '', $conf = [])
    {
        return GeneralUtility::formatSize($content, $conf['bytes.']['labels'], $conf['bytes.']['base']);
    }

    public function stdWrap_substring($content = '', $conf = [])
    {
        return $this->substring($content, $conf['substring']);
    }

    public function stdWrap_removeBadHTML($content = '')
    {
        return $this->removeBadHTML($content);
    }

    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'], $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'], $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']);
    }

    public function stdWrap_innerWrap2($content = '', $conf = [])
    {
        return $this->wrap($content, $conf['innerWrap2']);
    }

    public function stdWrap_fontTag($content = '', $conf = [])
    {
        return $this->wrap($content, $conf['fontTag']);
    }

    public function stdWrap_addParams($content = '', $conf = [])
    {
        return $this->addParams($content, $conf['addParams.']);
    }

    public function stdWrap_textStyle($content = '', $conf = [])
    {
        return $this->textStyle($content, $conf['textStyle.']);
    }

    public function stdWrap_tableStyle($content = '', $conf = [])
    {
        return $this->tableStyle($content, $conf['tableStyle.']);
    }

    public function stdWrap_filelink($content = '', $conf = [])
    {
        return $this->filelink($content, $conf['filelink.']);
    }

    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_TCAselectItem($content = '', $conf = [])
    {
        if (is_array($conf['TCAselectItem.'])) {
            $content = $this->TCAlookup($content, $conf['TCAselectItem.']);
        }
        return $content;
    }

    public function stdWrap_spaceBefore($content = '', $conf = [])
    {
        return $this->wrapSpace($content, trim($conf['spaceBefore']) . '|', $conf['space.']);
    }

    public function stdWrap_spaceAfter($content = '', $conf = [])
    {
        return $this->wrapSpace($content, '|' . trim($conf['spaceAfter']), $conf['space.']);
    }

    public function stdWrap_space($content = '', $conf = [])
    {
        return $this->wrapSpace($content, trim($conf['space']), $conf['space.']);
    }

    public function stdWrap_wrap($content = '', $conf = [])
    {
        return $this->wrap($content, $conf['wrap'], $conf['wrap.']['splitChar'] ? $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'], $conf['wrap2.']['splitChar'] ? $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'], $conf['wrap3.']['splitChar'] ? $conf['wrap3.']['splitChar'] : '|');
    }

    public function stdWrap_orderedStdWrap($content = '', $conf = [])
    {
        $sortedKeysArray = TemplateService::sortedKeyList($conf['orderedStdWrap.'], true);
        foreach ($sortedKeysArray as $key) {
            $content = $this->stdWrap($content, $conf['orderedStdWrap.'][$key . '.']);
        }
        return $content;
    }

    public function stdWrap_outerWrap($content = '', $conf = [])
    {
        return $this->wrap($content, $conf['outerWrap']);
    }

    public function stdWrap_insertData($content = '')
    {
        return $this->insertData($content);
    }

    public function stdWrap_offsetWrap($content = '', $conf = [])
    {
        GeneralUtility::logDeprecatedFunction();

        if (ExtensionManagementUtility::isLoaded('compatibility6')) {
            $controlTable = GeneralUtility::makeInstance(TYPO3\CMS\Compatibility6\ContentObject\OffsetTableContentObject::class);
            if ($conf['offsetWrap.']['tableParams'] || $conf['offsetWrap.']['tableParams.']) {
                $controlTable->tableParams = isset($conf['offsetWrap.']['tableParams.'])
                    ? $this->stdWrap($conf['offsetWrap.']['tableParams'], $conf['offsetWrap.']['tableParams.'])
                    : $conf['offsetWrap.']['tableParams'];
            }
            if ($conf['offsetWrap.']['tdParams'] || $conf['offsetWrap.']['tdParams.']) {
                $controlTable->tdParams = ' ' . (isset($conf['offsetWrap.']['tdParams.'])
                        ? $this->stdWrap($conf['offsetWrap.']['tdParams'], $conf['offsetWrap.']['tdParams.'])
                        : $conf['offsetWrap.']['tdParams']);
            }
            $content = $controlTable->start($content, $conf['offsetWrap']);
            if ($conf['offsetWrap.']['stdWrap.']) {
                $content = $this->stdWrap($content, $conf['offsetWrap.']['stdWrap.']);
            }
        }

        return $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 (!$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()->beUserLogin && $conf['editIcons']) {
            if (!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()->beUserLogin) {
            $content = $this->editPanel($content, $conf['editPanel.']);
        }
        return $content;
    }

    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('cache_hash');
        $tags = $this->calculateCacheTags($conf['cache.']);
        $lifetime = $this->calculateCacheLifetime($conf['cache.']);
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['stdWrap_cacheStore'])) {
            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
                ];
                GeneralUtility::callUserFunction($_funcRef, $params, $this);
            }
        }
        $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)
    {
        $result = false;
        $conf['select.']['selectFields'] = 'count(*)';
        $res = $this->exec_getQuery($conf['table'], $conf['select.']);
        $db = $this->getDatabaseConnection();
        if ($error = $db->sql_error()) {
            $this->getTimeTracker()->setTSlogMessage($error, 3);
        } else {
            $row = $db->sql_fetch_row($res);
            $result = (int)$row[0];
        }
        $db->sql_free_result($res);
        return $result;
    }

    public function listNum($content, $listNum, $char)
    {
        $char = $char ?: ',';
        if (MathUtility::canBeInterpretedAsInteger($char)) {
            $char = chr($char);
        }
        $temp = explode($char, $content);
        $last = '' . (count($temp) - 1);
        // Take a random item if requested
        if ($listNum === 'rand') {
            $listNum = rand(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 ($conf['negate']) {
            $flag = !$flag;
        }
        return $flag;
    }

    public function filelist($data)
    {
        $data = trim($data);
        if ($data === '') {
            return '';
        }
        $data_arr = explode('|', $data);
        // read directory:
        // MUST exist!
        $path = '';
        if ($this->getTypoScriptFrontendController()->lockFilePath) {
            // Cleaning name..., only relative paths accepted.
            $path = $this->clean_directory($data_arr[0]);
            // See if path starts with lockFilePath, the additional '/' is needed because clean_directory gets rid of it
            $path = GeneralUtility::isFirstPartOfStr($path . '/', $this->getTypoScriptFrontendController()->lockFilePath) ? $path : '';
        }
        if (!$path) {
            return '';
        }
        $items = [
            'files' => [],
            'sorting' => []
        ];
        $ext_list = strtolower(GeneralUtility::uniqueList($data_arr[1]));
        $sorting = trim($data_arr[2]);
        // Read dir:
        $d = @dir($path);
        if (is_object($d)) {
            $count = 0;
            while ($entry = $d->read()) {
                if ($entry != '.' && $entry != '..') {
                    // Because of odd PHP-error where <br />-tag is sometimes placed after a filename!!
                    $wholePath = $path . '/' . $entry;
                    if (file_exists($wholePath) && filetype($wholePath) === 'file') {
                        $info = GeneralUtility::split_fileref($wholePath);
                        if (!$ext_list || GeneralUtility::inList($ext_list, $info['fileext'])) {
                            $items['files'][] = $info['file'];
                            switch ($sorting) {
                                case 'name':
                                    $items['sorting'][] = strtolower($info['file']);
                                    break;
                                case 'size':
                                    $items['sorting'][] = filesize($wholePath);
                                    break;
                                case 'ext':
                                    $items['sorting'][] = $info['fileext'];
                                    break;
                                case 'date':
                                    $items['sorting'][] = filectime($wholePath);
                                    break;
                                case 'mdate':
                                    $items['sorting'][] = filemtime($wholePath);
                                    break;
                                default:
                                    $items['sorting'][] = $count;
                            }
                            $count++;
                        }
                    }
                }
            }
            $d->close();
        }
        // Sort if required
        if (!empty($items['sorting'])) {
            if (strtolower(trim($data_arr[3])) != 'r') {
                asort($items['sorting']);
            } else {
                arsort($items['sorting']);
            }
        }
        if (!empty($items['files'])) {
            // Make list
            reset($items['sorting']);
            $fullPath = trim($data_arr[4]);
            $list_arr = [];
            foreach ($items['sorting'] as $key => $v) {
                $list_arr[] = $fullPath ? $path . '/' . $items['files'][$key] : $items['files'][$key];
            }
            return implode(',', $list_arr);
        }
        return '';
    }

    public function clean_directory($theDir)
    {
        // proceeds if no '//', '..' or '\' is in the $theFile
        if (GeneralUtility::validPathStr($theDir)) {
            // Removes all dots, slashes and spaces after a path...
            $theDir = preg_replace('/[\\/\\. ]*$/', '', $theDir);
            if (!GeneralUtility::isAbsPath($theDir) && @is_dir($theDir)) {
                return $theDir;
            }
        }
        return '';
    }

    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 = 1;
            } else {
                $len = strcspn(substr($str, $pointer), '}') + 1;
                $newVal .= $this->getData(substr($str, $pointer + 1, $len - 2), $this->data);
                $inside = 0;
            }
            $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, TAB) . '<!-- ' . $comment . ' [begin] -->' . LF
            . str_pad('', ($indent + 1), TAB) . $content . LF
            . str_pad('', $indent, TAB) . '<!-- ' . $comment . ' [end] -->' . LF
            . str_pad('', ($indent + 1), TAB);
        return $output;
    }

    public function substring($content, $options)
    {
        $tsfe = $this->getTypoScriptFrontendController();
        $options = GeneralUtility::intExplode(',', $options . ',');
        if ($options[1]) {
            return $tsfe->csConvObj->substr($tsfe->renderCharset, $content, $options[0], $options[1]);
        } else {
            return $tsfe->csConvObj->substr($tsfe->renderCharset, $content, $options[0]);
        }
    }

    public function crop($content, $options)
    {
        $options = explode('|', $options);
        $chars = (int)$options[0];
        $afterstring = trim($options[1]);
        $crop2space = trim($options[2]);
        if ($chars) {
            $tsfe = $this->getTypoScriptFrontendController();
            if ($tsfe->csConvObj->strlen($tsfe->renderCharset, $content) > abs($chars)) {
                $truncatePosition = false;
                if ($chars < 0) {
                    $content = $tsfe->csConvObj->substr($tsfe->renderCharset, $content, $chars);
                    if ($crop2space) {
                        $truncatePosition = strpos($content, ' ');
                    }
                    $content = $truncatePosition ? $afterstring . substr($content, $truncatePosition) : $afterstring . $content;
                } else {
                    $content = $tsfe->csConvObj->substr($tsfe->renderCharset, $content, 0, $chars);
                    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);
        // 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;
        $tsfe = $this->getTypoScriptFrontendController();
        $countSplittedContent = count($splittedContent);
        for ($offset = 0; $offset < $countSplittedContent; $offset++) {
            if ($offset % 2 === 0) {
                $tempContent = $tsfe->csConvObj->utf8_encode($splittedContent[$offset], $tsfe->renderCharset);
                $thisStrLen = $tsfe->csConvObj->strlen('utf-8', html_entity_decode($tempContent, ENT_COMPAT, 'UTF-8'));
                if ($strLen + $thisStrLen > $absChars) {
                    $croppedOffset = $offset;
                    $cropPosition = $absChars - $strLen;
                    // The snippet "&[^&\s;]{2,8};" in the RegEx below represents entities.
                    $patternMatchEntityAsSingleChar = '(&[^&\\s;]{2,8};|.)';
                    $cropRegEx = $chars < 0 ? '#' . $patternMatchEntityAsSingleChar . '{0,' . ($cropPosition + 1) . '}$#uis' : '#^' . $patternMatchEntityAsSingleChar . '{0,' . ($cropPosition + 1) . '}#uis';
                    if (preg_match($cropRegEx, $tempContent, $croppedMatch)) {
                        $tempContentPlusOneCharacter = $croppedMatch[0];
                    } else {
                        $tempContentPlusOneCharacter = false;
                    }
                    $cropRegEx = $chars < 0 ? '#' . $patternMatchEntityAsSingleChar . '{0,' . $cropPosition . '}$#uis' : '#^' . $patternMatchEntityAsSingleChar . '{0,' . $cropPosition . '}#uis';
                    if (preg_match($cropRegEx, $tempContent, $croppedMatch)) {
                        $tempContent = $croppedMatch[0];
                        if ($crop2space && $tempContentPlusOneCharacter !== false) {
                            $cropRegEx = $chars < 0 ? '#(?<=\\s)' . $patternMatchEntityAsSingleChar . '{0,' . $cropPosition . '}$#uis' : '#^' . $patternMatchEntityAsSingleChar . '{0,' . $cropPosition . '}(?=\\s)#uis';
                            if (preg_match($cropRegEx, $tempContentPlusOneCharacter, $croppedMatch)) {
                                $tempContent = $croppedMatch[0];
                            }
                        }
                    }
                    $splittedContent[$offset] = $tsfe->csConvObj->utf8_decode($tempContent, $tsfe->renderCharset);
                    break;
                } else {
                    $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 = isset($matches[1]) ? $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 = isset($matches[1]) ? $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 removeBadHTML($text)
    {
        // Copyright 2002-2003 Thomas Bley
        $text = preg_replace([
            '\'<script[^>]*?>.*?</script[^>]*?>\'si',
            '\'<applet[^>]*?>.*?</applet[^>]*?>\'si',
            '\'<object[^>]*?>.*?</object[^>]*?>\'si',
            '\'<iframe[^>]*?>.*?</iframe[^>]*?>\'si',
            '\'<frameset[^>]*?>.*?</frameset[^>]*?>\'si',
            '\'<style[^>]*?>.*?</style[^>]*?>\'si',
            '\'<marquee[^>]*?>.*?</marquee[^>]*?>\'si',
            '\'<script[^>]*?>\'si',
            '\'<meta[^>]*?>\'si',
            '\'<base[^>]*?>\'si',
            '\'<applet[^>]*?>\'si',
            '\'<object[^>]*?>\'si',
            '\'<link[^>]*?>\'si',
            '\'<iframe[^>]*?>\'si',
            '\'<frame[^>]*?>\'si',
            '\'<frameset[^>]*?>\'si',
            '\'<input[^>]*?>\'si',
            '\'<form[^>]*?>\'si',
            '\'<embed[^>]*?>\'si',
            '\'background-image:url\'si',
            '\'<\\w+.*?(onabort|onbeforeunload|onblur|onchange|onclick|ondblclick|ondragdrop|onerror|onfilterchange|onfocus|onhelp|onkeydown|onkeypress|onkeyup|onload|onmousedown|onmousemove|onmouseout|onmouseover|onmouseup|onmove|onreadystatechange|onreset|onresize|onscroll|onselect|onselectstart|onsubmit|onunload).*?>\'si'
        ], '', $text);
        $text = preg_replace('/<a[^>]*href[[:space:]]*=[[:space:]]*["\']?[[:space:]]*javascript[^>]*/i', '', $text);
        // Return clean content
        return $text;
    }

    public function textStyle($theValue, $conf)
    {
        $this->getTypoScriptFrontendController()->logDeprecatedTyposcript('textStyle', 'Deprecated since 7.1 and will be removed with CMS 8. Use CSS instead');
        $conf['face.'][1] = 'Times New Roman';
        $conf['face.'][2] = 'Verdana,Arial,Helvetica,Sans serif';
        $conf['face.'][3] = 'Arial,Helvetica,Sans serif';
        $conf['size.'][1] = 1;
        $conf['size.'][2] = 2;
        $conf['size.'][3] = 3;
        $conf['size.'][4] = 4;
        $conf['size.'][5] = 5;
        $conf['size.'][10] = '+1';
        $conf['size.'][11] = '-1';
        $conf['color.'][240] = 'black';
        $conf['color.'][241] = 'white';
        $conf['color.'][242] = '#333333';
        $conf['color.'][243] = 'gray';
        $conf['color.'][244] = 'silver';
        $conf['color.'][245] = 'red';
        $conf['color.'][246] = 'navy';
        $conf['color.'][247] = 'yellow';
        $conf['color.'][248] = 'green';
        $conf['color.'][249] = 'olive';
        $conf['color.'][250] = 'maroon';
        $face = $this->data[$conf['face.']['field']];
        $size = $this->data[$conf['size.']['field']];
        $color = $this->data[$conf['color.']['field']];
        $align = $this->data[$conf['align.']['field']];
        $properties = $this->data[$conf['properties.']['field']];
        if (!$properties) {
            $properties = isset($conf['properties.']['default.']) ? $this->stdWrap($conf['properties.']['default'], $conf['properties.']['default.']) : $conf['properties.']['default'];
        }
        // Properties
        if ($properties & 8) {
            $theValue = $this->HTMLcaseshift($theValue, 'upper');
        }
        if ($properties & 1) {
            $theValue = '<strong>' . $theValue . '</strong>';
        }
        if ($properties & 2) {
            $theValue = '<i>' . $theValue . '</i>';
        }
        if ($properties & 4) {
            $theValue = '<u>' . $theValue . '</u>';
        }
        // Fonttag
        $theFace = $conf['face.'][$face];
        if (!$theFace) {
            $theFace = isset($conf['face.']['default.']) ? $this->stdWrap($conf['face.']['default'], $conf['face.']['default.']) : $conf['face.']['default'];
        }
        $theSize = $conf['size.'][$size];
        if (!$theSize) {
            $theSize = isset($conf['size.']['default.']) ? $this->stdWrap($conf['size.']['default'], $conf['size.']['default.']) : $conf['size.']['default'];
        }
        $theColor = $conf['color.'][$color];
        if (!$theColor) {
            $theColor = isset($conf['color.']['default.']) ? $this->stdWrap($conf['color.']['default'], $conf['color.']['default.']) : $conf['color.']['default.'];
        }
        if ($conf['altWrap']) {
            $theValue = $this->wrap($theValue, $conf['altWrap']);
        } elseif ($theFace || $theSize || $theColor) {
            $fontWrap = '<font' . ($theFace ? ' face="' . $theFace . '"' : '') . ($theSize ? ' size="' . $theSize . '"' : '') . ($theColor ? ' color="' . $theColor . '"' : '') . '>|</font>';
            $theValue = $this->wrap($theValue, $fontWrap);
        }
        // Align
        if ($align) {
            $theValue = $this->wrap($theValue, '<div style="text-align:' . $align . ';">|</div>');
        }
        // Return
        return $theValue;
    }

    public function tableStyle($theValue, $conf)
    {
        $this->getTypoScriptFrontendController()->logDeprecatedTyposcript('tableStyle', 'Deprecated since 7.1 and will be removed with CMS 8. Use CSS instead');
        $conf['color.'][240] = 'black';
        $conf['color.'][241] = 'white';
        $conf['color.'][242] = '#333333';
        $conf['color.'][243] = 'gray';
        $conf['color.'][244] = 'silver';
        $align = isset($conf['align.']) ? $this->stdWrap($conf['align'], $conf['align.']) : $conf['align'];
        $border = isset($conf['border.']) ? (int)$this->stdWrap($conf['border'], $conf['border.']) : (int)$conf['border'];
        $cellspacing = isset($conf['cellspacing.']) ? (int)$this->stdWrap($conf['cellspacing'], $conf['cellspacing.']) : (int)$conf['cellspacing'];
        $cellpadding = isset($conf['cellpadding.']) ? (int)$this->stdWrap($conf['cellpadding'], $conf['cellpadding.']) : (int)$conf['cellpadding'];
        $color = $this->data[$conf['color.']['field']];
        $theColor = $conf['color.'][$color] ? $conf['color.'][$color] : $conf['color.']['default'];
        // Assembling the table tag
        $tableTagArray = [
            '<table'
        ];
        $tableTagArray[] = 'border="' . $border . '"';
        $tableTagArray[] = 'cellspacing="' . $cellspacing . '"';
        $tableTagArray[] = 'cellpadding="' . $cellpadding . '"';
        if ($align) {
            $tableTagArray[] = 'align="' . $align . '"';
        }
        if ($theColor) {
            $tableTagArray[] = 'bgcolor="' . $theColor . '"';
        }
        if ($conf['params']) {
            $tableTagArray[] = $conf['params'];
        }
        $tableWrap = implode(' ', $tableTagArray) . '> | </table>';
        $theValue = $this->wrap($theValue, $tableWrap);
        // return
        return $theValue;
    }

    public function addParams($content, $conf)
    {
        // For XHTML compliance.
        $lowerCaseAttributes = true;
        if (!is_array($conf)) {
            return $content;
        }
        $key = 1;
        $parts = explode('<', $content);
        if ((int)$conf['_offset']) {
            $key = (int)$conf['_offset'] < 0 ? count($parts) + (int)$conf['_offset'] : (int)$conf['_offset'];
        }
        $subparts = explode('>', $parts[$key]);
        if (trim($subparts[0])) {
            // Get attributes and name
            $attribs = GeneralUtility::get_tag_attributes('<' . $subparts[0] . '>');
            list($tagName) = explode(' ', $subparts[0], 2);
            // adds/overrides attributes
            foreach ($conf as $pkey => $val) {
                if (substr($pkey, -1) !== '.' && $pkey[0] !== '_') {
                    $tmpVal = isset($conf[$pkey . '.']) ? $this->stdWrap($conf[$pkey], $conf[$pkey . '.']) : (string)$val;
                    if ($lowerCaseAttributes) {
                        $pkey = strtolower($pkey);
                    }
                    if ($tmpVal !== '') {
                        $attribs[$pkey] = $tmpVal;
                    }
                }
            }
            // Re-assembles the tag and content
            $subparts[0] = trim($tagName . ' ' . GeneralUtility::implodeAttributes($attribs));
            $parts[$key] = implode('>', $subparts);
            $content = implode('<', $parts);
        }
        return $content;
    }

    public function filelink($theValue, $conf)
    {
        $conf['path'] = isset($conf['path.']) ? $this->stdWrap($conf['path'], $conf['path.']) : $conf['path'];
        $theFile = trim($conf['path']) . $theValue;
        if (!@is_file($theFile)) {
            return '';
        }
        $theFileEnc = str_replace('%2F', '/', rawurlencode($theFile));
        $title = $conf['title'];
        if (isset($conf['title.'])) {
            $title = $this->stdWrap($title, $conf['title.']);
        }
        $target = $conf['target'];
        if (isset($conf['target.'])) {
            $target = $this->stdWrap($target, $conf['target.']);
        }
        $tsfe = $this->getTypoScriptFrontendController();

        $typoLinkConf = [
            'parameter' => $theFileEnc,
            'fileTarget' => $target,
            'title' => $title,
            'ATagParams' => $this->getATagParams($conf)
        ];

        if (isset($conf['typolinkConfiguration.'])) {
            $additionalTypoLinkConfiguration = $conf['typolinkConfiguration.'];
            // We only allow additional configuration. This is why the generated conf overwrites the additional conf.
            ArrayUtility::mergeRecursiveWithOverrule($additionalTypoLinkConfiguration, $typoLinkConf);
            $typoLinkConf = $additionalTypoLinkConfiguration;
        }

        if (isset($conf['jumpurl']) || isset($conf['jumpurl.'])) {
            GeneralUtility::deprecationLog('The TypoScript jumpurl configuration is deprecated for file links since TYPO3 CMS 7 and will be removed in TYPO3 CMS 8. Pass this configuration in the typolinkConfiguration property instead.');
            if (isset($conf['jumpurl'])) {
                $typoLinkConf['jumpurl'] = $conf['jumpurl'];
            }
            if (isset($conf['jumpurl.'])) {
                $typoLinkConf['jumpurl.'] = $conf['jumpurl.'];
            }
        }

        $theLinkWrap = $this->typoLink('|', $typoLinkConf);
        $theSize = filesize($theFile);
        $fI = GeneralUtility::split_fileref($theFile);
        $icon = '';
        if ($conf['icon']) {
            $conf['icon.']['path'] = isset($conf['icon.']['path.'])
                ? $this->stdWrap($conf['icon.']['path'], $conf['icon.']['path.'])
                : $conf['icon.']['path'];
            $iconP = !empty($conf['icon.']['path'])
                ? $conf['icon.']['path']
                : ExtensionManagementUtility::siteRelPath('frontend') . 'Resources/Public/Icons/FileIcons/';
            $conf['icon.']['ext'] = isset($conf['icon.']['ext.'])
                ? $this->stdWrap($conf['icon.']['ext'], $conf['icon.']['ext.'])
                : $conf['icon.']['ext'];
            $iconExt = !empty($conf['icon.']['ext']) ? '.' . $conf['icon.']['ext'] : '.gif';
            $icon = @is_file(($iconP . $fI['fileext'] . $iconExt))
                ? $iconP . $fI['fileext'] . $iconExt
                : $iconP . 'default' . $iconExt;
            // Checking for images: If image, then return link to thumbnail.
            $IEList = isset($conf['icon_image_ext_list.']) ? $this->stdWrap($conf['icon_image_ext_list'], $conf['icon_image_ext_list.']) : $conf['icon_image_ext_list'];
            $image_ext_list = str_replace(' ', '', strtolower($IEList));
            if ($fI['fileext'] && GeneralUtility::inList($image_ext_list, $fI['fileext'])) {
                if ($conf['iconCObject']) {
                    $icon = $this->cObjGetSingle($conf['iconCObject'], $conf['iconCObject.'], 'iconCObject');
                } else {
                    $notFoundThumb = ExtensionManagementUtility::siteRelPath('core') . 'Resources/Public/Images/NotFound.gif';
                    $sizeParts = [64, 64];
                    if ($GLOBALS['TYPO3_CONF_VARS']['GFX']['thumbnails']) {
                        // using the File Abstraction Layer to generate a preview image
                        try {
                            $fileObject = ResourceFactory::getInstance()->retrieveFileOrFolderObject($theFile);
                            if ($fileObject->isMissing()) {
                                $icon = $notFoundThumb;
                            } else {
                                $fileExtension = $fileObject->getExtension();
                                if ($fileExtension === 'ttf' || GeneralUtility::inList($GLOBALS['TYPO3_CONF_VARS']['GFX']['imagefile_ext'], $fileExtension)) {
                                    if ($conf['icon_thumbSize'] || $conf['icon_thumbSize.']) {
                                        $thumbSize = isset($conf['icon_thumbSize.']) ? $this->stdWrap($conf['icon_thumbSize'], $conf['icon_thumbSize.']) : $conf['icon_thumbSize'];
                                        $sizeParts = explode('x', $thumbSize);
                                    }
                                    $icon = $fileObject->process(ProcessedFile::CONTEXT_IMAGEPREVIEW, [
                                        'width' => $sizeParts[0],
                                        'height' => $sizeParts[1]
                                    ])->getPublicUrl(true);
                                }
                            }
                        } catch (ResourceDoesNotExistException $exception) {
                            $icon = $notFoundThumb;
                        }
                    } else {
                        $icon = $notFoundThumb;
                    }
                    $urlPrefix = '';
                    if (parse_url($icon, PHP_URL_HOST) === null) {
                        $urlPrefix = $tsfe->absRefPrefix;
                    }
                    $icon = '<img src="' . htmlspecialchars($urlPrefix . $icon) . '"' .
                            ' width="' . (int)$sizeParts[0] . '" height="' . (int)$sizeParts[1] . '" ' .
                            $this->getBorderAttr(' border="0"') . '' . $this->getAltParam($conf) . ' />';
                }
            } else {
                $conf['icon.']['widthAttribute'] = isset($conf['icon.']['widthAttribute.'])
                    ? $this->stdWrap($conf['icon.']['widthAttribute'], $conf['icon.']['widthAttribute.'])
                    : $conf['icon.']['widthAttribute'];
                $iconWidth = !empty($conf['icon.']['widthAttribute']) ? $conf['icon.']['widthAttribute'] : 18;
                $conf['icon.']['heightAttribute'] = isset($conf['icon.']['heightAttribute.'])
                    ? $this->stdWrap($conf['icon.']['heightAttribute'], $conf['icon.']['heightAttribute.'])
                    : $conf['icon.']['heightAttribute'];
                $iconHeight = !empty($conf['icon.']['heightAttribute']) ? (int)$conf['icon.']['heightAttribute'] : 16;
                $icon = '<img src="' . htmlspecialchars($tsfe->absRefPrefix . $icon) . '" width="' . (int)$iconWidth . '" height="' . (int)$iconHeight . '"'
                    . $this->getBorderAttr(' border="0"') . $this->getAltParam($conf) . ' />';
            }
            if ($conf['icon_link'] && !$conf['combinedLink']) {
                $icon = $this->wrap($icon, $theLinkWrap);
            }
            $icon = isset($conf['icon.']) ? $this->stdWrap($icon, $conf['icon.']) : $icon;
        }
        $size = '';
        if ($conf['size']) {
            $size = isset($conf['size.']) ? $this->stdWrap($theSize, $conf['size.']) : $theSize;
        }
        // Wrapping file label
        if ($conf['removePrependedNumbers']) {
            $theValue = preg_replace('/_[0-9][0-9](\\.[[:alnum:]]*)$/', '\\1', $theValue);
        }
        if (isset($conf['labelStdWrap.'])) {
            $theValue = $this->stdWrap($theValue, $conf['labelStdWrap.']);
        }
        // Wrapping file
        $wrap = isset($conf['wrap.']) ? $this->stdWrap($conf['wrap'], $conf['wrap.']) : $conf['wrap'];
        if ($conf['combinedLink']) {
            $theValue = $icon . $theValue;
            if ($conf['ATagBeforeWrap']) {
                $theValue = $this->wrap($this->wrap($theValue, $wrap), $theLinkWrap);
            } else {
                $theValue = $this->wrap($this->wrap($theValue, $theLinkWrap), $wrap);
            }
            $file = isset($conf['file.']) ? $this->stdWrap($theValue, $conf['file.']) : $theValue;
            // output
            $output = $file . $size;
        } else {
            if ($conf['ATagBeforeWrap']) {
                $theValue = $this->wrap($this->wrap($theValue, $wrap), $theLinkWrap);
            } else {
                $theValue = $this->wrap($this->wrap($theValue, $theLinkWrap), $wrap);
            }
            $file = isset($conf['file.']) ? $this->stdWrap($theValue, $conf['file.']) : $theValue;
            // output
            $output = $icon . $file . $size;
        }
        if (isset($conf['stdWrap.'])) {
            $output = $this->stdWrap($output, $conf['stdWrap.']);
        }
        return $output;
    }

    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 calcIntExplode($delim, $string)
    {
        $temp = explode($delim, $string);
        foreach ($temp as $key => $val) {
            $temp[$key] = (int)$this->calc($val);
        }
        return $temp;
    }

    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']) || $conf['returnKey.'])) {
            $key = isset($conf['returnKey.']) ? (int)$this->stdWrap($conf['returnKey'], $conf['returnKey.']) : (int)$conf['returnKey'];
            return isset($valArr[$key]) ? $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 = $GLOBALS['TSFE']->tmpl->splitConfArray($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 an 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'], $configuration['replace.']) : $configuration['replace'];
            // Determines whether regular expression shall be used
            if (isset($configuration['useRegExp']) || $configuration['useRegExp.']) {
                $useRegularExpression = isset($configuration['useRegExp.']) ? $this->stdWrap($configuration['useRegExp'], $configuration['useRegExp.']) : $configuration['useRegExp'];
            }
            // Determines whether replace-pattern uses option-split
            if (isset($configuration['useOptionSplitReplace']) || isset($configuration['useOptionSplitReplace.'])) {
                $useOptionSplitReplace = isset($configuration['useOptionSplitReplace.']) ? $this->stdWrap($configuration['useOptionSplitReplace'], $configuration['useOptionSplitReplace.']) : $configuration['useOptionSplitReplace'];
            }

            // Performs a replacement by preg_replace()
            if (isset($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 (empty($useOptionSplitReplace)) {
                    $content = preg_replace($search, $replace, $content);
                } else {
                    // init for replacement
                    $splitCount = preg_match_all($search, $content, $matches);
                    $replaceArray = $this->getTypoScriptFrontendController()->tmpl->splitConfArray([$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 {
                if (empty($useOptionSplitReplace)) {
                    $content = str_replace($search, $replace, $content);
                } else {
                    // turn search-string into a preg-pattern
                    $searchPreg = '#' . preg_quote($search, '#') . '#';

                    // init for replacement
                    $splitCount = preg_match_all($searchPreg, $content, $matches);
                    $replaceArray = $this->getTypoScriptFrontendController()->tmpl->splitConfArray([$replace], $splitCount);
                    $replaceCount = 0;

                    $replaceCallback = function () use ($replaceArray, $search, &$replaceCount) {
                        $replaceCount++;
                        return $replaceArray[$replaceCount - 1][0];
                    };
                    $content = preg_replace_callback($searchPreg, $replaceCallback, $content);
                }
            }
        }
        return $content;
    }

    protected function round($content, array $conf = [])
    {
        $decimals = isset($conf['decimals.']) ? $this->stdWrap($conf['decimals'], $conf['decimals.']) : $conf['decimals'];
        $type = isset($conf['roundType.']) ? $this->stdWrap($conf['roundType'], $conf['roundType.']) : $conf['roundType'];
        $floatVal = floatval($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'];
        $dec_point = isset($conf['dec_point.']) ? $this->stdWrap($conf['dec_point'], $conf['dec_point.']) : $conf['dec_point'];
        $thousands_sep = isset($conf['thousands_sep.']) ? $this->stdWrap($conf['thousands_sep'], $conf['thousands_sep.']) : $conf['thousands_sep'];
        return number_format(floatval($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.'];
        }
        // Process:
        if ((string)$conf['externalBlocks'] === '') {
            return $this->_parseFunc($theValue, $conf);
        }
        $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);
            }
        }
        return implode('', $parts);
    }

    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 = 0;
        // Pointer to the total string position
        $pointer = 0;
        // Loaded with the current typo-tag if any.
        $currentTag = '';
        $stripNL = 0;
        $contentAccum = [];
        $contentAccumP = 0;
        $allowTags = strtolower(str_replace(' ', '', $conf['allowTags']));
        $denyTags = strtolower(str_replace(' ', '', $conf['denyTags']));
        $totalLen = strlen($theValue);
        do {
            if (!$inside) {
                if (!is_array($currentTag)) {
                    // 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 {
                    // If we're inside a currentTag, just take it to the end of that tag!
                    $tempContent = strtolower(substr($theValue, $pointer));
                    $len = strpos($tempContent, '</' . $currentTag[0]);
                    if (is_string($len) && !$len) {
                        $len = strlen($tempContent);
                    }
                }
                // $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 != '') {
                    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);
                    }
                    // These operations should only be performed on code outside the tags...
                    if (!is_array($currentTag)) {
                        // Constants
                        $tsfe = $this->getTypoScriptFrontendController();
                        $tmpConstants = $tsfe->tmpl->setup['constants.'];
                        if ($conf['constants'] && is_array($tmpConstants)) {
                            foreach ($tmpConstants as $key => $val) {
                                if (is_string($val)) {
                                    $data = str_replace('###' . $key . '###', $val, $data);
                                }
                            }
                        }
                        // Short
                        if (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 (is_array($conf['plainTextStdWrap.'])) {
                            $data = $this->stdWrap($data, $conf['plainTextStdWrap.']);
                        }
                        // userFunc
                        if ($conf['userFunc']) {
                            $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']) {
                            $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 (strstr($pieces[0], '<') || strstr($pieces[0], '>')) {
                                    // 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;
                        }
                    }
                    $contentAccum[$contentAccumP] .= $data;
                }
                $inside = 1;
            } else {
                // tags
                $len = strcspn(substr($theValue, $pointer), '>') + 1;
                $data = substr($theValue, $pointer, $len);
                if (StringUtility::endsWith($data, '/>') && !StringUtility::beginsWith($data, '<link ')) {
                    $tagContent = substr($data, 1, -2);
                } else {
                    $tagContent = substr($data, 1, -1);
                }
                $tag = explode(' ', trim($tagContent), 2);
                $tag[0] = strtolower($tag[0]);
                if ($tag[0][0] === '/') {
                    $tag[0] = substr($tag[0], 1);
                    $tag['out'] = 1;
                }
                if ($conf['tags.'][$tag[0]]) {
                    $treated = false;
                    $stripNL = false;
                    // in-tag
                    if (!$currentTag && !$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', $tag[0])) {
                            $tag['out'] = 1;
                        }
                    }
                    // out-tag
                    if ($currentTag[0] === $tag[0] && $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'];
                        // This flag indicates, that this TypoTag section should NOT be included in the nonTypoTag content.
                        $breakOut = $theConf['breakoutTypoTagContent'] ? 1 : 0;
                        $this->parameters = [];
                        if ($currentTag[1]) {
                            $params = GeneralUtility::get_tag_attributes($currentTag[1]);
                            if (is_array($params)) {
                                foreach ($params as $option => $val) {
                                    $this->parameters[strtolower($option)] = $val;
                                }
                            }
                        }
                        $this->parameters['allParams'] = trim($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) {
                            $contentAccum[$contentAccumP - 2] .= $contentAccum[$contentAccumP - 1] . $contentAccum[$contentAccumP];
                            unset($contentAccum[$contentAccumP]);
                            unset($contentAccum[$contentAccumP - 1]);
                            $contentAccumP -= 2;
                        }
                        unset($currentTag);
                        $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, $tag[0]) || $denyTags != '*' && !GeneralUtility::inList($denyTags, $tag[0])) {
                        $contentAccum[$contentAccumP] .= $data;
                    } else {
                        $contentAccum[$contentAccumP] .= htmlspecialchars($data);
                    }
                }
                $inside = 0;
            }
            $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 (is_array($conf['nonTypoTagStdWrap.'])) {
                    $contentAccum[$a] = $this->stdWrap($contentAccum[$a], $conf['nonTypoTagStdWrap.']);
                }
                // userFunc
                if ($conf['nonTypoTagUserFunc']) {
                    $contentAccum[$a] = $this->callUserFunction($conf['nonTypoTagUserFunc'], $conf['nonTypoTagUserFunc.'], $contentAccum[$a]);
                }
            }
        }
        return implode('', $contentAccum);
    }

    public function encaps_lineSplit($theValue, $conf)
    {
        $lParts = explode(LF, $theValue);
        $encapTags = GeneralUtility::trimExplode(',', strtolower($conf['encapsTagList']), true);
        $nonWrappedTag = $conf['nonWrappedTag'];
        $defaultAlign = isset($conf['defaultAlign.'])
            ? trim($this->stdWrap($conf['defaultAlign'], $conf['defaultAlign.']))
            : trim($conf['defaultAlign']);
        if ((string)$theValue === '') {
            return '';
        }
        $str_content = '';
        foreach ($lParts as $k => $l) {
            $sameBeginEnd = 0;
            $emptyTag = 0;
            $l = trim($l);
            $attrib = [];
            $nWrapped = 0;
            $tagName = '';
            if ($l[0] === '<' && substr($l, -1) === '>') {
                $fwParts = explode('>', substr($l, 1), 2);
                list($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 = 1;
                        $attrib = GeneralUtility::get_tag_attributes('<' . substr($fwParts[0], 0, -1) . '>');
                    }
                } else {
                    $backParts = GeneralUtility::revExplode('<', substr($fwParts[1], 0, -1), 2);
                    $attrib = GeneralUtility::get_tag_attributes('<' . $fwParts[0] . '>');
                    $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] ? $conf['remapTag.'][$uTagName] : $uTagName);
            } else {
                $uTagName = strtoupper($nonWrappedTag);
                // The line will be wrapped: $uTagName should not be an empty tag
                $emptyTag = 0;
                $str_content = $lParts[$k];
                $nWrapped = 1;
                $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 (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 (is_array($conf['encapsLinesStdWrap.'][$uTagName . '.'])) {
                    $str_content = $this->stdWrap($str_content, $conf['encapsLinesStdWrap.'][$uTagName . '.']);
                }
                // Default align
                if (!$attrib['align'] && $defaultAlign) {
                    $attrib['align'] = $defaultAlign;
                }
                $params = GeneralUtility::implodeAttributes($attrib, 1);
                if (!($conf['removeWrapping'] && !($emptyTag && $conf['removeWrapping.']['keepSingleTag']))) {
                    if ($emptyTag) {
                        $str_content = '<' . strtolower($uTagName) . (trim($params) ? ' ' . trim($params) : '') . ' />';
                    } else {
                        $str_content = '<' . strtolower($uTagName) . (trim($params) ? ' ' . trim($params) : '') . '>' . $str_content . '</' . strtolower($uTagName) . '>';
                    }
                }
            }
            if ($nWrapped && $conf['wrapNonWrappedLines']) {
                $str_content = $this->wrap($str_content, $conf['wrapNonWrappedLines']);
            }
            $lParts[$k] = $str_content;
        }
        return implode(LF, $lParts);
    }

    public function http_makelinks($data, $conf)
    {
        $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) . TAB . 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 (strstr($keep, 'scheme')) {
                        $linktxt = $scheme;
                    }
                    $linktxt .= $linkParts['host'];
                    if (strstr($keep, 'path')) {
                        $linktxt .= $linkParts['path'];
                        // Added $linkParts['query'] 3/12
                        if (strstr($keep, 'query') && $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)
    {
        // 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) . TAB . 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 = preg_replace('/\\?.*/', '', $parts[0]);
                list($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)
    {
        if (empty($file) && empty($fileArray)) {
            return null;
        }
        if (!is_array($fileArray)) {
            $fileArray = (array)$fileArray;
        }
        $imageResource = null;
        $tsfe = $this->getTypoScriptFrontendController();
        if ($file === 'GIFBUILDER') {
            $gifCreator = GeneralUtility::makeInstance(GifBuilder::class);
            $gifCreator->init();
            $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();
                if (!isset($fileArray['crop'])) {
                    $fileArray['crop'] = $file->getProperty('crop');
                }
            } else {
                try {
                    if ($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)) {
                            $fileReference = $this->getResourceFactory()->getFileReferenceObject($file);
                            $fileObject = $fileReference->getOriginalFile();
                            if (!isset($fileArray['crop'])) {
                                $fileArray['crop'] = $fileReference->getProperty('crop');
                            }
                        } 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) {
                    $logger = GeneralUtility::makeInstance(LogManager::class)->getLogger(__CLASS__);
                    $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'];
                $processingConfiguration['crop'] = isset($fileArray['crop.'])
                    ? $this->stdWrap($fileArray['crop'], $fileArray['crop.'])
                    : (isset($fileArray['crop']) ? $fileArray['crop'] : null);
                // Possibility to cancel/force profile extraction
                // see $GLOBALS['TYPO3_CONF_VARS']['GFX']['im_stripProfileCommand']
                if (isset($fileArray['stripProfile'])) {
                    $processingConfiguration['stripProfile'] = $fileArray['stripProfile'];
                }
                // Check if we can handle this type of file for editing
                if (GeneralUtility::inList($GLOBALS['TYPO3_CONF_VARS']['GFX']['imagefile_ext'], $fileObject->getExtension())) {
                    $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);
                    $hash = $processedFileObject->calculateChecksum();
                    // store info in the TSFE template cache (kept for backwards compatibility)
                    if ($processedFileObject->isProcessed() && !isset($tsfe->tmpl->fileCache[$hash])) {
                        $tsfe->tmpl->fileCache[$hash] = [
                            0 => $processedFileObject->getProperty('width'),
                            1 => $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,
                            'fileCacheHash' => $hash
                        ];
                    }
                    $imageResource = $tsfe->tmpl->fileCache[$hash];
                }
            }
        }
        // If image was processed by GIFBUILDER:
        // ($imageResource indicates that it was processed the regular way)
        if (!isset($imageResource)) {
            $theImage = $tsfe->tmpl->getFileName($file);
            if ($theImage) {
                $gifCreator = GeneralUtility::makeInstance(GifBuilder::class);
                $gifCreator->init();
                $info = $gifCreator->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;
            }
        }
        // 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;
    }

    /***********************************************
     *
     * Data retrieval etc.
     *
     ***********************************************/
    public function getFieldVal($field)
    {
        if (!strstr($field, '//')) {
            return $this->data[trim($field)];
        } else {
            $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];
                        break;
                    case 'global':
                        $retVal = $this->getGlobal($key);
                        break;
                    case 'level':
                        $retVal = count($tsfe->tmpl->rootLine) - 1;
                        break;
                    case 'leveltitle':
                        $keyParts = GeneralUtility::trimExplode(',', $key);
                        $numericKey = $this->getKey($keyParts[0], $tsfe->tmpl->rootLine);
                        $retVal = $this->rootLineValue($numericKey, 'title', strtolower($keyParts[1]) === 'slide');
                        break;
                    case 'levelmedia':
                        $keyParts = GeneralUtility::trimExplode(',', $key);
                        $numericKey = $this->getKey($keyParts[0], $tsfe->tmpl->rootLine);
                        $retVal = $this->rootLineValue($numericKey, 'media', strtolower($keyParts[1]) === 'slide');
                        break;
                    case 'leveluid':
                        $numericKey = $this->getKey($key, $tsfe->tmpl->rootLine);
                        $retVal = $this->rootLineValue($numericKey, 'uid');
                        break;
                    case 'levelfield':
                        $keyParts = GeneralUtility::trimExplode(',', $key);
                        $numericKey = $this->getKey($keyParts[0], $tsfe->tmpl->rootLine);
                        $retVal = $this->rootLineValue($numericKey, $keyParts[1], strtolower($keyParts[2]) === 'slide');
                        break;
                    case 'fullrootline':
                        $keyParts = GeneralUtility::trimExplode(',', $key);
                        $fullKey = (int)$keyParts[0] - count($tsfe->tmpl->rootLine) + count($tsfe->rootLine);
                        if ($fullKey >= 0) {
                            $retVal = $this->rootLineValue($fullKey, $keyParts[1], stristr($keyParts[2], 'slide'), $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':
                        // Check if the current page has a value in the DB field "backend_layout"
                        // if empty, check the root line for "backend_layout_next_level"
                        // same as
                        //   field = backend_layout
                        //   ifEmpty.data = levelfield:-2, backend_layout_next_level, slide
                        //   ifEmpty.ifEmpty = default
                        $retVal = $GLOBALS['TSFE']->page['backend_layout'];

                        // If it is set to "none" - don't use any
                        if ($retVal === '-1') {
                            $retVal = 'none';
                        } elseif ($retVal === '' || $retVal === '0') {
                            // If it not set check the root-line for a layout on next level and use this
                            // Remove first element, which is the current page
                            // See also \TYPO3\CMS\Backend\View\BackendLayoutView::getSelectedCombinedIdentifier()
                            $rootLine = $tsfe->rootLine;
                            array_shift($rootLine);
                            foreach ($rootLine as $rootLinePage) {
                                $retVal = (string) $rootLinePage['backend_layout_next_level'];
                                // If layout for "next level" is set to "none" - don't use any and stop searching
                                if ($retVal === '-1') {
                                    $retVal = 'none';
                                    break;
                                } elseif ($retVal !== '' && $retVal !== '0') {
                                    // Stop searching if a layout for "next level" is set
                                    break;
                                }
                            }
                        }
                        if ($retVal === '0' || $retVal === '') {
                            $retVal = 'default';
                        }
                        break;
                    case 'current':
                        $retVal = $this->data[$this->currentValKey];
                        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':
                        $retVal = $tsfe->tmpl->getFileName($key);
                        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;
                }
            }
            if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getData'])) {
                foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getData'] as $classData) {
                    $hookObject = GeneralUtility::getUserObj($classData);
                    if (!$hookObject instanceof ContentObjectGetDataHookInterface) {
                        throw new \UnexpectedValueException('$hookObject must implement interface ' . ContentObjectGetDataHookInterface::class, 1195044480);
                    }
                    $retVal = $hookObject->getDataExtension($string, $fieldArray, $secVal, $retVal, $this);
                }
            }
        }
        return $retVal;
    }

    protected function getFileDataKey($key)
    {
        list($fileUidOrCurrentKeyword, $requestedFileInformationKey) = explode(':', $key, 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) {
            $logger = GeneralUtility::makeInstance(LogManager::class)->getLogger(__CLASS__);
            $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];
        } else {
            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;
    }

    public function TCAlookup($inputValue, $conf)
    {
        $table = $conf['table'];
        $field = $conf['field'];
        $delimiter = $conf['delimiter'] ? $conf['delimiter'] : ' ,';
        if (is_array($GLOBALS['TCA'][$table]) && is_array($GLOBALS['TCA'][$table]['columns'][$field]) && is_array($GLOBALS['TCA'][$table]['columns'][$field]['config']['items'])) {
            $tsfe = $this->getTypoScriptFrontendController();
            $values = GeneralUtility::trimExplode(',', $inputValue);
            $output = [];
            foreach ($values as $value) {
                // Traverse the items-array...
                foreach ($GLOBALS['TCA'][$table]['columns'][$field]['config']['items'] as $item) {
                    // ... and return the first found label where the value was equal to $key
                    if ((string)$item[1] === trim($value)) {
                        $output[] = $tsfe->sL($item[0]);
                    }
                }
            }
            $returnValue = implode($delimiter, $output);
        } else {
            $returnValue = $inputValue;
        }
        return $returnValue;
    }

    /***********************************************
     *
     * 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:
        list($linkHandlerKeyword, $linkHandlerValue) = explode(':', $linkParameterParts['url'], 2);
        if ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['typolinkLinkHandler'][$linkHandlerKeyword] && (string)$linkHandlerValue !== '') {
            $linkHandlerObj = GeneralUtility::getUserObj($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);
            }
        }

        // Resolve FAL-api "file:UID-of-sys_file-record" and "file:combined-identifier"
        if ($linkHandlerKeyword === 'file' && !StringUtility::beginsWith($linkParameterParts['url'], 'file://')) {
            try {
                $fileOrFolderObject = $this->getResourceFactory()->retrieveFileOrFolderObject($linkHandlerValue);
                // Link to a folder or file
                if ($fileOrFolderObject instanceof File || $fileOrFolderObject instanceof Folder) {
                    $linkParameter = $fileOrFolderObject->getPublicUrl();
                } else {
                    $linkParameter = null;
                }
            } catch (\RuntimeException $e) {
                // Element wasn't found
                $linkParameter = null;
            } catch (ResourceDoesNotExistException $e) {
                // Resource was not found
                return $linkText;
            }
        // Disallow direct javascript: or data: links
        } elseif (in_array(strtolower(trim($linkHandlerKeyword)), ['javascript', 'data'], true)) {
            return $linkText;
        } else {
            $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']
        ];
    }

    protected function detectLinkTypeFromLinkParameter($linkParameter)
    {
        if (stripos(rawurldecode(trim($linkParameter)), 'phar://') === 0) {
            throw new \RuntimeException(
                'phar scheme not allowed as soft reference target',
                1530030673
            );
        }

        // Parse URL:
        $scheme = parse_url($linkParameter, PHP_URL_SCHEME);
        // Detecting kind of link:
        // If it's a mail address:
        if (strpos($linkParameter, '@') > 0 && (!$scheme || $scheme === 'mailto')) {
            return 'mailto';
        }

        $isLocalFile = 0;
        $fileChar = intval(strpos($linkParameter, '/'));
        $urlChar = intval(strpos($linkParameter, '.'));

        $containsSlash = false;
        // Firsts, test if $linkParameter is numeric and page with such id exists. If yes, do not attempt to link to file
        if (!MathUtility::canBeInterpretedAsInteger($linkParameter) || empty($this->getTypoScriptFrontendController()->sys_page->getPage_noCheck($linkParameter))) {
            // Detects if a file is found in site-root and if so it will be treated like a normal file.
            list($rootFileDat) = explode('?', rawurldecode($linkParameter));
            $containsSlash = strpos($rootFileDat, '/') !== false;
            $rFD_fI = pathinfo($rootFileDat);
            $fileExtension = strtolower($rFD_fI['extension']);
            if (!$containsSlash && trim($rootFileDat) && (@is_file(PATH_site . $rootFileDat) || $fileExtension === 'php' || $fileExtension === 'html' || $fileExtension === 'htm')) {
                $isLocalFile = 1;
            } elseif ($containsSlash) {
                // Adding this so realurl directories are linked right (non-existing).
                $isLocalFile = 2;
            }
        }

        // url (external): If doubleSlash or if a '.' comes before a '/'.
        if ($scheme || $isLocalFile !== 1 && $urlChar && (!$containsSlash || $urlChar < $fileChar)) {
            return 'url';

        // file (internal)
        } elseif ($containsSlash || $isLocalFile) {
            return 'file';
        }

        // Integer or alias (alias is without slashes or periods or commas, that is
        // 'nospace,alphanum_x,lower,unique' according to definition in $GLOBALS['TCA']!)
        return 'page';
    }

    public function typoLink($linktxt, $conf)
    {
        $linktxt = (string)$linktxt;
        $tsfe = $this->getTypoScriptFrontendController();

        $LD = [];
        $finalTagParts = [];
        $finalTagParts['aTagParams'] = $this->getATagParams($conf);
        $linkParameter = trim(isset($conf['parameter.']) ? $this->stdWrap($conf['parameter'], $conf['parameter.']) : $conf['parameter']);
        $this->lastTypoLinkUrl = '';
        $this->lastTypoLinkTarget = '';

        $resolvedLinkParameters = $this->resolveMixedLinkParameter($linktxt, $linkParameter, $conf);
        // check if the link handler hook has resolved the link completely already
        if (!is_array($resolvedLinkParameters)) {
            return $resolvedLinkParameters;
        }

        $linkParameter = $resolvedLinkParameters['href'];
        $forceTarget = $resolvedLinkParameters['target'];
        $linkClass = $resolvedLinkParameters['class'];
        $forceTitle = $resolvedLinkParameters['title'];

        if (!$linkParameter) {
            return $linktxt;
        }

        // Check, if the target is coded as a JS open window link:
        $JSwindowParts = [];
        $JSwindowParams = '';
        if ($forceTarget && preg_match('/^([0-9]+)x([0-9]+)(:(.*)|.*)$/', $forceTarget, $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 = [];
            foreach ($JSwindow_tempParamsArr as $JSv) {
                list($JSp, $JSv) = explode('=', $JSv, 2);
                $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);
            // Resetting the target since we will use onClick.
            $forceTarget = '';
        }

        // Internal target:
        if ($tsfe->dtdAllowsFrames) {
            $target = isset($conf['target']) ? $conf['target'] : $tsfe->intTarget;
        } else {
            $target = isset($conf['target']) ? $conf['target'] : '';
        }
        if ($conf['target.']) {
            $target = $this->stdWrap($target, $conf['target.']);
        }

        // Title tag
        $title = $conf['title'];
        if ($conf['title.']) {
            $title = $this->stdWrap($title, $conf['title.']);
        }

        $theTypeP = '';
        // Detecting kind of link
        $linkType = $this->detectLinkTypeFromLinkParameter($linkParameter);
        switch ($linkType) {
            // If it's a mail address
            case 'mailto':
                $linkParameter = preg_replace('/^mailto:/i', '', $linkParameter);
                list($this->lastTypoLinkUrl, $linktxt) = $this->getMailTo($linkParameter, $linktxt);
                $finalTagParts['url'] = $this->lastTypoLinkUrl;
            break;

            // url (external): If doubleSlash or if a '.' comes before a '/'.
            case 'url':
                if ($tsfe->dtdAllowsFrames) {
                    $target = isset($conf['extTarget']) ? $conf['extTarget'] : $tsfe->extTarget;
                } else {
                    $target = isset($conf['extTarget']) ? $conf['extTarget'] : '';
                }
                if ($conf['extTarget.']) {
                    $target = $this->stdWrap($target, $conf['extTarget.']);
                }
                if ($forceTarget) {
                    $target = $forceTarget;
                }
                if ($linktxt === '') {
                    $linktxt = $this->parseFunc($linkParameter, ['makelinks' => 0], '< lib.parseFunc');
                }
                // Parse URL:
                $urlParts = parse_url($linkParameter);
                if (!$urlParts['scheme']) {
                    $scheme = 'http://';
                } else {
                    $scheme = '';
                }

                $this->lastTypoLinkUrl = $this->processUrl(UrlProcessorInterface::CONTEXT_EXTERNAL, $scheme . $linkParameter, $conf);

                $this->lastTypoLinkTarget = $target;
                $finalTagParts['url'] = $this->lastTypoLinkUrl;
                $finalTagParts['targetParams'] = $target ? ' target="' . htmlspecialchars($target) . '"' : '';
                $finalTagParts['aTagParams'] .= $this->extLinkATagParams($finalTagParts['url'], $linkType);
            break;

            // file (internal)
            case 'file':

                $splitLinkParam = explode('?', $linkParameter);

                // check if the file exists or if a / is contained (same check as in detectLinkType)
                if (file_exists(rawurldecode($splitLinkParam[0])) || strpos($linkParameter, '/') !== false) {
                    $fileUri = $linkParameter;
                    if ($linktxt === '') {
                        $linktxt = $this->parseFunc(rawurldecode($linkParameter), ['makelinks' => 0], '< lib.parseFunc');
                    }
                    if (!StringUtility::beginsWith($linkParameter, '/')
                        && parse_url($linkParameter, PHP_URL_SCHEME) === null
                    ) {
                        $fileUri = $tsfe->absRefPrefix . $fileUri;
                    }
                    $this->lastTypoLinkUrl = $this->processUrl(UrlProcessorInterface::CONTEXT_FILE, $fileUri, $conf);
                    $this->lastTypoLinkUrl = $this->forceAbsoluteUrl($this->lastTypoLinkUrl, $conf);
                    $target = isset($conf['fileTarget']) ? $conf['fileTarget'] : $tsfe->fileTarget;
                    if ($conf['fileTarget.']) {
                        $target = $this->stdWrap($target, $conf['fileTarget.']);
                    }
                    if ($forceTarget) {
                        $target = $forceTarget;
                    }
                    $this->lastTypoLinkTarget = $target;
                    $finalTagParts['url'] = $this->lastTypoLinkUrl;
                    $finalTagParts['targetParams'] = $target ? ' target="' . htmlspecialchars($target) . '"' : '';
                    $finalTagParts['aTagParams'] .= $this->extLinkATagParams($finalTagParts['url'], $linkType);
                } else {
                    $this->getTimeTracker()->setTSlogMessage('typolink(): File "' . $splitLinkParam[0] . '" did not exist, so "' . $linktxt . '" was not linked.', 1);
                    return $linktxt;
                }
            break;

            // Integer or alias (alias is without slashes or periods or commas, that is
            // 'nospace,alphanum_x,lower,unique' according to definition in $GLOBALS['TCA']!)
            case 'page':
                $enableLinksAcrossDomains = $tsfe->config['config']['typolinkEnableLinksAcrossDomains'];

                if ($conf['no_cache.']) {
                    $conf['no_cache'] = $this->stdWrap($conf['no_cache'], $conf['no_cache.']);
                }
                // Splitting the parameter by ',' and if the array counts more than 1 element it's an id/type/parameters triplet
                $pairParts = GeneralUtility::trimExplode(',', $linkParameter, true);
                $linkParameter = $pairParts[0];
                $link_params_parts = explode('#', $linkParameter);
                // Link-data del
                $linkParameter = trim($link_params_parts[0]);
                // If no id or alias is given
                if ($linkParameter === '') {
                    $linkParameter = $tsfe->id;
                }

                $sectionMark = trim(isset($conf['section.']) ? $this->stdWrap($conf['section'], $conf['section.']) : $conf['section']);
                if ($sectionMark !== '') {
                    $sectionMark = '#' . (MathUtility::canBeInterpretedAsInteger($sectionMark) ? 'c' : '') . $sectionMark;
                }

                if ($link_params_parts[1] && $sectionMark === '') {
                    $sectionMark = trim($link_params_parts[1]);
                    $sectionMark = '#' . (MathUtility::canBeInterpretedAsInteger($sectionMark) ? 'c' : '') . $sectionMark;
                }
                if (count($pairParts) > 1) {
                    // Overruling 'type'
                    $theTypeP = isset($pairParts[1]) ? $pairParts[1] : 0;
                    $conf['additionalParams'] .= isset($pairParts[2]) ? $pairParts[2] : '';
                }
                // Checking if the id-parameter is an alias.
                if (!MathUtility::canBeInterpretedAsInteger($linkParameter)) {
                    $linkParameter = $tsfe->sys_page->getPageIdFromAlias($linkParameter);
                }
                // Link to page even if access is missing?
                if (isset($conf['linkAccessRestrictedPages'])) {
                    $disableGroupAccessCheck = (bool)$conf['linkAccessRestrictedPages'];
                } else {
                    $disableGroupAccessCheck = (bool)$tsfe->config['config']['typolinkLinkAccessRestrictedPages'];
                }
                // Looking up the page record to verify its existence:
                $page = $tsfe->sys_page->getPage($linkParameter, $disableGroupAccessCheck);
                if (!empty($page)) {
                    // MointPoints, look for closest MPvar:
                    $MPvarAcc = [];
                    if (!$tsfe->config['config']['MP_disableTypolinkClosestMPvalue']) {
                        $temp_MP = $this->getClosestMPvalueForPage($page['uid'], true);
                        if ($temp_MP) {
                            $MPvarAcc['closest'] = $temp_MP;
                        }
                    }
                    // Look for overlay Mount Point:
                    $mount_info = $tsfe->sys_page->getMountPointInfo($page['uid'], $page);
                    if (is_array($mount_info) && $mount_info['overlay']) {
                        $page = $tsfe->sys_page->getPage($mount_info['mount_pid'], $disableGroupAccessCheck);
                        if (empty($page)) {
                            $this->getTimeTracker()->setTSlogMessage('typolink(): Mount point "' . $mount_info['mount_pid'] . '" was not available, so "' . $linktxt . '" was not linked.', 1);
                            return $linktxt;
                        }
                        $MPvarAcc['re-map'] = $mount_info['MPvar'];
                    }
                    // Setting title if blank value to link:
                    if ($linktxt === '') {
                        $linktxt = $this->parseFunc($page['title'], ['makelinks' => 0], '< lib.parseFunc');
                    }
                    // Query Params:
                    $addQueryParams = $conf['addQueryString'] ? $this->getQueryArguments($conf['addQueryString.']) : '';
                    $addQueryParams .= isset($conf['additionalParams.']) ? trim($this->stdWrap($conf['additionalParams'], $conf['additionalParams.'])) : trim($conf['additionalParams']);
                    if ($addQueryParams === '&' || $addQueryParams[0] !== '&') {
                        $addQueryParams = '';
                    }
                    $targetDomain = '';
                    $currentDomain = (string)$this->getEnvironmentVariable('HTTP_HOST');
                    // Mount pages are always local and never link to another domain
                    if (!empty($MPvarAcc)) {
                        // Add "&MP" var:
                        $addQueryParams .= '&MP=' . rawurlencode(implode(',', $MPvarAcc));
                    } elseif (strpos($addQueryParams, '&MP=') === false && $tsfe->config['config']['typolinkCheckRootline']) {
                        // We do not come here if additionalParams had '&MP='. This happens when typoLink is called from
                        // menu. Mount points always work in the content of the current domain and we must not change
                        // domain if MP variables exist.
                        // If we link across domains and page is free type shortcut, we must resolve the shortcut first!
                        // If we do not do it, TYPO3 will fail to (1) link proper page in RealURL/CoolURI because
                        // they return relative links and (2) show proper page if no RealURL/CoolURI exists when link is clicked
                        if ($enableLinksAcrossDomains
                            && (int)$page['doktype'] === PageRepository::DOKTYPE_SHORTCUT
                            && (int)$page['shortcut_mode'] === PageRepository::SHORTCUT_MODE_NONE
                        ) {
                            // Save in case of broken destination or endless loop
                            $page2 = $page;
                            // Same as in RealURL, seems enough
                            $maxLoopCount = 20;
                            while ($maxLoopCount
                                && is_array($page)
                                && (int)$page['doktype'] === PageRepository::DOKTYPE_SHORTCUT
                                && (int)$page['shortcut_mode'] === PageRepository::SHORTCUT_MODE_NONE
                            ) {
                                $page = $tsfe->sys_page->getPage($page['shortcut'], $disableGroupAccessCheck);
                                $maxLoopCount--;
                            }
                            if (empty($page) || $maxLoopCount === 0) {
                                // We revert if shortcut is broken or maximum number of loops is exceeded (indicates endless loop)
                                $page = $page2;
                            }
                        }

                        $targetDomain = $tsfe->getDomainNameForPid($page['uid']);
                        // Do not prepend the domain if it is the current hostname
                        if (!$targetDomain || $tsfe->domainNameMatchesCurrentRequest($targetDomain)) {
                            $targetDomain = '';
                        }
                    }
                    if ($conf['useCacheHash']) {
                        $params = $tsfe->linkVars . $addQueryParams . '&id=' . $page['uid'];
                        if (trim($params, '& ') != '') {
                            $cacheHash = GeneralUtility::makeInstance(CacheHashCalculator::class);
                            $cHash = $cacheHash->generateForParameters($params);
                            $addQueryParams .= $cHash ? '&cHash=' . $cHash : '';
                        }
                        unset($params);
                    }
                    $absoluteUrlScheme = 'http';
                    // URL shall be absolute:
                    if (isset($conf['forceAbsoluteUrl']) && $conf['forceAbsoluteUrl'] || $page['url_scheme'] > 0) {
                        // Override scheme:
                        if (isset($conf['forceAbsoluteUrl.']['scheme']) && $conf['forceAbsoluteUrl.']['scheme']) {
                            $absoluteUrlScheme = $conf['forceAbsoluteUrl.']['scheme'];
                        } elseif ($page['url_scheme'] > 0) {
                            $absoluteUrlScheme = (int)$page['url_scheme'] === HttpUtility::SCHEME_HTTP ? 'http' : 'https';
                        } elseif ($this->getEnvironmentVariable('TYPO3_SSL')) {
                            $absoluteUrlScheme = 'https';
                        }
                        // If no domain records are defined, use current domain:
                        $currentUrlScheme = parse_url($this->getEnvironmentVariable('TYPO3_REQUEST_URL'), PHP_URL_SCHEME);
                        if ($targetDomain === '' && ($conf['forceAbsoluteUrl'] || $absoluteUrlScheme !== $currentUrlScheme)) {
                            $targetDomain = $currentDomain;
                        }
                        // If go for an absolute link, add site path if it's not taken care about by absRefPrefix
                        if (!$tsfe->config['config']['absRefPrefix'] && $targetDomain === $currentDomain) {
                            $targetDomain = $currentDomain . rtrim($this->getEnvironmentVariable('TYPO3_SITE_PATH'), '/');
                        }
                    }
                    // If target page has a different domain and the current domain's linking scheme (e.g. RealURL/...) should not be used
                    if ($targetDomain !== '' && $targetDomain !== $currentDomain && !$enableLinksAcrossDomains) {
                        $target = isset($conf['extTarget']) ? $conf['extTarget'] : $tsfe->extTarget;
                        if ($conf['extTarget.']) {
                            $target = $this->stdWrap($target, $conf['extTarget.']);
                        }
                        if ($forceTarget) {
                            $target = $forceTarget;
                        }
                        $LD['target'] = $target;
                        // Convert IDNA-like domain (if any)
                        if (!preg_match('/^[a-z0-9.\\-]*$/i', $targetDomain)) {
                            $targetDomain =  GeneralUtility::idnaEncode($targetDomain);
                        }
                        $this->lastTypoLinkUrl = $this->URLqMark($absoluteUrlScheme . '://' . $targetDomain . '/index.php?id=' . $page['uid'], $addQueryParams) . $sectionMark;
                    } else {
                        // Internal link or current domain's linking scheme should be used
                        if ($forceTarget) {
                            $target = $forceTarget;
                        }
                        $LD = $tsfe->tmpl->linkData($page, $target, $conf['no_cache'], '', '', $addQueryParams, $theTypeP, $targetDomain);
                        if ($targetDomain !== '') {
                            // We will add domain only if URL does not have it already.
                            if ($enableLinksAcrossDomains && $targetDomain !== $currentDomain) {
                                // Get rid of the absRefPrefix if necessary. absRefPrefix is applicable only
                                // to the current web site. If we have domain here it means we link across
                                // domains. absRefPrefix can contain domain name, which will screw up
                                // the link to the external domain.
                                $prefixLength = strlen($tsfe->config['config']['absRefPrefix']);
                                if (substr($LD['totalURL'], 0, $prefixLength) === $tsfe->config['config']['absRefPrefix']) {
                                    $LD['totalURL'] = substr($LD['totalURL'], $prefixLength);
                                }
                            }
                            $urlParts = parse_url($LD['totalURL']);
                            if (empty($urlParts['host'])) {
                                $LD['totalURL'] = $absoluteUrlScheme . '://' . $targetDomain . ($LD['totalURL'][0] === '/' ? '' : '/') . $LD['totalURL'];
                            }
                        }
                        $this->lastTypoLinkUrl = $this->URLqMark($LD['totalURL'], '') . $sectionMark;
                    }
                    $this->lastTypoLinkTarget = $LD['target'];
                    // If sectionMark is set, there is no baseURL AND the current page is the page the link is to, check if there are any additional parameters or addQueryString parameters and if not, drop the url.
                    if ($sectionMark
                        && !$tsfe->config['config']['baseURL']
                        && (int)$page['uid'] === (int)$tsfe->id
                        && !trim($addQueryParams)
                        && (empty($conf['addQueryString']) || !isset($conf['addQueryString.']))
                    ) {
                        $currentQueryParams = $this->getQueryArguments([]);
                        if (!trim($currentQueryParams)) {
                            list(, $URLparams) = explode('?', $this->lastTypoLinkUrl);
                            list($URLparams) = explode('#', $URLparams);
                            parse_str($URLparams . $LD['orig_type'], $URLparamsArray);
                            // Type nums must match as well as page ids
                            if ((int)$URLparamsArray['type'] === (int)$tsfe->type) {
                                unset($URLparamsArray['id']);
                                unset($URLparamsArray['type']);
                                // If there are no parameters left.... set the new url.
                                if (empty($URLparamsArray)) {
                                    $this->lastTypoLinkUrl = $sectionMark;
                                }
                            }
                        }
                    }
                    // If link is to an access restricted page which should be redirected, then find new URL:
                    if (empty($conf['linkAccessRestrictedPages'])
                        && $tsfe->config['config']['typolinkLinkAccessRestrictedPages']
                        && $tsfe->config['config']['typolinkLinkAccessRestrictedPages'] !== 'NONE'
                        && !$tsfe->checkPageGroupAccess($page)
                    ) {
                        $thePage = $tsfe->sys_page->getPage($tsfe->config['config']['typolinkLinkAccessRestrictedPages']);
                        $addParams = str_replace(
                            [
                                '###RETURN_URL###',
                                '###PAGE_ID###'
                            ],
                            [
                                rawurlencode($this->lastTypoLinkUrl),
                                $page['uid']
                            ],
                            $tsfe->config['config']['typolinkLinkAccessRestrictedPages_addParams']
                        );
                        $this->lastTypoLinkUrl = $this->getTypoLink_URL($thePage['uid'] . ($theTypeP ? ',' . $theTypeP : ''), $addParams, $target);
                        $this->lastTypoLinkUrl = $this->forceAbsoluteUrl($this->lastTypoLinkUrl, $conf);
                        $this->lastTypoLinkLD['totalUrl'] = $this->lastTypoLinkUrl;
                        $LD = $this->lastTypoLinkLD;
                    }
                    // Rendering the tag.
                    $finalTagParts['url'] = $this->lastTypoLinkUrl;
                    $finalTagParts['targetParams'] = (string)$LD['target'] !== '' ? ' target="' . htmlspecialchars($LD['target']) . '"' : '';
                } else {
                    $this->getTimeTracker()->setTSlogMessage('typolink(): Page id "' . $linkParameter . '" was not found, so "' . $linktxt . '" was not linked.', 1);
                    return $linktxt;
                }
            break;
        }

        $finalTagParts['TYPE'] = $linkType;
        $this->lastTypoLinkLD = $LD;

        if ($forceTitle) {
            $title = $forceTitle;
        }

        if ($JSwindowParams) {
            // Create TARGET-attribute only if the right doctype is used
            $xhtmlDocType = $tsfe->xhtmlDoctype;
            if ($xhtmlDocType !== 'xhtml_strict' && $xhtmlDocType !== 'xhtml_11' && $xhtmlDocType !== 'xhtml_2') {
                $target = ' target="FEopenLink"';
            } else {
                $target = '';
            }
            $onClick = 'vHWin=window.open(' . GeneralUtility::quoteJSvalue($tsfe->baseUrlWrap($finalTagParts['url'])) . ',\'FEopenLink\',' . GeneralUtility::quoteJSvalue($JSwindowParams) . ');vHWin.focus();return false;';
            $finalAnchorTag = '<a href="' . htmlspecialchars($finalTagParts['url']) . '"'
                . $target
                . ' onclick="' . htmlspecialchars($onClick) . '"'
                . ((string)$title !== '' ? ' title="' . htmlspecialchars($title) . '"' : '')
                . ($linkClass !== '' ? ' class="' . htmlspecialchars($linkClass) . '"' : '')
                . $finalTagParts['aTagParams']
                . '>';
        } else {
            if ($tsfe->spamProtectEmailAddresses === 'ascii' && $linkType === 'mailto') {
                $finalAnchorTag = '<a href="' . $finalTagParts['url'] . '"';
            } else {
                $finalAnchorTag = '<a href="' . htmlspecialchars($finalTagParts['url']) . '"';
            }
            $finalAnchorTag .= ((string)$title !== '' ? ' title="' . htmlspecialchars($title) . '"' : '')
                . $finalTagParts['targetParams']
                . ($linkClass ? ' class="' . htmlspecialchars($linkClass) . '"' : '')
                . $finalTagParts['aTagParams']
                . '>';
        }

        // Call user function:
        if ($conf['userFunc']) {
            $finalTagParts['TAG'] = $finalAnchorTag;
            $finalAnchorTag = $this->callUserFunction($conf['userFunc'], $conf['userFunc.'], $finalTagParts);
        }

        // Hook: Call post processing function for link rendering:
        if (isset($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['typoLink_PostProc']) && is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['typoLink_PostProc'])) {
            $_params = [
                'conf' => &$conf,
                'linktxt' => &$linktxt,
                'finalTag' => &$finalAnchorTag,
                'finalTagParts' => &$finalTagParts
            ];
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['typoLink_PostProc'] as $_funcRef) {
                GeneralUtility::callUserFunction($_funcRef, $_params, $this);
            }
        }

        // If flag "returnLastTypoLinkUrl" set, then just return the latest URL made:
        if ($conf['returnLast']) {
            switch ($conf['returnLast']) {
                case 'url':
                    return $this->lastTypoLinkUrl;
                    break;
                case 'target':
                    return $this->lastTypoLinkTarget;
                    break;
            }
        }

        $wrap = isset($conf['wrap.']) ? $this->stdWrap($conf['wrap'], $conf['wrap.']) : $conf['wrap'];

        if ($conf['ATagBeforeWrap']) {
            return $finalAnchorTag . $this->wrap($linktxt, $wrap) . '</a>';
        }
        return $this->wrap($finalAnchorTag . $linktxt . '</a>', $wrap);
    }

    protected function forceAbsoluteUrl($url, array $configuration)
    {
        if (!empty($url) && !empty($configuration['forceAbsoluteUrl']) &&  preg_match('#^(?:([a-z]+)(://)([^/]*)/?)?(.*)$#', $url, $matches)) {
            $urlParts = [
                'scheme' => $matches[1],
                'delimiter' => '://',
                'host' => $matches[3],
                'path' => $matches[4]
            ];
            $isUrlModified = false;
            // Set scheme and host if not yet part of the URL:
            if (empty($urlParts['host'])) {
                $urlParts['scheme'] = $this->getEnvironmentVariable('TYPO3_SSL') ? 'https' : 'http';
                $urlParts['host'] = $this->getEnvironmentVariable('HTTP_HOST');
                $urlParts['path'] = '/' . ltrim($urlParts['path'], '/');
                // absRefPrefix has been prepended to $url beforehand
                // so we only modify the path if no absRefPrefix has been set
                // otherwise we would destroy the path
                if ($this->getTypoScriptFrontendController()->absRefPrefix === '') {
                    $urlParts['path'] = $this->getEnvironmentVariable('TYPO3_SITE_PATH') . ltrim($urlParts['path'], '/');
                }
                $isUrlModified = true;
            }
            // Override scheme:
            $forceAbsoluteUrl = &$configuration['forceAbsoluteUrl.']['scheme'];
            if (!empty($forceAbsoluteUrl) && $urlParts['scheme'] !== $forceAbsoluteUrl) {
                $urlParts['scheme'] = $forceAbsoluteUrl;
                $isUrlModified = true;
            }
            // Recreate the absolute URL:
            if ($isUrlModified) {
                $url = implode('', $urlParts);
            }
        }
        return $url;
    }

    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'] .= GeneralUtility::implodeArrayForUrl('', $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 : '')
            ];
            $conf['useCacheHash'] = GeneralUtility::_GET('cHash') ? '1' : '0';
        }

        return $this->typoLink_URL($conf);
    }

    public function getTypoLink_URL($params, $urlParameters = [], $target = '')
    {
        $this->getTypoLink('', $params, $urlParameters, $target);
        return $this->lastTypoLinkUrl;
    }

    public function typolinkWrap($conf)
    {
        $k = md5(microtime());
        return explode($k, $this->typoLink($k, $conf));
    }

    public function currentPageUrl($urlParameters = [], $id = 0)
    {
        $tsfe = $this->getTypoScriptFrontendController();
        return $this->getTypoLink_URL($id ?: $tsfe->id, $urlParameters, $tsfe->sPre);
    }

    protected function processUrl($context, $url, $typolinkConfiguration = [])
    {
        if (
            empty($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['urlProcessing']['urlProcessors'])
            || !is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['urlProcessing']['urlProcessors'])
        ) {
            return $url;
        }

        $urlProcessors = $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['urlProcessing']['urlProcessors'];
        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 getClosestMPvalueForPage($pageId, $raw = false)
    {
        $tsfe = $this->getTypoScriptFrontendController();
        if (empty($GLOBALS['TYPO3_CONF_VARS']['FE']['enable_mount_pids']) || !$tsfe->MP) {
            return '';
        }
        // MountPoints:
        $MP = '';
        // Same page as current.
        if ((int)$tsfe->id === (int)$pageId) {
            $MP = $tsfe->MP;
        } else {
            // ... otherwise find closest meeting point:
            // Gets rootline of linked-to page
            $tCR_rootline = $tsfe->sys_page->getRootLine($pageId, '', true);
            $inverseTmplRootline = array_reverse($tsfe->tmpl->rootLine);
            $rl_mpArray = [];
            $startMPaccu = false;
            // Traverse root line of link uid and inside of that the REAL root line of current position.
            foreach ($tCR_rootline as $tCR_data) {
                foreach ($inverseTmplRootline as $rlKey => $invTmplRLRec) {
                    // Force accumulating when in overlay mode: Links to this page have to stay within the current branch
                    if ($invTmplRLRec['_MOUNT_OL'] && (int)$tCR_data['uid'] === (int)$invTmplRLRec['uid']) {
                        $startMPaccu = true;
                    }
                    // Accumulate MP data:
                    if ($startMPaccu && $invTmplRLRec['_MP_PARAM']) {
                        $rl_mpArray[] = $invTmplRLRec['_MP_PARAM'];
                    }
                    // If two PIDs matches and this is NOT the site root, start accumulation of MP data (on the next level):
                    // (The check for site root is done so links to branches outsite the site but sharing the site roots PID
                    // is NOT detected as within the branch!)
                    if ((int)$tCR_data['pid'] === (int)$invTmplRLRec['pid'] && count($inverseTmplRootline) !== $rlKey + 1) {
                        $startMPaccu = true;
                    }
                }
                if ($startMPaccu) {
                    // Good enough...
                    break;
                }
            }
            if (!empty($rl_mpArray)) {
                $MP = implode(',', array_reverse($rl_mpArray));
            }
        }
        return $raw ? $MP : ($MP ? '&MP=' . rawurlencode($MP) : '');
    }

    public function getMailTo($mailAddress, $linktxt)
    {
        $mailAddress = (string)$mailAddress;
        if ((string)$linktxt === '') {
            $linktxt = htmlspecialchars($mailAddress);
        }

        $originalMailToUrl = 'mailto:' . $mailAddress;
        $mailToUrl = $this->processUrl(UrlProcessorInterface::CONTEXT_MAIL, $originalMailToUrl);

        $tsfe = $this->getTypoScriptFrontendController();
        // no processing happened, therefore
        if ($mailToUrl === $originalMailToUrl) {
            if ($tsfe->spamProtectEmailAddresses) {
                if ($tsfe->spamProtectEmailAddresses === 'ascii') {
                    $mailToUrl = $tsfe->encryptEmail($mailToUrl);
                } else {
                    $mailToUrl = 'javascript:linkTo_UnCryptMailto(' . GeneralUtility::quoteJSvalue($tsfe->encryptEmail($mailToUrl)) . ');';
                }
                $atLabel = '';
                if ($tsfe->config['config']['spamProtectEmailAddresses_atSubst']) {
                    $atLabel = trim($tsfe->config['config']['spamProtectEmailAddresses_atSubst']);
                }
                $spamProtectedMailAddress = str_replace('@', $atLabel ? $atLabel : '(at)', htmlspecialchars($mailAddress));
                if ($tsfe->config['config']['spamProtectEmailAddresses_lastDotSubst']) {
                    $lastDotLabel = trim($tsfe->config['config']['spamProtectEmailAddresses_lastDotSubst']);
                    $lastDotLabel = $lastDotLabel ? $lastDotLabel : '(dot)';
                    $spamProtectedMailAddress = preg_replace('/\\.([^\\.]+)$/', $lastDotLabel . '$1', $spamProtectedMailAddress);
                }
                $linktxt = str_ireplace($mailAddress, $spamProtectedMailAddress, $linktxt);
            }
        }

        return [$mailToUrl, $linktxt];
    }

    public function getQueryArguments($conf, $overruleQueryArguments = [], $forceOverruleArguments = false)
    {
        switch ((string)$conf['method']) {
            case 'GET':
                $currentQueryArray = GeneralUtility::_GET();
                break;
            case 'POST':
                $currentQueryArray = GeneralUtility::_POST();
                break;
            case 'GET,POST':
                $currentQueryArray = GeneralUtility::_GET();
                ArrayUtility::mergeRecursiveWithOverrule($currentQueryArray, GeneralUtility::_POST());
                break;
            case 'POST,GET':
                $currentQueryArray = GeneralUtility::_POST();
                ArrayUtility::mergeRecursiveWithOverrule($currentQueryArray, GeneralUtility::_GET());
                break;
            default:
                $currentQueryArray = GeneralUtility::explodeUrl2Array($this->getEnvironmentVariable('QUERY_STRING'), true);
        }
        if ($conf['exclude']) {
            $exclude = str_replace(',', '&', $conf['exclude']);
            $exclude = GeneralUtility::explodeUrl2Array($exclude, true);
            // never repeat id
            $exclude['id'] = 0;
            $newQueryArray = ArrayUtility::arrayDiffAssocRecursive($currentQueryArray, $exclude);
        } else {
            $newQueryArray = $currentQueryArray;
        }
        if ($forceOverruleArguments) {
            ArrayUtility::mergeRecursiveWithOverrule($newQueryArray, $overruleQueryArguments);
        } else {
            ArrayUtility::mergeRecursiveWithOverrule($newQueryArray, $overruleQueryArguments, false);
        }
        return GeneralUtility::implodeArrayForUrl('', $newQueryArray, '', false, true);
    }

    /***********************************************
     *
     * 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 wrapSpace($content, $wrap, array $conf = null)
    {
        if (trim($wrap)) {
            $wrapArray = explode('|', $wrap);
            $wrapBefore = (int)$wrapArray[0];
            $wrapAfter = (int)$wrapArray[1];
            $useDivTag = isset($conf['useDiv']) && $conf['useDiv'];
            if ($wrapBefore) {
                if ($useDivTag) {
                    $content = '<div class="content-spacer spacer-before" style="height:' . $wrapBefore . 'px;"></div>' . $content;
                } else {
                    $content = '<span style="width: 1px; height: ' . $wrapBefore . 'px; display: inline-block;"></span><br />' . $content;
                }
            }
            if ($wrapAfter) {
                if ($useDivTag) {
                    $content .= '<div class="content-spacer spacer-after" style="height:' . $wrapAfter . 'px;"></div>';
                } else {
                    $content .= '<span style="width: 1px; height: ' . $wrapAfter . 'px; display: inline-block;"></span><br />';
                }
            }
        }
        return $content;
    }

    public function callUserFunction($funcName, $conf, $content)
    {
        // Split parts
        $parts = explode('->', $funcName);
        if (count($parts) === 2) {
            // Class
            // Check whether class is available and try to reload includeLibs if possible:
            if ($this->isClassAvailable($parts[0], $conf)) {
                $classObj = GeneralUtility::makeInstance($parts[0]);
                if (is_object($classObj) && method_exists($classObj, $parts[1])) {
                    $classObj->cObj = $this;
                    $content = call_user_func_array([
                        $classObj,
                        $parts[1]
                    ], [
                        $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 = call_user_func($funcName, $content, $conf);
        } else {
            $this->getTimeTracker()->setTSlogMessage('Function "' . $funcName . '" did not exist', 3);
        }
        return $content;
    }

    public function processParams($params)
    {
        $paramArr = [];
        $lines = GeneralUtility::trimExplode(LF, $params, true);
        foreach ($lines as $val) {
            $pair = explode('=', $val, 2);
            $key = trim($pair[0]);
            if ($key[0] !== '#' && $key[0] !== '/') {
                $paramArr[$key] = trim($pair[1]);
            }
        }
        return $paramArr;
    }

    public function keywords($content)
    {
        $listArr = preg_split('/[,;' . LF . ']/', $content);
        foreach ($listArr as $k => $v) {
            $listArr[$k] = trim($v);
        }
        return implode(',', $listArr);
    }

    public function caseshift($theValue, $case)
    {
        $tsfe = $this->getTypoScriptFrontendController();
        switch (strtolower($case)) {
            case 'upper':
                $theValue = $tsfe->csConvObj->conv_case($tsfe->renderCharset, $theValue, 'toUpper');
                break;
            case 'lower':
                $theValue = $tsfe->csConvObj->conv_case($tsfe->renderCharset, $theValue, 'toLower');
                break;
            case 'capitalize':
                $theValue = $tsfe->csConvObj->convCapitalize($tsfe->renderCharset, $theValue);
                break;
            case 'ucfirst':
                $theValue = $tsfe->csConvObj->convCaseFirst($tsfe->renderCharset, $theValue, 'toUpper');
                break;
            case 'lcfirst':
                $theValue = $tsfe->csConvObj->convCaseFirst($tsfe->renderCharset, $theValue, 'toLower');
                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] : $labelArr[3]);
        }
        return $seconds;
    }

    public function sendNotifyEmail($message, $recipients, $cc, $senderAddress, $senderName = '', $replyTo = '')
    {
        $mail = GeneralUtility::makeInstance(MailMessage::class);
        $senderName = trim($senderName);
        $senderAddress = trim($senderAddress);
        if ($senderName !== '' && $senderAddress !== '') {
            $sender = [$senderAddress => $senderName];
        } elseif ($senderAddress !== '') {
            $sender = [$senderAddress];
        } else {
            $sender = MailUtility::getSystemFrom();
        }
        $mail->setFrom($sender);
        $parsedReplyTo = MailUtility::parseAddresses($replyTo);
        if (!empty($parsedReplyTo)) {
            $mail->setReplyTo($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->setTo($parsedRecipients)
                    ->setSubject($subject)
                    ->setBody($plainMessage);
                $mail->send();
            }
            $parsedCc = MailUtility::parseAddresses($cc);
            if (!empty($parsedCc)) {
                $mail = GeneralUtility::makeInstance(MailMessage::class);
                if (!empty($parsedReplyTo)) {
                    $mail->setReplyTo($parsedReplyTo);
                }
                $mail->setFrom($sender)
                    ->setTo($parsedCc)
                    ->setSubject($subject)
                    ->setBody($plainMessage);
                $mail->send();
            }
            return true;
        }
        return false;
    }

    public function URLqMark($url, $params)
    {
        if ($params && !strstr($url, '?')) {
            return $url . '?' . $params;
        } else {
            return $url . $params;
        }
    }

    public function clearTSProperties($TSArr, $propList)
    {
        $list = explode(',', $propList);
        foreach ($list as $prop) {
            $prop = trim($prop);
            unset($TSArr[$prop]);
            unset($TSArr[$prop . '.']);
        }
        return $TSArr;
    }

    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 . '.'];
            list(, $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;
    }

    public function gifBuilderTextBox($gifbuilderConf, $conf, $text)
    {
        $chars = (int)$conf['chars'] ?: 20;
        $lineDist = (int)$conf['lineDist'] ?: 20;
        $Valign = strtolower(trim($conf['Valign']));
        $tmplObjNumber = (int)$conf['tmplObjNumber'];
        $maxLines = (int)$conf['maxLines'];
        if ($tmplObjNumber && $gifbuilderConf[$tmplObjNumber] === 'TEXT') {
            $textArr = $this->linebreaks($text, $chars, $maxLines);
            $angle = (int)$gifbuilderConf[$tmplObjNumber . '.']['angle'];
            foreach ($textArr as $c => $textChunk) {
                $index = $tmplObjNumber + 1 + $c * 2;
                // Workarea
                $gifbuilderConf = $this->clearTSProperties($gifbuilderConf, $index);
                $rad_angle = 2 * pi() / 360 * $angle;
                $x_d = sin($rad_angle) * $lineDist;
                $y_d = cos($rad_angle) * $lineDist;
                $diff_x_d = 0;
                $diff_y_d = 0;
                if ($Valign === 'center') {
                    $diff_x_d = $x_d * count($textArr);
                    $diff_x_d = $diff_x_d / 2;
                    $diff_y_d = $y_d * count($textArr);
                    $diff_y_d = $diff_y_d / 2;
                }
                $x_d = round($x_d * $c - $diff_x_d);
                $y_d = round($y_d * $c - $diff_y_d);
                $gifbuilderConf[$index] = 'WORKAREA';
                $gifbuilderConf[$index . '.']['set'] = $x_d . ',' . $y_d;
                // Text
                $index++;
                $gifbuilderConf = $this->clearTSProperties($gifbuilderConf, $index);
                $gifbuilderConf[$index] = 'TEXT';
                $gifbuilderConf[$index . '.'] = $this->clearTSProperties($gifbuilderConf[$tmplObjNumber . '.'], 'text');
                $gifbuilderConf[$index . '.']['text'] = $textChunk;
            }
            $gifbuilderConf = $this->clearTSProperties($gifbuilderConf, $tmplObjNumber);
        }
        return $gifbuilderConf;
    }

    public function linebreaks($string, $chars, $maxLines = 0)
    {
        $lines = explode(LF, $string);
        $lineArr = [];
        $c = 0;
        foreach ($lines as $paragraph) {
            $words = explode(' ', $paragraph);
            foreach ($words as $word) {
                if (strlen($lineArr[$c] . $word) > $chars) {
                    $c++;
                }
                if (!$maxLines || $c < $maxLines) {
                    $lineArr[$c] .= $word . ' ';
                }
            }
            $c++;
        }
        return $lineArr;
    }

    public function includeLibs(array $config)
    {
        $librariesIncluded = false;
        if (isset($config['includeLibs']) && $config['includeLibs']) {
            $libraries = GeneralUtility::trimExplode(',', $config['includeLibs'], true);
            $this->getTypoScriptFrontendController()->includeLibraries($libraries);
            $librariesIncluded = true;
        }
        return $librariesIncluded;
    }

    protected function isClassAvailable($className, array $config = null)
    {
        if (class_exists($className)) {
            return true;
        }
        if ($config) {
            $pluginConfiguration = &$this->getTypoScriptFrontendController()->tmpl->setup['plugin.'][$className . '.'];
            if (isset($pluginConfiguration['includeLibs']) && $pluginConfiguration['includeLibs']) {
                $config['includeLibs'] = $pluginConfiguration['includeLibs'];
                return $this->includeLibs($config);
            }
        }
        return false;
    }

    /***********************************************
     *
     * Database functions, making of queries
     *
     ***********************************************/
    public function DBgetDelete($table, $uid, $doExec = false)
    {
        $uid = (int)$uid;
        if (!$uid) {
            return '';
        }
        $db = $this->getDatabaseConnection();
        if ($GLOBALS['TCA'][$table]['ctrl']['delete']) {
            $updateFields = [];
            $updateFields[$GLOBALS['TCA'][$table]['ctrl']['delete']] = 1;
            if ($GLOBALS['TCA'][$table]['ctrl']['tstamp']) {
                $updateFields[$GLOBALS['TCA'][$table]['ctrl']['tstamp']] = $GLOBALS['EXEC_TIME'];
            }
            if ($doExec) {
                return $db->exec_UPDATEquery($table, 'uid=' . $uid, $updateFields);
            } else {
                return $db->UPDATEquery($table, 'uid=' . $uid, $updateFields);
            }
        } elseif ($doExec) {
            return $db->exec_DELETEquery($table, 'uid=' . $uid);
        } else {
            return $db->DELETEquery($table, 'uid=' . $uid);
        }
    }

    public function DBgetUpdate($table, $uid, $dataArr, $fieldList, $doExec = false)
    {
        // uid can never be set
        unset($dataArr['uid']);
        $uid = (int)$uid;
        if ($uid) {
            $fieldList = implode(',', GeneralUtility::trimExplode(',', $fieldList, true));
            $updateFields = [];
            foreach ($dataArr as $f => $v) {
                if (GeneralUtility::inList($fieldList, $f)) {
                    $updateFields[$f] = $v;
                }
            }
            if ($GLOBALS['TCA'][$table]['ctrl']['tstamp']) {
                $updateFields[$GLOBALS['TCA'][$table]['ctrl']['tstamp']] = $GLOBALS['EXEC_TIME'];
            }
            if (!empty($updateFields)) {
                if ($doExec) {
                    return $this->getDatabaseConnection()->exec_UPDATEquery($table, 'uid=' . $uid, $updateFields);
                }
                return $this->getDatabaseConnection()->UPDATEquery($table, 'uid=' . $uid, $updateFields);
            }
        }
        return '';
    }

    public function DBgetInsert($table, $pid, $dataArr, $fieldList, $doExec = false)
    {
        $extraList = 'pid';
        if ($GLOBALS['TCA'][$table]['ctrl']['tstamp']) {
            $field = $GLOBALS['TCA'][$table]['ctrl']['tstamp'];
            $dataArr[$field] = $GLOBALS['EXEC_TIME'];
            $extraList .= ',' . $field;
        }
        if ($GLOBALS['TCA'][$table]['ctrl']['crdate']) {
            $field = $GLOBALS['TCA'][$table]['ctrl']['crdate'];
            $dataArr[$field] = $GLOBALS['EXEC_TIME'];
            $extraList .= ',' . $field;
        }
        if ($GLOBALS['TCA'][$table]['ctrl']['cruser_id']) {
            $field = $GLOBALS['TCA'][$table]['ctrl']['cruser_id'];
            $dataArr[$field] = 0;
            $extraList .= ',' . $field;
        }
        if ($GLOBALS['TCA'][$table]['ctrl']['fe_cruser_id']) {
            $field = $GLOBALS['TCA'][$table]['ctrl']['fe_cruser_id'];
            $dataArr[$field] = (int)$this->getTypoScriptFrontendController()->fe_user->user['uid'];
            $extraList .= ',' . $field;
        }
        if ($GLOBALS['TCA'][$table]['ctrl']['fe_crgroup_id']) {
            $field = $GLOBALS['TCA'][$table]['ctrl']['fe_crgroup_id'];
            list($dataArr[$field]) = explode(',', $this->getTypoScriptFrontendController()->fe_user->user['usergroup']);
            $dataArr[$field] = (int)$dataArr[$field];
            $extraList .= ',' . $field;
        }
        // Uid can never be set
        unset($dataArr['uid']);
        if ($pid >= 0) {
            $dataArr['pid'] = $pid;
        }
        // Set pid < 0 and the dataarr-pid will be used!
        $fieldList = implode(',', GeneralUtility::trimExplode(',', $fieldList . ',' . $extraList, true));
        $insertFields = [];
        foreach ($dataArr as $f => $v) {
            if (GeneralUtility::inList($fieldList, $f)) {
                $insertFields[$f] = $v;
            }
        }
        if ($doExec) {
            return $this->getDatabaseConnection()->exec_INSERTquery($table, $insertFields);
        } else {
            return $this->getDatabaseConnection()->INSERTquery($table, $insertFields);
        }
    }

    public function DBmayFEUserEdit($table, $row, $feUserRow, $allowedGroups = '', $feEditSelf = 0)
    {
        if ($allowedGroups) {
            $groupList = implode(
                ',',
                array_intersect(
                    GeneralUtility::trimExplode(',', $feUserRow['usergroup'], true),
                    GeneralUtility::trimExplode(',', $allowedGroups, true)
                )
            );
        } else {
            $groupList = $feUserRow['usergroup'];
        }
        $ok = 0;
        // Points to the field that allows further editing from frontend if not set. If set the record is locked.
        if (!$GLOBALS['TCA'][$table]['ctrl']['fe_admin_lock'] || !$row[$GLOBALS['TCA'][$table]['ctrl']['fe_admin_lock']]) {
            // Points to the field (int) that holds the fe_users-id of the creator fe_user
            if ($GLOBALS['TCA'][$table]['ctrl']['fe_cruser_id']) {
                $rowFEUser = (int)$row[$GLOBALS['TCA'][$table]['ctrl']['fe_cruser_id']];
                if ($rowFEUser && $rowFEUser === (int)$feUserRow['uid']) {
                    $ok = 1;
                }
            }
            // If $feEditSelf is set, fe_users may always edit them selves...
            if ($feEditSelf && $table === 'fe_users' && (int)$feUserRow['uid'] === (int)$row['uid']) {
                $ok = 1;
            }
            // Points to the field (int) that holds the fe_group-id of the creator fe_user's first group
            if ($GLOBALS['TCA'][$table]['ctrl']['fe_crgroup_id']) {
                $rowFEUser = (int)$row[$GLOBALS['TCA'][$table]['ctrl']['fe_crgroup_id']];
                if ($rowFEUser) {
                    if (GeneralUtility::inList($groupList, $rowFEUser)) {
                        $ok = 1;
                    }
                }
            }
        }
        return $ok;
    }

    public function DBmayFEUserEditSelect($table, $feUserRow, $allowedGroups = '', $feEditSelf = 0)
    {
        // Returns where-definition that selects user-editable records.
        if ($allowedGroups) {
            $groupList = implode(
                ',',
                array_intersect(
                    GeneralUtility::trimExplode(',', $feUserRow['usergroup'], true),
                    GeneralUtility::trimExplode(',', $allowedGroups, true)
                )
            );
        } else {
            $groupList = $feUserRow['usergroup'];
        }
        $OR_arr = [];
        // Points to the field (int) that holds the fe_users-id of the creator fe_user
        if ($GLOBALS['TCA'][$table]['ctrl']['fe_cruser_id']) {
            $OR_arr[] = $GLOBALS['TCA'][$table]['ctrl']['fe_cruser_id'] . '=' . $feUserRow['uid'];
        }
        // Points to the field (int) that holds the fe_group-id of the creator fe_user's first group
        if ($GLOBALS['TCA'][$table]['ctrl']['fe_crgroup_id']) {
            $values = GeneralUtility::intExplode(',', $groupList);
            foreach ($values as $theGroupUid) {
                if ($theGroupUid) {
                    $OR_arr[] = $GLOBALS['TCA'][$table]['ctrl']['fe_crgroup_id'] . '=' . $theGroupUid;
                }
            }
        }
        // If $feEditSelf is set, fe_users may always edit them selves...
        if ($feEditSelf && $table === 'fe_users') {
            $OR_arr[] = 'uid=' . (int)$feUserRow['uid'];
        }
        $whereDef = ' AND 1=0';
        if (!empty($OR_arr)) {
            $whereDef = ' AND (' . implode(' OR ', $OR_arr) . ')';
            if ($GLOBALS['TCA'][$table]['ctrl']['fe_admin_lock']) {
                $whereDef .= ' AND ' . $GLOBALS['TCA'][$table]['ctrl']['fe_admin_lock'] . '=0';
            }
        }
        return $whereDef;
    }

    public function enableFields($table, $show_hidden = false, array $ignore_array = [])
    {
        $tsfe = $this->getTypoScriptFrontendController();
        $show_hidden = $show_hidden ?: ($table === 'pages' ? $tsfe->showHiddenPage : $tsfe->showHiddenRecords);
        return $tsfe->sys_page->enableFields($table, (bool)$show_hidden, $ignore_array);
    }

    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' . $addSelectFields;
        $depth = (int)$depth;
        $begin = (int)$begin;
        $theList = [];
        $addId = 0;
        $requestHash = '';

        // First level, check id (second level, this is done BEFORE the recursive call)
        $db = $this->getDatabaseConnection();
        $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,
                $tsfe->gr_list
            ];
            $requestHash = md5(serialize($parameters));
            $cacheEntry = $db->exec_SELECTgetSingleRow(
                'treelist',
                'cache_treelist',
                'md5hash = \'' . $requestHash . '\' AND ( expires > ' . (int)$GLOBALS['EXEC_TIME'] . ' OR expires = 0 )'
            );
            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) {
            $rows = $db->exec_SELECTgetRows(
                $allFields,
                'pages',
                'pid = ' . (int)$id . ' AND deleted = 0 ' . $moreWhereClauses,
                '',
                'sorting'
            );
            if (is_array($rows)) {
                foreach ($rows as $row) {
                    $versionState = VersionState::cast($row['t3ver_state']);
                    $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.
                        // 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'];
                        $row = $db->exec_SELECTgetSingleRow(
                            $allFields,
                            'pages',
                            'uid = ' . (int)$next_id . ' AND deleted = 0 ' . $moreWhereClauses,
                            '',
                            'sorting'
                        );
                        $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;
                }
            }
            $db->exec_INSERTquery('cache_treelist', [
                'md5hash' => $requestHash,
                'pid' => $id,
                'treelist' => implode(',', $theList),
                'tstamp' => $GLOBALS['EXEC_TIME']
            ]);
        }

        return implode(',', $theList);
    }

    public function exec_mm_query($select, $local_table, $mm_table, $foreign_table, $whereClause = '', $groupBy = '', $orderBy = '', $limit = '')
    {
        return $this->getDatabaseConnection()->exec_SELECTquery(
            $select,
            $local_table . ',' . $mm_table . ($foreign_table ? ',' . $foreign_table : ''),
            $local_table . '.uid=' . $mm_table . '.uid_local'
                . ($foreign_table ? ' AND ' . $foreign_table . '.uid=' . $mm_table . '.uid_foreign' : '')
                . $whereClause,
            $groupBy,
            $orderBy,
            $limit
        );
    }

    public function exec_mm_query_uidList($select, $local_table_uidlist, $mm_table, $foreign_table = '', $whereClause = '', $groupBy = '', $orderBy = '', $limit = '')
    {
        return $this->getDatabaseConnection()->exec_SELECTquery(
            $select,
            $mm_table . ($foreign_table ? ',' . $foreign_table : ''),
            $mm_table . '.uid_local IN (' . $local_table_uidlist . ')'
                . ($foreign_table ? ' AND ' . $foreign_table . '.uid=' . $mm_table . '.uid_foreign' : '')
                . $whereClause,
            $groupBy,
            $orderBy,
            $limit
        );
    }

    public function searchWhere($sw, $searchFieldList, $searchTable = '')
    {
        $prefixTableName = $searchTable ? $searchTable . '.' : '';
        $where = '';
        if ($sw) {
            $searchFields = explode(',', $searchFieldList);
            $kw = preg_split('/[ ,]/', $sw);
            $db = $this->getDatabaseConnection();
            foreach ($kw as $val) {
                $val = trim($val);
                $where_p = [];
                if (strlen($val) >= 2) {
                    $val = $db->escapeStrForLike($db->quoteStr($val, $searchTable), $searchTable);
                    foreach ($searchFields as $field) {
                        $where_p[] = $prefixTableName . $field . ' LIKE \'%' . $val . '%\'';
                    }
                }
                if (!empty($where_p)) {
                    $where .= ' AND (' . implode(' OR ', $where_p) . ')';
                }
            }
        }
        return $where;
    }

    public function exec_getQuery($table, $conf)
    {
        $queryParts = $this->getQuery($table, $conf, true);
        return $this->getDatabaseConnection()->exec_SELECT_queryArray($queryParts);
    }

    public function getRecords($tableName, array $queryConfiguration)
    {
        $records = [];

        $res = $this->exec_getQuery($tableName, $queryConfiguration);

        $db = $this->getDatabaseConnection();
        if ($error = $db->sql_error()) {
            $this->getTimeTracker()->setTSlogMessage($error, 3);
        } else {
            $tsfe = $this->getTypoScriptFrontendController();
            while (($row = $db->sql_fetch_assoc($res)) !== false) {

                // Versioning preview:
                $tsfe->sys_page->versionOL($tableName, $row, true);

                // Language overlay:
                if (is_array($row) && $tsfe->sys_language_contentOL) {
                    if ($tableName === 'pages') {
                        $row = $tsfe->sys_page->getPageOverlay($row);
                    } else {
                        $row = $tsfe->sys_page->getRecordOverlay(
                            $tableName,
                            $row,
                            $tsfe->sys_language_content,
                            $tsfe->sys_language_contentOL
                        );
                    }
                }

                // Might be unset in the sys_language_contentOL
                if (is_array($row)) {
                    $records[] = $row;
                }
            }
            $db->sql_free_result($res);
        }

        return $records;
    }

    public function getQuery($table, $conf, $returnQueryArray = false)
    {
        // Resolve stdWrap in these properties first
        $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]);
            }
            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($value, $conf['recursive'])),
                        $expandedPidList
                    );
                }
                $conf['pidInList'] = implode(',', $expandedPidList);
            }
        }
        if ((string)$conf['pidInList'] === '') {
            $conf['pidInList'] = 'this';
        }
        $queryParts = $this->getWhere($table, $conf, true);
        // Fields:
        if ($conf['selectFields']) {
            $queryParts['SELECT'] = $this->sanitizeSelectPart($conf['selectFields'], $table);
        } else {
            $queryParts['SELECT'] = '*';
        }
        // Setting LIMIT:
        $db = $this->getDatabaseConnection();
        $error = 0;
        if ($conf['max'] || $conf['begin']) {
            // Finding the total number of records, if used:
            if (strstr(strtolower($conf['begin'] . $conf['max']), 'total')) {
                $res = $db->exec_SELECTquery('count(*)', $table, $queryParts['WHERE'], $queryParts['GROUPBY']);
                if ($error = $db->sql_error()) {
                    $this->getTimeTracker()->setTSlogMessage($error);
                } else {
                    $row = $db->sql_fetch_row($res);
                    $conf['max'] = str_ireplace('total', $row[0], $conf['max']);
                    $conf['begin'] = str_ireplace('total', $row[0], $conf['begin']);
                }
                $db->sql_free_result($res);
            }
            if (!$error) {
                $conf['begin'] = MathUtility::forceIntegerInRange(ceil($this->calc($conf['begin'])), 0);
                $conf['max'] = MathUtility::forceIntegerInRange(ceil($this->calc($conf['max'])), 0);
                if ($conf['begin'] && !$conf['max']) {
                    $conf['max'] = 100000;
                }
                if ($conf['begin'] && $conf['max']) {
                    $queryParts['LIMIT'] = $conf['begin'] . ',' . $conf['max'];
                } elseif (!$conf['begin'] && $conf['max']) {
                    $queryParts['LIMIT'] = $conf['max'];
                }
            }
        }
        if (!$error) {
            // Setting up tablejoins:
            $joinPart = '';
            if ($conf['join']) {
                $joinPart = 'JOIN ' . $conf['join'];
            } elseif ($conf['leftjoin']) {
                $joinPart = 'LEFT OUTER JOIN ' . $conf['leftjoin'];
            } elseif ($conf['rightjoin']) {
                $joinPart = 'RIGHT OUTER JOIN ' . $conf['rightjoin'];
            }
            // Compile and return query:
            $queryParts['FROM'] = trim($table . ' ' . $joinPart);
            // Replace the markers in the queryParts to handle stdWrap
            // enabled properties
            foreach ($queryMarkers as $marker => $markerValue) {
                foreach ($queryParts as $queryPartKey => &$queryPartValue) {
                    $queryPartValue = str_replace('###' . $marker . '###', $markerValue, $queryPartValue);
                }
                unset($queryPartValue);
            }
            $query = $db->SELECTquery($queryParts['SELECT'], $queryParts['FROM'], $queryParts['WHERE'], $queryParts['GROUPBY'], $queryParts['ORDERBY'], $queryParts['LIMIT']);
            return $returnQueryArray ? $queryParts : $query;
        }
        return '';
    }

    public function getWhere($table, $conf, $returnQueryArray = false)
    {
        // Init:
        $query = '';
        $pid_uid_flag = 0;
        $enableFieldsIgnore = [];
        $queryParts = [
            'SELECT' => '',
            'FROM' => '',
            'WHERE' => '',
            'GROUPBY' => '',
            'ORDERBY' => '',
            'LIMIT' => ''
        ];
        $tsfe = $this->getTypoScriptFrontendController();
        $considerMovePlaceholders = (
            $tsfe->sys_page->versioningPreview && $table !== 'pages'
            && !empty($GLOBALS['TCA'][$table]['ctrl']['versioningWS'])
        );
        if (trim($conf['uidInList'])) {
            $listArr = GeneralUtility::intExplode(',', str_replace('this', $tsfe->contentPid, $conf['uidInList']));
            if (count($listArr) === 1) {
                $comparison = '=' . (int)$listArr[0];
            } else {
                $comparison = ' IN (' . implode(',', $this->getDatabaseConnection()->cleanIntArray($listArr)) . ')';
            }
            // If move placeholder shall be considered, select via t3ver_move_id
            if ($considerMovePlaceholders) {
                $movePlaceholderComparison = $table . '.t3ver_state=' . VersionState::cast(VersionState::MOVE_PLACEHOLDER) . ' AND ' . $table . '.t3ver_move_id' . $comparison;
                $query .= ' AND (' . $table . '.uid' . $comparison . ' OR ' . $movePlaceholderComparison . ')';
            } else {
                $query .= ' AND ' . $table . '.uid' . $comparison;
            }
            $pid_uid_flag++;
        }
        // Static_* tables are allowed to be fetched from root page
        if (substr($table, 0, 7) === 'static_') {
            $pid_uid_flag++;
        }
        if (trim($conf['pidInList'])) {
            $listArr = GeneralUtility::intExplode(',', str_replace('this', $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)) {
                $query .= ' AND ' . $table . '.pid IN (' . implode(',', 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) {
            $query .= ' AND ' . $table . '.uid=0';
        }
        $where = isset($conf['where.']) ? trim($this->stdWrap($conf['where'], $conf['where.'])) : trim($conf['where']);
        if ($where) {
            $query .= ' AND ' . $where;
        }

        // Check if the table is translatable, and set the language field by default from the TCA information
        $languageField = '';
        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($GLOBALS['TCA'][$table]['ctrl']['transOrigPointerField'])) {
                $languageField = $table . '.' . $GLOBALS['TCA'][$table]['ctrl']['languageField'];
            }
        }

        if (!empty($languageField)) {
            // The sys_language record UID of the content of the page
            $sys_language_content = (int)$tsfe->sys_language_content;

            if ($tsfe->sys_language_contentOL && !empty($GLOBALS['TCA'][$table]['ctrl']['transOrigPointerField'])) {
                // 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 = $languageField . ' IN (0,-1)';
                // Use this option to include records that don't have a default translation
                // (originalpointerfield is 0 and the language field contains the requested language)
                $includeRecordsWithoutDefaultTranslation = isset($conf['includeRecordsWithoutDefaultTranslation.']) ?
                    $this->stdWrap($conf['includeRecordsWithoutDefaultTranslation'], $conf['includeRecordsWithoutDefaultTranslation.']) :
                    $conf['includeRecordsWithoutDefaultTranslation'];
                if (!empty(trim($includeRecordsWithoutDefaultTranslation))) {
                    $languageQuery .= ' OR (' . $GLOBALS['TCA'][$table]['ctrl']['transOrigPointerField'] . ' = 0 AND ' .
                        $languageField . ' = ' . $sys_language_content . ')';
                }
            } else {
                $languageQuery = $languageField . ' = ' . $sys_language_content;
            }
            $query .= ' AND (' . $languageQuery . ')';
        }
        $andWhere = isset($conf['andWhere.']) ? trim($this->stdWrap($conf['andWhere'], $conf['andWhere.'])) : trim($conf['andWhere']);
        if ($andWhere) {
            GeneralUtility::deprecationLog('Usage of TypoScript property "andWhere" is deprecated since 7.1 in favor of "where". It has been used to query the table "' . $table . '".');
            $query .= ' AND ' . $andWhere;
        }
        // Enablefields
        if ($table === 'pages') {
            $query .= ' ' . $tsfe->sys_page->where_hid_del . $tsfe->sys_page->where_groupAccess;
        } else {
            $query .= $this->enableFields($table, false, $enableFieldsIgnore);
        }
        // MAKE WHERE:
        if ($query) {
            // Stripping of " AND"...
            $queryParts['WHERE'] = trim(substr($query, 4));
            $query = 'WHERE ' . $queryParts['WHERE'];
        }
        // GROUP BY
        if (trim($conf['groupBy'])) {
            $queryParts['GROUPBY'] = isset($conf['groupBy.']) ? trim($this->stdWrap($conf['groupBy'], $conf['groupBy.'])) : trim($conf['groupBy']);
            $query .= ' GROUP BY ' . $queryParts['GROUPBY'];
        }
        // ORDER BY
        if (trim($conf['orderBy'])) {
            $queryParts['ORDERBY'] = isset($conf['orderBy.']) ? trim($this->stdWrap($conf['orderBy'], $conf['orderBy.'])) : trim($conf['orderBy']);
            $query .= ' ORDER BY ' . $queryParts['ORDERBY'];
        }
        // Return result:
        return $returnQueryArray ? $queryParts : $query;
    }

    protected function sanitizeSelectPart($selectPart, $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)\\([^\\)]+\\)/i', $selectPart)) {
            foreach ($necessaryFields as $field) {
                $match = $matchStart . $field . $matchEnd;
                if (!preg_match($match, $selectPart)) {
                    $selectPart .= ', ' . $table . '.' . $field . ' as ' . $field;
                }
            }
            if ($GLOBALS['TCA'][$table]['ctrl']['versioningWS']) {
                foreach ($wsFields as $field) {
                    $match = $matchStart . $field . $matchEnd;
                    if (!preg_match($match, $selectPart)) {
                        $selectPart .= ', ' . $table . '.' . $field . ' as ' . $field;
                    }
                }
            }
        }
        return $selectPart;
    }

    public function checkPidArray($listArr)
    {
        if (!is_array($listArr) || empty($listArr)) {
            return [];
        }
        $outArr = [];
        $db = $this->getDatabaseConnection();
        $res = $db->exec_SELECTquery('uid', 'pages', 'uid IN (' . implode(',', $listArr) . ')' . $this->enableFields('pages') . ' AND doktype NOT IN (' . $this->checkPid_badDoktypeList . ')');
        if ($error = $db->sql_error()) {
            $this->getTimeTracker()->setTSlogMessage($error . ': ' . $db->debug_lastBuiltQuery, 3);
        } else {
            while ($row = $db->sql_fetch_assoc($res)) {
                $outArr[] = $row['uid'];
            }
        }
        $db->sql_free_result($res);
        return $outArr;
    }

    public function checkPid($uid)
    {
        $uid = (int)$uid;
        if (!isset($this->checkPid_cache[$uid])) {
            $count = $this->getDatabaseConnection()->exec_SELECTcountRows('uid', 'pages', 'uid=' . $uid . $this->enableFields('pages') . ' AND doktype NOT IN (' . $this->checkPid_badDoktypeList . ')');
            $this->checkPid_cache[$uid] = (bool)$count;
        }
        return $this->checkPid_cache[$uid];
    }

    public function getQueryMarkers($table, $conf)
    {
        if (!is_array($conf['markers.'])) {
            return [];
        }
        // Parse markers and prepare their values
        $db = $this->getDatabaseConnection();
        $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] = floatval($tempValue);
                }
            } elseif (is_null($tempValue)) {
                // 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[] = floatval($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[] = $db->fullQuoteStr($listValue, $table);
                        }
                    }
                    $markerValues[$marker] = implode(',', $tempArray);
                } else {
                    // Handle remaining values as string
                    $markerValues[$marker] = $db->fullQuoteStr($tempValue, $table);
                }
            } else {
                // Handle remaining values as string
                $markerValues[$marker] = $db->fullQuoteStr($tempValue, $table);
            }
        }
        return $markerValues;
    }

    /***********************************************
     *
     * Frontend editing functions
     *
     ***********************************************/
    public function editPanel($content, $conf, $currentRecord = '', $dataArr = [])
    {
        if ($this->getTypoScriptFrontendController()->beUserLogin && $this->getFrontendBackendUser()->frontendEdit instanceof FrontendEditingController) {
            if (!$currentRecord) {
                $currentRecord = $this->currentRecord;
            }
            if (empty($dataArr)) {
                $dataArr = $this->data;
            }
            // Delegate rendering of the edit panel to the frontend edit
            $content = $this->getFrontendBackendUser()->frontendEdit->displayEditPanel($content, $conf, $currentRecord, $dataArr);
        }
        return $content;
    }

    public function editIcons($content, $params, array $conf = [], $currentRecord = '', $dataArr = [], $addUrlParamStr = '')
    {
        if ($this->getTypoScriptFrontendController()->beUserLogin && $this->getFrontendBackendUser()->frontendEdit instanceof FrontendEditingController) {
            if (!$currentRecord) {
                $currentRecord = $this->currentRecord;
            }
            if (empty($dataArr)) {
                $dataArr = $this->data;
            }
            // Delegate rendering of the edit panel to frontend edit class.
            $content = $this->getFrontendBackendUser()->frontendEdit->displayEditIcons($content, $params, $conf, $currentRecord, $dataArr, $addUrlParamStr);
        }
        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 ResourceFactory::getInstance();
    }

    protected function getEnvironmentVariable($key)
    {
        return GeneralUtility::getIndpEnv($key);
    }

    protected function getFromCache(array $configuration)
    {
        $content = false;

        $cacheKey = $this->calculateCacheKey($configuration);
        if (!empty($cacheKey)) {
            $cacheFrontend = GeneralUtility::makeInstance(CacheManager::class)
                ->getCache('cache_hash');
            $content = $cacheFrontend->get($cacheKey);
        }
        return $content;
    }

    protected function calculateCacheLifetime(array $configuration)
    {
        $lifetimeConfiguration = isset($configuration['lifetime'])
            ? $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 = isset($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 = isset($configuration['key']) ? $configuration['key'] : '';
        return isset($configuration['key.'])
            ? $this->stdWrap($key, $configuration['key.'])
            : $key;
    }

    protected function getFrontendBackendUser()
    {
        return $GLOBALS['BE_USER'];
    }

    protected function getDatabaseConnection()
    {
        return $GLOBALS['TYPO3_DB'];
    }

    protected function getTimeTracker()
    {
        return $GLOBALS['TT'];
    }

    protected function getTypoScriptFrontendController()
    {
        return $this->typoScriptFrontendController ?: $GLOBALS['TSFE'];
    }
}