Proyectos de Subversion Moodle

<?php

/**

 * SCSSPHP

 *

 * @copyright 2012-2020 Leaf Corcoran

 *

 * @license http://opensource.org/licenses/MIT MIT

 *

 * @link http://scssphp.github.io/scssphp

 */

namespace ScssPhp\ScssPhp;

use ScssPhp\ScssPhp\Base\Range;

use ScssPhp\ScssPhp\Block\AtRootBlock;

use ScssPhp\ScssPhp\Block\CallableBlock;

use ScssPhp\ScssPhp\Block\DirectiveBlock;

use ScssPhp\ScssPhp\Block\EachBlock;

use ScssPhp\ScssPhp\Block\ElseBlock;

use ScssPhp\ScssPhp\Block\ElseifBlock;

use ScssPhp\ScssPhp\Block\ForBlock;

use ScssPhp\ScssPhp\Block\IfBlock;

use ScssPhp\ScssPhp\Block\MediaBlock;

use ScssPhp\ScssPhp\Block\NestedPropertyBlock;

use ScssPhp\ScssPhp\Block\WhileBlock;

use ScssPhp\ScssPhp\Compiler\CachedResult;

use ScssPhp\ScssPhp\Compiler\Environment;

use ScssPhp\ScssPhp\Exception\CompilerException;

use ScssPhp\ScssPhp\Exception\ParserException;

use ScssPhp\ScssPhp\Exception\SassException;

use ScssPhp\ScssPhp\Exception\SassScriptException;

use ScssPhp\ScssPhp\Formatter\Compressed;

use ScssPhp\ScssPhp\Formatter\Expanded;

use ScssPhp\ScssPhp\Formatter\OutputBlock;

use ScssPhp\ScssPhp\Logger\LoggerInterface;

use ScssPhp\ScssPhp\Logger\StreamLogger;

use ScssPhp\ScssPhp\Node\Number;

use ScssPhp\ScssPhp\SourceMap\SourceMapGenerator;

use ScssPhp\ScssPhp\Util\Path;

/**

 * The scss compiler and parser.

 *

 * Converting SCSS to CSS is a three stage process. The incoming file is parsed

 * by `Parser` into a syntax tree, then it is compiled into another tree

 * representing the CSS structure by `Compiler`. The CSS tree is fed into a

 * formatter, like `Formatter` which then outputs CSS as a string.

 *

 * During the first compile, all values are *reduced*, which means that their

 * types are brought to the lowest form before being dump as strings. This

 * handles math equations, variable dereferences, and the like.

 *

 * The `compile` function of `Compiler` is the entry point.

 *

 * In summary:

 *

 * The `Compiler` class creates an instance of the parser, feeds it SCSS code,

 * then transforms the resulting tree to a CSS tree. This class also holds the

 * evaluation context, such as all available mixins and variables at any given

 * time.

 *

 * The `Parser` class is only concerned with parsing its input.

 *

 * The `Formatter` takes a CSS tree, and dumps it to a formatted string,

 * handling things like indentation.

 */

/**

 * SCSS compiler

 *

 * @author Leaf Corcoran <leafot@gmail.com>

 *

 * @final Extending the Compiler is deprecated

 */

class Compiler

{

    /**

     * @deprecated

     */

    const LINE_COMMENTS = 1;

    /**

     * @deprecated

     */

    const DEBUG_INFO    = 2;

    /**

     * @deprecated

     */

    const WITH_RULE     = 1;

    /**

     * @deprecated

     */

    const WITH_MEDIA    = 2;

    /**

     * @deprecated

     */

    const WITH_SUPPORTS = 4;

    /**

     * @deprecated

     */

    const WITH_ALL      = 7;

    const SOURCE_MAP_NONE   = 0;

    const SOURCE_MAP_INLINE = 1;

    const SOURCE_MAP_FILE   = 2;

    /**

     * @var array<string, string>

     */

