HtmlParser.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Html;

/*
 * 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\Service\MarkerBasedTemplateService;
use TYPO3\CMS\Core\Utility\GeneralUtility;

class HtmlParser
{
    protected $caseShift_cache = [];

    // Void elements that do not have closing tags, as defined by HTML5, except link element
    const VOID_ELEMENTS = 'area|base|br|col|command|embed|hr|img|input|keygen|meta|param|source|track|wbr';

    public static function getSubpart($content, $marker)
    {
        GeneralUtility::logDeprecatedFunction();
        $templateService = GeneralUtility::makeInstance(MarkerBasedTemplateService::class);
        return $templateService->getSubpart($content, $marker);
    }

    public static function substituteSubpart($content, $marker, $subpartContent, $recursive = true, $keepMarker = false)
    {
        GeneralUtility::logDeprecatedFunction();
        $templateService = GeneralUtility::makeInstance(MarkerBasedTemplateService::class);
        return $templateService->substituteSubpart($content, $marker, $subpartContent, $recursive, $keepMarker);
    }

    public static function substituteSubpartArray($content, array $subpartsContent)
    {
        GeneralUtility::logDeprecatedFunction();
        $templateService = GeneralUtility::makeInstance(MarkerBasedTemplateService::class);
        return $templateService->substituteSubpartArray($content, $subpartsContent);
    }

    public static function substituteMarker($content, $marker, $markContent)
    {
        GeneralUtility::logDeprecatedFunction();
        $templateService = GeneralUtility::makeInstance(MarkerBasedTemplateService::class);
        return $templateService->substituteMarker($content, $marker, $markContent);
    }

    public static function substituteMarkerArray($content, $markContentArray, $wrap = '', $uppercase = false, $deleteUnused = false)
    {
        GeneralUtility::logDeprecatedFunction();
        $templateService = GeneralUtility::makeInstance(MarkerBasedTemplateService::class);
        return $templateService->substituteMarkerArray($content, $markContentArray, $wrap, $uppercase, $deleteUnused);
    }

    public static function substituteMarkerAndSubpartArrayRecursive($content, array $markersAndSubparts, $wrap = '', $uppercase = false, $deleteUnused = false)
    {
        GeneralUtility::logDeprecatedFunction();
        $templateService = GeneralUtility::makeInstance(MarkerBasedTemplateService::class);
        return $templateService->substituteMarkerAndSubpartArrayRecursive($content, $markersAndSubparts, $wrap, $uppercase, $deleteUnused);
    }

    /************************************
     *
     * Parsing HTML code
     *
     ************************************/
    public function splitIntoBlock($tag, $content, $eliminateExtraEndTags = false)
    {
        $tags = array_unique(GeneralUtility::trimExplode(',', $tag, true));
        foreach ($tags as &$tag) {
            $tag = preg_quote($tag, '/');
        }
        $regexStr = '/\\<\\/?(' . implode('|', $tags) . ')(\\s*\\>|\\s[^\\>]*\\>)/si';
        $parts = preg_split($regexStr, $content);
        $newParts = [];
        $pointer = strlen($parts[0]);
        $buffer = $parts[0];
        $nested = 0;
        reset($parts);
        // We skip the first element in foreach loop
        $partsSliced = array_slice($parts, 1, null, true);
        foreach ($partsSliced as $v) {
            $isEndTag = substr($content, $pointer, 2) == '</' ? 1 : 0;
            $tagLen = strcspn(substr($content, $pointer), '>') + 1;
            // We meet a start-tag:
            if (!$isEndTag) {
                // Ground level:
                if (!$nested) {
                    // Previous buffer stored
                    $newParts[] = $buffer;
                    $buffer = '';
                }
                // We are inside now!
                $nested++;
                // New buffer set and pointer increased
                $mbuffer = substr($content, $pointer, strlen($v) + $tagLen);
                $pointer += strlen($mbuffer);
                $buffer .= $mbuffer;
            } else {
                // If we meet an endtag:
                // Decrease nested-level
                $nested--;
                $eliminated = 0;
                if ($eliminateExtraEndTags && $nested < 0) {
                    $nested = 0;
                    $eliminated = 1;
                } else {
                    // In any case, add the endtag to current buffer and increase pointer
                    $buffer .= substr($content, $pointer, $tagLen);
                }
                $pointer += $tagLen;
                // if we're back on ground level, (and not by eliminating tags...
                if (!$nested && !$eliminated) {
                    $newParts[] = $buffer;
                    $buffer = '';
                }
                // New buffer set and pointer increased
                $mbuffer = substr($content, $pointer, strlen($v));
                $pointer += strlen($mbuffer);
                $buffer .= $mbuffer;
            }
        }
        $newParts[] = $buffer;
        return $newParts;
    }

    public function splitIntoBlockRecursiveProc($tag, $content, &$procObj, $callBackContent, $callBackTags, $level = 0)
    {
        $parts = $this->splitIntoBlock($tag, $content, true);
        foreach ($parts as $k => $v) {
            if ($k % 2) {
                $firstTagName = $this->getFirstTagName($v, true);
                $tagsArray = [];
                $tagsArray['tag_start'] = $this->getFirstTag($v);
                $tagsArray['tag_end'] = '</' . $firstTagName . '>';
                $tagsArray['tag_name'] = strtolower($firstTagName);
                $tagsArray['add_level'] = 1;
                $tagsArray['content'] = $this->splitIntoBlockRecursiveProc($tag, $this->removeFirstAndLastTag($v), $procObj, $callBackContent, $callBackTags, $level + $tagsArray['add_level']);
                if ($callBackTags) {
                    $tagsArray = $procObj->{$callBackTags}($tagsArray, $level);
                }
                $parts[$k] = $tagsArray['tag_start'] . $tagsArray['content'] . $tagsArray['tag_end'];
            } else {
                if ($callBackContent) {
                    $parts[$k] = $procObj->{$callBackContent}($parts[$k], $level);
                }
            }
        }
        return implode('', $parts);
    }

    public function splitTags($tag, $content)
    {
        $tags = GeneralUtility::trimExplode(',', $tag, true);
        foreach ($tags as &$tag) {
            $tag = preg_quote($tag, '/');
        }
        $regexStr = '/\\<(' . implode('|', $tags) . ')(\\s[^>]*)?\\/?>/si';
        $parts = preg_split($regexStr, $content);
        $pointer = strlen($parts[0]);
        $newParts = [];
        $newParts[] = $parts[0];
        reset($parts);
        // We skip the first element in foreach loop
        $partsSliced = array_slice($parts, 1, null, true);
        foreach ($partsSliced as $v) {
            $tagLen = strcspn(substr($content, $pointer), '>') + 1;
            // Set tag:
            // New buffer set and pointer increased
            $tag = substr($content, $pointer, $tagLen);
            $newParts[] = $tag;
            $pointer += strlen($tag);
            // Set content:
            $newParts[] = $v;
            $pointer += strlen($v);
        }
        return $newParts;
    }

    public function getAllParts($parts, $tag_parts = true, $include_tag = true)
    {
        $newParts = [];
        foreach ($parts as $k => $v) {
            if (($k + ($tag_parts ? 0 : 1)) % 2) {
                if (!$include_tag) {
                    $v = $this->removeFirstAndLastTag($v);
                }
                $newParts[] = $v;
            }
        }
        return $newParts;
    }

    public function removeFirstAndLastTag($str)
    {
        // End of first tag:
        $start = strpos($str, '>');
        // Begin of last tag:
        $end = strrpos($str, '<');
        // Return
        return substr($str, $start + 1, $end - $start - 1);
    }

    public function getFirstTag($str)
    {
        // First:
        $endLen = strpos($str, '>');
        return $endLen !== false ? substr($str, 0, $endLen + 1) : '';
    }

    public function getFirstTagName($str, $preserveCase = false)
    {
        $matches = [];
        if (preg_match('/^\\s*\\<([^\\s\\>]+)(\\s|\\>)/', $str, $matches) === 1) {
            if (!$preserveCase) {
                return strtoupper($matches[1]);
            }
            return $matches[1];
        }
        return '';
    }

    public function get_tag_attributes($tag, $deHSC = 0)
    {
        list($components, $metaC) = $this->split_tag_attributes($tag);
        // Attribute name is stored here
        $name = '';
        $valuemode = false;
        $attributes = [];
        $attributesMeta = [];
        if (is_array($components)) {
            foreach ($components as $key => $val) {
                // Only if $name is set (if there is an attribute, that waits for a value), that valuemode is enabled. This ensures that the attribute is assigned it's value
                if ($val != '=') {
                    if ($valuemode) {
                        if ($name) {
                            $attributes[$name] = $deHSC ? htmlspecialchars_decode($val) : $val;
                            $attributesMeta[$name]['dashType'] = $metaC[$key];
                            $name = '';
                        }
                    } else {
                        if ($namekey = preg_replace('/[^[:alnum:]_\\:\\-]/', '', $val)) {
                            $name = strtolower($namekey);
                            $attributesMeta[$name] = [];
                            $attributesMeta[$name]['origTag'] = $namekey;
                            $attributes[$name] = '';
                        }
                    }
                    $valuemode = false;
                } else {
                    $valuemode = true;
                }
            }
            return [$attributes, $attributesMeta];
        }
    }

    public function split_tag_attributes($tag)
    {
        $matches = [];
        if (preg_match('/(\\<[^\\s]+\\s+)?(.*?)\\s*(\\>)?$/s', $tag, $matches) !== 1) {
            return [[], []];
        }
        $tag_tmp = $matches[2];
        $metaValue = [];
        $value = [];
        $matches = [];
        if (preg_match_all('/("[^"]*"|\'[^\']*\'|[^\\s"\'\\=]+|\\=)/s', $tag_tmp, $matches) > 0) {
            foreach ($matches[1] as $part) {
                $firstChar = $part[0];
                if ($firstChar == '"' || $firstChar == '\'') {
                    $metaValue[] = $firstChar;
                    $value[] = substr($part, 1, -1);
                } else {
                    $metaValue[] = '';
                    $value[] = $part;
                }
            }
        }
        return [$value, $metaValue];
    }

    public function checkTagTypeCounts($content, $blockTags = 'a,b,blockquote,body,div,em,font,form,h1,h2,h3,h4,h5,h6,i,li,map,ol,option,p,pre,select,span,strong,table,td,textarea,tr,u,ul', $soloTags = 'br,hr,img,input,area')
    {
        $content = strtolower($content);
        $analyzedOutput = [];
        // Counts appearances of start-tags
        $analyzedOutput['counts'] = [];
        // Lists ERRORS
        $analyzedOutput['errors'] = [];
        // Lists warnings.
        $analyzedOutput['warnings'] = [];
        // Lists stats for block-tags
        $analyzedOutput['blocks'] = [];
        // Lists stats for solo-tags
        $analyzedOutput['solo'] = [];
        // Block tags, must have endings...
        $blockTags = explode(',', $blockTags);
        foreach ($blockTags as $tagName) {
            $countBegin = count(preg_split(('/\\<' . preg_quote($tagName, '/') . '(\\s|\\>)/s'), $content)) - 1;
            $countEnd = count(preg_split(('/\\<\\/' . preg_quote($tagName, '/') . '(\\s|\\>)/s'), $content)) - 1;
            $analyzedOutput['blocks'][$tagName] = [$countBegin, $countEnd, $countBegin - $countEnd];
            if ($countBegin) {
                $analyzedOutput['counts'][$tagName] = $countBegin;
            }
            if ($countBegin - $countEnd) {
                if ($countBegin - $countEnd > 0) {
                    $analyzedOutput['errors'][$tagName] = 'There were more start-tags (' . $countBegin . ') than end-tags (' . $countEnd . ') for the element "' . $tagName . '". There should be an equal amount!';
                } else {
                    $analyzedOutput['warnings'][$tagName] = 'There were more end-tags (' . $countEnd . ') than start-tags (' . $countBegin . ') for the element "' . $tagName . '". There should be an equal amount! However the problem is not fatal.';
                }
            }
        }
        // Solo tags, must NOT have endings...
        $soloTags = explode(',', $soloTags);
        foreach ($soloTags as $tagName) {
            $countBegin = count(preg_split(('/\\<' . preg_quote($tagName, '/') . '(\\s|\\>)/s'), $content)) - 1;
            $countEnd = count(preg_split(('/\\<\\/' . preg_quote($tagName, '/') . '(\\s|\\>)/s'), $content)) - 1;
            $analyzedOutput['solo'][$tagName] = [$countBegin, $countEnd];
            if ($countBegin) {
                $analyzedOutput['counts'][$tagName] = $countBegin;
            }
            if ($countEnd) {
                $analyzedOutput['warnings'][$tagName] = 'There were end-tags found (' . $countEnd . ') for the element "' . $tagName . '". This was not expected (although XHTML technically allows it).';
            }
        }
        return $analyzedOutput;
    }

    /*********************************
     *
     * Clean HTML code
     *
     *********************************/
    public function HTMLcleaner($content, $tags = [], $keepAll = 0, $hSC = 0, $addConfig = [])
    {
        $newContent = [];
        $tokArr = explode('<', $content);
        $newContent[] = $this->processContent(current($tokArr), $hSC, $addConfig);
        // We skip the first element in foreach loop
        $tokArrSliced = array_slice($tokArr, 1, null, true);
        $c = 1;
        $tagRegister = [];
        $tagStack = [];
        $inComment = false;
        $inCdata = false;
        $skipTag = false;
        foreach ($tokArrSliced as $tok) {
            if ($inComment) {
                if (($eocPos = strpos($tok, '-->')) === false) {
                    // End of comment is not found in the token. Go further until end of comment is found in other tokens.
                    $newContent[$c++] = '<' . $tok;
                    continue;
                }
                // Comment ends in the middle of the token: add comment and proceed with rest of the token
                $newContent[$c++] = '<' . substr($tok, 0, ($eocPos + 3));
                $tok = substr($tok, $eocPos + 3);
                $inComment = false;
                $skipTag = true;
            } elseif ($inCdata) {
                if (($eocPos = strpos($tok, '/*]]>*/')) === false) {
                    // End of comment is not found in the token. Go futher until end of comment is found in other tokens.
                    $newContent[$c++] = '<' . $tok;
                    continue;
                }
                // Comment ends in the middle of the token: add comment and proceed with rest of the token
                $newContent[$c++] = '<' . substr($tok, 0, $eocPos + 10);
                $tok = substr($tok, $eocPos + 10);
                $inCdata = false;
                $skipTag = true;
            } elseif (substr($tok, 0, 3) == '!--') {
                if (($eocPos = strpos($tok, '-->')) === false) {
                    // Comment started in this token but it does end in the same token. Set a flag to skip till the end of comment
                    $newContent[$c++] = '<' . $tok;
                    $inComment = true;
                    continue;
                }
                // Start and end of comment are both in the current token. Add comment and proceed with rest of the token
                $newContent[$c++] = '<' . substr($tok, 0, ($eocPos + 3));
                $tok = substr($tok, $eocPos + 3);
                $skipTag = true;
            } elseif (substr($tok, 0, 10) === '![CDATA[*/') {
                if (($eocPos = strpos($tok, '/*]]>*/')) === false) {
                    // Comment started in this token but it does end in the same token. Set a flag to skip till the end of comment
                    $newContent[$c++] = '<' . $tok;
                    $inCdata = true;
                    continue;
                }
                // Start and end of comment are both in the current token. Add comment and proceed with rest of the token
                $newContent[$c++] = '<' . substr($tok, 0, $eocPos + 10);
                $tok = substr($tok, $eocPos + 10);
                $skipTag = true;
            }
            $firstChar = $tok[0];
            // It is a tag... (first char is a-z0-9 or /) (fixed 19/01 2004). This also avoids triggering on <?xml..> and <!DOCTYPE..>
            if (!$skipTag && preg_match('/[[:alnum:]\\/]/', $firstChar) == 1) {
                $tagEnd = strpos($tok, '>');
                // If there is and end-bracket...   tagEnd can't be 0 as the first character can't be a >
                if ($tagEnd) {
                    $endTag = $firstChar == '/' ? 1 : 0;
                    $tagContent = substr($tok, $endTag, $tagEnd - $endTag);
                    $tagParts = preg_split('/\\s+/s', $tagContent, 2);
                    $tagName = strtolower($tagParts[0]);
                    $emptyTag = 0;
                    if (isset($tags[$tagName])) {
                        // If there is processing to do for the tag:
                        if (is_array($tags[$tagName])) {
                            if (preg_match('/^(' . self::VOID_ELEMENTS . ' )$/i', $tagName)) {
                                $emptyTag = 1;
                            }
                            // If NOT an endtag, do attribute processing (added dec. 2003)
                            if (!$endTag) {
                                // Override attributes
                                if ((string)$tags[$tagName]['overrideAttribs'] !== '') {
                                    $tagParts[1] = $tags[$tagName]['overrideAttribs'];
                                }
                                // Allowed tags
                                if ((string)$tags[$tagName]['allowedAttribs'] !== '') {
                                    // No attribs allowed
                                    if ((string)$tags[$tagName]['allowedAttribs'] === '0') {
                                        $tagParts[1] = '';
                                    } elseif (trim($tagParts[1])) {
                                        $tagAttrib = $this->get_tag_attributes($tagParts[1]);
                                        $tagParts[1] = '';
                                        $newTagAttrib = [];
                                        if (!($tList = $tags[$tagName]['_allowedAttribs'])) {
                                            // Just explode attribts for tag once
                                            $tList = ($tags[$tagName]['_allowedAttribs'] = GeneralUtility::trimExplode(',', strtolower($tags[$tagName]['allowedAttribs']), true));
                                        }
                                        foreach ($tList as $allowTag) {
                                            if (isset($tagAttrib[0][$allowTag])) {
                                                $newTagAttrib[$allowTag] = $tagAttrib[0][$allowTag];
                                            }
                                        }
                                        $tagParts[1] = $this->compileTagAttribs($newTagAttrib, $tagAttrib[1]);
                                    }
                                }
                                // Fixed attrib values
                                if (is_array($tags[$tagName]['fixAttrib'])) {
                                    $tagAttrib = $this->get_tag_attributes($tagParts[1]);
                                    $tagParts[1] = '';
                                    foreach ($tags[$tagName]['fixAttrib'] as $attr => $params) {
                                        if (isset($params['set']) && $params['set'] !== '') {
                                            $tagAttrib[0][$attr] = $params['set'];
                                        }
                                        if (!empty($params['unset'])) {
                                            unset($tagAttrib[0][$attr]);
                                        }
                                        if (!isset($tagAttrib[0][$attr]) && (string)$params['default'] !== '') {
                                            $tagAttrib[0][$attr] = $params['default'];
                                        }
                                        if ($params['always'] || isset($tagAttrib[0][$attr])) {
                                            if ($params['trim']) {
                                                $tagAttrib[0][$attr] = trim($tagAttrib[0][$attr]);
                                            }
                                            if ($params['intval']) {
                                                $tagAttrib[0][$attr] = (int)$tagAttrib[0][$attr];
                                            }
                                            if ($params['lower']) {
                                                $tagAttrib[0][$attr] = strtolower($tagAttrib[0][$attr]);
                                            }
                                            if ($params['upper']) {
                                                $tagAttrib[0][$attr] = strtoupper($tagAttrib[0][$attr]);
                                            }
                                            if ($params['range']) {
                                                if (isset($params['range'][1])) {
                                                    $tagAttrib[0][$attr] = \TYPO3\CMS\Core\Utility\MathUtility::forceIntegerInRange($tagAttrib[0][$attr], (int)$params['range'][0], (int)$params['range'][1]);
                                                } else {
                                                    $tagAttrib[0][$attr] = \TYPO3\CMS\Core\Utility\MathUtility::forceIntegerInRange($tagAttrib[0][$attr], (int)$params['range'][0]);
                                                }
                                            }
                                            if (is_array($params['list'])) {
                                                // For the class attribute, remove from the attribute value any class not in the list
                                                // Classes are case sensitive
                                                if ($attr == 'class') {
                                                    $newClasses = [];
                                                    $classes = GeneralUtility::trimExplode(' ', $tagAttrib[0][$attr], true);
                                                    foreach ($classes as $class) {
                                                        if (in_array($class, $params['list'])) {
                                                            $newClasses[] = $class;
                                                        }
                                                    }
                                                    if (!empty($newClasses)) {
                                                        $tagAttrib[0][$attr] = implode(' ', $newClasses);
                                                    } else {
                                                        $tagAttrib[0][$attr] = $params['list'][0];
                                                    }
                                                } else {
                                                    if (!in_array($this->caseShift($tagAttrib[0][$attr], $params['casesensitiveComp']), $this->caseShift($params['list'], $params['casesensitiveComp'], $tagName))) {
                                                        $tagAttrib[0][$attr] = $params['list'][0];
                                                    }
                                                }
                                            }
                                            if ($params['removeIfFalse'] && $params['removeIfFalse'] != 'blank' && !$tagAttrib[0][$attr] || $params['removeIfFalse'] == 'blank' && (string)$tagAttrib[0][$attr] === '') {
                                                unset($tagAttrib[0][$attr]);
                                            }
                                            if ((string)$params['removeIfEquals'] !== '' && $this->caseShift($tagAttrib[0][$attr], $params['casesensitiveComp']) === $this->caseShift($params['removeIfEquals'], $params['casesensitiveComp'])) {
                                                unset($tagAttrib[0][$attr]);
                                            }
                                            if ($params['prefixLocalAnchors']) {
                                                if ($tagAttrib[0][$attr][0] === '#') {
                                                    if ($params['prefixLocalAnchors'] == 2) {
                                                        $contentObjectRenderer = GeneralUtility::makeInstance(\TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer::class);
                                                        $prefix = $contentObjectRenderer->getUrlToCurrentLocation();
                                                    } else {
                                                        $prefix = GeneralUtility::getIndpEnv('TYPO3_REQUEST_URL');
                                                    }
                                                    $tagAttrib[0][$attr] = $prefix . $tagAttrib[0][$attr];
                                                }
                                            }
                                            if ($params['prefixRelPathWith']) {
                                                $urlParts = parse_url($tagAttrib[0][$attr]);
                                                if (!$urlParts['scheme'] && $urlParts['path'][0] !== '/') {
                                                    // If it is NOT an absolute URL (by http: or starting "/")
                                                    $tagAttrib[0][$attr] = $params['prefixRelPathWith'] . $tagAttrib[0][$attr];
                                                }
                                            }
                                            if ($params['userFunc']) {
                                                if (is_array($params['userFunc.'])) {
                                                    $params['userFunc.']['attributeValue'] = $tagAttrib[0][$attr];
                                                } else {
                                                    $params['userFunc.'] = $tagAttrib[0][$attr];
                                                }
                                                $tagAttrib[0][$attr] = GeneralUtility::callUserFunction($params['userFunc'], $params['userFunc.'], $this);
                                            }
                                        }
                                    }
                                    $tagParts[1] = $this->compileTagAttribs($tagAttrib[0], $tagAttrib[1]);
                                }
                            } else {
                                // If endTag, remove any possible attributes:
                                $tagParts[1] = '';
                            }
                            // Protecting the tag by converting < and > to &lt; and &gt; ??
                            if ($tags[$tagName]['protect']) {
                                $lt = '&lt;';
                                $gt = '&gt;';
                            } else {
                                $lt = '<';
                                $gt = '>';
                            }
                            // Remapping tag name?
                            if ($tags[$tagName]['remap']) {
                                $tagParts[0] = $tags[$tagName]['remap'];
                            }
                            // rmTagIfNoAttrib
                            if ($endTag || trim($tagParts[1]) || !$tags[$tagName]['rmTagIfNoAttrib']) {
                                $setTag = 1;
                                // Remove this closing tag if $tagName was among $TSconfig['removeTags']
                                if ($endTag && $tags[$tagName]['allowedAttribs'] === 0 && $tags[$tagName]['rmTagIfNoAttrib'] === 1) {
                                    $setTag = 0;
                                }
                                if ($tags[$tagName]['nesting']) {
                                    if (!is_array($tagRegister[$tagName])) {
                                        $tagRegister[$tagName] = [];
                                    }
                                    if ($endTag) {
                                        $correctTag = 1;
                                        if ($tags[$tagName]['nesting'] == 'global') {
                                            $lastEl = end($tagStack);
                                            if ($tagName !== $lastEl) {
                                                if (in_array($tagName, $tagStack)) {
                                                    while (!empty($tagStack) && $tagName !== $lastEl) {
                                                        $elPos = end($tagRegister[$lastEl]);
                                                        unset($newContent[$elPos]);
                                                        array_pop($tagRegister[$lastEl]);
                                                        array_pop($tagStack);
                                                        $lastEl = end($tagStack);
                                                    }
                                                } else {
                                                    // In this case the
                                                    $correctTag = 0;
                                                }
                                            }
                                        }
                                        if (empty($tagRegister[$tagName]) || !$correctTag) {
                                            $setTag = 0;
                                        } else {
                                            array_pop($tagRegister[$tagName]);
                                            if ($tags[$tagName]['nesting'] == 'global') {
                                                array_pop($tagStack);
                                            }
                                        }
                                    } else {
                                        array_push($tagRegister[$tagName], $c);
                                        if ($tags[$tagName]['nesting'] == 'global') {
                                            array_push($tagStack, $tagName);
                                        }
                                    }
                                }
                                if ($setTag) {
                                    // Setting the tag
                                    $newContent[$c++] = $this->processTag($lt . ($endTag ? '/' : '') . trim($tagParts[0] . ' ' . $tagParts[1]) . ($emptyTag ? ' /' : '') . $gt, $addConfig, $endTag, $lt == '&lt;');
                                }
                            }
                        } else {
                            $newContent[$c++] = $this->processTag('<' . ($endTag ? '/' : '') . $tagContent . '>', $addConfig, $endTag);
                        }
                    } elseif ($keepAll) {
                        // This is if the tag was not defined in the array for processing:
                        if ($keepAll === 'protect') {
                            $lt = '&lt;';
                            $gt = '&gt;';
                        } else {
                            $lt = '<';
                            $gt = '>';
                        }
                        $newContent[$c++] = $this->processTag($lt . ($endTag ? '/' : '') . $tagContent . $gt, $addConfig, $endTag, $lt == '&lt;');
                    }
                    $newContent[$c++] = $this->processContent(substr($tok, $tagEnd + 1), $hSC, $addConfig);
                } else {
                    $newContent[$c++] = $this->processContent('<' . $tok, $hSC, $addConfig);
                }
            } else {
                $newContent[$c++] = $this->processContent(($skipTag ? '' : '<') . $tok, $hSC, $addConfig);
                // It was not a tag anyways
                $skipTag = false;
            }
        }
        // Unsetting tags:
        foreach ($tagRegister as $tag => $positions) {
            foreach ($positions as $pKey) {
                unset($newContent[$pKey]);
            }
        }
        $newContent = implode('', $newContent);
        $newContent = $this->stripEmptyTagsIfConfigured($newContent, $addConfig);
        return $newContent;
    }

    public function bidir_htmlspecialchars($value, $dir)
    {
        $dir = (int)$dir;
        if ($dir === 1) {
            $value = htmlspecialchars($value);
        } elseif ($dir === 2) {
            $value = htmlspecialchars($value, ENT_COMPAT, 'UTF-8', false);
        } elseif ($dir === -1) {
            $value = htmlspecialchars_decode($value);
        }
        return $value;
    }

    public function prefixResourcePath($main_prefix, $content, $alternatives = [], $suffix = '')
    {
        $parts = $this->splitTags('embed,td,table,body,img,input,form,link,script,a,param', $content);
        foreach ($parts as $k => $v) {
            if ($k % 2) {
                $params = $this->get_tag_attributes($v);
                // Detect tag-ending so that it is re-applied correctly.
                $tagEnd = substr($v, -2) == '/>' ? ' />' : '>';
                // The 'name' of the first tag
                $firstTagName = $this->getFirstTagName($v);
                $somethingDone = 0;
                $prefix = isset($alternatives[strtoupper($firstTagName)]) ? $alternatives[strtoupper($firstTagName)] : $main_prefix;
                switch (strtolower($firstTagName)) {
                    case 'td':

                    case 'body':

                    case 'table':
                        $src = $params[0]['background'];
                        if ($src) {
                            $params[0]['background'] = $this->prefixRelPath($prefix, $params[0]['background'], $suffix);
                            $somethingDone = 1;
                        }
                        break;
                    case 'img':

                    case 'input':

                    case 'script':

                    case 'embed':
                        $src = $params[0]['src'];
                        if ($src) {
                            $params[0]['src'] = $this->prefixRelPath($prefix, $params[0]['src'], $suffix);
                            $somethingDone = 1;
                        }
                        break;
                    case 'link':

                    case 'a':
                        $src = $params[0]['href'];
                        if ($src) {
                            $params[0]['href'] = $this->prefixRelPath($prefix, $params[0]['href'], $suffix);
                            $somethingDone = 1;
                        }
                        break;
                    case 'form':
                        $src = $params[0]['action'];
                        if ($src) {
                            $params[0]['action'] = $this->prefixRelPath($prefix, $params[0]['action'], $suffix);
                            $somethingDone = 1;
                        }
                        break;
                    case 'param':
                        $test = $params[0]['name'];
                        if ($test && $test === 'movie') {
                            if ($params[0]['value']) {
                                $params[0]['value'] = $this->prefixRelPath($prefix, $params[0]['value'], $suffix);
                                $somethingDone = 1;
                            }
                        }
                        break;
                }
                if ($somethingDone) {
                    $tagParts = preg_split('/\\s+/s', $v, 2);
                    $tagParts[1] = $this->compileTagAttribs($params[0], $params[1]);
                    $parts[$k] = '<' . trim(strtolower($firstTagName) . ' ' . $tagParts[1]) . $tagEnd;
                }
            }
        }
        $content = implode('', $parts);
        // Fix <style> section:
        $prefix = isset($alternatives['style']) ? $alternatives['style'] : $main_prefix;
        if ((string)$prefix !== '') {
            $parts = $this->splitIntoBlock('style', $content);
            foreach ($parts as $k => &$part) {
                if ($k % 2) {
                    $part = preg_replace('/(url[[:space:]]*\\([[:space:]]*["\']?)([^"\')]*)(["\']?[[:space:]]*\\))/i', '\\1' . $prefix . '\\2' . $suffix . '\\3', $part);
                }
            }
            unset($part);
            $content = implode('', $parts);
        }
        return $content;
    }

    public function prefixRelPath($prefix, $srcVal, $suffix = '')
    {
        // Only prefix if it's not an absolute URL or
        // only a link to a section within the page.
        if ($srcVal[0] !== '/' && $srcVal[0] !== '#') {
            $urlParts = parse_url($srcVal);
            // Only prefix URLs without a scheme
            if (!$urlParts['scheme']) {
                $srcVal = $prefix . $srcVal . $suffix;
            }
        }
        return $srcVal;
    }

    public function cleanFontTags($value, $keepFace = 0, $keepSize = 0, $keepColor = 0)
    {
        // ,1 ?? - could probably be more stable if splitTags() was used since this depends on end-tags being properly set!
        $fontSplit = $this->splitIntoBlock('font', $value);
        foreach ($fontSplit as $k => $v) {
            // Font
            if ($k % 2) {
                $attribArray = $this->get_tag_attributes_classic($this->getFirstTag($v));
                $newAttribs = [];
                if ($keepFace && $attribArray['face']) {
                    $newAttribs[] = 'face="' . $attribArray['face'] . '"';
                }
                if ($keepSize && $attribArray['size']) {
                    $newAttribs[] = 'size="' . $attribArray['size'] . '"';
                }
                if ($keepColor && $attribArray['color']) {
                    $newAttribs[] = 'color="' . $attribArray['color'] . '"';
                }
                $innerContent = $this->cleanFontTags($this->removeFirstAndLastTag($v), $keepFace, $keepSize, $keepColor);
                if (!empty($newAttribs)) {
                    $fontSplit[$k] = '<font ' . implode(' ', $newAttribs) . '>' . $innerContent . '</font>';
                } else {
                    $fontSplit[$k] = $innerContent;
                }
            }
        }
        return implode('', $fontSplit);
    }

    public function mapTags($value, $tags = [], $ltChar = '<', $ltChar2 = '<')
    {
        foreach ($tags as $from => $to) {
            $value = preg_replace('/' . preg_quote($ltChar, '/') . '(\\/)?' . $from . '\\s([^\\>])*(\\/)?\\>/', $ltChar2 . '$1' . $to . ' $2$3>', $value);
        }
        return $value;
    }

    public function unprotectTags($content, $tagList = '')
    {
        $tagsArray = GeneralUtility::trimExplode(',', $tagList, true);
        $contentParts = explode('&lt;', $content);
        // bypass the first
        $contentPartsSliced = array_slice($contentParts, 1, null, true);
        foreach ($contentPartsSliced as $k => $tok) {
            $firstChar = $tok[0];
            if (trim($firstChar) !== '') {
                $subparts = explode('&gt;', $tok, 2);
                $tagEnd = strlen($subparts[0]);
                if (strlen($tok) != $tagEnd) {
                    $endTag = $firstChar == '/' ? 1 : 0;
                    $tagContent = substr($tok, $endTag, $tagEnd - $endTag);
                    $tagParts = preg_split('/\\s+/s', $tagContent, 2);
                    $tagName = strtolower($tagParts[0]);
                    if ((string)$tagList === '' || in_array($tagName, $tagsArray)) {
                        $contentParts[$k] = '<' . $subparts[0] . '>' . $subparts[1];
                    } else {
                        $contentParts[$k] = '&lt;' . $tok;
                    }
                } else {
                    $contentParts[$k] = '&lt;' . $tok;
                }
            } else {
                $contentParts[$k] = '&lt;' . $tok;
            }
        }
        return implode('', $contentParts);
    }

    public function caseShift($str, $flag, $cacheKey = '')
    {
        $cacheKey .= $flag ? 1 : 0;
        if (is_array($str)) {
            if (!$cacheKey || !isset($this->caseShift_cache[$cacheKey])) {
                foreach ($str as &$v) {
                    if (!$flag) {
                        $v = strtoupper($v);
                    }
                }
                unset($v);
                if ($cacheKey) {
                    $this->caseShift_cache[$cacheKey] = $str;
                }
            } else {
                $str = $this->caseShift_cache[$cacheKey];
            }
        } elseif (!$flag) {
            $str = strtoupper($str);
        }
        return $str;
    }

    public function compileTagAttribs($tagAttrib, $meta = [], $xhtmlClean = 0)
    {
        $accu = [];
        foreach ($tagAttrib as $k => $v) {
            if ($xhtmlClean) {
                $attr = strtolower($k);
                if ((string)$v !== '' || isset($meta[$k]['dashType'])) {
                    $attr .= '="' . htmlspecialchars($v) . '"';
                }
            } else {
                $attr = $meta[$k]['origTag'] ?: $k;
                if (strcmp($v, '') || isset($meta[$k]['dashType'])) {
                    $dash = $meta[$k]['dashType'] ?: (\TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($v) ? '' : '"');
                    $attr .= '=' . $dash . $v . $dash;
                }
            }
            $accu[] = $attr;
        }
        return implode(' ', $accu);
    }

    public function get_tag_attributes_classic($tag, $deHSC = 0)
    {
        $attr = $this->get_tag_attributes($tag, $deHSC);
        return is_array($attr[0]) ? $attr[0] : [];
    }

    public function indentLines($content, $number = 1, $indentChar = TAB)
    {
        $preTab = str_pad('', $number * strlen($indentChar), $indentChar);
        $lines = explode(LF, str_replace(CR, '', $content));
        foreach ($lines as &$line) {
            $line = $preTab . $line;
        }
        unset($line);
        return implode(LF, $lines);
    }

    public function HTMLparserConfig($TSconfig, $keepTags = [])
    {
        // Allow tags (base list, merged with incoming array)
        $alTags = array_flip(GeneralUtility::trimExplode(',', strtolower($TSconfig['allowTags']), true));
        $keepTags = array_merge($alTags, $keepTags);
        // Set config properties.
        if (is_array($TSconfig['tags.'])) {
            foreach ($TSconfig['tags.'] as $key => $tagC) {
                if (!is_array($tagC) && $key == strtolower($key)) {
                    if ((string)$tagC === '0') {
                        unset($keepTags[$key]);
                    }
                    if ((string)$tagC === '1' && !isset($keepTags[$key])) {
                        $keepTags[$key] = 1;
                    }
                }
            }
            foreach ($TSconfig['tags.'] as $key => $tagC) {
                if (is_array($tagC) && $key == strtolower($key)) {
                    $key = substr($key, 0, -1);
                    if (!is_array($keepTags[$key])) {
                        $keepTags[$key] = [];
                    }
                    if (is_array($tagC['fixAttrib.'])) {
                        foreach ($tagC['fixAttrib.'] as $atName => $atConfig) {
                            if (is_array($atConfig)) {
                                $atName = substr($atName, 0, -1);
                                if (!is_array($keepTags[$key]['fixAttrib'][$atName])) {
                                    $keepTags[$key]['fixAttrib'][$atName] = [];
                                }
                                $keepTags[$key]['fixAttrib'][$atName] = array_merge($keepTags[$key]['fixAttrib'][$atName], $atConfig);
                                if ((string)$keepTags[$key]['fixAttrib'][$atName]['range'] !== '') {
                                    $keepTags[$key]['fixAttrib'][$atName]['range'] = GeneralUtility::trimExplode(',', $keepTags[$key]['fixAttrib'][$atName]['range']);
                                }
                                if ((string)$keepTags[$key]['fixAttrib'][$atName]['list'] !== '') {
                                    $keepTags[$key]['fixAttrib'][$atName]['list'] = GeneralUtility::trimExplode(',', $keepTags[$key]['fixAttrib'][$atName]['list']);
                                }
                            }
                        }
                    }
                    unset($tagC['fixAttrib.']);
                    unset($tagC['fixAttrib']);
                    if (isset($tagC['rmTagIfNoAttrib']) && $tagC['rmTagIfNoAttrib'] && empty($tagC['nesting'])) {
                        $tagC['nesting'] = 1;
                    }
                    $keepTags[$key] = array_merge($keepTags[$key], $tagC);
                }
            }
        }
        // LocalNesting
        if ($TSconfig['localNesting']) {
            $lN = GeneralUtility::trimExplode(',', strtolower($TSconfig['localNesting']), true);
            foreach ($lN as $tn) {
                if (isset($keepTags[$tn])) {
                    if (!is_array($keepTags[$tn])) {
                        $keepTags[$tn] = [];
                    }
                    $keepTags[$tn]['nesting'] = 1;
                }
            }
        }
        if ($TSconfig['globalNesting']) {
            $lN = GeneralUtility::trimExplode(',', strtolower($TSconfig['globalNesting']), true);
            foreach ($lN as $tn) {
                if (isset($keepTags[$tn])) {
                    if (!is_array($keepTags[$tn])) {
                        $keepTags[$tn] = [];
                    }
                    $keepTags[$tn]['nesting'] = 'global';
                }
            }
        }
        if ($TSconfig['rmTagIfNoAttrib']) {
            $lN = GeneralUtility::trimExplode(',', strtolower($TSconfig['rmTagIfNoAttrib']), true);
            foreach ($lN as $tn) {
                if (isset($keepTags[$tn])) {
                    if (!is_array($keepTags[$tn])) {
                        $keepTags[$tn] = [];
                    }
                    $keepTags[$tn]['rmTagIfNoAttrib'] = 1;
                    if (empty($keepTags[$tn]['nesting'])) {
                        $keepTags[$tn]['nesting'] = 1;
                    }
                }
            }
        }
        if ($TSconfig['noAttrib']) {
            $lN = GeneralUtility::trimExplode(',', strtolower($TSconfig['noAttrib']), true);
            foreach ($lN as $tn) {
                if (isset($keepTags[$tn])) {
                    if (!is_array($keepTags[$tn])) {
                        $keepTags[$tn] = [];
                    }
                    $keepTags[$tn]['allowedAttribs'] = 0;
                }
            }
        }
        if ($TSconfig['removeTags']) {
            $lN = GeneralUtility::trimExplode(',', strtolower($TSconfig['removeTags']), true);
            foreach ($lN as $tn) {
                $keepTags[$tn] = [];
                $keepTags[$tn]['allowedAttribs'] = 0;
                $keepTags[$tn]['rmTagIfNoAttrib'] = 1;
            }
        }
        // Create additional configuration:
        $addConfig = [];
        if ($TSconfig['xhtml_cleaning']) {
            $addConfig['xhtml'] = 1;
        }
        if (isset($TSconfig['stripEmptyTags'])) {
            $addConfig['stripEmptyTags'] = $TSconfig['stripEmptyTags'];
            if (isset($TSconfig['stripEmptyTags.'])) {
                $addConfig['stripEmptyTags.'] = $TSconfig['stripEmptyTags.'];
            }
        }
        return [
            $keepTags,
            '' . $TSconfig['keepNonMatchedTags'],
            (int)$TSconfig['htmlSpecialChars'],
            $addConfig
        ];
    }

    public function XHTML_clean($content)
    {
        GeneralUtility::logDeprecatedFunction('TYPO3\CMS\Core\Html\HtmlParser::XHTML_clean has been deprecated with TYPO3 CMS 7 and will be removed with TYPO3 CMS 8.');
        return $this->HTMLcleaner($content, [], 1, 0, ['xhtml' => 1]);
    }

    public function processTag($value, $conf, $endTag, $protected = 0)
    {
        // Return immediately if protected or no parameters
        if ($protected || empty($conf)) {
            return $value;
        }
        // OK then, begin processing for XHTML output:
        // STILL VERY EXPERIMENTAL!!
        if ($conf['xhtml']) {
            GeneralUtility::deprecationLog('This section has been deprecated with TYPO3 CMS 7 and will be removed with CMS 8.');
            // Endtags are just set lowercase right away
            if ($endTag) {
                $value = strtolower($value);
            } elseif (substr($value, 0, 4) != '<!--') {
                // ... and comments are ignored.
                // Finding inner value with out < >
                $inValue = substr($value, 1, substr($value, -2) == '/>' ? -2 : -1);
                // Separate attributes and tagname
                list($tagName, $tagP) = preg_split('/\\s+/s', $inValue, 2);
                $tagName = strtolower($tagName);
                // Process attributes
                $tagAttrib = $this->get_tag_attributes($tagP);
                if ($tagName === 'img' && !isset($tagAttrib[0]['alt'])) {
                    $tagAttrib[0]['alt'] = '';
                }
                // Set alt attribute for all images (not XHTML though...)
                if ($tagName === 'script' && !isset($tagAttrib[0]['type'])) {
                    $tagAttrib[0]['type'] = 'text/javascript';
                }
                // Set type attribute for all script-tags
                $outA = [];
                foreach ($tagAttrib[0] as $attrib_name => $attrib_value) {
                    // Set attributes: lowercase, always in quotes, with htmlspecialchars converted.
                    $outA[] = $attrib_name . '="' . $this->bidir_htmlspecialchars($attrib_value, 2) . '"';
                }
                $newTag = '<' . trim($tagName . ' ' . implode(' ', $outA));
                // All tags that are standalone (not wrapping, not having endtags) should be ended with '/>'
                if (
                    $tagName === 'img' || $tagName === 'br' || $tagName === 'hr' || $tagName === 'meta' || $tagName === 'link' || $tagName === 'base'
                    || $tagName === 'area' || $tagName === 'input' || $tagName === 'param' || $tagName === 'col' || substr($value, -2) === '/>'
                ) {
                    $newTag .= ' />';
                } else {
                    $newTag .= '>';
                }
                $value = $newTag;
            }
        }
        return $value;
    }

    public function processContent($value, $dir, $conf)
    {
        if ($dir != 0) {
            $value = $this->bidir_htmlspecialchars($value, $dir);
        }
        return $value;
    }

    public function stripEmptyTags($content, $tagList = null, $treatNonBreakingSpaceAsEmpty = false)
    {
        $tagRegEx = '[^ >]+'; // all characters until you reach a > or space;
        if ($tagList) {
            $tags = preg_split('/,/', $tagList);
            $tagRegEx = preg_replace('/ */', '', implode('|', $tags));
        }
        $count = 1;
        $nbspRegex = $treatNonBreakingSpaceAsEmpty ? '|(&nbsp;)' : '';
        while ($count != 0) {
            $content = preg_replace(sprintf('/<(%s)[^>]*>( %s)*<\/\\1[^>]*>/i', $tagRegEx, $nbspRegex), '', $content, -1, $count);
        }
        return $content;
    }

    protected function stripEmptyTagsIfConfigured($value, $configuration)
    {
        if (isset($configuration['stripEmptyTags']) && $configuration['stripEmptyTags']) {
            $tags = null;
            if (
                isset($configuration['stripEmptyTags.']['tags'])
                && $configuration['stripEmptyTags.']['tags'] !== ''
            ) {
                $tags = $configuration['stripEmptyTags.']['tags'];
            }

            $treatNonBreakingSpaceAsEmpty = false;
            if (
                isset($configuration['stripEmptyTags.']['treatNonBreakingSpaceAsEmpty'])
                && $configuration['stripEmptyTags.']['treatNonBreakingSpaceAsEmpty']
            ) {
                $treatNonBreakingSpaceAsEmpty = (bool)$configuration['stripEmptyTags.']['treatNonBreakingSpaceAsEmpty'];
            }

            $value = $this->stripEmptyTags($value, $tags, $treatNonBreakingSpaceAsEmpty);
        }

        return $value;
    }
}