    protected static $operatorNames = [

        '+'   => 'add',

        '-'   => 'sub',

        '*'   => 'mul',

        '/'   => 'div',

        '%'   => 'mod',

        '=='  => 'eq',

        '!='  => 'neq',

        '<'   => 'lt',

        '>'   => 'gt',

        '<='  => 'lte',

        '>='  => 'gte',

    ];

    /**

     * @var array<string, string>

     */

    protected static $namespaces = [

        'special'  => '%',

        'mixin'    => '@',

        'function' => '^',

    ];

    public static $true         = [Type::T_KEYWORD, 'true'];

    public static $false        = [Type::T_KEYWORD, 'false'];

    /** @deprecated */

    public static $NaN          = [Type::T_KEYWORD, 'NaN'];

    /** @deprecated */

    public static $Infinity     = [Type::T_KEYWORD, 'Infinity'];

    public static $null         = [Type::T_NULL];

    public static $nullString   = [Type::T_STRING, '', []];

    public static $defaultValue = [Type::T_KEYWORD, ''];

    public static $selfSelector = [Type::T_SELF];

    public static $emptyList    = [Type::T_LIST, '', []];

    public static $emptyMap     = [Type::T_MAP, [], []];

    public static $emptyString  = [Type::T_STRING, '"', []];

    public static $with         = [Type::T_KEYWORD, 'with'];

    public static $without      = [Type::T_KEYWORD, 'without'];

    private static $emptyArgumentList = [Type::T_LIST, '', [], []];

    /**

     * @var array<int, string|callable>

     */

    protected $importPaths = [];

    /**

     * @var array<string, Block>

     */

    protected $importCache = [];

    /**

     * @var string[]

     */

    protected $importedFiles = [];

    /**

     * @var array

     * @phpstan-var array<string, array{0: callable, 1: string[]|null}>

     */

    protected $userFunctions = [];

    /**

     * @var array<string, mixed>

     */

    protected $registeredVars = [];

    /**

     * @var array<string, bool>

     */

    protected $registeredFeatures = [

        'extend-selector-pseudoclass' => false,

        'at-error'                    => true,

        'units-level-3'               => true,

        'global-variable-shadowing'   => false,

    ];

    /**

     * @var string|null

     */

    protected $encoding = null;

    /**

     * @var null

     * @deprecated

     */

    protected $lineNumberStyle = null;

    /**

     * @var int|SourceMapGenerator

     * @phpstan-var self::SOURCE_MAP_*|SourceMapGenerator

     */

    protected $sourceMap = self::SOURCE_MAP_NONE;

    /**

     * @var array

     * @phpstan-var array{sourceRoot?: string, sourceMapFilename?: string|null, sourceMapURL?: string|null, sourceMapWriteTo?: string|null, outputSourceFiles?: bool, sourceMapRootpath?: string, sourceMapBasepath?: string}

     */

    protected $sourceMapOptions = [];

    /**

     * @var bool

     */

    private $charset = true;

    /**

     * @var Formatter

     */

    protected $formatter;

    /**

     * @var string

     * @phpstan-var class-string<Formatter>

     */

    private $configuredFormatter = Expanded::class;

    /**

     * @var Environment

     */

    protected $rootEnv;

    /**

     * @var OutputBlock|null

     */

    protected $rootBlock;

    /**

     * @var \ScssPhp\ScssPhp\Compiler\Environment

     */

    protected $env;

    /**

     * @var OutputBlock|null

     */

    protected $scope;

    /**

     * @var Environment|null

     */

    protected $storeEnv;

    /**

     * @var bool|null

     *

     * @deprecated

     */

    protected $charsetSeen;

    /**

     * @var array<int, string|null>

     */

    protected $sourceNames;

    /**

     * @var Cache|null

     */

    protected $cache;

    /**

     * @var bool

     */

    protected $cacheCheckImportResolutions = false;

    /**

     * @var int

     */

    protected $indentLevel;

    /**

     * @var array[]

     */

    protected $extends;

    /**

     * @var array<string, int[]>

     */

    protected $extendsMap;

    /**

     * @var array<string, int>

     */

    protected $parsedFiles = [];

    /**

     * @var Parser|null

     */

    protected $parser;

    /**

     * @var int|null

     */

    protected $sourceIndex;

    /**

     * @var int|null

     */

    protected $sourceLine;

    /**

     * @var int|null

     */

    protected $sourceColumn;

    /**

     * @var bool|null

     */

    protected $shouldEvaluate;

    /**

     * @var null

     * @deprecated

     */

    protected $ignoreErrors;

    /**

     * @var bool

     */

    protected $ignoreCallStackMessage = false;

    /**

     * @var array[]

     */

    protected $callStack = [];

    /**

     * @var array

     * @phpstan-var list<array{currentDir: string|null, path: string, filePath: string}>

     */

    private $resolvedImports = [];

    /**

     * The directory of the currently processed file

     *

     * @var string|null

     */

    private $currentDirectory;

    /**

     * The directory of the input file

     *

     * @var string

     */

    private $rootDirectory;

    /**

     * @var bool

     */

    private $legacyCwdImportPath = true;

    /**

     * @var LoggerInterface

     */

    private $logger;

    /**

     * @var array<string, bool>

     */

    private $warnedChildFunctions = [];

    /**

     * Constructor

     *

     * @param array|null $cacheOptions

     * @phpstan-param array{cacheDir?: string, prefix?: string, forceRefresh?: string, checkImportResolutions?: bool}|null $cacheOptions

     */

    public function __construct($cacheOptions = null)

    {

        $this->sourceNames = [];

        if ($cacheOptions) {

            $this->cache = new Cache($cacheOptions);

            if (!empty($cacheOptions['checkImportResolutions'])) {

                $this->cacheCheckImportResolutions = true;

            }

        }

        $this->logger = new StreamLogger(fopen('php://stderr', 'w'), true);

    }

    /**

     * Get compiler options

     *

     * @return array<string, mixed>

     *

     * @internal

     */

    public function getCompileOptions()

    {

        $options = [

            'importPaths'        => $this->importPaths,

            'registeredVars'     => $this->registeredVars,

            'registeredFeatures' => $this->registeredFeatures,

            'encoding'           => $this->encoding,

            'sourceMap'          => serialize($this->sourceMap),

            'sourceMapOptions'   => $this->sourceMapOptions,

            'formatter'          => $this->configuredFormatter,

            'legacyImportPath'   => $this->legacyCwdImportPath,

        ];

        return $options;

    }

    /**

     * Sets an alternative logger.

     *

     * Changing the logger in the middle of the compilation is not

     * supported and will result in an undefined behavior.

     *

     * @param LoggerInterface $logger

     *

     * @return void

     */

    public function setLogger(LoggerInterface $logger)

    {

        $this->logger = $logger;

    }

    /**

     * Set an alternative error output stream, for testing purpose only

     *

     * @param resource $handle

     *

     * @return void

     *

     * @deprecated Use {@see setLogger} instead

     */

    public function setErrorOuput($handle)

    {

        @trigger_error('The method "setErrorOuput" is deprecated. Use "setLogger" instead.', E_USER_DEPRECATED);

        $this->logger = new StreamLogger($handle);

    }

    /**

     * Compile scss

     *

     * @param string      $code

     * @param string|null $path

     *

     * @return string

     *

     * @throws SassException when the source fails to compile

     *

     * @deprecated Use {@see compileString} instead.

     */

    public function compile($code, $path = null)

    {

        @trigger_error(sprintf('The "%s" method is deprecated. Use "compileString" instead.', __METHOD__), E_USER_DEPRECATED);

        $result = $this->compileString($code, $path);

        $sourceMap = $result->getSourceMap();

        if ($sourceMap !== null) {

            if ($this->sourceMap instanceof SourceMapGenerator) {

                $this->sourceMap->saveMap($sourceMap);

            } elseif ($this->sourceMap === self::SOURCE_MAP_FILE) {

                $sourceMapGenerator = new SourceMapGenerator($this->sourceMapOptions);

                $sourceMapGenerator->saveMap($sourceMap);

            }

        }

        return $result->getCss();

    }

    /**

     * Compiles the provided scss file into CSS.

     *

     * @param string $path

     *

     * @return CompilationResult

     *

     * @throws SassException when the source fails to compile

     */

    public function compileFile($path)

    {

        $source = file_get_contents($path);

        if ($source === false) {

            throw new \RuntimeException('Could not read the file content');

        }

        return $this->compileString($source, $path);

    }

    /**

     * Compiles the provided scss source code into CSS.

     *

     * If provided, the path is considered to be the path from which the source code comes

     * from, which will be used to resolve relative imports.

     *

     * @param string      $source

     * @param string|null $path   The path for the source, used to resolve relative imports

     *

     * @return CompilationResult

     *

     * @throws SassException when the source fails to compile

     */

    public function compileString($source, $path = null)

    {

        if ($this->cache) {

            $cacheKey       = ($path ? $path : '(stdin)') . ':' . md5($source);

            $compileOptions = $this->getCompileOptions();

            $cachedResult = $this->cache->getCache('compile', $cacheKey, $compileOptions);

            if ($cachedResult instanceof CachedResult && $this->isFreshCachedResult($cachedResult)) {

                return $cachedResult->getResult();

            }

        }

        $this->indentLevel    = -1;

        $this->extends        = [];

        $this->extendsMap     = [];

        $this->sourceIndex    = null;

        $this->sourceLine     = null;

        $this->sourceColumn   = null;

        $this->env            = null;

        $this->scope          = null;

        $this->storeEnv       = null;

        $this->shouldEvaluate = null;

        $this->ignoreCallStackMessage = false;

        $this->parsedFiles = [];

        $this->importedFiles = [];

        $this->resolvedImports = [];

        if (!\is_null($path) && is_file($path)) {

            $path = realpath($path) ?: $path;

            $this->currentDirectory = dirname($path);

            $this->rootDirectory = $this->currentDirectory;

        } else {

            $this->currentDirectory = null;

            $this->rootDirectory = getcwd();

        }

        try {

            $this->parser = $this->parserFactory($path);

            $tree         = $this->parser->parse($source);

            $this->parser = null;

            $this->formatter = new $this->configuredFormatter();

            $this->rootBlock = null;

            $this->rootEnv   = $this->pushEnv($tree);

            $warnCallback = function ($message, $deprecation) {

                $this->logger->warn($message, $deprecation);

            };

            $previousWarnCallback = Warn::setCallback($warnCallback);

            try {

                $this->injectVariables($this->registeredVars);

                $this->compileRoot($tree);

                $this->popEnv();

            } finally {

                Warn::setCallback($previousWarnCallback);

            }

            $sourceMapGenerator = null;

            if ($this->sourceMap) {

                if (\is_object($this->sourceMap) && $this->sourceMap instanceof SourceMapGenerator) {

                    $sourceMapGenerator = $this->sourceMap;

                    $this->sourceMap = self::SOURCE_MAP_FILE;

                } elseif ($this->sourceMap !== self::SOURCE_MAP_NONE) {

                    $sourceMapGenerator = new SourceMapGenerator($this->sourceMapOptions);

                }

            }

            assert($this->scope !== null);

            $out = $this->formatter->format($this->scope, $sourceMapGenerator);

            $prefix = '';

            if ($this->charset && strlen($out) !== Util::mbStrlen($out)) {

                $prefix = '@charset "UTF-8";' . "\n";

                $out = $prefix . $out;

            }

            $sourceMap = null;

            if (! empty($out) && $this->sourceMap !== self::SOURCE_MAP_NONE && $this->sourceMap) {

                assert($sourceMapGenerator !== null);

                $sourceMap = $sourceMapGenerator->generateJson($prefix);

                $sourceMapUrl = null;

                switch ($this->sourceMap) {

                    case self::SOURCE_MAP_INLINE:

                        $sourceMapUrl = sprintf('data:application/json,%s', Util::encodeURIComponent($sourceMap));

                        break;

                    case self::SOURCE_MAP_FILE:

                        if (isset($this->sourceMapOptions['sourceMapURL'])) {

                            $sourceMapUrl = $this->sourceMapOptions['sourceMapURL'];

                        }

                        break;

                }

                if ($sourceMapUrl !== null) {

                    $out .= sprintf('/*# sourceMappingURL=%s */', $sourceMapUrl);

                }

            }

        } catch (SassScriptException $e) {

            throw new CompilerException($this->addLocationToMessage($e->getMessage()), 0, $e);

        }

        $includedFiles = [];

        foreach ($this->resolvedImports as $resolvedImport) {

            $includedFiles[$resolvedImport['filePath']] = $resolvedImport['filePath'];

        }

        $result = new CompilationResult($out, $sourceMap, array_values($includedFiles));

        if ($this->cache && isset($cacheKey) && isset($compileOptions)) {

            $this->cache->setCache('compile', $cacheKey, new CachedResult($result, $this->parsedFiles, $this->resolvedImports), $compileOptions);

        }

        // Reset state to free memory

        // TODO in 2.0, reset parsedFiles as well when the getter is removed.

        $this->resolvedImports = [];

        $this->importedFiles = [];

        return $result;

    }

    /**

     * @param CachedResult $result

     *

     * @return bool

     */

    private function isFreshCachedResult(CachedResult $result)

    {

        // check if any dependency file changed since the result was compiled

        foreach ($result->getParsedFiles() as $file => $mtime) {

            if (! is_file($file) || filemtime($file) !== $mtime) {

                return false;

            }

        }

        if ($this->cacheCheckImportResolutions) {

            $resolvedImports = [];

            foreach ($result->getResolvedImports() as $import) {

                $currentDir = $import['currentDir'];

                $path = $import['path'];

                // store the check across all the results in memory to avoid multiple findImport() on the same path

                // with same context.

                // this is happening in a same hit with multiple compilations (especially with big frameworks)

                if (empty($resolvedImports[$currentDir][$path])) {

                    $resolvedImports[$currentDir][$path] = $this->findImport($path, $currentDir);

                }

                if ($resolvedImports[$currentDir][$path] !== $import['filePath']) {

                    return false;

                }

            }

        }

        return true;

    }

    /**

     * Instantiate parser

     *

     * @param string|null $path

     *

     * @return \ScssPhp\ScssPhp\Parser

     */

    protected function parserFactory($path)

    {

        // https://sass-lang.com/documentation/at-rules/import

        // CSS files imported by Sass don’t allow any special Sass features.

        // In order to make sure authors don’t accidentally write Sass in their CSS,

        // all Sass features that aren’t also valid CSS will produce errors.

        // Otherwise, the CSS will be rendered as-is. It can even be extended!

        $cssOnly = false;

        if ($path !== null && substr($path, -4) === '.css') {

            $cssOnly = true;

        }

        $parser = new Parser($path, \count($this->sourceNames), $this->encoding, $this->cache, $cssOnly, $this->logger);

        $this->sourceNames[] = $path;

        $this->addParsedFile($path);

        return $parser;

    }

    /**

     * Is self extend?

     *

     * @param array $target

     * @param array $origin

     *

     * @return bool

     */

    protected function isSelfExtend($target, $origin)

    {

        foreach ($origin as $sel) {

            if (\in_array($target, $sel)) {

                return true;

            }

        }

        return false;

    }

    /**

     * Push extends

     *

     * @param string[]   $target

     * @param array      $origin

     * @param array|null $block

     *

     * @return void

     */

    protected function pushExtends($target, $origin, $block)

    {

        $i = \count($this->extends);

        $this->extends[] = [$target, $origin, $block];

        foreach ($target as $part) {

            if (isset($this->extendsMap[$part])) {

                $this->extendsMap[$part][] = $i;

            } else {

                $this->extendsMap[$part] = [$i];

            }

        }

    }

    /**

     * Make output block

     *

     * @param string|null   $type

     * @param string[]|null $selectors

     *

     * @return \ScssPhp\ScssPhp\Formatter\OutputBlock

     */

    protected function makeOutputBlock($type, $selectors = null)

    {

        $out = new OutputBlock();

        $out->type      = $type;

        $out->lines     = [];

        $out->children  = [];

        $out->parent    = $this->scope;

        $out->selectors = $selectors;

        $out->depth     = $this->env->depth;

        if ($this->env->block instanceof Block) {

            $out->sourceName   = $this->env->block->sourceName;

            $out->sourceLine   = $this->env->block->sourceLine;

            $out->sourceColumn = $this->env->block->sourceColumn;

        } else {

            $out->sourceName = isset($this->sourceNames[$this->sourceIndex]) ? $this->sourceNames[$this->sourceIndex] : '(stdin)';

            $out->sourceLine = $this->sourceLine;

            $out->sourceColumn = $this->sourceColumn;

        }

        return $out;

    }

    /**

     * Compile root

     *

     * @param \ScssPhp\ScssPhp\Block $rootBlock

     *

     * @return void

     */

    protected function compileRoot(Block $rootBlock)

    {

        $this->rootBlock = $this->scope = $this->makeOutputBlock(Type::T_ROOT);

        $this->compileChildrenNoReturn($rootBlock->children, $this->scope);

        assert($this->scope !== null);

        $this->flattenSelectors($this->scope);

        $this->missingSelectors();

    }

    /**

     * Report missing selectors

     *

     * @return void

     */

    protected function missingSelectors()

    {

        foreach ($this->extends as $extend) {

            if (isset($extend[3])) {

                continue;

            }

            list($target, $origin, $block) = $extend;

            // ignore if !optional

            if ($block[2]) {

                continue;

            }

            $target = implode(' ', $target);

            $origin = $this->collapseSelectors($origin);

            $this->sourceLine = $block[Parser::SOURCE_LINE];

            throw $this->error("\"$origin\" failed to @extend \"$target\". The selector \"$target\" was not found.");

        }

    }

    /**

     * Flatten selectors

     *

     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block

     * @param string                                 $parentKey

     *

     * @return void

     */

    protected function flattenSelectors(OutputBlock $block, $parentKey = null)

    {

        if ($block->selectors) {

            $selectors = [];

            foreach ($block->selectors as $s) {

                $selectors[] = $s;

                if (! \is_array($s)) {

                    continue;

                }

                // check extends

                if (! empty($this->extendsMap)) {

                    $this->matchExtends($s, $selectors);

                    // remove duplicates

                    array_walk($selectors, function (&$value) {

                        $value = serialize($value);

                    });

                    $selectors = array_unique($selectors);

                    array_walk($selectors, function (&$value) {

                        $value = unserialize($value);

                    });

                }

            }

            $block->selectors = [];

            $placeholderSelector = false;

            foreach ($selectors as $selector) {

                if ($this->hasSelectorPlaceholder($selector)) {

                    $placeholderSelector = true;

                    continue;

                }

                $block->selectors[] = $this->compileSelector($selector);

            }

            if ($placeholderSelector && 0 === \count($block->selectors) && null !== $parentKey) {

                assert($block->parent !== null);

                unset($block->parent->children[$parentKey]);

                return;

            }

        }

        foreach ($block->children as $key => $child) {

            $this->flattenSelectors($child, $key);

        }

    }

    /**

     * Glue parts of :not( or :nth-child( ... that are in general split in selectors parts

     *

     * @param array $parts

     *

     * @return array

     */

    protected function glueFunctionSelectors($parts)

    {

        $new = [];

        foreach ($parts as $part) {

            if (\is_array($part)) {

                $part = $this->glueFunctionSelectors($part);

                $new[] = $part;

            } else {

                // a selector part finishing with a ) is the last part of a :not( or :nth-child(

                // and need to be joined to this

                if (

                    \count($new) && \is_string($new[\count($new) - 1]) &&

                    \strlen($part) && substr($part, -1) === ')' && strpos($part, '(') === false

                ) {

                    while (\count($new) > 1 && substr($new[\count($new) - 1], -1) !== '(') {

                        $part = array_pop($new) . $part;

                    }

                    $new[\count($new) - 1] .= $part;

                } else {

                    $new[] = $part;

                }

            }

        }

        return $new;

    }

    /**

     * Match extends

     *

     * @param array $selector

     * @param array $out

     * @param int   $from

     * @param bool  $initial

     *

     * @return void

     */

    protected function matchExtends($selector, &$out, $from = 0, $initial = true)

    {

        static $partsPile = [];

        $selector = $this->glueFunctionSelectors($selector);

        if (\count($selector) == 1 && \in_array(reset($selector), $partsPile)) {

            return;

        }

        $outRecurs = [];

        foreach ($selector as $i => $part) {

            if ($i < $from) {

                continue;

            }

            // check that we are not building an infinite loop of extensions

            // if the new part is just including a previous part don't try to extend anymore

            if (\count($part) > 1) {

                foreach ($partsPile as $previousPart) {

                    if (! \count(array_diff($previousPart, $part))) {

                        continue 2;

                    }

                }

            }

            $partsPile[] = $part;

            if ($this->matchExtendsSingle($part, $origin, $initial)) {

                $after       = \array_slice($selector, $i + 1);

                $before      = \array_slice($selector, 0, $i);

                list($before, $nonBreakableBefore) = $this->extractRelationshipFromFragment($before);

                foreach ($origin as $new) {

                    $k = 0;

                    // remove shared parts

                    if (\count($new) > 1) {

                        while ($k < $i && isset($new[$k]) && $selector[$k] === $new[$k]) {

                            $k++;

                        }

                    }

                    if (\count($nonBreakableBefore) && $k === \count($new)) {

                        $k--;

                    }

                    $replacement = [];

                    $tempReplacement = $k > 0 ? \array_slice($new, $k) : $new;

                    for ($l = \count($tempReplacement) - 1; $l >= 0; $l--) {

                        $slice = [];

                        foreach ($tempReplacement[$l] as $chunk) {

                            if (! \in_array($chunk, $slice)) {

                                $slice[] = $chunk;

                            }

                        }

                        array_unshift($replacement, $slice);

                        if (! $this->isImmediateRelationshipCombinator(end($slice))) {

                            break;

                        }

                    }

                    $afterBefore = $l != 0 ? \array_slice($tempReplacement, 0, $l) : [];

                    // Merge shared direct relationships.

                    $mergedBefore = $this->mergeDirectRelationships($afterBefore, $nonBreakableBefore);

                    $result = array_merge(

                        $before,

                        $mergedBefore,

                        $replacement,

                        $after

                    );

                    if ($result === $selector) {

                        continue;

                    }

                    $this->pushOrMergeExtentedSelector($out, $result);

                    // recursively check for more matches

                    $startRecurseFrom = \count($before) + min(\count($nonBreakableBefore), \count($mergedBefore));

                    if (\count($origin) > 1) {

                        $this->matchExtends($result, $out, $startRecurseFrom, false);

                    } else {

                        $this->matchExtends($result, $outRecurs, $startRecurseFrom, false);

                    }

                    // selector sequence merging

                    if (! empty($before) && \count($new) > 1) {

                        $preSharedParts = $k > 0 ? \array_slice($before, 0, $k) : [];

                        $postSharedParts = $k > 0 ? \array_slice($before, $k) : $before;

                        list($betweenSharedParts, $nonBreakabl2) = $this->extractRelationshipFromFragment($afterBefore);