vendor/scssphp/scssphp/src/Compiler.php line 5576

Open in your IDE?
  1. <?php
  3. /**
  4.  * SCSSPHP
  5.  *
  6.  * @copyright 2012-2020 Leaf Corcoran
  7.  *
  8.  * @license http://opensource.org/licenses/MIT MIT
  9.  *
  10.  * @link http://scssphp.github.io/scssphp
  11.  */
  13. namespace ScssPhp\ScssPhp;
  15. use ScssPhp\ScssPhp\Base\Range;
  16. use ScssPhp\ScssPhp\Block\AtRootBlock;
  17. use ScssPhp\ScssPhp\Block\CallableBlock;
  18. use ScssPhp\ScssPhp\Block\DirectiveBlock;
  19. use ScssPhp\ScssPhp\Block\EachBlock;
  20. use ScssPhp\ScssPhp\Block\ElseBlock;
  21. use ScssPhp\ScssPhp\Block\ElseifBlock;
  22. use ScssPhp\ScssPhp\Block\ForBlock;
  23. use ScssPhp\ScssPhp\Block\IfBlock;
  24. use ScssPhp\ScssPhp\Block\MediaBlock;
  25. use ScssPhp\ScssPhp\Block\NestedPropertyBlock;
  26. use ScssPhp\ScssPhp\Block\WhileBlock;
  27. use ScssPhp\ScssPhp\Compiler\CachedResult;
  28. use ScssPhp\ScssPhp\Compiler\Environment;
  29. use ScssPhp\ScssPhp\Exception\CompilerException;
  30. use ScssPhp\ScssPhp\Exception\ParserException;
  31. use ScssPhp\ScssPhp\Exception\SassException;
  32. use ScssPhp\ScssPhp\Exception\SassScriptException;
  33. use ScssPhp\ScssPhp\Formatter\Compressed;
  34. use ScssPhp\ScssPhp\Formatter\Expanded;
  35. use ScssPhp\ScssPhp\Formatter\OutputBlock;
  36. use ScssPhp\ScssPhp\Logger\LoggerInterface;
  37. use ScssPhp\ScssPhp\Logger\StreamLogger;
  38. use ScssPhp\ScssPhp\Node\Number;
  39. use ScssPhp\ScssPhp\SourceMap\SourceMapGenerator;
  40. use ScssPhp\ScssPhp\Util\Path;
  42. /**
  43.  * The scss compiler and parser.
  44.  *
  45.  * Converting SCSS to CSS is a three stage process. The incoming file is parsed
  46.  * by `Parser` into a syntax tree, then it is compiled into another tree
  47.  * representing the CSS structure by `Compiler`. The CSS tree is fed into a
  48.  * formatter, like `Formatter` which then outputs CSS as a string.
  49.  *
  50.  * During the first compile, all values are *reduced*, which means that their
  51.  * types are brought to the lowest form before being dump as strings. This
  52.  * handles math equations, variable dereferences, and the like.
  53.  *
  54.  * The `compile` function of `Compiler` is the entry point.
  55.  *
  56.  * In summary:
  57.  *
  58.  * The `Compiler` class creates an instance of the parser, feeds it SCSS code,
  59.  * then transforms the resulting tree to a CSS tree. This class also holds the
  60.  * evaluation context, such as all available mixins and variables at any given
  61.  * time.
  62.  *
  63.  * The `Parser` class is only concerned with parsing its input.
  64.  *
  65.  * The `Formatter` takes a CSS tree, and dumps it to a formatted string,
  66.  * handling things like indentation.
  67.  */
  69. /**
  70.  * SCSS compiler
  71.  *
  72.  * @author Leaf Corcoran <leafot@gmail.com>
  73.  *
  74.  * @final Extending the Compiler is deprecated
  75.  */
  76. class Compiler
  77. {
  78.     /**
  79.      * @deprecated
  80.      */
  81.     const LINE_COMMENTS = 1;
  82.     /**
  83.      * @deprecated
  84.      */
  85.     const DEBUG_INFO    = 2;
  87.     /**
  88.      * @deprecated
  89.      */
  90.     const WITH_RULE     = 1;
  91.     /**
  92.      * @deprecated
  93.      */
  94.     const WITH_MEDIA    = 2;
  95.     /**
  96.      * @deprecated
  97.      */
  98.     const WITH_SUPPORTS = 4;
  99.     /**
  100.      * @deprecated
  101.      */
  102.     const WITH_ALL      = 7;
  104.     const SOURCE_MAP_NONE   = 0;
  105.     const SOURCE_MAP_INLINE = 1;
  106.     const SOURCE_MAP_FILE   = 2;
  108.     /**
  109.      * @var array<string, string>
  110.      */
  111.     protected static $operatorNames = [
  112.         '+'   => 'add',
  113.         '-'   => 'sub',
  114.         '*'   => 'mul',
  115.         '/'   => 'div',
  116.         '%'   => 'mod',
  118.         '=='  => 'eq',
  119.         '!='  => 'neq',
  120.         '<'   => 'lt',
  121.         '>'   => 'gt',
  123.         '<='  => 'lte',
  124.         '>='  => 'gte',
  125.     ];
  127.     /**
  128.      * @var array<string, string>
  129.      */
  130.     protected static $namespaces = [
  131.         'special'  => '%',
  132.         'mixin'    => '@',
  133.         'function' => '^',
  134.     ];
  136.     public static $true         = [Type::T_KEYWORD, 'true'];
  137.     public static $false        = [Type::T_KEYWORD, 'false'];
  138.     /** @deprecated */
  139.     public static $NaN          = [Type::T_KEYWORD, 'NaN'];
  140.     /** @deprecated */
  141.     public static $Infinity     = [Type::T_KEYWORD, 'Infinity'];
  142.     public static $null         = [Type::T_NULL];
  143.     public static $nullString   = [Type::T_STRING, '', []];
  144.     public static $defaultValue = [Type::T_KEYWORD, ''];
  145.     public static $selfSelector = [Type::T_SELF];
  146.     public static $emptyList    = [Type::T_LIST, '', []];
  147.     public static $emptyMap     = [Type::T_MAP, [], []];
  148.     public static $emptyString  = [Type::T_STRING, '"', []];
  149.     public static $with         = [Type::T_KEYWORD, 'with'];
  150.     public static $without      = [Type::T_KEYWORD, 'without'];
  151.     private static $emptyArgumentList = [Type::T_LIST, '', [], []];
  153.     /**
  154.      * @var array<int, string|callable>
  155.      */
  156.     protected $importPaths = [];
  157.     /**
  158.      * @var array<string, Block>
  159.      */
  160.     protected $importCache = [];
  162.     /**
  163.      * @var string[]
  164.      */
  165.     protected $importedFiles = [];
  167.     /**
  168.      * @var array
  169.      * @phpstan-var array<string, array{0: callable, 1: string[]|null}>
  170.      */
  171.     protected $userFunctions = [];
  172.     /**
  173.      * @var array<string, mixed>
  174.      */
  175.     protected $registeredVars = [];
  176.     /**
  177.      * @var array<string, bool>
  178.      */
  179.     protected $registeredFeatures = [
  180.         'extend-selector-pseudoclass' => false,
  181.         'at-error'                    => true,
  182.         'units-level-3'               => true,
  183.         'global-variable-shadowing'   => false,
  184.     ];
  186.     /**
  187.      * @var string|null
  188.      */
  189.     protected $encoding = null;
  190.     /**
  191.      * @var null
  192.      * @deprecated
  193.      */
  194.     protected $lineNumberStyle = null;
  196.     /**
  197.      * @var int|SourceMapGenerator
  198.      * @phpstan-var self::SOURCE_MAP_*|SourceMapGenerator
  199.      */
  200.     protected $sourceMap = self::SOURCE_MAP_NONE;
  202.     /**
  203.      * @var array
  204.      * @phpstan-var array{sourceRoot?: string, sourceMapFilename?: string|null, sourceMapURL?: string|null, sourceMapWriteTo?: string|null, outputSourceFiles?: bool, sourceMapRootpath?: string, sourceMapBasepath?: string}
  205.      */
  206.     protected $sourceMapOptions = [];
  208.     /**
  209.      * @var bool
  210.      */
  211.     private $charset = true;
  213.     /**
  214.      * @var Formatter
  215.      */
  216.     protected $formatter;
  218.     /**
  219.      * @var string
  220.      * @phpstan-var class-string<Formatter>
  221.      */
  222.     private $configuredFormatter = Expanded::class;
  224.     /**
  225.      * @var Environment
  226.      */
  227.     protected $rootEnv;
  228.     /**
  229.      * @var OutputBlock|null
  230.      */
  231.     protected $rootBlock;
  233.     /**
  234.      * @var \ScssPhp\ScssPhp\Compiler\Environment
  235.      */
  236.     protected $env;
  237.     /**
  238.      * @var OutputBlock|null
  239.      */
  240.     protected $scope;
  241.     /**
  242.      * @var Environment|null
  243.      */
  244.     protected $storeEnv;
  245.     /**
  246.      * @var bool|null
  247.      *
  248.      * @deprecated
  249.      */
  250.     protected $charsetSeen;
  251.     /**
  252.      * @var array<int, string|null>
  253.      */
  254.     protected $sourceNames;
  256.     /**
  257.      * @var Cache|null
  258.      */
  259.     protected $cache;
  261.     /**
  262.      * @var bool
  263.      */
  264.     protected $cacheCheckImportResolutions = false;
  266.     /**
  267.      * @var int
  268.      */
  269.     protected $indentLevel;
  270.     /**
  271.      * @var array[]
  272.      */
  273.     protected $extends;
  274.     /**
  275.      * @var array<string, int[]>
  276.      */
  277.     protected $extendsMap;
  279.     /**
  280.      * @var array<string, int>
  281.      */
  282.     protected $parsedFiles = [];
  284.     /**
  285.      * @var Parser|null
  286.      */
  287.     protected $parser;
  288.     /**
  289.      * @var int|null
  290.      */
  291.     protected $sourceIndex;
  292.     /**
  293.      * @var int|null
  294.      */
  295.     protected $sourceLine;
  296.     /**
  297.      * @var int|null
  298.      */
  299.     protected $sourceColumn;
  300.     /**
  301.      * @var bool|null
  302.      */
  303.     protected $shouldEvaluate;
  304.     /**
  305.      * @var null
  306.      * @deprecated
  307.      */
  308.     protected $ignoreErrors;
  309.     /**
  310.      * @var bool
  311.      */
  312.     protected $ignoreCallStackMessage = false;
  314.     /**
  315.      * @var array[]
  316.      */
  317.     protected $callStack = [];
  319.     /**
  320.      * @var array
  321.      * @phpstan-var list<array{currentDir: string|null, path: string, filePath: string}>
  322.      */
  323.     private $resolvedImports = [];
  325.     /**
  326.      * The directory of the currently processed file
  327.      *
  328.      * @var string|null
  329.      */
  330.     private $currentDirectory;
  332.     /**
  333.      * The directory of the input file
  334.      *
  335.      * @var string
  336.      */
  337.     private $rootDirectory;
  339.     /**
  340.      * @var bool
  341.      */
  342.     private $legacyCwdImportPath = true;
  344.     /**
  345.      * @var LoggerInterface
  346.      */
  347.     private $logger;
  349.     /**
  350.      * @var array<string, bool>
  351.      */
  352.     private $warnedChildFunctions = [];
  354.     /**
  355.      * Constructor
  356.      *
  357.      * @param array|null $cacheOptions
  358.      * @phpstan-param array{cacheDir?: string, prefix?: string, forceRefresh?: string, checkImportResolutions?: bool}|null $cacheOptions
  359.      */
  360.     public function __construct($cacheOptions = null)
  361.     {
  362.         $this->sourceNames = [];
  364.         if ($cacheOptions) {
  365.             $this->cache = new Cache($cacheOptions);
  366.             if (!empty($cacheOptions['checkImportResolutions'])) {
  367.                 $this->cacheCheckImportResolutions = true;
  368.             }
  369.         }
  371.         $this->logger = new StreamLogger(fopen('php://stderr', 'w'), true);
  372.     }
  374.     /**
  375.      * Get compiler options
  376.      *
  377.      * @return array<string, mixed>
  378.      *
  379.      * @internal
  380.      */
  381.     public function getCompileOptions()
  382.     {
  383.         $options = [
  384.             'importPaths'        => $this->importPaths,
  385.             'registeredVars'     => $this->registeredVars,
  386.             'registeredFeatures' => $this->registeredFeatures,
  387.             'encoding'           => $this->encoding,
  388.             'sourceMap'          => serialize($this->sourceMap),
  389.             'sourceMapOptions'   => $this->sourceMapOptions,
  390.             'formatter'          => $this->configuredFormatter,
  391.             'legacyImportPath'   => $this->legacyCwdImportPath,
  392.         ];
  394.         return $options;
  395.     }
  397.     /**
  398.      * Sets an alternative logger.
  399.      *
  400.      * Changing the logger in the middle of the compilation is not
  401.      * supported and will result in an undefined behavior.
  402.      *
  403.      * @param LoggerInterface $logger
  404.      *
  405.      * @return void
  406.      */
  407.     public function setLogger(LoggerInterface $logger)
  408.     {
  409.         $this->logger = $logger;
  410.     }
  412.     /**
  413.      * Set an alternative error output stream, for testing purpose only
  414.      *
  415.      * @param resource $handle
  416.      *
  417.      * @return void
  418.      *
  419.      * @deprecated Use {@see setLogger} instead
  420.      */
  421.     public function setErrorOuput($handle)
  422.     {
  423.         @trigger_error('The method "setErrorOuput" is deprecated. Use "setLogger" instead.', E_USER_DEPRECATED);
  425.         $this->logger = new StreamLogger($handle);
  426.     }
  428.     /**
  429.      * Compile scss
  430.      *
  431.      * @param string      $code
  432.      * @param string|null $path
  433.      *
  434.      * @return string
  435.      *
  436.      * @throws SassException when the source fails to compile
  437.      *
  438.      * @deprecated Use {@see compileString} instead.
  439.      */
  440.     public function compile($code, $path = null)
  441.     {
  442.         @trigger_error(sprintf('The "%s" method is deprecated. Use "compileString" instead.', __METHOD__), E_USER_DEPRECATED);
  444.         $result = $this->compileString($code, $path);
  446.         $sourceMap = $result->getSourceMap();
  448.         if ($sourceMap !== null) {
  449.             if ($this->sourceMap instanceof SourceMapGenerator) {
  450.                 $this->sourceMap->saveMap($sourceMap);
  451.             } elseif ($this->sourceMap === self::SOURCE_MAP_FILE) {
  452.                 $sourceMapGenerator = new SourceMapGenerator($this->sourceMapOptions);
  453.                 $sourceMapGenerator->saveMap($sourceMap);
  454.             }
  455.         }
  457.         return $result->getCss();
  458.     }
  460.     /**
  461.      * Compile scss
  462.      *
  463.      * @param string      $source
  464.      * @param string|null $path
  465.      *
  466.      * @return CompilationResult
  467.      *
  468.      * @throws SassException when the source fails to compile
  469.      */
  470.     public function compileString($source, $path = null)
  471.     {
  472.         if ($this->cache) {
  473.             $cacheKey       = ($path ? $path : '(stdin)') . ':' . md5($source);
  474.             $compileOptions = $this->getCompileOptions();
  475.             $cachedResult = $this->cache->getCache('compile', $cacheKey, $compileOptions);
  477.             if ($cachedResult instanceof CachedResult && $this->isFreshCachedResult($cachedResult)) {
  478.                 return $cachedResult->getResult();
  479.             }
  480.         }
  482.         $this->indentLevel    = -1;
  483.         $this->extends        = [];
  484.         $this->extendsMap     = [];
  485.         $this->sourceIndex    = null;
  486.         $this->sourceLine     = null;
  487.         $this->sourceColumn   = null;
  488.         $this->env            = null;
  489.         $this->scope          = null;
  490.         $this->storeEnv       = null;
  491.         $this->shouldEvaluate = null;
  492.         $this->ignoreCallStackMessage = false;
  493.         $this->parsedFiles = [];
  494.         $this->importedFiles = [];
  495.         $this->resolvedImports = [];
  497.         if (!\is_null($path) && is_file($path)) {
  498.             $path = realpath($path) ?: $path;
  499.             $this->currentDirectory = dirname($path);
  500.             $this->rootDirectory = $this->currentDirectory;
  501.         } else {
  502.             $this->currentDirectory = null;
  503.             $this->rootDirectory = getcwd();
  504.         }
  506.         try {
  507.             $this->parser = $this->parserFactory($path);
  508.             $tree         = $this->parser->parse($source);
  509.             $this->parser = null;
  511.             $this->formatter = new $this->configuredFormatter();
  512.             $this->rootBlock = null;
  513.             $this->rootEnv   = $this->pushEnv($tree);
  515.             $warnCallback = function ($message, $deprecation) {
  516.                 $this->logger->warn($message, $deprecation);
  517.             };
  518.             $previousWarnCallback = Warn::setCallback($warnCallback);
  520.             try {
  521.                 $this->injectVariables($this->registeredVars);
  522.                 $this->compileRoot($tree);
  523.                 $this->popEnv();
  524.             } finally {
  525.                 Warn::setCallback($previousWarnCallback);
  526.             }
  528.             $sourceMapGenerator = null;
  530.             if ($this->sourceMap) {
  531.                 if (\is_object($this->sourceMap) && $this->sourceMap instanceof SourceMapGenerator) {
  532.                     $sourceMapGenerator = $this->sourceMap;
  533.                     $this->sourceMap = self::SOURCE_MAP_FILE;
  534.                 } elseif ($this->sourceMap !== self::SOURCE_MAP_NONE) {
  535.                     $sourceMapGenerator = new SourceMapGenerator($this->sourceMapOptions);
  536.                 }
  537.             }
  538.             assert($this->scope !== null);
  540.             $out = $this->formatter->format($this->scope, $sourceMapGenerator);
  542.             $prefix = '';
  544.             if ($this->charset && strlen($out) !== Util::mbStrlen($out)) {
  545.                 $prefix = '@charset "UTF-8";' . "\n";
  546.                 $out = $prefix . $out;
  547.             }
  549.             $sourceMap = null;
  551.             if (! empty($out) && $this->sourceMap && $this->sourceMap !== self::SOURCE_MAP_NONE) {
  552.                 assert($sourceMapGenerator !== null);
  553.                 $sourceMap = $sourceMapGenerator->generateJson($prefix);
  554.                 $sourceMapUrl = null;
  556.                 switch ($this->sourceMap) {
  557.                     case self::SOURCE_MAP_INLINE:
  558.                         $sourceMapUrl = sprintf('data:application/json,%s', Util::encodeURIComponent($sourceMap));
  559.                         break;
  561.                     case self::SOURCE_MAP_FILE:
  562.                         if (isset($this->sourceMapOptions['sourceMapURL'])) {
  563.                             $sourceMapUrl = $this->sourceMapOptions['sourceMapURL'];
  564.                         }
  565.                         break;
  566.                 }
  568.                 if ($sourceMapUrl !== null) {
  569.                     $out .= sprintf('/*# sourceMappingURL=%s */', $sourceMapUrl);
  570.                 }
  571.             }
  572.         } catch (SassScriptException $e) {
  573.             throw new CompilerException($this->addLocationToMessage($e->getMessage()), 0, $e);
  574.         }
  576.         $includedFiles = [];
  578.         foreach ($this->resolvedImports as $resolvedImport) {
  579.             $includedFiles[$resolvedImport['filePath']] = $resolvedImport['filePath'];
  580.         }
  582.         $result = new CompilationResult($out, $sourceMap, array_values($includedFiles));
  584.         if ($this->cache && isset($cacheKey) && isset($compileOptions)) {
  585.             $this->cache->setCache('compile', $cacheKey, new CachedResult($result, $this->parsedFiles, $this->resolvedImports), $compileOptions);
  586.         }
  588.         // Reset state to free memory
  589.         // TODO in 2.0, reset parsedFiles as well when the getter is removed.
  590.         $this->resolvedImports = [];
  591.         $this->importedFiles = [];
  593.         return $result;
  594.     }
  596.     /**
  597.      * @param CachedResult $result
  598.      *
  599.      * @return bool
  600.      */
  601.     private function isFreshCachedResult(CachedResult $result)
  602.     {
  603.         // check if any dependency file changed since the result was compiled
  604.         foreach ($result->getParsedFiles() as $file => $mtime) {
  605.             if (! is_file($file) || filemtime($file) !== $mtime) {
  606.                 return false;
  607.             }
  608.         }
  610.         if ($this->cacheCheckImportResolutions) {
  611.             $resolvedImports = [];
  613.             foreach ($result->getResolvedImports() as $import) {
  614.                 $currentDir = $import['currentDir'];
  615.                 $path = $import['path'];
  616.                 // store the check across all the results in memory to avoid multiple findImport() on the same path
  617.                 // with same context.
  618.                 // this is happening in a same hit with multiple compilations (especially with big frameworks)
  619.                 if (empty($resolvedImports[$currentDir][$path])) {
  620.                     $resolvedImports[$currentDir][$path] = $this->findImport($path, $currentDir);
  621.                 }
  623.                 if ($resolvedImports[$currentDir][$path] !== $import['filePath']) {
  624.                     return false;
  625.                 }
  626.             }
  627.         }
  629.         return true;
  630.     }
  632.     /**
  633.      * Instantiate parser
  634.      *
  635.      * @param string|null $path
  636.      *
  637.      * @return \ScssPhp\ScssPhp\Parser
  638.      */
  639.     protected function parserFactory($path)
  640.     {
  641.         // https://sass-lang.com/documentation/at-rules/import
  642.         // CSS files imported by Sass don’t allow any special Sass features.
  643.         // In order to make sure authors don’t accidentally write Sass in their CSS,
  644.         // all Sass features that aren’t also valid CSS will produce errors.
  645.         // Otherwise, the CSS will be rendered as-is. It can even be extended!
  646.         $cssOnly = false;
  648.         if ($path !== null && substr($path, -4) === '.css') {
  649.             $cssOnly = true;
  650.         }
  652.         $parser = new Parser($path, \count($this->sourceNames), $this->encoding, $this->cache, $cssOnly, $this->logger);
  654.         $this->sourceNames[] = $path;
  655.         $this->addParsedFile($path);
  657.         return $parser;
  658.     }
  660.     /**
  661.      * Is self extend?
  662.      *
  663.      * @param array $target
  664.      * @param array $origin
  665.      *
  666.      * @return bool
  667.      */
  668.     protected function isSelfExtend($target, $origin)
  669.     {
  670.         foreach ($origin as $sel) {
  671.             if (\in_array($target, $sel)) {
  672.                 return true;
  673.             }
  674.         }
  676.         return false;
  677.     }
  679.     /**
  680.      * Push extends
  681.      *
  682.      * @param string[]   $target
  683.      * @param array      $origin
  684.      * @param array|null $block
  685.      *
  686.      * @return void
  687.      */
  688.     protected function pushExtends($target, $origin, $block)
  689.     {
  690.         $i = \count($this->extends);
  691.         $this->extends[] = [$target, $origin, $block];
  693.         foreach ($target as $part) {
  694.             if (isset($this->extendsMap[$part])) {
  695.                 $this->extendsMap[$part][] = $i;
  696.             } else {
  697.                 $this->extendsMap[$part] = [$i];
  698.             }
  699.         }
  700.     }
  702.     /**
  703.      * Make output block
  704.      *
  705.      * @param string|null   $type
  706.      * @param string[]|null $selectors
  707.      *
  708.      * @return \ScssPhp\ScssPhp\Formatter\OutputBlock
  709.      */
  710.     protected function makeOutputBlock($type, $selectors = null)
  711.     {
  712.         $out = new OutputBlock();
  713.         $out->type      = $type;
  714.         $out->lines     = [];
  715.         $out->children  = [];
  716.         $out->parent    = $this->scope;
  717.         $out->selectors = $selectors;
  718.         $out->depth     = $this->env->depth;
  720.         if ($this->env->block instanceof Block) {
  721.             $out->sourceName   = $this->env->block->sourceName;
  722.             $out->sourceLine   = $this->env->block->sourceLine;
  723.             $out->sourceColumn = $this->env->block->sourceColumn;
  724.         } else {
  725.             $out->sourceName = isset($this->sourceNames[$this->sourceIndex]) ? $this->sourceNames[$this->sourceIndex] : '(stdin)';
  726.             $out->sourceLine = $this->sourceLine;
  727.             $out->sourceColumn = $this->sourceColumn;
  728.         }
  730.         return $out;
  731.     }
  733.     /**
  734.      * Compile root
  735.      *
  736.      * @param \ScssPhp\ScssPhp\Block $rootBlock
  737.      *
  738.      * @return void
  739.      */
  740.     protected function compileRoot(Block $rootBlock)
  741.     {
  742.         $this->rootBlock = $this->scope = $this->makeOutputBlock(Type::T_ROOT);
  744.         $this->compileChildrenNoReturn($rootBlock->children, $this->scope);
  745.         assert($this->scope !== null);
  746.         $this->flattenSelectors($this->scope);
  747.         $this->missingSelectors();
  748.     }
  750.     /**
  751.      * Report missing selectors
  752.      *
  753.      * @return void
  754.      */
  755.     protected function missingSelectors()
  756.     {
  757.         foreach ($this->extends as $extend) {
  758.             if (isset($extend[3])) {
  759.                 continue;
  760.             }
  762.             list($target, $origin, $block) = $extend;
  764.             // ignore if !optional
  765.             if ($block[2]) {
  766.                 continue;
  767.             }
  769.             $target = implode(' ', $target);
  770.             $origin = $this->collapseSelectors($origin);
  772.             $this->sourceLine = $block[Parser::SOURCE_LINE];
  773.             throw $this->error("\"$origin\" failed to @extend \"$target\". The selector \"$target\" was not found.");
  774.         }
  775.     }
  777.     /**
  778.      * Flatten selectors
  779.      *
  780.      * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
  781.      * @param string                                 $parentKey
  782.      *
  783.      * @return void
  784.      */
  785.     protected function flattenSelectors(OutputBlock $block, $parentKey = null)
  786.     {
  787.         if ($block->selectors) {
  788.             $selectors = [];
  790.             foreach ($block->selectors as $s) {
  791.                 $selectors[] = $s;
  793.                 if (! \is_array($s)) {
  794.                     continue;
  795.                 }
  797.                 // check extends
  798.                 if (! empty($this->extendsMap)) {
  799.                     $this->matchExtends($s, $selectors);
  801.                     // remove duplicates
  802.                     array_walk($selectors, function (&$value) {
  803.                         $value = serialize($value);
  804.                     });
  806.                     $selectors = array_unique($selectors);
  808.                     array_walk($selectors, function (&$value) {
  809.                         $value = unserialize($value);
  810.                     });
  811.                 }
  812.             }
  814.             $block->selectors = [];
  815.             $placeholderSelector = false;
  817.             foreach ($selectors as $selector) {
  818.                 if ($this->hasSelectorPlaceholder($selector)) {
  819.                     $placeholderSelector = true;
  820.                     continue;
  821.                 }
  823.                 $block->selectors[] = $this->compileSelector($selector);
  824.             }
  826.             if ($placeholderSelector && 0 === \count($block->selectors) && null !== $parentKey) {
  827.                 assert($block->parent !== null);
  828.                 unset($block->parent->children[$parentKey]);
  830.                 return;
  831.             }
  832.         }
  834.         foreach ($block->children as $key => $child) {
  835.             $this->flattenSelectors($child, $key);
  836.         }
  837.     }
  839.     /**
  840.      * Glue parts of :not( or :nth-child( ... that are in general split in selectors parts
  841.      *
  842.      * @param array $parts
  843.      *
  844.      * @return array
  845.      */
  846.     protected function glueFunctionSelectors($parts)
  847.     {
  848.         $new = [];
  850.         foreach ($parts as $part) {
  851.             if (\is_array($part)) {
  852.                 $part = $this->glueFunctionSelectors($part);
  853.                 $new[] = $part;
  854.             } else {
  855.                 // a selector part finishing with a ) is the last part of a :not( or :nth-child(
  856.                 // and need to be joined to this
  857.                 if (
  858.                     \count($new) && \is_string($new[\count($new) - 1]) &&
  859.                     \strlen($part) && substr($part, -1) === ')' && strpos($part, '(') === false
  860.                 ) {
  861.                     while (\count($new) > 1 && substr($new[\count($new) - 1], -1) !== '(') {
  862.                         $part = array_pop($new) . $part;
  863.                     }
  864.                     $new[\count($new) - 1] .= $part;
  865.                 } else {
  866.                     $new[] = $part;
  867.                 }
  868.             }
  869.         }
  871.         return $new;
  872.     }
  874.     /**
  875.      * Match extends
  876.      *
  877.      * @param array $selector
  878.      * @param array $out
  879.      * @param int   $from
  880.      * @param bool  $initial
  881.      *
  882.      * @return void
  883.      */
  884.     protected function matchExtends($selector, &$out, $from = 0, $initial = true)
  885.     {
  886.         static $partsPile = [];
  887.         $selector = $this->glueFunctionSelectors($selector);
  889.         if (\count($selector) == 1 && \in_array(reset($selector), $partsPile)) {
  890.             return;
  891.         }
  893.         $outRecurs = [];
  895.         foreach ($selector as $i => $part) {
  896.             if ($i < $from) {
  897.                 continue;
  898.             }
  900.             // check that we are not building an infinite loop of extensions
  901.             // if the new part is just including a previous part don't try to extend anymore
  902.             if (\count($part) > 1) {
  903.                 foreach ($partsPile as $previousPart) {
  904.                     if (! \count(array_diff($previousPart, $part))) {
  905.                         continue 2;
  906.                     }
  907.                 }
  908.             }
  910.             $partsPile[] = $part;
  912.             if ($this->matchExtendsSingle($part, $origin, $initial)) {
  913.                 $after       = \array_slice($selector, $i + 1);
  914.                 $before      = \array_slice($selector, 0, $i);
  915.                 list($before, $nonBreakableBefore) = $this->extractRelationshipFromFragment($before);
  917.                 foreach ($origin as $new) {
  918.                     $k = 0;
  920.                     // remove shared parts
  921.                     if (\count($new) > 1) {
  922.                         while ($k < $i && isset($new[$k]) && $selector[$k] === $new[$k]) {
  923.                             $k++;
  924.                         }
  925.                     }
  927.                     if (\count($nonBreakableBefore) && $k === \count($new)) {
  928.                         $k--;
  929.                     }
  931.                     $replacement = [];
  932.                     $tempReplacement = $k > 0 ? \array_slice($new, $k) : $new;
  934.                     for ($l = \count($tempReplacement) - 1; $l >= 0; $l--) {
  935.                         $slice = [];
  937.                         foreach ($tempReplacement[$l] as $chunk) {
  938.                             if (! \in_array($chunk, $slice)) {
  939.                                 $slice[] = $chunk;
  940.                             }
  941.                         }
  943.                         array_unshift($replacement, $slice);
  945.                         if (! $this->isImmediateRelationshipCombinator(end($slice))) {
  946.                             break;
  947.                         }
  948.                     }
  950.                     $afterBefore = $l != 0 ? \array_slice($tempReplacement, 0, $l) : [];
  952.                     // Merge shared direct relationships.
  953.                     $mergedBefore = $this->mergeDirectRelationships($afterBefore, $nonBreakableBefore);
  955.                     $result = array_merge(
  956.                         $before,
  957.                         $mergedBefore,
  958.                         $replacement,
  959.                         $after
  960.                     );
  962.                     if ($result === $selector) {
  963.                         continue;
  964.                     }
  966.                     $this->pushOrMergeExtentedSelector($out, $result);
  968.                     // recursively check for more matches
  969.                     $startRecurseFrom = \count($before) + min(\count($nonBreakableBefore), \count($mergedBefore));
  971.                     if (\count($origin) > 1) {
  972.                         $this->matchExtends($result, $out, $startRecurseFrom, false);
  973.                     } else {
  974.                         $this->matchExtends($result, $outRecurs, $startRecurseFrom, false);
  975.                     }
  977.                     // selector sequence merging
  978.                     if (! empty($before) && \count($new) > 1) {
  979.                         $preSharedParts = $k > 0 ? \array_slice($before, 0, $k) : [];
  980.                         $postSharedParts = $k > 0 ? \array_slice($before, $k) : $before;
  982.                         list($betweenSharedParts, $nonBreakabl2) = $this->extractRelationshipFromFragment($afterBefore);
  984.                         $result2 = array_merge(
  985.                             $preSharedParts,
  986.                             $betweenSharedParts,
  987.                             $postSharedParts,
  988.                             $nonBreakabl2,
  989.                             $nonBreakableBefore,
  990.                             $replacement,
  991.                             $after
  992.                         );
  994.                         $this->pushOrMergeExtentedSelector($out, $result2);
  995.                     }
  996.                 }
  997.             }
  998.             array_pop($partsPile);
  999.         }
  1001.         while (\count($outRecurs)) {
  1002.             $result = array_shift($outRecurs);
  1003.             $this->pushOrMergeExtentedSelector($out, $result);
  1004.         }
  1005.     }
  1007.     /**
  1008.      * Test a part for being a pseudo selector
  1009.      *
  1010.      * @param string $part
  1011.      * @param array  $matches
  1012.      *
  1013.      * @return bool
  1014.      */
  1015.     protected function isPseudoSelector($part, &$matches)
  1016.     {
  1017.         if (
  1018.             strpos($part, ':') === 0 &&
  1019.             preg_match(",^::?([\w-]+)\((.+)\)$,", $part, $matches)
  1020.         ) {
  1021.             return true;
  1022.         }
  1024.         return false;
  1025.     }
  1027.     /**
  1028.      * Push extended selector except if
  1029.      *  - this is a pseudo selector
  1030.      *  - same as previous
  1031.      *  - in a white list
  1032.      * in this case we merge the pseudo selector content
  1033.      *
  1034.      * @param array $out
  1035.      * @param array $extended
  1036.      *
  1037.      * @return void
  1038.      */
  1039.     protected function pushOrMergeExtentedSelector(&$out, $extended)
  1040.     {
  1041.         if (\count($out) && \count($extended) === 1 && \count(reset($extended)) === 1) {
  1042.             $single = reset($extended);
  1043.             $part = reset($single);
  1045.             if (
  1046.                 $this->isPseudoSelector($part, $matchesExtended) &&
  1047.                 \in_array($matchesExtended[1], [ 'slotted' ])
  1048.             ) {
  1049.                 $prev = end($out);
  1050.                 $prev = $this->glueFunctionSelectors($prev);
  1052.                 if (\count($prev) === 1 && \count(reset($prev)) === 1) {
  1053.                     $single = reset($prev);
  1054.                     $part = reset($single);
  1056.                     if (
  1057.                         $this->isPseudoSelector($part, $matchesPrev) &&
  1058.                         $matchesPrev[1] === $matchesExtended[1]
  1059.                     ) {
  1060.                         $extended = explode($matchesExtended[1] . '(', $matchesExtended[0], 2);
  1061.                         $extended[1] = $matchesPrev[2] . ', ' . $extended[1];
  1062.                         $extended = implode($matchesExtended[1] . '(', $extended);
  1063.                         $extended = [ [ $extended ]];
  1064.                         array_pop($out);
  1065.                     }
  1066.                 }
  1067.             }
  1068.         }
  1069.         $out[] = $extended;
  1070.     }
  1072.     /**
  1073.      * Match extends single
  1074.      *
  1075.      * @param array $rawSingle
  1076.      * @param array $outOrigin
  1077.      * @param bool  $initial
  1078.      *
  1079.      * @return bool
  1080.      */
  1081.     protected function matchExtendsSingle($rawSingle, &$outOrigin, $initial = true)
  1082.     {
  1083.         $counts = [];
  1084.         $single = [];
  1086.         // simple usual cases, no need to do the whole trick
  1087.         if (\in_array($rawSingle, [['>'],['+'],['~']])) {
  1088.             return false;
  1089.         }
  1091.         foreach ($rawSingle as $part) {
  1092.             // matches Number
  1093.             if (! \is_string($part)) {
  1094.                 return false;
  1095.             }
  1097.             if (! preg_match('/^[\[.:#%]/', $part) && \count($single)) {
  1098.                 $single[\count($single) - 1] .= $part;
  1099.             } else {
  1100.                 $single[] = $part;
  1101.             }
  1102.         }
  1104.         $extendingDecoratedTag = false;
  1106.         if (\count($single) > 1) {
  1107.             $matches = null;
  1108.             $extendingDecoratedTag = preg_match('/^[a-z0-9]+$/i', $single[0], $matches) ? $matches[0] : false;
  1109.         }
  1111.         $outOrigin = [];
  1112.         $found = false;
  1114.         foreach ($single as $k => $part) {
  1115.             if (isset($this->extendsMap[$part])) {
  1116.                 foreach ($this->extendsMap[$part] as $idx) {
  1117.                     $counts[$idx] = isset($counts[$idx]) ? $counts[$idx] + 1 : 1;
  1118.                 }
  1119.             }
  1121.             if (
  1122.                 $initial &&
  1123.                 $this->isPseudoSelector($part, $matches) &&
  1124.                 ! \in_array($matches[1], [ 'not' ])
  1125.             ) {
  1126.                 $buffer    = $matches[2];
  1127.                 $parser    = $this->parserFactory(__METHOD__);
  1129.                 if ($parser->parseSelector($buffer, $subSelectors, false)) {
  1130.                     foreach ($subSelectors as $ksub => $subSelector) {
  1131.                         $subExtended = [];
  1132.                         $this->matchExtends($subSelector, $subExtended, 0, false);
  1134.                         if ($subExtended) {
  1135.                             $subSelectorsExtended = $subSelectors;
  1136.                             $subSelectorsExtended[$ksub] = $subExtended;
  1138.                             foreach ($subSelectorsExtended as $ksse => $sse) {
  1139.                                 $subSelectorsExtended[$ksse] = $this->collapseSelectors($sse);
  1140.                             }
  1142.                             $subSelectorsExtended = implode(', ', $subSelectorsExtended);
  1143.                             $singleExtended = $single;
  1144.                             $singleExtended[$k] = str_replace('(' . $buffer . ')', "($subSelectorsExtended)", $part);
  1145.                             $outOrigin[] = [ $singleExtended ];
  1146.                             $found = true;
  1147.                         }
  1148.                     }
  1149.                 }
  1150.             }
  1151.         }
  1153.         foreach ($counts as $idx => $count) {
  1154.             list($target, $origin, /* $block */) = $this->extends[$idx];
  1156.             $origin = $this->glueFunctionSelectors($origin);
  1158.             // check count
  1159.             if ($count !== \count($target)) {
  1160.                 continue;
  1161.             }
  1163.             $this->extends[$idx][3] = true;
  1165.             $rem = array_diff($single, $target);
  1167.             foreach ($origin as $j => $new) {
  1168.                 // prevent infinite loop when target extends itself
  1169.                 if ($this->isSelfExtend($single, $origin) && ! $initial) {
  1170.                     return false;
  1171.                 }
  1173.                 $replacement = end($new);
  1175.                 // Extending a decorated tag with another tag is not possible.
  1176.                 if (
  1177.                     $extendingDecoratedTag && $replacement[0] != $extendingDecoratedTag &&
  1178.                     preg_match('/^[a-z0-9]+$/i', $replacement[0])
  1179.                 ) {
  1180.                     unset($origin[$j]);
  1181.                     continue;
  1182.                 }
  1184.                 $combined = $this->combineSelectorSingle($replacement, $rem);
  1186.                 if (\count(array_diff($combined, $origin[$j][\count($origin[$j]) - 1]))) {
  1187.                     $origin[$j][\count($origin[$j]) - 1] = $combined;
  1188.                 }
  1189.             }
  1191.             $outOrigin = array_merge($outOrigin, $origin);
  1193.             $found = true;
  1194.         }
  1196.         return $found;
  1197.     }
  1199.     /**
  1200.      * Extract a relationship from the fragment.
  1201.      *
  1202.      * When extracting the last portion of a selector we will be left with a
  1203.      * fragment which may end with a direction relationship combinator. This
  1204.      * method will extract the relationship fragment and return it along side
  1205.      * the rest.
  1206.      *
  1207.      * @param array $fragment The selector fragment maybe ending with a direction relationship combinator.
  1208.      *
  1209.      * @return array The selector without the relationship fragment if any, the relationship fragment.
  1210.      */
  1211.     protected function extractRelationshipFromFragment(array $fragment)
  1212.     {
  1213.         $parents = [];
  1214.         $children = [];
  1216.         $j = $i = \count($fragment);
  1218.         for (;;) {
  1219.             $children = $j != $i ? \array_slice($fragment, $j, $i - $j) : [];
  1220.             $parents  = \array_slice($fragment, 0, $j);
  1221.             $slice    = end($parents);
  1223.             if (empty($slice) || ! $this->isImmediateRelationshipCombinator($slice[0])) {
  1224.                 break;
  1225.             }
  1227.             $j -= 2;
  1228.         }
  1230.         return [$parents, $children];
  1231.     }
  1233.     /**
  1234.      * Combine selector single
  1235.      *
  1236.      * @param array $base
  1237.      * @param array $other
  1238.      *
  1239.      * @return array
  1240.      */
  1241.     protected function combineSelectorSingle($base, $other)
  1242.     {
  1243.         $tag    = [];
  1244.         $out    = [];
  1245.         $wasTag = false;
  1246.         $pseudo = [];
  1248.         while (\count($other) && strpos(end($other), ':') === 0) {
  1249.             array_unshift($pseudo, array_pop($other));
  1250.         }
  1252.         foreach ([array_reverse($base), array_reverse($other)] as $single) {
  1253.             $rang = count($single);
  1255.             foreach ($single as $part) {
  1256.                 if (preg_match('/^[\[:]/', $part)) {
  1257.                     $out[] = $part;
  1258.                     $wasTag = false;
  1259.                 } elseif (preg_match('/^[\.#]/', $part)) {
  1260.                     array_unshift($out, $part);
  1261.                     $wasTag = false;
  1262.                 } elseif (preg_match('/^[^_-]/', $part) && $rang === 1) {
  1263.                     $tag[] = $part;
  1264.                     $wasTag = true;
  1265.                 } elseif ($wasTag) {
  1266.                     $tag[\count($tag) - 1] .= $part;
  1267.                 } else {
  1268.                     array_unshift($out, $part);
  1269.                 }
  1270.                 $rang--;
  1271.             }
  1272.         }
  1274.         if (\count($tag)) {
  1275.             array_unshift($out, $tag[0]);
  1276.         }
  1278.         while (\count($pseudo)) {
  1279.             $out[] = array_shift($pseudo);
  1280.         }
  1282.         return $out;
  1283.     }
  1285.     /**
  1286.      * Compile media
  1287.      *
  1288.      * @param \ScssPhp\ScssPhp\Block $media
  1289.      *
  1290.      * @return void
  1291.      */
  1292.     protected function compileMedia(Block $media)
  1293.     {
  1294.         assert($media instanceof MediaBlock);
  1295.         $this->pushEnv($media);
  1297.         $mediaQueries = $this->compileMediaQuery($this->multiplyMedia($this->env));
  1299.         if (! empty($mediaQueries)) {
  1300.             assert($this->scope !== null);
  1301.             $previousScope = $this->scope;
  1302.             $parentScope = $this->mediaParent($this->scope);
  1304.             foreach ($mediaQueries as $mediaQuery) {
  1305.                 $this->scope = $this->makeOutputBlock(Type::T_MEDIA, [$mediaQuery]);
  1307.                 $parentScope->children[] = $this->scope;
  1308.                 $parentScope = $this->scope;
  1309.             }
  1311.             // top level properties in a media cause it to be wrapped
  1312.             $needsWrap = false;
  1314.             foreach ($media->children as $child) {
  1315.                 $type = $child[0];
  1317.                 if (
  1318.                     $type !== Type::T_BLOCK &&
  1319.                     $type !== Type::T_MEDIA &&
  1320.                     $type !== Type::T_DIRECTIVE &&
  1321.                     $type !== Type::T_IMPORT
  1322.                 ) {
  1323.                     $needsWrap = true;
  1324.                     break;
  1325.                 }
  1326.             }
  1328.             if ($needsWrap) {
  1329.                 $wrapped = new Block();
  1330.                 $wrapped->sourceName   = $media->sourceName;
  1331.                 $wrapped->sourceIndex  = $media->sourceIndex;
  1332.                 $wrapped->sourceLine   = $media->sourceLine;
  1333.                 $wrapped->sourceColumn = $media->sourceColumn;
  1334.                 $wrapped->selectors    = [];
  1335.                 $wrapped->comments     = [];
  1336.                 $wrapped->parent       = $media;
  1337.                 $wrapped->children     = $media->children;
  1339.                 $media->children = [[Type::T_BLOCK, $wrapped]];
  1340.             }
  1342.             $this->compileChildrenNoReturn($media->children, $this->scope);
  1344.             $this->scope = $previousScope;
  1345.         }
  1347.         $this->popEnv();
  1348.     }
  1350.     /**
  1351.      * Media parent
  1352.      *
  1353.      * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $scope
  1354.      *
  1355.      * @return \ScssPhp\ScssPhp\Formatter\OutputBlock
  1356.      */
  1357.     protected function mediaParent(OutputBlock $scope)
  1358.     {
  1359.         while (! empty($scope->parent)) {
  1360.             if (! empty($scope->type) && $scope->type !== Type::T_MEDIA) {
  1361.                 break;
  1362.             }
  1364.             $scope = $scope->parent;
  1365.         }
  1367.         return $scope;
  1368.     }
  1370.     /**
  1371.      * Compile directive
  1372.      *
  1373.      * @param DirectiveBlock|array                   $directive
  1374.      * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
  1375.      *
  1376.      * @return void
  1377.      */
  1378.     protected function compileDirective($directive, OutputBlock $out)
  1379.     {
  1380.         if (\is_array($directive)) {
  1381.             $directiveName = $this->compileDirectiveName($directive[0]);
  1382.             $s = '@' . $directiveName;
  1384.             if (! empty($directive[1])) {
  1385.                 $s .= ' ' . $this->compileValue($directive[1]);
  1386.             }
  1387.             // sass-spec compliance on newline after directives, a bit tricky :/
  1388.             $appendNewLine = (! empty($directive[2]) || strpos($s, "\n")) ? "\n" : "";
  1389.             if (\is_array($directive[0]) && empty($directive[1])) {
  1390.                 $appendNewLine = "\n";
  1391.             }
  1393.             if (empty($directive[3])) {
  1394.                 $this->appendRootDirective($s . ';' . $appendNewLine, $out, [Type::T_COMMENT, Type::T_DIRECTIVE]);
  1395.             } else {
  1396.                 $this->appendOutputLine($out, Type::T_DIRECTIVE, $s . ';');
  1397.             }
  1398.         } else {
  1399.             $directive->name = $this->compileDirectiveName($directive->name);
  1400.             $s = '@' . $directive->name;
  1402.             if (! empty($directive->value)) {
  1403.                 $s .= ' ' . $this->compileValue($directive->value);
  1404.             }
  1406.             if ($directive->name === 'keyframes' || substr($directive->name, -10) === '-keyframes') {
  1407.                 $this->compileKeyframeBlock($directive, [$s]);
  1408.             } else {
  1409.                 $this->compileNestedBlock($directive, [$s]);
  1410.             }
  1411.         }
  1412.     }
  1414.     /**
  1415.      * directive names can include some interpolation
  1416.      *
  1417.      * @param string|array $directiveName
  1418.      * @return string
  1419.      * @throws CompilerException
  1420.      */
  1421.     protected function compileDirectiveName($directiveName)
  1422.     {
  1423.         if (is_string($directiveName)) {
  1424.             return $directiveName;
  1425.         }
  1427.         return $this->compileValue($directiveName);
  1428.     }
  1430.     /**
  1431.      * Compile at-root
  1432.      *
  1433.      * @param \ScssPhp\ScssPhp\Block $block
  1434.      *
  1435.      * @return void
  1436.      */
  1437.     protected function compileAtRoot(Block $block)
  1438.     {
  1439.         assert($block instanceof AtRootBlock);
  1440.         $env     = $this->pushEnv($block);
  1441.         $envs    = $this->compactEnv($env);
  1442.         list($with, $without) = $this->compileWith(isset($block->with) ? $block->with : null);
  1444.         // wrap inline selector
  1445.         if ($block->selector) {
  1446.             $wrapped = new Block();
  1447.             $wrapped->sourceName   = $block->sourceName;
  1448.             $wrapped->sourceIndex  = $block->sourceIndex;
  1449.             $wrapped->sourceLine   = $block->sourceLine;
  1450.             $wrapped->sourceColumn = $block->sourceColumn;
  1451.             $wrapped->selectors    = $block->selector;
  1452.             $wrapped->comments     = [];
  1453.             $wrapped->parent       = $block;
  1454.             $wrapped->children     = $block->children;
  1455.             $wrapped->selfParent   = $block->selfParent;
  1457.             $block->children = [[Type::T_BLOCK, $wrapped]];
  1458.             $block->selector = null;
  1459.         }
  1461.         $selfParent = $block->selfParent;
  1462.         assert($selfParent !== null, 'at-root blocks must have a selfParent set.');
  1464.         if (
  1465.             ! $selfParent->selectors &&
  1466.             isset($block->parent) &&
  1467.             isset($block->parent->selectors) && $block->parent->selectors
  1468.         ) {
  1469.             $selfParent = $block->parent;
  1470.         }
  1472.         $this->env = $this->filterWithWithout($envs, $with, $without);
  1474.         assert($this->scope !== null);
  1475.         $saveScope   = $this->scope;
  1476.         $this->scope = $this->filterScopeWithWithout($saveScope, $with, $without);
  1478.         // propagate selfParent to the children where they still can be useful
  1479.         $this->compileChildrenNoReturn($block->children, $this->scope, $selfParent);
  1481.         assert($this->scope !== null);
  1482.         $this->completeScope($this->scope, $saveScope);
  1483.         $this->scope = $saveScope;
  1484.         $this->env   = $this->extractEnv($envs);
  1486.         $this->popEnv();
  1487.     }
  1489.     /**
  1490.      * Filter at-root scope depending on with/without option
  1491.      *
  1492.      * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $scope
  1493.      * @param array                                  $with
  1494.      * @param array                                  $without
  1495.      *
  1496.      * @return OutputBlock
  1497.      */
  1498.     protected function filterScopeWithWithout($scope, $with, $without)
  1499.     {
  1500.         $filteredScopes = [];
  1501.         $childStash = [];
  1503.         if ($scope->type === Type::T_ROOT) {
  1504.             return $scope;
  1505.         }
  1506.         assert($this->rootBlock !== null);
  1508.         // start from the root
  1509.         while ($scope->parent && $scope->parent->type !== Type::T_ROOT) {
  1510.             array_unshift($childStash, $scope);
  1511.             $scope = $scope->parent;
  1512.         }
  1514.         for (;;) {
  1515.             if (! $scope) {
  1516.                 break;
  1517.             }
  1519.             if ($this->isWith($scope, $with, $without)) {
  1520.                 $s = clone $scope;
  1521.                 $s->children = [];
  1522.                 $s->lines    = [];
  1523.                 $s->parent   = null;
  1525.                 if ($s->type !== Type::T_MEDIA && $s->type !== Type::T_DIRECTIVE) {
  1526.                     $s->selectors = [];
  1527.                 }
  1529.                 $filteredScopes[] = $s;
  1530.             }
  1532.             if (\count($childStash)) {
  1533.                 $scope = array_shift($childStash);
  1534.             } elseif ($scope->children) {
  1535.                 $scope = end($scope->children);
  1536.             } else {
  1537.                 $scope = null;
  1538.             }
  1539.         }
  1541.         if (! \count($filteredScopes)) {
  1542.             return $this->rootBlock;
  1543.         }
  1545.         $newScope = array_shift($filteredScopes);
  1546.         $newScope->parent = $this->rootBlock;
  1548.         $this->rootBlock->children[] = $newScope;
  1550.         $p = &$newScope;
  1552.         while (\count($filteredScopes)) {
  1553.             $s = array_shift($filteredScopes);
  1554.             $s->parent = $p;
  1555.             $p->children[] = $s;
  1556.             $newScope = &$p->children[0];
  1557.             $p = &$p->children[0];
  1558.         }
  1560.         return $newScope;
  1561.     }
  1563.     /**
  1564.      * found missing selector from a at-root compilation in the previous scope
  1565.      * (if at-root is just enclosing a property, the selector is in the parent tree)
  1566.      *
  1567.      * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $scope
  1568.      * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $previousScope
  1569.      *
  1570.      * @return OutputBlock
  1571.      */
  1572.     protected function completeScope($scope, $previousScope)
  1573.     {
  1574.         if (! $scope->type && ! $scope->selectors && \count($scope->lines)) {
  1575.             $scope->selectors = $this->findScopeSelectors($previousScope, $scope->depth);
  1576.         }
  1578.         if ($scope->children) {
  1579.             foreach ($scope->children as $k => $c) {
  1580.                 $scope->children[$k] = $this->completeScope($c, $previousScope);
  1581.             }
  1582.         }
  1584.         return $scope;
  1585.     }
  1587.     /**
  1588.      * Find a selector by the depth node in the scope
  1589.      *
  1590.      * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $scope
  1591.      * @param int                                    $depth
  1592.      *
  1593.      * @return array
  1594.      */
  1595.     protected function findScopeSelectors($scope, $depth)
  1596.     {
  1597.         if ($scope->depth === $depth && $scope->selectors) {
  1598.             return $scope->selectors;
  1599.         }
  1601.         if ($scope->children) {
  1602.             foreach (array_reverse($scope->children) as $c) {
  1603.                 if ($s = $this->findScopeSelectors($c, $depth)) {
  1604.                     return $s;
  1605.                 }
  1606.             }
  1607.         }
  1609.         return [];
  1610.     }
  1612.     /**
  1613.      * Compile @at-root's with: inclusion / without: exclusion into 2 lists uses to filter scope/env later
  1614.      *
  1615.      * @param array|null $withCondition
  1616.      *
  1617.      * @return array
  1618.      *
  1619.      * @phpstan-return array{array<string, bool>, array<string, bool>}
  1620.      */
  1621.     protected function compileWith($withCondition)
  1622.     {
  1623.         // just compile what we have in 2 lists
  1624.         $with = [];
  1625.         $without = ['rule' => true];
  1627.         if ($withCondition) {
  1628.             if ($withCondition[0] === Type::T_INTERPOLATE) {
  1629.                 $w = $this->compileValue($withCondition);
  1631.                 $buffer = "($w)";
  1632.                 $parser = $this->parserFactory(__METHOD__);
  1634.                 if ($parser->parseValue($buffer, $reParsedWith)) {
  1635.                     $withCondition = $reParsedWith;
  1636.                 }
  1637.             }
  1639.             $withConfig = $this->mapGet($withCondition, static::$with);
  1640.             if ($withConfig !== null) {
  1641.                 $without = []; // cancel the default
  1642.                 $list = $this->coerceList($withConfig);
  1644.                 foreach ($list[2] as $item) {
  1645.                     $keyword = $this->compileStringContent($this->coerceString($item));
  1647.                     $with[$keyword] = true;
  1648.                 }
  1649.             }
  1651.             $withoutConfig = $this->mapGet($withCondition, static::$without);
  1652.             if ($withoutConfig !== null) {
  1653.                 $without = []; // cancel the default
  1654.                 $list = $this->coerceList($withoutConfig);
  1656.                 foreach ($list[2] as $item) {
  1657.                     $keyword = $this->compileStringContent($this->coerceString($item));
  1659.                     $without[$keyword] = true;
  1660.                 }
  1661.             }
  1662.         }
  1664.         return [$with, $without];
  1665.     }
  1667.     /**
  1668.      * Filter env stack
  1669.      *
  1670.      * @param Environment[] $envs
  1671.      * @param array $with
  1672.      * @param array $without
  1673.      *
  1674.      * @return Environment
  1675.      *
  1676.      * @phpstan-param  non-empty-array<Environment> $envs
  1677.      */
  1678.     protected function filterWithWithout($envs, $with, $without)
  1679.     {
  1680.         $filtered = [];
  1682.         foreach ($envs as $e) {
  1683.             if ($e->block && ! $this->isWith($e->block, $with, $without)) {
  1684.                 $ec = clone $e;
  1685.                 $ec->block     = null;
  1686.                 $ec->selectors = [];
  1688.                 $filtered[] = $ec;
  1689.             } else {
  1690.                 $filtered[] = $e;
  1691.             }
  1692.         }
  1694.         return $this->extractEnv($filtered);
  1695.     }
  1697.     /**
  1698.      * Filter WITH rules
  1699.      *
  1700.      * @param \ScssPhp\ScssPhp\Block|\ScssPhp\ScssPhp\Formatter\OutputBlock $block
  1701.      * @param array                                                         $with
  1702.      * @param array                                                         $without
  1703.      *
  1704.      * @return bool
  1705.      */
  1706.     protected function isWith($block, $with, $without)
  1707.     {
  1708.         if (isset($block->type)) {
  1709.             if ($block->type === Type::T_MEDIA) {
  1710.                 return $this->testWithWithout('media', $with, $without);
  1711.             }
  1713.             if ($block->type === Type::T_DIRECTIVE) {
  1714.                 assert($block instanceof DirectiveBlock || $block instanceof OutputBlock);
  1715.                 if (isset($block->name)) {
  1716.                     return $this->testWithWithout($this->compileDirectiveName($block->name), $with, $without);
  1717.                 } elseif (isset($block->selectors) && preg_match(',@(\w+),ims', json_encode($block->selectors), $m)) {
  1718.                     return $this->testWithWithout($m[1], $with, $without);
  1719.                 } else {
  1720.                     return $this->testWithWithout('???', $with, $without);
  1721.                 }
  1722.             }
  1723.         } elseif (isset($block->selectors)) {
  1724.             // a selector starting with number is a keyframe rule
  1725.             if (\count($block->selectors)) {
  1726.                 $s = reset($block->selectors);
  1728.                 while (\is_array($s)) {
  1729.                     $s = reset($s);
  1730.                 }
  1732.                 if (\is_object($s) && $s instanceof Number) {
  1733.                     return $this->testWithWithout('keyframes', $with, $without);
  1734.                 }
  1735.             }
  1737.             return $this->testWithWithout('rule', $with, $without);
  1738.         }
  1740.         return true;
  1741.     }
  1743.     /**
  1744.      * Test a single type of block against with/without lists
  1745.      *
  1746.      * @param string $what
  1747.      * @param array  $with
  1748.      * @param array  $without
  1749.      *
  1750.      * @return bool
  1751.      *   true if the block should be kept, false to reject
  1752.      */
  1753.     protected function testWithWithout($what, $with, $without)
  1754.     {
  1755.         // if without, reject only if in the list (or 'all' is in the list)
  1756.         if (\count($without)) {
  1757.             return (isset($without[$what]) || isset($without['all'])) ? false : true;
  1758.         }
  1760.         // otherwise reject all what is not in the with list
  1761.         return (isset($with[$what]) || isset($with['all'])) ? true : false;
  1762.     }
  1765.     /**
  1766.      * Compile keyframe block
  1767.      *
  1768.      * @param \ScssPhp\ScssPhp\Block $block
  1769.      * @param string[]               $selectors
  1770.      *
  1771.      * @return void
  1772.      */
  1773.     protected function compileKeyframeBlock(Block $block, $selectors)
  1774.     {
  1775.         $env = $this->pushEnv($block);
  1777.         $envs = $this->compactEnv($env);
  1779.         $this->env = $this->extractEnv(array_filter($envs, function (Environment $e) {
  1780.             return ! isset($e->block->selectors);
  1781.         }));
  1783.         $this->scope = $this->makeOutputBlock($block->type, $selectors);
  1784.         $this->scope->depth = 1;
  1785.         assert($this->scope->parent !== null);
  1786.         $this->scope->parent->children[] = $this->scope;
  1788.         $this->compileChildrenNoReturn($block->children, $this->scope);
  1790.         assert($this->scope !== null);
  1791.         $this->scope = $this->scope->parent;
  1792.         $this->env   = $this->extractEnv($envs);
  1794.         $this->popEnv();
  1795.     }
  1797.     /**
  1798.      * Compile nested properties lines
  1799.      *
  1800.      * @param \ScssPhp\ScssPhp\Block                 $block
  1801.      * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
  1802.      *
  1803.      * @return void
  1804.      */
  1805.     protected function compileNestedPropertiesBlock(Block $block, OutputBlock $out)
  1806.     {
  1807.         assert($block instanceof NestedPropertyBlock);
  1808.         $prefix = $this->compileValue($block->prefix) . '-';
  1810.         $nested = $this->makeOutputBlock($block->type);
  1811.         $nested->parent = $out;
  1813.         if ($block->hasValue) {
  1814.             $nested->depth = $out->depth + 1;
  1815.         }
  1817.         $out->children[] = $nested;
  1819.         foreach ($block->children as $child) {
  1820.             switch ($child[0]) {
  1821.                 case Type::T_ASSIGN:
  1822.                     array_unshift($child[1][2], $prefix);
  1823.                     break;
  1825.                 case Type::T_NESTED_PROPERTY:
  1826.                     assert($child[1] instanceof NestedPropertyBlock);
  1827.                     array_unshift($child[1]->prefix[2], $prefix);
  1828.                     break;
  1829.             }
  1831.             $this->compileChild($child, $nested);
  1832.         }
  1833.     }
  1835.     /**
  1836.      * Compile nested block
  1837.      *
  1838.      * @param \ScssPhp\ScssPhp\Block $block
  1839.      * @param string[]               $selectors
  1840.      *
  1841.      * @return void
  1842.      */
  1843.     protected function compileNestedBlock(Block $block, $selectors)
  1844.     {
  1845.         $this->pushEnv($block);
  1847.         $this->scope = $this->makeOutputBlock($block->type, $selectors);
  1848.         assert($this->scope->parent !== null);
  1849.         $this->scope->parent->children[] = $this->scope;
  1851.         // wrap assign children in a block
  1852.         // except for @font-face
  1853.         if (!$block instanceof DirectiveBlock || $this->compileDirectiveName($block->name) !== 'font-face') {
  1854.             // need wrapping?
  1855.             $needWrapping = false;
  1857.             foreach ($block->children as $child) {
  1858.                 if ($child[0] === Type::T_ASSIGN) {
  1859.                     $needWrapping = true;
  1860.                     break;
  1861.                 }
  1862.             }
  1864.             if ($needWrapping) {
  1865.                 $wrapped = new Block();
  1866.                 $wrapped->sourceName   = $block->sourceName;
  1867.                 $wrapped->sourceIndex  = $block->sourceIndex;
  1868.                 $wrapped->sourceLine   = $block->sourceLine;
  1869.                 $wrapped->sourceColumn = $block->sourceColumn;
  1870.                 $wrapped->selectors    = [];
  1871.                 $wrapped->comments     = [];
  1872.                 $wrapped->parent       = $block;
  1873.                 $wrapped->children     = $block->children;
  1874.                 $wrapped->selfParent   = $block->selfParent;
  1876.                 $block->children = [[Type::T_BLOCK, $wrapped]];
  1877.             }
  1878.         }
  1880.         $this->compileChildrenNoReturn($block->children, $this->scope);
  1882.         assert($this->scope !== null);
  1883.         $this->scope = $this->scope->parent;
  1885.         $this->popEnv();
  1886.     }
  1888.     /**
  1889.      * Recursively compiles a block.
  1890.      *
  1891.      * A block is analogous to a CSS block in most cases. A single SCSS document
  1892.      * is encapsulated in a block when parsed, but it does not have parent tags
  1893.      * so all of its children appear on the root level when compiled.
  1894.      *
  1895.      * Blocks are made up of selectors and children.
  1896.      *
  1897.      * The children of a block are just all the blocks that are defined within.
  1898.      *
  1899.      * Compiling the block involves pushing a fresh environment on the stack,
  1900.      * and iterating through the props, compiling each one.
  1901.      *
  1902.      * @see Compiler::compileChild()
  1903.      *
  1904.      * @param \ScssPhp\ScssPhp\Block $block
  1905.      *
  1906.      * @return void
  1907.      */
  1908.     protected function compileBlock(Block $block)
  1909.     {
  1910.         $env = $this->pushEnv($block);
  1911.         assert($block->selectors !== null);
  1912.         $env->selectors = $this->evalSelectors($block->selectors);
  1914.         $out = $this->makeOutputBlock(null);
  1916.         assert($this->scope !== null);
  1917.         $this->scope->children[] = $out;
  1919.         if (\count($block->children)) {
  1920.             $out->selectors = $this->multiplySelectors($env, $block->selfParent);
  1922.             // propagate selfParent to the children where they still can be useful
  1923.             $selfParentSelectors = null;
  1925.             if (isset($block->selfParent->selectors)) {
  1926.                 $selfParentSelectors = $block->selfParent->selectors;
  1927.                 $block->selfParent->selectors = $out->selectors;
  1928.             }
  1930.             $this->compileChildrenNoReturn($block->children, $out, $block->selfParent);
  1932.             // and revert for the following children of the same block
  1933.             if ($selfParentSelectors) {
  1934.                 assert($block->selfParent !== null);
  1935.                 $block->selfParent->selectors = $selfParentSelectors;
  1936.             }
  1937.         }
  1939.         $this->popEnv();
  1940.     }
  1943.     /**
  1944.      * Compile the value of a comment that can have interpolation
  1945.      *
  1946.      * @param array $value
  1947.      * @param bool  $pushEnv
  1948.      *
  1949.      * @return string
  1950.      */
  1951.     protected function compileCommentValue($value, $pushEnv = false)
  1952.     {
  1953.         $c = $value[1];
  1955.         if (isset($value[2])) {
  1956.             if ($pushEnv) {
  1957.                 $this->pushEnv();
  1958.             }
  1960.             try {
  1961.                 $c = $this->compileValue($value[2]);
  1962.             } catch (SassScriptException $e) {
  1963.                 $this->logger->warn('Ignoring interpolation errors in multiline comments is deprecated and will be removed in ScssPhp 2.0. ' . $this->addLocationToMessage($e->getMessage()), true);
  1964.                 // ignore error in comment compilation which are only interpolation
  1965.             } catch (SassException $e) {
  1966.                 $this->logger->warn('Ignoring interpolation errors in multiline comments is deprecated and will be removed in ScssPhp 2.0. ' . $e->getMessage(), true);
  1967.                 // ignore error in comment compilation which are only interpolation
  1968.             }
  1970.             if ($pushEnv) {
  1971.                 $this->popEnv();
  1972.             }
  1973.         }
  1975.         return $c;
  1976.     }
  1978.     /**
  1979.      * Compile root level comment
  1980.      *
  1981.      * @param array $block
  1982.      *
  1983.      * @return void
  1984.      */
  1985.     protected function compileComment($block)
  1986.     {
  1987.         $out = $this->makeOutputBlock(Type::T_COMMENT);
  1988.         $out->lines[] = $this->compileCommentValue($block, true);
  1990.         assert($this->scope !== null);
  1991.         $this->scope->children[] = $out;
  1992.     }
  1994.     /**
  1995.      * Evaluate selectors
  1996.      *
  1997.      * @param array $selectors
  1998.      *
  1999.      * @return array
  2000.      */
  2001.     protected function evalSelectors($selectors)
  2002.     {
  2003.         $this->shouldEvaluate = false;
  2005.         $evaluatedSelectors = [];
  2006.         foreach ($selectors as $selector) {
  2007.             $evaluatedSelectors[] = $this->evalSelector($selector);
  2008.         }
  2009.         $selectors = $evaluatedSelectors;
  2011.         // after evaluating interpolates, we might need a second pass
  2012.         if ($this->shouldEvaluate) {
  2013.             $selectors = $this->replaceSelfSelector($selectors, '&');
  2014.             $buffer    = $this->collapseSelectors($selectors);
  2015.             $parser    = $this->parserFactory(__METHOD__);
  2017.             try {
  2018.                 $isValid = $parser->parseSelector($buffer, $newSelectors, true);
  2019.             } catch (ParserException $e) {
  2020.                 throw $this->error($e->getMessage());
  2021.             }
  2023.             if ($isValid) {
  2024.                 $selectors = array_map([$this, 'evalSelector'], $newSelectors);
  2025.             }
  2026.         }
  2028.         return $selectors;
  2029.     }
  2031.     /**
  2032.      * Evaluate selector
  2033.      *
  2034.      * @param array $selector
  2035.      *
  2036.      * @return array
  2037.      *
  2038.      * @phpstan-impure
  2039.      */
  2040.     protected function evalSelector($selector)
  2041.     {
  2042.         return array_map([$this, 'evalSelectorPart'], $selector);
  2043.     }
  2045.     /**
  2046.      * Evaluate selector part; replaces all the interpolates, stripping quotes
  2047.      *
  2048.      * @param array $part
  2049.      *
  2050.      * @return array
  2051.      *
  2052.      * @phpstan-impure
  2053.      */
  2054.     protected function evalSelectorPart($part)
  2055.     {
  2056.         foreach ($part as &$p) {
  2057.             if (\is_array($p) && ($p[0] === Type::T_INTERPOLATE || $p[0] === Type::T_STRING)) {
  2058.                 $p = $this->compileValue($p);
  2060.                 // force re-evaluation if self char or non standard char
  2061.                 if (preg_match(',[^\w-],', $p)) {
  2062.                     $this->shouldEvaluate = true;
  2063.                 }
  2064.             } elseif (
  2065.                 \is_string($p) && \strlen($p) >= 2 &&
  2066.                 ($p[0] === '"' || $p[0] === "'") &&
  2067.                 substr($p, -1) === $p[0]
  2068.             ) {
  2069.                 $p = substr($p, 1, -1);
  2070.             }
  2071.         }
  2073.         return $this->flattenSelectorSingle($part);
  2074.     }
  2076.     /**
  2077.      * Collapse selectors
  2078.      *
  2079.      * @param array $selectors
  2080.      *
  2081.      * @return string
  2082.      */
  2083.     protected function collapseSelectors($selectors)
  2084.     {
  2085.         $parts = [];
  2087.         foreach ($selectors as $selector) {
  2088.             $output = [];
  2090.             foreach ($selector as $node) {
  2091.                 $compound = '';
  2093.                 array_walk_recursive(
  2094.                     $node,
  2095.                     function ($value, $key) use (&$compound) {
  2096.                         $compound .= $value;
  2097.                     }
  2098.                 );
  2100.                 $output[] = $compound;
  2101.             }
  2103.             $parts[] = implode(' ', $output);
  2104.         }
  2106.         return implode(', ', $parts);
  2107.     }
  2109.     /**
  2110.      * Collapse selectors
  2111.      *
  2112.      * @param array $selectors
  2113.      *
  2114.      * @return array
  2115.      */
  2116.     private function collapseSelectorsAsList($selectors)
  2117.     {
  2118.         $parts = [];
  2120.         foreach ($selectors as $selector) {
  2121.             $output = [];
  2122.             $glueNext = false;
  2124.             foreach ($selector as $node) {
  2125.                 $compound = '';
  2127.                 array_walk_recursive(
  2128.                     $node,
  2129.                     function ($value, $key) use (&$compound) {
  2130.                         $compound .= $value;
  2131.                     }
  2132.                 );
  2134.                 if ($this->isImmediateRelationshipCombinator($compound)) {
  2135.                     if (\count($output)) {
  2136.                         $output[\count($output) - 1] .= ' ' . $compound;
  2137.                     } else {
  2138.                         $output[] = $compound;
  2139.                     }
  2141.                     $glueNext = true;
  2142.                 } elseif ($glueNext) {
  2143.                     $output[\count($output) - 1] .= ' ' . $compound;
  2144.                     $glueNext = false;
  2145.                 } else {
  2146.                     $output[] = $compound;
  2147.                 }
  2148.             }
  2150.             foreach ($output as &$o) {
  2151.                 $o = [Type::T_STRING, '', [$o]];
  2152.             }
  2154.             $parts[] = [Type::T_LIST, ' ', $output];
  2155.         }
  2157.         return [Type::T_LIST, ',', $parts];
  2158.     }
  2160.     /**
  2161.      * Parse down the selector and revert [self] to "&" before a reparsing
  2162.      *
  2163.      * @param array       $selectors
  2164.      * @param string|null $replace
  2165.      *
  2166.      * @return array
  2167.      */
  2168.     protected function replaceSelfSelector($selectors, $replace = null)
  2169.     {
  2170.         foreach ($selectors as &$part) {
  2171.             if (\is_array($part)) {
  2172.                 if ($part === [Type::T_SELF]) {
  2173.                     if (\is_null($replace)) {
  2174.                         $replace = $this->reduce([Type::T_SELF]);
  2175.                         $replace = $this->compileValue($replace);
  2176.                     }
  2177.                     $part = $replace;
  2178.                 } else {
  2179.                     $part = $this->replaceSelfSelector($part, $replace);
  2180.                 }
  2181.             }
  2182.         }
  2184.         return $selectors;
  2185.     }
  2187.     /**
  2188.      * Flatten selector single; joins together .classes and #ids
  2189.      *
  2190.      * @param array $single
  2191.      *
  2192.      * @return array
  2193.      */
  2194.     protected function flattenSelectorSingle($single)
  2195.     {
  2196.         $joined = [];
  2198.         foreach ($single as $part) {
  2199.             if (
  2200.                 empty($joined) ||
  2201.                 ! \is_string($part) ||
  2202.                 preg_match('/[\[.:#%]/', $part)
  2203.             ) {
  2204.                 $joined[] = $part;
  2205.                 continue;
  2206.             }
  2208.             if (\is_array(end($joined))) {
  2209.                 $joined[] = $part;
  2210.             } else {
  2211.                 $joined[\count($joined) - 1] .= $part;
  2212.             }
  2213.         }
  2215.         return $joined;
  2216.     }
  2218.     /**
  2219.      * Compile selector to string; self(&) should have been replaced by now
  2220.      *
  2221.      * @param string|array $selector
  2222.      *
  2223.      * @return string
  2224.      */
  2225.     protected function compileSelector($selector)
  2226.     {
  2227.         if (! \is_array($selector)) {
  2228.             return $selector; // media and the like
  2229.         }
  2231.         return implode(
  2232.             ' ',
  2233.             array_map(
  2234.                 [$this, 'compileSelectorPart'],
  2235.                 $selector
  2236.             )
  2237.         );
  2238.     }
  2240.     /**
  2241.      * Compile selector part
  2242.      *
  2243.      * @param array $piece
  2244.      *
  2245.      * @return string
  2246.      */
  2247.     protected function compileSelectorPart($piece)
  2248.     {
  2249.         foreach ($piece as &$p) {
  2250.             if (! \is_array($p)) {
  2251.                 continue;
  2252.             }
  2254.             switch ($p[0]) {
  2255.                 case Type::T_SELF:
  2256.                     $p = '&';
  2257.                     break;
  2259.                 default:
  2260.                     $p = $this->compileValue($p);
  2261.                     break;
  2262.             }
  2263.         }
  2265.         return implode($piece);
  2266.     }
  2268.     /**
  2269.      * Has selector placeholder?
  2270.      *
  2271.      * @param array $selector
  2272.      *
  2273.      * @return bool
  2274.      */
  2275.     protected function hasSelectorPlaceholder($selector)
  2276.     {
  2277.         if (! \is_array($selector)) {
  2278.             return false;
  2279.         }
  2281.         foreach ($selector as $parts) {
  2282.             foreach ($parts as $part) {
  2283.                 if (\strlen($part) && '%' === $part[0]) {
  2284.                     return true;
  2285.                 }
  2286.             }
  2287.         }
  2289.         return false;
  2290.     }
  2292.     /**
  2293.      * @param string $name
  2294.      *
  2295.      * @return void
  2296.      */
  2297.     protected function pushCallStack($name = '')
  2298.     {
  2299.         $this->callStack[] = [
  2300.           'n' => $name,
  2301.           Parser::SOURCE_INDEX => $this->sourceIndex,
  2302.           Parser::SOURCE_LINE => $this->sourceLine,
  2303.           Parser::SOURCE_COLUMN => $this->sourceColumn
  2304.         ];
  2306.         // infinite calling loop
  2307.         if (\count($this->callStack) > 25000) {
  2308.             // not displayed but you can var_dump it to deep debug
  2309.             $msg = $this->callStackMessage(true, 100);
  2310.             $msg = 'Infinite calling loop';
  2312.             throw $this->error($msg);
  2313.         }
  2314.     }
  2316.     /**
  2317.      * @return void
  2318.      */
  2319.     protected function popCallStack()
  2320.     {
  2321.         array_pop($this->callStack);
  2322.     }
  2324.     /**
  2325.      * Compile children and return result
  2326.      *
  2327.      * @param array                                  $stms
  2328.      * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
  2329.      * @param string                                 $traceName
  2330.      *
  2331.      * @return array|Number|null
  2332.      */
  2333.     protected function compileChildren($stms, OutputBlock $out, $traceName = '')
  2334.     {
  2335.         $this->pushCallStack($traceName);
  2337.         foreach ($stms as $stm) {
  2338.             $ret = $this->compileChild($stm, $out);
  2340.             if (isset($ret)) {
  2341.                 $this->popCallStack();
  2343.                 return $ret;
  2344.             }
  2345.         }
  2347.         $this->popCallStack();
  2349.         return null;
  2350.     }
  2352.     /**
  2353.      * Compile children and throw exception if unexpected at-return
  2354.      *
  2355.      * @param array[]                                $stms
  2356.      * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
  2357.      * @param \ScssPhp\ScssPhp\Block                 $selfParent
  2358.      * @param string                                 $traceName
  2359.      *
  2360.      * @return void
  2361.      *
  2362.      * @throws \Exception
  2363.      */
  2364.     protected function compileChildrenNoReturn($stms, OutputBlock $out, $selfParent = null, $traceName = '')
  2365.     {
  2366.         $this->pushCallStack($traceName);
  2368.         foreach ($stms as $stm) {
  2369.             if ($selfParent && isset($stm[1]) && \is_object($stm[1]) && $stm[1] instanceof Block) {
  2370.                 $oldSelfParent = $stm[1]->selfParent;
  2371.                 $stm[1]->selfParent = $selfParent;
  2372.                 $ret = $this->compileChild($stm, $out);
  2373.                 $stm[1]->selfParent = $oldSelfParent;
  2374.             } elseif ($selfParent && \in_array($stm[0], [Type::T_INCLUDE, Type::T_EXTEND])) {
  2375.                 $stm['selfParent'] = $selfParent;
  2376.                 $ret = $this->compileChild($stm, $out);
  2377.             } else {
  2378.                 $ret = $this->compileChild($stm, $out);
  2379.             }
  2381.             if (isset($ret)) {
  2382.                 throw $this->error('@return may only be used within a function');
  2383.             }
  2384.         }
  2386.         $this->popCallStack();
  2387.     }
  2390.     /**
  2391.      * evaluate media query : compile internal value keeping the structure unchanged
  2392.      *
  2393.      * @param array $queryList
  2394.      *
  2395.      * @return array
  2396.      */
  2397.     protected function evaluateMediaQuery($queryList)
  2398.     {
  2399.         static $parser = null;
  2401.         $outQueryList = [];
  2403.         foreach ($queryList as $kql => $query) {
  2404.             $shouldReparse = false;
  2406.             foreach ($query as $kq => $q) {
  2407.                 for ($i = 1; $i < \count($q); $i++) {
  2408.                     $value = $this->compileValue($q[$i]);
  2410.                     // the parser had no mean to know if media type or expression if it was an interpolation
  2411.                     // so you need to reparse if the T_MEDIA_TYPE looks like anything else a media type
  2412.                     if (
  2413.                         $q[0] == Type::T_MEDIA_TYPE &&
  2414.                         (strpos($value, '(') !== false ||
  2415.                         strpos($value, ')') !== false ||
  2416.                         strpos($value, ':') !== false ||
  2417.                         strpos($value, ',') !== false)
  2418.                     ) {
  2419.                         $shouldReparse = true;
  2420.                     }
  2422.                     $queryList[$kql][$kq][$i] = [Type::T_KEYWORD, $value];
  2423.                 }
  2424.             }
  2426.             if ($shouldReparse) {
  2427.                 if (\is_null($parser)) {
  2428.                     $parser = $this->parserFactory(__METHOD__);
  2429.                 }
  2431.                 $queryString = $this->compileMediaQuery([$queryList[$kql]]);
  2432.                 $queryString = reset($queryString);
  2434.                 if ($queryString !== false && strpos($queryString, '@media ') === 0) {
  2435.                     $queryString = substr($queryString, 7);
  2436.                     $queries = [];
  2438.                     if ($parser->parseMediaQueryList($queryString, $queries)) {
  2439.                         $queries = $this->evaluateMediaQuery($queries[2]);
  2441.                         while (\count($queries)) {
  2442.                             $outQueryList[] = array_shift($queries);
  2443.                         }
  2445.                         continue;
  2446.                     }
  2447.                 }
  2448.             }
  2450.             $outQueryList[] = $queryList[$kql];
  2451.         }
  2453.         return $outQueryList;
  2454.     }
  2456.     /**
  2457.      * Compile media query
  2458.      *
  2459.      * @param array $queryList
  2460.      *
  2461.      * @return string[]
  2462.      */
  2463.     protected function compileMediaQuery($queryList)
  2464.     {
  2465.         $start   = '@media ';
  2466.         $default = trim($start);
  2467.         $out     = [];
  2468.         $current = '';
  2470.         foreach ($queryList as $query) {
  2471.             $type = null;
  2472.             $parts = [];
  2474.             $mediaTypeOnly = true;
  2476.             foreach ($query as $q) {
  2477.                 if ($q[0] !== Type::T_MEDIA_TYPE) {
  2478.                     $mediaTypeOnly = false;
  2479.                     break;
  2480.                 }
  2481.             }
  2483.             foreach ($query as $q) {
  2484.                 switch ($q[0]) {
  2485.                     case Type::T_MEDIA_TYPE:
  2486.                         $newType = array_map([$this, 'compileValue'], \array_slice($q, 1));
  2488.                         // combining not and anything else than media type is too risky and should be avoided
  2489.                         if (! $mediaTypeOnly) {
  2490.                             if (\in_array(Type::T_NOT, $newType) || ($type && \in_array(Type::T_NOT, $type) )) {
  2491.                                 if ($type) {
  2492.                                     array_unshift($parts, implode(' ', array_filter($type)));
  2493.                                 }
  2495.                                 if (! empty($parts)) {
  2496.                                     if (\strlen($current)) {
  2497.                                         $current .= $this->formatter->tagSeparator;
  2498.                                     }
  2500.                                     $current .= implode(' and ', $parts);
  2501.                                 }
  2503.                                 if ($current) {
  2504.                                     $out[] = $start . $current;
  2505.                                 }
  2507.                                 $current = '';
  2508.                                 $type    = null;
  2509.                                 $parts   = [];
  2510.                             }
  2511.                         }
  2513.                         if ($newType === ['all'] && $default) {
  2514.                             $default = $start . 'all';
  2515.                         }
  2517.                         // all can be safely ignored and mixed with whatever else
  2518.                         if ($newType !== ['all']) {
  2519.                             if ($type) {
  2520.                                 $type = $this->mergeMediaTypes($type, $newType);
  2522.                                 if (empty($type)) {
  2523.                                     // merge failed : ignore this query that is not valid, skip to the next one
  2524.                                     $parts = [];
  2525.                                     $default = ''; // if everything fail, no @media at all
  2526.                                     continue 3;
  2527.                                 }
  2528.                             } else {
  2529.                                 $type = $newType;
  2530.                             }
  2531.                         }
  2532.                         break;
  2534.                     case Type::T_MEDIA_EXPRESSION:
  2535.                         if (isset($q[2])) {
  2536.                             $parts[] = '('
  2537.                                 . $this->compileValue($q[1])
  2538.                                 . $this->formatter->assignSeparator
  2539.                                 . $this->compileValue($q[2])
  2540.                                 . ')';
  2541.                         } else {
  2542.                             $parts[] = '('
  2543.                                 . $this->compileValue($q[1])
  2544.                                 . ')';
  2545.                         }
  2546.                         break;
  2548.                     case Type::T_MEDIA_VALUE:
  2549.                         $parts[] = $this->compileValue($q[1]);
  2550.                         break;
  2551.                 }
  2552.             }
  2554.             if ($type) {
  2555.                 array_unshift($parts, implode(' ', array_filter($type)));
  2556.             }
  2558.             if (! empty($parts)) {
  2559.                 if (\strlen($current)) {
  2560.                     $current .= $this->formatter->tagSeparator;
  2561.                 }
  2563.                 $current .= implode(' and ', $parts);
  2564.             }
  2565.         }
  2567.         if ($current) {
  2568.             $out[] = $start . $current;
  2569.         }
  2571.         // no @media type except all, and no conflict?
  2572.         if (! $out && $default) {
  2573.             $out[] = $default;
  2574.         }
  2576.         return $out;
  2577.     }
  2579.     /**
  2580.      * Merge direct relationships between selectors
  2581.      *
  2582.      * @param array $selectors1
  2583.      * @param array $selectors2
  2584.      *
  2585.      * @return array
  2586.      */
  2587.     protected function mergeDirectRelationships($selectors1, $selectors2)
  2588.     {
  2589.         if (empty($selectors1) || empty($selectors2)) {
  2590.             return array_merge($selectors1, $selectors2);
  2591.         }
  2593.         $part1 = end($selectors1);
  2594.         $part2 = end($selectors2);
  2596.         if (! $this->isImmediateRelationshipCombinator($part1[0]) && $part1 !== $part2) {
  2597.             return array_merge($selectors1, $selectors2);
  2598.         }
  2600.         $merged = [];
  2602.         do {
  2603.             $part1 = array_pop($selectors1);
  2604.             $part2 = array_pop($selectors2);
  2606.             if (! $this->isImmediateRelationshipCombinator($part1[0]) && $part1 !== $part2) {
  2607.                 if ($this->isImmediateRelationshipCombinator(reset($merged)[0])) {
  2608.                     array_unshift($merged, [$part1[0] . $part2[0]]);
  2609.                     $merged = array_merge($selectors1, $selectors2, $merged);
  2610.                 } else {
  2611.                     $merged = array_merge($selectors1, [$part1], $selectors2, [$part2], $merged);
  2612.                 }
  2614.                 break;
  2615.             }
  2617.             array_unshift($merged, $part1);
  2618.         } while (! empty($selectors1) && ! empty($selectors2));
  2620.         return $merged;
  2621.     }
  2623.     /**
  2624.      * Merge media types
  2625.      *
  2626.      * @param array $type1
  2627.      * @param array $type2
  2628.      *
  2629.      * @return array|null
  2630.      */
  2631.     protected function mergeMediaTypes($type1, $type2)
  2632.     {
  2633.         if (empty($type1)) {
  2634.             return $type2;
  2635.         }
  2637.         if (empty($type2)) {
  2638.             return $type1;
  2639.         }
  2641.         if (\count($type1) > 1) {
  2642.             $m1 = strtolower($type1[0]);
  2643.             $t1 = strtolower($type1[1]);
  2644.         } else {
  2645.             $m1 = '';
  2646.             $t1 = strtolower($type1[0]);
  2647.         }
  2649.         if (\count($type2) > 1) {
  2650.             $m2 = strtolower($type2[0]);
  2651.             $t2 = strtolower($type2[1]);
  2652.         } else {
  2653.             $m2 = '';
  2654.             $t2 = strtolower($type2[0]);
  2655.         }
  2657.         if (($m1 === Type::T_NOT) ^ ($m2 === Type::T_NOT)) {
  2658.             if ($t1 === $t2) {
  2659.                 return null;
  2660.             }
  2662.             return [
  2663.                 $m1 === Type::T_NOT ? $m2 : $m1,
  2664.                 $m1 === Type::T_NOT ? $t2 : $t1,
  2665.             ];
  2666.         }
  2668.         if ($m1 === Type::T_NOT && $m2 === Type::T_NOT) {
  2669.             // CSS has no way of representing "neither screen nor print"
  2670.             if ($t1 !== $t2) {
  2671.                 return null;
  2672.             }
  2674.             return [Type::T_NOT, $t1];
  2675.         }
  2677.         if ($t1 !== $t2) {
  2678.             return null;
  2679.         }
  2681.         // t1 == t2, neither m1 nor m2 are "not"
  2682.         return [empty($m1) ? $m2 : $m1, $t1];
  2683.     }
  2685.     /**
  2686.      * Compile import; returns true if the value was something that could be imported
  2687.      *
  2688.      * @param array                                  $rawPath
  2689.      * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
  2690.      * @param bool                                   $once
  2691.      *
  2692.      * @return bool
  2693.      */
  2694.     protected function compileImport($rawPath, OutputBlock $out, $once = false)
  2695.     {
  2696.         if ($rawPath[0] === Type::T_STRING) {
  2697.             $path = $this->compileStringContent($rawPath);
  2699.             if (strpos($path, 'url(') !== 0 && $filePath = $this->findImport($path, $this->currentDirectory)) {
  2700.                 $this->registerImport($this->currentDirectory, $path, $filePath);
  2702.                 if (! $once || ! \in_array($filePath, $this->importedFiles)) {
  2703.                     $this->importFile($filePath, $out);
  2704.                     $this->importedFiles[] = $filePath;
  2705.                 }
  2707.                 return true;
  2708.             }
  2710.             $this->appendRootDirective('@import ' . $this->compileImportPath($rawPath) . ';', $out);
  2712.             return false;
  2713.         }
  2715.         if ($rawPath[0] === Type::T_LIST) {
  2716.             // handle a list of strings
  2717.             if (\count($rawPath[2]) === 0) {
  2718.                 return false;
  2719.             }
  2721.             foreach ($rawPath[2] as $path) {
  2722.                 if ($path[0] !== Type::T_STRING) {
  2723.                     $this->appendRootDirective('@import ' . $this->compileImportPath($rawPath) . ';', $out);
  2725.                     return false;
  2726.                 }
  2727.             }
  2729.             foreach ($rawPath[2] as $path) {
  2730.                 $this->compileImport($path, $out, $once);
  2731.             }
  2733.             return true;
  2734.         }
  2736.         $this->appendRootDirective('@import ' . $this->compileImportPath($rawPath) . ';', $out);
  2738.         return false;
  2739.     }
  2741.     /**
  2742.      * @param array $rawPath
  2743.      * @return string
  2744.      * @throws CompilerException
  2745.      */
  2746.     protected function compileImportPath($rawPath)
  2747.     {
  2748.         $path = $this->compileValue($rawPath);
  2750.         // case url() without quotes : suppress \r \n remaining in the path
  2751.         // if this is a real string there can not be CR or LF char
  2752.         if (strpos($path, 'url(') === 0) {
  2753.             $path = str_replace(array("\r", "\n"), array('', ' '), $path);
  2754.         } else {
  2755.             // if this is a file name in a string, spaces should be escaped
  2756.             $path = $this->reduce($rawPath);
  2757.             $path = $this->escapeImportPathString($path);
  2758.             $path = $this->compileValue($path);
  2759.         }
  2761.         return $path;
  2762.     }
  2764.     /**
  2765.      * @param array $path
  2766.      * @return array
  2767.      * @throws CompilerException
  2768.      */
  2769.     protected function escapeImportPathString($path)
  2770.     {
  2771.         switch ($path[0]) {
  2772.             case Type::T_LIST:
  2773.                 foreach ($path[2] as $k => $v) {
  2774.                     $path[2][$k] = $this->escapeImportPathString($v);
  2775.                 }
  2776.                 break;
  2777.             case Type::T_STRING:
  2778.                 if ($path[1]) {
  2779.                     $path = $this->compileValue($path);
  2780.                     $path = str_replace(' ', '\\ ', $path);
  2781.                     $path = [Type::T_KEYWORD, $path];
  2782.                 }
  2783.                 break;
  2784.         }
  2786.         return $path;
  2787.     }
  2789.     /**
  2790.      * Append a root directive like @import or @charset as near as the possible from the source code
  2791.      * (keeping before comments, @import and @charset coming before in the source code)
  2792.      *
  2793.      * @param string                                 $line
  2794.      * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
  2795.      * @param array                                  $allowed
  2796.      *
  2797.      * @return void
  2798.      */
  2799.     protected function appendRootDirective($line, $out, $allowed = [Type::T_COMMENT])
  2800.     {
  2801.         $root = $out;
  2803.         while ($root->parent) {
  2804.             $root = $root->parent;
  2805.         }
  2807.         $i = 0;
  2809.         while ($i < \count($root->children)) {
  2810.             if (! isset($root->children[$i]->type) || ! \in_array($root->children[$i]->type, $allowed)) {
  2811.                 break;
  2812.             }
  2814.             $i++;
  2815.         }
  2817.         // remove incompatible children from the bottom of the list
  2818.         $saveChildren = [];
  2820.         while ($i < \count($root->children)) {
  2821.             $saveChildren[] = array_pop($root->children);
  2822.         }
  2824.         // insert the directive as a comment
  2825.         $child = $this->makeOutputBlock(Type::T_COMMENT);
  2826.         $child->lines[]      = $line;
  2827.         $child->sourceName   = $this->sourceNames[$this->sourceIndex] ?: '(stdin)';
  2828.         $child->sourceLine   = $this->sourceLine;
  2829.         $child->sourceColumn = $this->sourceColumn;
  2831.         $root->children[] = $child;
  2833.         // repush children
  2834.         while (\count($saveChildren)) {
  2835.             $root->children[] = array_pop($saveChildren);
  2836.         }
  2837.     }
  2839.     /**
  2840.      * Append lines to the current output block:
  2841.      * directly to the block or through a child if necessary
  2842.      *
  2843.      * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
  2844.      * @param string                                 $type
  2845.      * @param string                                 $line
  2846.      *
  2847.      * @return void
  2848.      */
  2849.     protected function appendOutputLine(OutputBlock $out, $type, $line)
  2850.     {
  2851.         $outWrite = &$out;
  2853.         // check if it's a flat output or not
  2854.         if (\count($out->children)) {
  2855.             $lastChild = &$out->children[\count($out->children) - 1];
  2857.             if (
  2858.                 $lastChild->depth === $out->depth &&
  2859.                 \is_null($lastChild->selectors) &&
  2860.                 ! \count($lastChild->children)
  2861.             ) {
  2862.                 $outWrite = $lastChild;
  2863.             } else {
  2864.                 $nextLines = $this->makeOutputBlock($type);
  2865.                 $nextLines->parent = $out;
  2866.                 $nextLines->depth  = $out->depth;
  2868.                 $out->children[] = $nextLines;
  2869.                 $outWrite = &$nextLines;
  2870.             }
  2871.         }
  2873.         $outWrite->lines[] = $line;
  2874.     }
  2876.     /**
  2877.      * Compile child; returns a value to halt execution
  2878.      *
  2879.      * @param array                                  $child
  2880.      * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
  2881.      *
  2882.      * @return array|Number|null
  2883.      */
  2884.     protected function compileChild($child, OutputBlock $out)
  2885.     {
  2886.         if (isset($child[Parser::SOURCE_LINE])) {
  2887.             $this->sourceIndex  = isset($child[Parser::SOURCE_INDEX]) ? $child[Parser::SOURCE_INDEX] : null;
  2888.             $this->sourceLine   = isset($child[Parser::SOURCE_LINE]) ? $child[Parser::SOURCE_LINE] : -1;
  2889.             $this->sourceColumn = isset($child[Parser::SOURCE_COLUMN]) ? $child[Parser::SOURCE_COLUMN] : -1;
  2890.         } elseif (\is_array($child) && isset($child[1]->sourceLine) && $child[1] instanceof Block) {
  2891.             $this->sourceIndex  = $child[1]->sourceIndex;
  2892.             $this->sourceLine   = $child[1]->sourceLine;
  2893.             $this->sourceColumn = $child[1]->sourceColumn;
  2894.         } elseif (! empty($out->sourceLine) && ! empty($out->sourceName)) {
  2895.             $this->sourceLine   = $out->sourceLine;
  2896.             $sourceIndex  = array_search($out->sourceName, $this->sourceNames);
  2897.             $this->sourceColumn = $out->sourceColumn;
  2899.             if ($sourceIndex === false) {
  2900.                 $sourceIndex = null;
  2901.             }
  2902.             $this->sourceIndex = $sourceIndex;
  2903.         }
  2905.         switch ($child[0]) {
  2906.             case Type::T_SCSSPHP_IMPORT_ONCE:
  2907.                 $rawPath = $this->reduce($child[1]);
  2909.                 $this->compileImport($rawPath, $out, true);
  2910.                 break;
  2912.             case Type::T_IMPORT:
  2913.                 $rawPath = $this->reduce($child[1]);
  2915.                 $this->compileImport($rawPath, $out);
  2916.                 break;
  2918.             case Type::T_DIRECTIVE:
  2919.                 $this->compileDirective($child[1], $out);
  2920.                 break;
  2922.             case Type::T_AT_ROOT:
  2923.                 $this->compileAtRoot($child[1]);
  2924.                 break;
  2926.             case Type::T_MEDIA:
  2927.                 $this->compileMedia($child[1]);
  2928.                 break;
  2930.             case Type::T_BLOCK:
  2931.                 $this->compileBlock($child[1]);
  2932.                 break;
  2934.             case Type::T_CHARSET:
  2935.                 break;
  2937.             case Type::T_CUSTOM_PROPERTY:
  2938.                 list(, $name, $value) = $child;
  2939.                 $compiledName = $this->compileValue($name);
  2941.                 // if the value reduces to null from something else then
  2942.                 // the property should be discarded
  2943.                 if ($value[0] !== Type::T_NULL) {
  2944.                     $value = $this->reduce($value);
  2946.                     if ($value[0] === Type::T_NULL || $value === static::$nullString) {
  2947.                         break;
  2948.                     }
  2949.                 }
  2951.                 $compiledValue = $this->compileValue($value);
  2953.                 $line = $this->formatter->customProperty(
  2954.                     $compiledName,
  2955.                     $compiledValue
  2956.                 );
  2958.                 $this->appendOutputLine($out, Type::T_ASSIGN, $line);
  2959.                 break;
  2961.             case Type::T_ASSIGN:
  2962.                 list(, $name, $value) = $child;
  2964.                 if ($name[0] === Type::T_VARIABLE) {
  2965.                     $flags     = isset($child[3]) ? $child[3] : [];
  2966.                     $isDefault = \in_array('!default', $flags);
  2967.                     $isGlobal  = \in_array('!global', $flags);
  2969.                     if ($isGlobal) {
  2970.                         $this->set($name[1], $this->reduce($value), false, $this->rootEnv, $value);
  2971.                         break;
  2972.                     }
  2974.                     $shouldSet = $isDefault &&
  2975.                         (\is_null($result = $this->get($name[1], false)) ||
  2976.                         $result === static::$null);
  2978.                     if (! $isDefault || $shouldSet) {
  2979.                         $this->set($name[1], $this->reduce($value), true, null, $value);
  2980.                     }
  2981.                     break;
  2982.                 }
  2984.                 $compiledName = $this->compileValue($name);
  2986.                 // handle shorthand syntaxes : size / line-height...
  2987.                 if (\in_array($compiledName, ['font', 'grid-row', 'grid-column', 'border-radius'])) {
  2988.                     if ($value[0] === Type::T_VARIABLE) {
  2989.                         // if the font value comes from variable, the content is already reduced
  2990.                         // (i.e., formulas were already calculated), so we need the original unreduced value
  2991.                         $value = $this->get($value[1], true, null, true);
  2992.                     }
  2994.                     $shorthandValue=&$value;
  2996.                     $shorthandDividerNeedsUnit = false;
  2997.                     $maxListElements           = null;
  2998.                     $maxShorthandDividers      = 1;
  3000.                     switch ($compiledName) {
  3001.                         case 'border-radius':
  3002.                             $maxListElements = 4;
  3003.                             $shorthandDividerNeedsUnit = true;
  3004.                             break;
  3005.                     }
  3007.                     if ($compiledName === 'font' && $value[0] === Type::T_LIST && $value[1] === ',') {
  3008.                         // this is the case if more than one font is given: example: "font: 400 1em/1.3 arial,helvetica"
  3009.                         // we need to handle the first list element
  3010.                         $shorthandValue=&$value[2][0];
  3011.                     }
  3013.                     if ($shorthandValue[0] === Type::T_EXPRESSION && $shorthandValue[1] === '/') {
  3014.                         $revert = true;
  3016.                         if ($shorthandDividerNeedsUnit) {
  3017.                             $divider = $shorthandValue[3];
  3019.                             if (\is_array($divider)) {
  3020.                                 $divider = $this->reduce($divider, true);
  3021.                             }
  3023.                             if ($divider instanceof Number && \intval($divider->getDimension()) && $divider->unitless()) {
  3024.                                 $revert = false;
  3025.                             }
  3026.                         }
  3028.                         if ($revert) {
  3029.                             $shorthandValue = $this->expToString($shorthandValue);
  3030.                         }
  3031.                     } elseif ($shorthandValue[0] === Type::T_LIST) {
  3032.                         foreach ($shorthandValue[2] as &$item) {
  3033.                             if ($item[0] === Type::T_EXPRESSION && $item[1] === '/') {
  3034.                                 if ($maxShorthandDividers > 0) {
  3035.                                     $revert = true;
  3037.                                     // if the list of values is too long, this has to be a shorthand,
  3038.                                     // otherwise it could be a real division
  3039.                                     if (\is_null($maxListElements) || \count($shorthandValue[2]) <= $maxListElements) {
  3040.                                         if ($shorthandDividerNeedsUnit) {
  3041.                                             $divider = $item[3];
  3043.                                             if (\is_array($divider)) {
  3044.                                                 $divider = $this->reduce($divider, true);
  3045.                                             }
  3047.                                             if ($divider instanceof Number && \intval($divider->getDimension()) && $divider->unitless()) {
  3048.                                                 $revert = false;
  3049.                                             }
  3050.                                         }
  3051.                                     }
  3053.                                     if ($revert) {
  3054.                                         $item = $this->expToString($item);
  3055.                                         $maxShorthandDividers--;
  3056.                                     }
  3057.                                 }
  3058.                             }
  3059.                         }
  3060.                     }
  3061.                 }
  3063.                 // if the value reduces to null from something else then
  3064.                 // the property should be discarded
  3065.                 if ($value[0] !== Type::T_NULL) {
  3066.                     $value = $this->reduce($value);
  3068.                     if ($value[0] === Type::T_NULL || $value === static::$nullString) {
  3069.                         break;
  3070.                     }
  3071.                 }
  3073.                 $compiledValue = $this->compileValue($value);
  3075.                 // ignore empty value
  3076.                 if (\strlen($compiledValue)) {
  3077.                     $line = $this->formatter->property(
  3078.                         $compiledName,
  3079.                         $compiledValue
  3080.                     );
  3081.                     $this->appendOutputLine($out, Type::T_ASSIGN, $line);
  3082.                 }
  3083.                 break;
  3085.             case Type::T_COMMENT:
  3086.                 if ($out->type === Type::T_ROOT) {
  3087.                     $this->compileComment($child);
  3088.                     break;
  3089.                 }
  3091.                 $line = $this->compileCommentValue($child, true);
  3092.                 $this->appendOutputLine($out, Type::T_COMMENT, $line);
  3093.                 break;
  3095.             case Type::T_MIXIN:
  3096.             case Type::T_FUNCTION:
  3097.                 list(, $block) = $child;
  3098.                 assert($block instanceof CallableBlock);
  3099.                 // the block need to be able to go up to it's parent env to resolve vars
  3100.                 $block->parentEnv = $this->getStoreEnv();
  3101.                 $this->set(static::$namespaces[$block->type] . $block->name, $block, true);
  3102.                 break;
  3104.             case Type::T_EXTEND:
  3105.                 foreach ($child[1] as $sel) {
  3106.                     $replacedSel = $this->replaceSelfSelector($sel);
  3108.                     if ($replacedSel !== $sel) {
  3109.                         throw $this->error('Parent selectors aren\'t allowed here.');
  3110.                     }
  3112.                     $results = $this->evalSelectors([$sel]);
  3114.                     foreach ($results as $result) {
  3115.                         if (\count($result) !== 1) {
  3116.                             throw $this->error('complex selectors may not be extended.');
  3117.                         }
  3119.                         // only use the first one
  3120.                         $result = $result[0];
  3121.                         $selectors = $out->selectors;
  3123.                         if (! $selectors && isset($child['selfParent'])) {
  3124.                             $selectors = $this->multiplySelectors($this->env, $child['selfParent']);
  3125.                         }
  3126.                         assert($selectors !== null);
  3128.                         if (\count($result) > 1) {
  3129.                             $replacement = implode(', ', $result);
  3130.                             $fname = $this->getPrettyPath($this->sourceNames[$this->sourceIndex]);
  3131.                             $line = $this->sourceLine;
  3133.                             $message = <<<EOL
  3134. on line $line of $fname:
  3135. Compound selectors may no longer be extended.
  3136. Consider `@extend $replacement` instead.
  3137. See http://bit.ly/ExtendCompound for details.
  3138. EOL;
  3140.                             $this->logger->warn($message);
  3141.                         }
  3143.                         $this->pushExtends($result, $selectors, $child);
  3144.                     }
  3145.                 }
  3146.                 break;
  3148.             case Type::T_IF:
  3149.                 list(, $if) = $child;
  3150.                 assert($if instanceof IfBlock);
  3152.                 if ($this->isTruthy($this->reduce($if->cond, true))) {
  3153.                     return $this->compileChildren($if->children, $out);
  3154.                 }
  3156.                 foreach ($if->cases as $case) {
  3157.                     if (
  3158.                         $case instanceof ElseBlock ||
  3159.                         $case instanceof ElseifBlock && $this->isTruthy($this->reduce($case->cond))
  3160.                     ) {
  3161.                         return $this->compileChildren($case->children, $out);
  3162.                     }
  3163.                 }
  3164.                 break;
  3166.             case Type::T_EACH:
  3167.                 list(, $each) = $child;
  3168.                 assert($each instanceof EachBlock);
  3170.                 $list = $this->coerceList($this->reduce($each->list), ',', true);
  3172.                 $this->pushEnv();
  3174.                 foreach ($list[2] as $item) {
  3175.                     if (\count($each->vars) === 1) {
  3176.                         $this->set($each->vars[0], $item, true);
  3177.                     } else {
  3178.                         list(,, $values) = $this->coerceList($item);
  3180.                         foreach ($each->vars as $i => $var) {
  3181.                             $this->set($var, isset($values[$i]) ? $values[$i] : static::$null, true);
  3182.                         }
  3183.                     }
  3185.                     $ret = $this->compileChildren($each->children, $out);
  3187.                     if ($ret) {
  3188.                         $store = $this->env->store;
  3189.                         $this->popEnv();
  3190.                         $this->backPropagateEnv($store, $each->vars);
  3192.                         return $ret;
  3193.                     }
  3194.                 }
  3195.                 $store = $this->env->store;
  3196.                 $this->popEnv();
  3197.                 $this->backPropagateEnv($store, $each->vars);
  3199.                 break;
  3201.             case Type::T_WHILE:
  3202.                 list(, $while) = $child;
  3203.                 assert($while instanceof WhileBlock);
  3205.                 while ($this->isTruthy($this->reduce($while->cond, true))) {
  3206.                     $ret = $this->compileChildren($while->children, $out);
  3208.                     if ($ret) {
  3209.                         return $ret;
  3210.                     }
  3211.                 }
  3212.                 break;
  3214.             case Type::T_FOR:
  3215.                 list(, $for) = $child;
  3216.                 assert($for instanceof ForBlock);
  3218.                 $startNumber = $this->assertNumber($this->reduce($for->start, true));
  3219.                 $endNumber = $this->assertNumber($this->reduce($for->end, true));
  3221.                 $start = $this->assertInteger($startNumber);
  3223.                 $numeratorUnits = $startNumber->getNumeratorUnits();
  3224.                 $denominatorUnits = $startNumber->getDenominatorUnits();
  3226.                 $end = $this->assertInteger($endNumber->coerce($numeratorUnits, $denominatorUnits));
  3228.                 $d = $start < $end ? 1 : -1;
  3230.                 $this->pushEnv();
  3232.                 for (;;) {
  3233.                     if (
  3234.                         (! $for->until && $start - $d == $end) ||
  3235.                         ($for->until && $start == $end)
  3236.                     ) {
  3237.                         break;
  3238.                     }
  3240.                     $this->set($for->var, new Number($start, $numeratorUnits, $denominatorUnits));
  3241.                     $start += $d;
  3243.                     $ret = $this->compileChildren($for->children, $out);
  3245.                     if ($ret) {
  3246.                         $store = $this->env->store;
  3247.                         $this->popEnv();
  3248.                         $this->backPropagateEnv($store, [$for->var]);
  3250.                         return $ret;
  3251.                     }
  3252.                 }
  3254.                 $store = $this->env->store;
  3255.                 $this->popEnv();
  3256.                 $this->backPropagateEnv($store, [$for->var]);
  3258.                 break;
  3260.             case Type::T_RETURN:
  3261.                 return $this->reduce($child[1], true);
  3263.             case Type::T_NESTED_PROPERTY:
  3264.                 $this->compileNestedPropertiesBlock($child[1], $out);
  3265.                 break;
  3267.             case Type::T_INCLUDE:
  3268.                 // including a mixin
  3269.                 list(, $name, $argValues, $content, $argUsing) = $child;
  3271.                 $mixin = $this->get(static::$namespaces['mixin'] . $name, false);
  3273.                 if (! $mixin) {
  3274.                     throw $this->error("Undefined mixin $name");
  3275.                 }
  3277.                 assert($mixin instanceof CallableBlock);
  3279.                 $callingScope = $this->getStoreEnv();
  3281.                 // push scope, apply args
  3282.                 $this->pushEnv();
  3283.                 $this->env->depth--;
  3285.                 // Find the parent selectors in the env to be able to know what '&' refers to in the mixin
  3286.                 // and assign this fake parent to childs
  3287.                 $selfParent = null;
  3289.                 if (isset($child['selfParent']) && $child['selfParent'] instanceof Block && isset($child['selfParent']->selectors)) {
  3290.                     $selfParent = $child['selfParent'];
  3291.                 } else {
  3292.                     $parentSelectors = $this->multiplySelectors($this->env);
  3294.                     if ($parentSelectors) {
  3295.                         $parent = new Block();
  3296.                         $parent->selectors = $parentSelectors;
  3298.                         foreach ($mixin->children as $k => $child) {
  3299.                             if (isset($child[1]) && $child[1] instanceof Block) {
  3300.                                 $mixin->children[$k][1]->parent = $parent;
  3301.                             }
  3302.                         }
  3303.                     }
  3304.                 }
  3306.                 // clone the stored content to not have its scope spoiled by a further call to the same mixin
  3307.                 // i.e., recursive @include of the same mixin
  3308.                 if (isset($content)) {
  3309.                     $copyContent = clone $content;
  3310.                     $copyContent->scope = clone $callingScope;
  3312.                     $this->setRaw(static::$namespaces['special'] . 'content', $copyContent, $this->env);
  3313.                 } else {
  3314.                     $this->setRaw(static::$namespaces['special'] . 'content', null, $this->env);
  3315.                 }
  3317.                 // save the "using" argument list for applying it to when "@content" is invoked
  3318.                 if (isset($argUsing)) {
  3319.                     $this->setRaw(static::$namespaces['special'] . 'using', $argUsing, $this->env);
  3320.                 } else {
  3321.                     $this->setRaw(static::$namespaces['special'] . 'using', null, $this->env);
  3322.                 }
  3324.                 if (isset($mixin->args)) {
  3325.                     $this->applyArguments($mixin->args, $argValues);
  3326.                 }
  3328.                 $this->env->marker = 'mixin';
  3330.                 if (! empty($mixin->parentEnv)) {
  3331.                     $this->env->declarationScopeParent = $mixin->parentEnv;
  3332.                 } else {
  3333.                     throw $this->error("@mixin $name() without parentEnv");
  3334.                 }
  3336.                 $this->compileChildrenNoReturn($mixin->children, $out, $selfParent, $this->env->marker . ' ' . $name);
  3338.                 $this->popEnv();
  3339.                 break;
  3341.             case Type::T_MIXIN_CONTENT:
  3342.                 $env        = isset($this->storeEnv) ? $this->storeEnv : $this->env;
  3343.                 $content    = $this->get(static::$namespaces['special'] . 'content', false, $env);
  3344.                 $argUsing   = $this->get(static::$namespaces['special'] . 'using', false, $env);
  3345.                 $argContent = $child[1];
  3347.                 if (! $content) {
  3348.                     break;
  3349.                 }
  3351.                 $storeEnv = $this->storeEnv;
  3352.                 $varsUsing = [];
  3354.                 if (isset($argUsing) && isset($argContent)) {
  3355.                     // Get the arguments provided for the content with the names provided in the "using" argument list
  3356.                     $this->storeEnv = null;
  3357.                     $varsUsing = $this->applyArguments($argUsing, $argContent, false);
  3358.                 }
  3360.                 // restore the scope from the @content
  3361.                 $this->storeEnv = $content->scope;
  3363.                 // append the vars from using if any
  3364.                 foreach ($varsUsing as $name => $val) {
  3365.                     $this->set($name, $val, true, $this->storeEnv);
  3366.                 }
  3368.                 $this->compileChildrenNoReturn($content->children, $out);
  3370.                 $this->storeEnv = $storeEnv;
  3371.                 break;
  3373.             case Type::T_DEBUG:
  3374.                 list(, $value) = $child;
  3376.                 $fname = $this->getPrettyPath($this->sourceNames[$this->sourceIndex]);
  3377.                 $line  = $this->sourceLine;
  3378.                 $value = $this->compileDebugValue($value);
  3380.                 $this->logger->debug("$fname:$line DEBUG: $value");
  3381.                 break;
  3383.             case Type::T_WARN:
  3384.                 list(, $value) = $child;
  3386.                 $fname = $this->getPrettyPath($this->sourceNames[$this->sourceIndex]);
  3387.                 $line  = $this->sourceLine;
  3388.                 $value = $this->compileDebugValue($value);
  3390.                 $this->logger->warn("$value\n         on line $line of $fname");
  3391.                 break;
  3393.             case Type::T_ERROR:
  3394.                 list(, $value) = $child;
  3396.                 $fname = $this->getPrettyPath($this->sourceNames[$this->sourceIndex]);
  3397.                 $line  = $this->sourceLine;
  3398.                 $value = $this->compileValue($this->reduce($value, true));
  3400.                 throw $this->error("File $fname on line $line ERROR: $value\n");
  3402.             default:
  3403.                 throw $this->error("unknown child type: $child[0]");
  3404.         }
  3406.         return null;
  3407.     }
  3409.     /**
  3410.      * Reduce expression to string
  3411.      *
  3412.      * @param array $exp
  3413.      * @param bool $keepParens
  3414.      *
  3415.      * @return array
  3416.      */
  3417.     protected function expToString($exp, $keepParens = false)
  3418.     {
  3419.         list(, $op, $left, $right, $inParens, $whiteLeft, $whiteRight) = $exp;
  3421.         $content = [];
  3423.         if ($keepParens && $inParens) {
  3424.             $content[] = '(';
  3425.         }
  3427.         $content[] = $this->reduce($left);
  3429.         if ($whiteLeft) {
  3430.             $content[] = ' ';
  3431.         }
  3433.         $content[] = $op;
  3435.         if ($whiteRight) {
  3436.             $content[] = ' ';
  3437.         }
  3439.         $content[] = $this->reduce($right);
  3441.         if ($keepParens && $inParens) {
  3442.             $content[] = ')';
  3443.         }
  3445.         return [Type::T_STRING, '', $content];
  3446.     }
  3448.     /**
  3449.      * Is truthy?
  3450.      *
  3451.      * @param array|Number $value
  3452.      *
  3453.      * @return bool
  3454.      */
  3455.     public function isTruthy($value)
  3456.     {
  3457.         return $value !== static::$false && $value !== static::$null;
  3458.     }
  3460.     /**
  3461.      * Is the value a direct relationship combinator?
  3462.      *
  3463.      * @param string $value
  3464.      *
  3465.      * @return bool
  3466.      */
  3467.     protected function isImmediateRelationshipCombinator($value)
  3468.     {
  3469.         return $value === '>' || $value === '+' || $value === '~';
  3470.     }
  3472.     /**
  3473.      * Should $value cause its operand to eval
  3474.      *
  3475.      * @param array $value
  3476.      *
  3477.      * @return bool
  3478.      */
  3479.     protected function shouldEval($value)
  3480.     {
  3481.         switch ($value[0]) {
  3482.             case Type::T_EXPRESSION:
  3483.                 if ($value[1] === '/') {
  3484.                     return $this->shouldEval($value[2]) || $this->shouldEval($value[3]);
  3485.                 }
  3487.                 // fall-thru
  3488.             case Type::T_VARIABLE:
  3489.             case Type::T_FUNCTION_CALL:
  3490.                 return true;
  3491.         }
  3493.         return false;
  3494.     }
  3496.     /**
  3497.      * Reduce value
  3498.      *
  3499.      * @param array|Number $value
  3500.      * @param bool         $inExp
  3501.      *
  3502.      * @return array|Number
  3503.      */
  3504.     protected function reduce($value, $inExp = false)
  3505.     {
  3506.         if ($value instanceof Number) {
  3507.             return $value;
  3508.         }
  3510.         switch ($value[0]) {
  3511.             case Type::T_EXPRESSION:
  3512.                 list(, $op, $left, $right, $inParens) = $value;
  3514.                 $opName = isset(static::$operatorNames[$op]) ? static::$operatorNames[$op] : $op;
  3515.                 $inExp = $inExp || $this->shouldEval($left) || $this->shouldEval($right);
  3517.                 $left = $this->reduce($left, true);
  3519.                 if ($op !== 'and' && $op !== 'or') {
  3520.                     $right = $this->reduce($right, true);
  3521.                 }
  3523.                 // special case: looks like css shorthand
  3524.                 if (
  3525.                     $opName == 'div' && ! $inParens && ! $inExp &&
  3526.                     (($right[0] !== Type::T_NUMBER && isset($right[2]) && $right[2] != '') ||
  3527.                     ($right[0] === Type::T_NUMBER && ! $right->unitless()))
  3528.                 ) {
  3529.                     return $this->expToString($value);
  3530.                 }
  3532.                 $left  = $this->coerceForExpression($left);
  3533.                 $right = $this->coerceForExpression($right);
  3534.                 $ltype = $left[0];
  3535.                 $rtype = $right[0];
  3537.                 $ucOpName = ucfirst($opName);
  3538.                 $ucLType  = ucfirst($ltype);
  3539.                 $ucRType  = ucfirst($rtype);
  3541.                 $shouldEval = $inParens || $inExp;
  3543.                 // this tries:
  3544.                 // 1. op[op name][left type][right type]
  3545.                 // 2. op[left type][right type] (passing the op as first arg)
  3546.                 // 3. op[op name]
  3547.                 if (\is_callable([$this, $fn = "op${ucOpName}${ucLType}${ucRType}"])) {
  3548.                     $out = $this->$fn($left, $right, $shouldEval);
  3549.                 } elseif (\is_callable([$this, $fn = "op${ucLType}${ucRType}"])) {
  3550.                     $out = $this->$fn($op, $left, $right, $shouldEval);
  3551.                 } elseif (\is_callable([$this, $fn = "op${ucOpName}"])) {
  3552.                     $out = $this->$fn($left, $right, $shouldEval);
  3553.                 } else {
  3554.                     $out = null;
  3555.                 }
  3557.                 if (isset($out)) {
  3558.                     return $out;
  3559.                 }
  3561.                 return $this->expToString($value);
  3563.             case Type::T_UNARY:
  3564.                 list(, $op, $exp, $inParens) = $value;
  3566.                 $inExp = $inExp || $this->shouldEval($exp);
  3567.                 $exp = $this->reduce($exp);
  3569.                 if ($exp instanceof Number) {
  3570.                     switch ($op) {
  3571.                         case '+':
  3572.                             return $exp;
  3574.                         case '-':
  3575.                             return $exp->unaryMinus();
  3576.                     }
  3577.                 }
  3579.                 if ($op === 'not') {
  3580.                     if ($inExp || $inParens) {
  3581.                         if ($exp === static::$false || $exp === static::$null) {
  3582.                             return static::$true;
  3583.                         }
  3585.                         return static::$false;
  3586.                     }
  3588.                     $op = $op . ' ';
  3589.                 }
  3591.                 return [Type::T_STRING, '', [$op, $exp]];
  3593.             case Type::T_VARIABLE:
  3594.                 return $this->reduce($this->get($value[1]));
  3596.             case Type::T_LIST:
  3597.                 foreach ($value[2] as &$item) {
  3598.                     $item = $this->reduce($item);
  3599.                 }
  3600.                 unset($item);
  3602.                 if (isset($value[3]) && \is_array($value[3])) {
  3603.                     foreach ($value[3] as &$item) {
  3604.                         $item = $this->reduce($item);
  3605.                     }
  3606.                     unset($item);
  3607.                 }
  3609.                 return $value;
  3611.             case Type::T_MAP:
  3612.                 foreach ($value[1] as &$item) {
  3613.                     $item = $this->reduce($item);
  3614.                 }
  3616.                 foreach ($value[2] as &$item) {
  3617.                     $item = $this->reduce($item);
  3618.                 }
  3620.                 return $value;
  3622.             case Type::T_STRING:
  3623.                 foreach ($value[2] as &$item) {
  3624.                     if (\is_array($item) || $item instanceof Number) {
  3625.                         $item = $this->reduce($item);
  3626.                     }
  3627.                 }
  3629.                 return $value;
  3631.             case Type::T_INTERPOLATE:
  3632.                 $value[1] = $this->reduce($value[1]);
  3634.                 if ($inExp) {
  3635.                     return [Type::T_KEYWORD, $this->compileValue($value, false)];
  3636.                 }
  3638.                 return $value;
  3640.             case Type::T_FUNCTION_CALL:
  3641.                 return $this->fncall($value[1], $value[2]);
  3643.             case Type::T_SELF:
  3644.                 $selfParent = ! empty($this->env->block->selfParent) ? $this->env->block->selfParent : null;
  3645.                 $selfSelector = $this->multiplySelectors($this->env, $selfParent);
  3646.                 $selfSelector = $this->collapseSelectorsAsList($selfSelector);
  3648.                 return $selfSelector;
  3650.             default:
  3651.                 return $value;
  3652.         }
  3653.     }
  3655.     /**
  3656.      * Function caller
  3657.      *
  3658.      * @param string|array $functionReference
  3659.      * @param array        $argValues
  3660.      *
  3661.      * @return array|Number
  3662.      */
  3663.     protected function fncall($functionReference, $argValues)
  3664.     {
  3665.         // a string means this is a static hard reference coming from the parsing
  3666.         if (is_string($functionReference)) {
  3667.             $name = $functionReference;
  3669.             $functionReference = $this->getFunctionReference($name);
  3670.             if ($functionReference === static::$null || $functionReference[0] !== Type::T_FUNCTION_REFERENCE) {
  3671.                 $functionReference = [Type::T_FUNCTION, $name, [Type::T_LIST, ',', []]];
  3672.             }
  3673.         }
  3675.         // a function type means we just want a plain css function call
  3676.         if ($functionReference[0] === Type::T_FUNCTION) {
  3677.             // for CSS functions, simply flatten the arguments into a list
  3678.             $listArgs = [];
  3680.             foreach ((array) $argValues as $arg) {
  3681.                 if (empty($arg[0]) || count($argValues) === 1) {
  3682.                     $listArgs[] = $this->reduce($this->stringifyFncallArgs($arg[1]));
  3683.                 }
  3684.             }
  3686.             return [Type::T_FUNCTION, $functionReference[1], [Type::T_LIST, ',', $listArgs]];
  3687.         }
  3689.         if ($functionReference === static::$null || $functionReference[0] !== Type::T_FUNCTION_REFERENCE) {
  3690.             return static::$defaultValue;
  3691.         }
  3694.         switch ($functionReference[1]) {
  3695.             // SCSS @function
  3696.             case 'scss':
  3697.                 return $this->callScssFunction($functionReference[3], $argValues);
  3699.             // native PHP functions
  3700.             case 'user':
  3701.             case 'native':
  3702.                 list(,,$name, $fn, $prototype) = $functionReference;
  3704.                 // special cases of css valid functions min/max
  3705.                 $name = strtolower($name);
  3706.                 if (\in_array($name, ['min', 'max']) && count($argValues) >= 1) {
  3707.                     $cssFunction = $this->cssValidArg(
  3708.                         [Type::T_FUNCTION_CALL, $name, $argValues],
  3709.                         ['min', 'max', 'calc', 'env', 'var']
  3710.                     );
  3711.                     if ($cssFunction !== false) {
  3712.                         return $cssFunction;
  3713.                     }
  3714.                 }
  3715.                 $returnValue = $this->callNativeFunction($name, $fn, $prototype, $argValues);
  3717.                 if (! isset($returnValue)) {
  3718.                     return $this->fncall([Type::T_FUNCTION, $name, [Type::T_LIST, ',', []]], $argValues);
  3719.                 }
  3721.                 return $returnValue;
  3723.             default:
  3724.                 return static::$defaultValue;
  3725.         }
  3726.     }
  3728.     /**
  3729.      * @param array|Number $arg
  3730.      * @param string[]     $allowed_function
  3731.      * @param bool         $inFunction
  3732.      *
  3733.      * @return array|Number|false
  3734.      */
  3735.     protected function cssValidArg($arg, $allowed_function = [], $inFunction = false)
  3736.     {
  3737.         if ($arg instanceof Number) {
  3738.             return $this->stringifyFncallArgs($arg);
  3739.         }
  3741.         switch ($arg[0]) {
  3742.             case Type::T_INTERPOLATE:
  3743.                 return [Type::T_KEYWORD, $this->CompileValue($arg)];
  3745.             case Type::T_FUNCTION:
  3746.                 if (! \in_array($arg[1], $allowed_function)) {
  3747.                     return false;
  3748.                 }
  3749.                 if ($arg[2][0] === Type::T_LIST) {
  3750.                     foreach ($arg[2][2] as $k => $subarg) {
  3751.                         $arg[2][2][$k] = $this->cssValidArg($subarg, $allowed_function, $arg[1]);
  3752.                         if ($arg[2][2][$k] === false) {
  3753.                             return false;
  3754.                         }
  3755.                     }
  3756.                 }
  3757.                 return $arg;
  3759.             case Type::T_FUNCTION_CALL:
  3760.                 if (! \in_array($arg[1], $allowed_function)) {
  3761.                     return false;
  3762.                 }
  3763.                 $cssArgs = [];
  3764.                 foreach ($arg[2] as $argValue) {
  3765.                     if ($argValue === static::$null) {
  3766.                         return false;
  3767.                     }
  3768.                     $cssArg = $this->cssValidArg($argValue[1], $allowed_function, $arg[1]);
  3769.                     if (empty($argValue[0]) && $cssArg !== false) {
  3770.                         $cssArgs[] = [$argValue[0], $cssArg];
  3771.                     } else {
  3772.                         return false;
  3773.                     }
  3774.                 }
  3776.                 return $this->fncall([Type::T_FUNCTION, $arg[1], [Type::T_LIST, ',', []]], $cssArgs);
  3778.             case Type::T_STRING:
  3779.             case Type::T_KEYWORD:
  3780.                 if (!$inFunction or !\in_array($inFunction, ['calc', 'env', 'var'])) {
  3781.                     return false;
  3782.                 }
  3783.                 return $this->stringifyFncallArgs($arg);
  3785.             case Type::T_LIST:
  3786.                 if (!$inFunction) {
  3787.                     return false;
  3788.                 }
  3789.                 if (empty($arg['enclosing']) and $arg[1] === '') {
  3790.                     foreach ($arg[2] as $k => $subarg) {
  3791.                         $arg[2][$k] = $this->cssValidArg($subarg, $allowed_function, $inFunction);
  3792.                         if ($arg[2][$k] === false) {
  3793.                             return false;
  3794.                         }
  3795.                     }
  3796.                     $arg[0] = Type::T_STRING;
  3797.                     return $arg;
  3798.                 }
  3799.                 return false;
  3801.             case Type::T_EXPRESSION:
  3802.                 if (! \in_array($arg[1], ['+', '-', '/', '*'])) {
  3803.                     return false;
  3804.                 }
  3805.                 $arg[2] = $this->cssValidArg($arg[2], $allowed_function, $inFunction);
  3806.                 $arg[3] = $this->cssValidArg($arg[3], $allowed_function, $inFunction);
  3807.                 if ($arg[2] === false || $arg[3] === false) {
  3808.                     return false;
  3809.                 }
  3810.                 return $this->expToString($arg, true);
  3812.             case Type::T_VARIABLE:
  3813.             case Type::T_SELF:
  3814.             default:
  3815.                 return false;
  3816.         }
  3817.     }
  3820.     /**
  3821.      * Reformat fncall arguments to proper css function output
  3822.      *
  3823.      * @param array|Number $arg
  3824.      *
  3825.      * @return array|Number
  3826.      */
  3827.     protected function stringifyFncallArgs($arg)
  3828.     {
  3829.         if ($arg instanceof Number) {
  3830.             return $arg;
  3831.         }
  3833.         switch ($arg[0]) {
  3834.             case Type::T_LIST:
  3835.                 foreach ($arg[2] as $k => $v) {
  3836.                     $arg[2][$k] = $this->stringifyFncallArgs($v);
  3837.                 }
  3838.                 break;
  3840.             case Type::T_EXPRESSION:
  3841.                 if ($arg[1] === '/') {
  3842.                     $arg[2] = $this->stringifyFncallArgs($arg[2]);
  3843.                     $arg[3] = $this->stringifyFncallArgs($arg[3]);
  3844.                     $arg[5] = $arg[6] = false; // no space around /
  3845.                     $arg = $this->expToString($arg);
  3846.                 }
  3847.                 break;
  3849.             case Type::T_FUNCTION_CALL:
  3850.                 $name = strtolower($arg[1]);
  3852.                 if (in_array($name, ['max', 'min', 'calc'])) {
  3853.                     $args = $arg[2];
  3854.                     $arg = $this->fncall([Type::T_FUNCTION, $name, [Type::T_LIST, ',', []]], $args);
  3855.                 }
  3856.                 break;
  3857.         }
  3859.         return $arg;
  3860.     }
  3862.     /**
  3863.      * Find a function reference
  3864.      * @param string $name
  3865.      * @param bool $safeCopy
  3866.      * @return array
  3867.      */
  3868.     protected function getFunctionReference($name, $safeCopy = false)
  3869.     {
  3870.         // SCSS @function
  3871.         if ($func = $this->get(static::$namespaces['function'] . $name, false)) {
  3872.             if ($safeCopy) {
  3873.                 $func = clone $func;
  3874.             }
  3876.             return [Type::T_FUNCTION_REFERENCE, 'scss', $name, $func];
  3877.         }
  3879.         // native PHP functions
  3881.         // try to find a native lib function
  3882.         $normalizedName = $this->normalizeName($name);
  3884.         if (isset($this->userFunctions[$normalizedName])) {
  3885.             // see if we can find a user function
  3886.             list($f, $prototype) = $this->userFunctions[$normalizedName];
  3888.             return [Type::T_FUNCTION_REFERENCE, 'user', $name, $f, $prototype];
  3889.         }
  3891.         $lowercasedName = strtolower($normalizedName);
  3893.         // Special functions overriding a CSS function are case-insensitive. We normalize them as lowercase
  3894.         // to avoid the deprecation warning about the wrong case being used.
  3895.         if ($lowercasedName === 'min' || $lowercasedName === 'max') {
  3896.             $normalizedName = $lowercasedName;
  3897.         }
  3899.         if (($f = $this->getBuiltinFunction($normalizedName)) && \is_callable($f)) {
  3900.             /** @var string $libName */
  3901.             $libName   = $f[1];
  3902.             $prototype = isset(static::$$libName) ? static::$$libName : null;
  3904.             // All core functions have a prototype defined. Not finding the
  3905.             // prototype can mean 2 things:
  3906.             // - the function comes from a child class (deprecated just after)
  3907.             // - the function was found with a different case, which relates to calling the
  3908.             //   wrong Sass function due to our camelCase usage (`fade-in()` vs `fadein()`),
  3909.             //   because PHP method names are case-insensitive while property names are
  3910.             //   case-sensitive.
  3911.             if ($prototype === null || strtolower($normalizedName) !== $normalizedName) {
  3912.                 $r = new \ReflectionMethod($this, $libName);
  3913.                 $actualLibName = $r->name;
  3915.                 if ($actualLibName !== $libName || strtolower($normalizedName) !== $normalizedName) {
  3916.                     $kebabCaseName = preg_replace('~(?<=\\w)([A-Z])~', '-$1', substr($actualLibName, 3));
  3917.                     assert($kebabCaseName !== null);
  3918.                     $originalName = strtolower($kebabCaseName);
  3919.                     $warning = "Calling built-in functions with a non-standard name is deprecated since Scssphp 1.8.0 and will not work anymore in 2.0 (they will be treated as CSS function calls instead).\nUse \"$originalName\" instead of \"$name\".";
  3920.                     @trigger_error($warning, E_USER_DEPRECATED);
  3921.                     $fname = $this->getPrettyPath($this->sourceNames[$this->sourceIndex]);
  3922.                     $line  = $this->sourceLine;
  3923.                     Warn::deprecation("$warning\n         on line $line of $fname");
  3925.                     // Use the actual function definition
  3926.                     $prototype = isset(static::$$actualLibName) ? static::$$actualLibName : null;
  3927.                     $f[1] = $libName = $actualLibName;
  3928.                 }
  3929.             }
  3931.             if (\get_class($this) !== __CLASS__ && !isset($this->warnedChildFunctions[$libName])) {
  3932.                 $r = new \ReflectionMethod($this, $libName);
  3933.                 $declaringClass = $r->getDeclaringClass()->name;
  3935.                 $needsWarning = $this->warnedChildFunctions[$libName] = $declaringClass !== __CLASS__;
  3937.                 if ($needsWarning) {
  3938.                     if (method_exists(__CLASS__, $libName)) {
  3939.                         @trigger_error(sprintf('Overriding the "%s" core function by extending the Compiler is deprecated and will be unsupported in 2.0. Remove the "%s::%s" method.', $normalizedName, $declaringClass, $libName), E_USER_DEPRECATED);
  3940.                     } else {
  3941.                         @trigger_error(sprintf('Registering custom functions by extending the Compiler and using the lib* discovery mechanism is deprecated and will be removed in 2.0. Replace the "%s::%s" method with registering the "%s" function through "Compiler::registerFunction".', $declaringClass, $libName, $normalizedName), E_USER_DEPRECATED);
  3942.                     }
  3943.                 }
  3944.             }
  3946.             return [Type::T_FUNCTION_REFERENCE, 'native', $name, $f, $prototype];
  3947.         }
  3949.         return static::$null;
  3950.     }
  3953.     /**
  3954.      * Normalize name
  3955.      *
  3956.      * @param string $name
  3957.      *
  3958.      * @return string
  3959.      */
  3960.     protected function normalizeName($name)
  3961.     {
  3962.         return str_replace('-', '_', $name);
  3963.     }
  3965.     /**
  3966.      * Normalize value
  3967.      *
  3968.      * @internal
  3969.      *
  3970.      * @param array|Number $value
  3971.      *
  3972.      * @return array|Number
  3973.      */
  3974.     public function normalizeValue($value)
  3975.     {
  3976.         $value = $this->coerceForExpression($this->reduce($value));
  3978.         if ($value instanceof Number) {
  3979.             return $value;
  3980.         }
  3982.         switch ($value[0]) {
  3983.             case Type::T_LIST:
  3984.                 $value = $this->extractInterpolation($value);
  3986.                 if ($value[0] !== Type::T_LIST) {
  3987.                     return [Type::T_KEYWORD, $this->compileValue($value)];
  3988.                 }
  3990.                 foreach ($value[2] as $key => $item) {
  3991.                     $value[2][$key] = $this->normalizeValue($item);
  3992.                 }
  3994.                 if (! empty($value['enclosing'])) {
  3995.                     unset($value['enclosing']);
  3996.                 }
  3998.                 if ($value[1] === '' && count($value[2]) > 1) {
  3999.                     $value[1] = ' ';
  4000.                 }
  4002.                 return $value;
  4004.             case Type::T_STRING:
  4005.                 return [$value[0], '"', [$this->compileStringContent($value)]];
  4007.             case Type::T_INTERPOLATE:
  4008.                 return [Type::T_KEYWORD, $this->compileValue($value)];
  4010.             default:
  4011.                 return $value;
  4012.         }
  4013.     }
  4015.     /**
  4016.      * Add numbers
  4017.      *
  4018.      * @param Number $left
  4019.      * @param Number $right
  4020.      *
  4021.      * @return Number
  4022.      */
  4023.     protected function opAddNumberNumber(Number $left, Number $right)
  4024.     {
  4025.         return $left->plus($right);
  4026.     }
  4028.     /**
  4029.      * Multiply numbers
  4030.      *
  4031.      * @param Number $left
  4032.      * @param Number $right
  4033.      *
  4034.      * @return Number
  4035.      */
  4036.     protected function opMulNumberNumber(Number $left, Number $right)
  4037.     {
  4038.         return $left->times($right);
  4039.     }
  4041.     /**
  4042.      * Subtract numbers
  4043.      *
  4044.      * @param Number $left
  4045.      * @param Number $right
  4046.      *
  4047.      * @return Number
  4048.      */
  4049.     protected function opSubNumberNumber(Number $left, Number $right)
  4050.     {
  4051.         return $left->minus($right);
  4052.     }
  4054.     /**
  4055.      * Divide numbers
  4056.      *
  4057.      * @param Number $left
  4058.      * @param Number $right
  4059.      *
  4060.      * @return Number
  4061.      */
  4062.     protected function opDivNumberNumber(Number $left, Number $right)
  4063.     {
  4064.         return $left->dividedBy($right);
  4065.     }
  4067.     /**
  4068.      * Mod numbers
  4069.      *
  4070.      * @param Number $left
  4071.      * @param Number $right
  4072.      *
  4073.      * @return Number
  4074.      */
  4075.     protected function opModNumberNumber(Number $left, Number $right)
  4076.     {
  4077.         return $left->modulo($right);
  4078.     }
  4080.     /**
  4081.      * Add strings
  4082.      *
  4083.      * @param array $left
  4084.      * @param array $right
  4085.      *
  4086.      * @return array|null
  4087.      */
  4088.     protected function opAdd($left, $right)
  4089.     {
  4090.         if ($strLeft = $this->coerceString($left)) {
  4091.             if ($right[0] === Type::T_STRING) {
  4092.                 $right[1] = '';
  4093.             }
  4095.             $strLeft[2][] = $right;
  4097.             return $strLeft;
  4098.         }
  4100.         if ($strRight = $this->coerceString($right)) {
  4101.             if ($left[0] === Type::T_STRING) {
  4102.                 $left[1] = '';
  4103.             }
  4105.             array_unshift($strRight[2], $left);
  4107.             return $strRight;
  4108.         }
  4110.         return null;
  4111.     }
  4113.     /**
  4114.      * Boolean and
  4115.      *
  4116.      * @param array|Number $left
  4117.      * @param array|Number $right
  4118.      * @param bool         $shouldEval
  4119.      *
  4120.      * @return array|Number|null
  4121.      */
  4122.     protected function opAnd($left, $right, $shouldEval)
  4123.     {
  4124.         $truthy = ($left === static::$null || $right === static::$null) ||
  4125.                   ($left === static::$false || $left === static::$true) &&
  4126.                   ($right === static::$false || $right === static::$true);
  4128.         if (! $shouldEval) {
  4129.             if (! $truthy) {
  4130.                 return null;
  4131.             }
  4132.         }
  4134.         if ($left !== static::$false && $left !== static::$null) {
  4135.             return $this->reduce($right, true);
  4136.         }
  4138.         return $left;
  4139.     }
  4141.     /**
  4142.      * Boolean or
  4143.      *
  4144.      * @param array|Number $left
  4145.      * @param array|Number $right
  4146.      * @param bool         $shouldEval
  4147.      *
  4148.      * @return array|Number|null
  4149.      */
  4150.     protected function opOr($left, $right, $shouldEval)
  4151.     {
  4152.         $truthy = ($left === static::$null || $right === static::$null) ||
  4153.                   ($left === static::$false || $left === static::$true) &&
  4154.                   ($right === static::$false || $right === static::$true);
  4156.         if (! $shouldEval) {
  4157.             if (! $truthy) {
  4158.                 return null;
  4159.             }
  4160.         }
  4162.         if ($left !== static::$false && $left !== static::$null) {
  4163.             return $left;
  4164.         }
  4166.         return $this->reduce($right, true);
  4167.     }
  4169.     /**
  4170.      * Compare colors
  4171.      *
  4172.      * @param string $op
  4173.      * @param array  $left
  4174.      * @param array  $right
  4175.      *
  4176.      * @return array
  4177.      */
  4178.     protected function opColorColor($op, $left, $right)
  4179.     {
  4180.         if ($op !== '==' && $op !== '!=') {
  4181.             $warning = "Color arithmetic is deprecated and will be an error in future versions.\n"
  4182.                 . "Consider using Sass's color functions instead.";
  4183.             $fname = $this->getPrettyPath($this->sourceNames[$this->sourceIndex]);
  4184.             $line  = $this->sourceLine;
  4186.             Warn::deprecation("$warning\n         on line $line of $fname");
  4187.         }
  4189.         $out = [Type::T_COLOR];
  4191.         foreach ([1, 2, 3] as $i) {
  4192.             $lval = isset($left[$i]) ? $left[$i] : 0;
  4193.             $rval = isset($right[$i]) ? $right[$i] : 0;
  4195.             switch ($op) {
  4196.                 case '+':
  4197.                     $out[] = $lval + $rval;
  4198.                     break;
  4200.                 case '-':
  4201.                     $out[] = $lval - $rval;
  4202.                     break;
  4204.                 case '*':
  4205.                     $out[] = $lval * $rval;
  4206.                     break;
  4208.                 case '%':
  4209.                     if ($rval == 0) {
  4210.                         throw $this->error("color: Can't take modulo by zero");
  4211.                     }
  4213.                     $out[] = $lval % $rval;
  4214.                     break;
  4216.                 case '/':
  4217.                     if ($rval == 0) {
  4218.                         throw $this->error("color: Can't divide by zero");
  4219.                     }
  4221.                     $out[] = (int) ($lval / $rval);
  4222.                     break;
  4224.                 case '==':
  4225.                     return $this->opEq($left, $right);
  4227.                 case '!=':
  4228.                     return $this->opNeq($left, $right);
  4230.                 default:
  4231.                     throw $this->error("color: unknown op $op");
  4232.             }
  4233.         }
  4235.         if (isset($left[4])) {
  4236.             $out[4] = $left[4];
  4237.         } elseif (isset($right[4])) {
  4238.             $out[4] = $right[4];
  4239.         }
  4241.         return $this->fixColor($out);
  4242.     }
  4244.     /**
  4245.      * Compare color and number
  4246.      *
  4247.      * @param string $op
  4248.      * @param array  $left
  4249.      * @param Number  $right
  4250.      *
  4251.      * @return array
  4252.      */
  4253.     protected function opColorNumber($op, $left, Number $right)
  4254.     {
  4255.         if ($op === '==') {
  4256.             return static::$false;
  4257.         }
  4259.         if ($op === '!=') {
  4260.             return static::$true;
  4261.         }
  4263.         $value = $right->getDimension();
  4265.         return $this->opColorColor(
  4266.             $op,
  4267.             $left,
  4268.             [Type::T_COLOR, $value, $value, $value]
  4269.         );
  4270.     }
  4272.     /**
  4273.      * Compare number and color
  4274.      *
  4275.      * @param string $op
  4276.      * @param Number  $left
  4277.      * @param array  $right
  4278.      *
  4279.      * @return array
  4280.      */
  4281.     protected function opNumberColor($op, Number $left, $right)
  4282.     {
  4283.         if ($op === '==') {
  4284.             return static::$false;
  4285.         }
  4287.         if ($op === '!=') {
  4288.             return static::$true;
  4289.         }
  4291.         $value = $left->getDimension();
  4293.         return $this->opColorColor(
  4294.             $op,
  4295.             [Type::T_COLOR, $value, $value, $value],
  4296.             $right
  4297.         );
  4298.     }
  4300.     /**
  4301.      * Compare number1 == number2
  4302.      *
  4303.      * @param array|Number $left
  4304.      * @param array|Number $right
  4305.      *
  4306.      * @return array
  4307.      */
  4308.     protected function opEq($left, $right)
  4309.     {
  4310.         if (($lStr = $this->coerceString($left)) && ($rStr = $this->coerceString($right))) {
  4311.             $lStr[1] = '';
  4312.             $rStr[1] = '';
  4314.             $left = $this->compileValue($lStr);
  4315.             $right = $this->compileValue($rStr);
  4316.         }
  4318.         return $this->toBool($left === $right);
  4319.     }
  4321.     /**
  4322.      * Compare number1 != number2
  4323.      *
  4324.      * @param array|Number $left
  4325.      * @param array|Number $right
  4326.      *
  4327.      * @return array
  4328.      */
  4329.     protected function opNeq($left, $right)
  4330.     {
  4331.         if (($lStr = $this->coerceString($left)) && ($rStr = $this->coerceString($right))) {
  4332.             $lStr[1] = '';
  4333.             $rStr[1] = '';
  4335.             $left = $this->compileValue($lStr);
  4336.             $right = $this->compileValue($rStr);
  4337.         }
  4339.         return $this->toBool($left !== $right);
  4340.     }
  4342.     /**
  4343.      * Compare number1 == number2
  4344.      *
  4345.      * @param Number $left
  4346.      * @param Number $right
  4347.      *
  4348.      * @return array
  4349.      */
  4350.     protected function opEqNumberNumber(Number $left, Number $right)
  4351.     {
  4352.         return $this->toBool($left->equals($right));
  4353.     }
  4355.     /**
  4356.      * Compare number1 != number2
  4357.      *
  4358.      * @param Number $left
  4359.      * @param Number $right
  4360.      *
  4361.      * @return array
  4362.      */
  4363.     protected function opNeqNumberNumber(Number $left, Number $right)
  4364.     {
  4365.         return $this->toBool(!$left->equals($right));
  4366.     }
  4368.     /**
  4369.      * Compare number1 >= number2
  4370.      *
  4371.      * @param Number $left
  4372.      * @param Number $right
  4373.      *
  4374.      * @return array
  4375.      */
  4376.     protected function opGteNumberNumber(Number $left, Number $right)
  4377.     {
  4378.         return $this->toBool($left->greaterThanOrEqual($right));
  4379.     }
  4381.     /**
  4382.      * Compare number1 > number2
  4383.      *
  4384.      * @param Number $left
  4385.      * @param Number $right
  4386.      *
  4387.      * @return array
  4388.      */
  4389.     protected function opGtNumberNumber(Number $left, Number $right)
  4390.     {
  4391.         return $this->toBool($left->greaterThan($right));
  4392.     }
  4394.     /**
  4395.      * Compare number1 <= number2
  4396.      *
  4397.      * @param Number $left
  4398.      * @param Number $right
  4399.      *
  4400.      * @return array
  4401.      */
  4402.     protected function opLteNumberNumber(Number $left, Number $right)
  4403.     {
  4404.         return $this->toBool($left->lessThanOrEqual($right));
  4405.     }
  4407.     /**
  4408.      * Compare number1 < number2
  4409.      *
  4410.      * @param Number $left
  4411.      * @param Number $right
  4412.      *
  4413.      * @return array
  4414.      */
  4415.     protected function opLtNumberNumber(Number $left, Number $right)
  4416.     {
  4417.         return $this->toBool($left->lessThan($right));
  4418.     }
  4420.     /**
  4421.      * Cast to boolean
  4422.      *
  4423.      * @api
  4424.      *
  4425.      * @param bool $thing
  4426.      *
  4427.      * @return array
  4428.      */
  4429.     public function toBool($thing)
  4430.     {
  4431.         return $thing ? static::$true : static::$false;
  4432.     }
  4434.     /**
  4435.      * Escape non printable chars in strings output as in dart-sass
  4436.      *
  4437.      * @internal
  4438.      *
  4439.      * @param string $string
  4440.      * @param bool   $inKeyword
  4441.      *
  4442.      * @return string
  4443.      */
  4444.     public function escapeNonPrintableChars($string, $inKeyword = false)
  4445.     {
  4446.         static $replacement = [];
  4447.         if (empty($replacement[$inKeyword])) {
  4448.             for ($i = 0; $i < 32; $i++) {
  4449.                 if ($i !== 9 || $inKeyword) {
  4450.                     $replacement[$inKeyword][chr($i)] = '\\' . dechex($i) . ($inKeyword ? ' ' : chr(0));
  4451.                 }
  4452.             }
  4453.         }
  4454.         $string = str_replace(array_keys($replacement[$inKeyword]), array_values($replacement[$inKeyword]), $string);
  4455.         // chr(0) is not a possible char from the input, so any chr(0) comes from our escaping replacement
  4456.         if (strpos($string, chr(0)) !== false) {
  4457.             if (substr($string, -1) === chr(0)) {
  4458.                 $string = substr($string, 0, -1);
  4459.             }
  4460.             $string = str_replace(
  4461.                 [chr(0) . '\\',chr(0) . ' '],
  4462.                 [ '\\', ' '],
  4463.                 $string
  4464.             );
  4465.             if (strpos($string, chr(0)) !== false) {
  4466.                 $parts = explode(chr(0), $string);
  4467.                 $string = array_shift($parts);
  4468.                 while (count($parts)) {
  4469.                     $next = array_shift($parts);
  4470.                     if (strpos("0123456789abcdefABCDEF" . chr(9), $next[0]) !== false) {
  4471.                         $string .= " ";
  4472.                     }
  4473.                     $string .= $next;
  4474.                 }
  4475.             }
  4476.         }
  4478.         return $string;
  4479.     }
  4481.     /**
  4482.      * Compiles a primitive value into a CSS property value.
  4483.      *
  4484.      * Values in scssphp are typed by being wrapped in arrays, their format is
  4485.      * typically:
  4486.      *
  4487.      *     array(type, contents [, additional_contents]*)
  4488.      *
  4489.      * The input is expected to be reduced. This function will not work on
  4490.      * things like expressions and variables.
  4491.      *
  4492.      * @api
  4493.      *
  4494.      * @param array|Number $value
  4495.      * @param bool         $quote
  4496.      *
  4497.      * @return string
  4498.      */
  4499.     public function compileValue($value, $quote = true)
  4500.     {
  4501.         $value = $this->reduce($value);
  4503.         if ($value instanceof Number) {
  4504.             return $value->output($this);
  4505.         }
  4507.         switch ($value[0]) {
  4508.             case Type::T_KEYWORD:
  4509.                 return $this->escapeNonPrintableChars($value[1], true);
  4511.             case Type::T_COLOR:
  4512.                 // [1] - red component (either number for a %)
  4513.                 // [2] - green component
  4514.                 // [3] - blue component
  4515.                 // [4] - optional alpha component
  4516.                 list(, $r, $g, $b) = $value;
  4518.                 $r = $this->compileRGBAValue($r);
  4519.                 $g = $this->compileRGBAValue($g);
  4520.                 $b = $this->compileRGBAValue($b);
  4522.                 if (\count($value) === 5) {
  4523.                     $alpha = $this->compileRGBAValue($value[4], true);
  4525.                     if (! is_numeric($alpha) || $alpha < 1) {
  4526.                         $colorName = Colors::RGBaToColorName($r, $g, $b, $alpha);
  4528.                         if (! \is_null($colorName)) {
  4529.                             return $colorName;
  4530.                         }
  4532.                         if (is_numeric($alpha)) {
  4533.                             $a = new Number($alpha, '');
  4534.                         } else {
  4535.                             $a = $alpha;
  4536.                         }
  4538.                         return 'rgba(' . $r . ', ' . $g . ', ' . $b . ', ' . $a . ')';
  4539.                     }
  4540.                 }
  4542.                 if (! is_numeric($r) || ! is_numeric($g) || ! is_numeric($b)) {
  4543.                     return 'rgb(' . $r . ', ' . $g . ', ' . $b . ')';
  4544.                 }
  4546.                 $colorName = Colors::RGBaToColorName($r, $g, $b);
  4548.                 if (! \is_null($colorName)) {
  4549.                     return $colorName;
  4550.                 }
  4552.                 $h = sprintf('#%02x%02x%02x', $r, $g, $b);
  4554.                 // Converting hex color to short notation (e.g. #003399 to #039)
  4555.                 if ($h[1] === $h[2] && $h[3] === $h[4] && $h[5] === $h[6]) {
  4556.                     $h = '#' . $h[1] . $h[3] . $h[5];
  4557.                 }
  4559.                 return $h;
  4561.             case Type::T_STRING:
  4562.                 $content = $this->compileStringContent($value, $quote);
  4564.                 if ($value[1] && $quote) {
  4565.                     $content = str_replace('\\', '\\\\', $content);
  4567.                     $content = $this->escapeNonPrintableChars($content);
  4569.                     // force double quote as string quote for the output in certain cases
  4570.                     if (
  4571.                         $value[1] === "'" &&
  4572.                         (strpos($content, '"') === false or strpos($content, "'") !== false)
  4573.                     ) {
  4574.                         $value[1] = '"';
  4575.                     } elseif (
  4576.                         $value[1] === '"' &&
  4577.                         (strpos($content, '"') !== false and strpos($content, "'") === false)
  4578.                     ) {
  4579.                         $value[1] = "'";
  4580.                     }
  4582.                     $content = str_replace($value[1], '\\' . $value[1], $content);
  4583.                 }
  4585.                 return $value[1] . $content . $value[1];
  4587.             case Type::T_FUNCTION:
  4588.                 $args = ! empty($value[2]) ? $this->compileValue($value[2], $quote) : '';
  4590.                 return "$value[1]($args)";
  4592.             case Type::T_FUNCTION_REFERENCE:
  4593.                 $name = ! empty($value[2]) ? $value[2] : '';
  4595.                 return "get-function(\"$name\")";
  4597.             case Type::T_LIST:
  4598.                 $value = $this->extractInterpolation($value);
  4600.                 if ($value[0] !== Type::T_LIST) {
  4601.                     return $this->compileValue($value, $quote);
  4602.                 }
  4604.                 list(, $delim, $items) = $value;
  4605.                 $pre = $post = '';
  4607.                 if (! empty($value['enclosing'])) {
  4608.                     switch ($value['enclosing']) {
  4609.                         case 'parent':
  4610.                             //$pre = '(';
  4611.                             //$post = ')';
  4612.                             break;
  4613.                         case 'forced_parent':
  4614.                             $pre = '(';
  4615.                             $post = ')';
  4616.                             break;
  4617.                         case 'bracket':
  4618.                         case 'forced_bracket':
  4619.                             $pre = '[';
  4620.                             $post = ']';
  4621.                             break;
  4622.                     }
  4623.                 }
  4625.                 $separator = $delim === '/' ? ' /' : $delim;
  4627.                 $prefix_value = '';
  4629.                 if ($delim !== ' ') {
  4630.                     $prefix_value = ' ';
  4631.                 }
  4633.                 $filtered = [];
  4635.                 $same_string_quote = null;
  4636.                 foreach ($items as $item) {
  4637.                     if (\is_null($same_string_quote)) {
  4638.                         $same_string_quote = false;
  4639.                         if ($item[0] === Type::T_STRING) {
  4640.                             $same_string_quote = $item[1];
  4641.                             foreach ($items as $ii) {
  4642.                                 if ($ii[0] !== Type::T_STRING) {
  4643.                                     $same_string_quote = false;
  4644.                                     break;
  4645.                                 }
  4646.                             }
  4647.                         }
  4648.                     }
  4649.                     if ($item[0] === Type::T_NULL) {
  4650.                         continue;
  4651.                     }
  4652.                     if ($same_string_quote === '"' && $item[0] === Type::T_STRING && $item[1]) {
  4653.                         $item[1] = $same_string_quote;
  4654.                     }
  4656.                     $compiled = $this->compileValue($item, $quote);
  4658.                     if ($prefix_value && \strlen($compiled)) {
  4659.                         $compiled = $prefix_value . $compiled;
  4660.                     }
  4662.                     $filtered[] = $compiled;
  4663.                 }
  4665.                 return $pre . substr(implode($separator, $filtered), \strlen($prefix_value)) . $post;
  4667.             case Type::T_MAP:
  4668.                 $keys     = $value[1];
  4669.                 $values   = $value[2];
  4670.                 $filtered = [];
  4672.                 for ($i = 0, $s = \count($keys); $i < $s; $i++) {
  4673.                     $filtered[$this->compileValue($keys[$i], $quote)] = $this->compileValue($values[$i], $quote);
  4674.                 }
  4676.                 array_walk($filtered, function (&$value, $key) {
  4677.                     $value = $key . ': ' . $value;
  4678.                 });
  4680.                 return '(' . implode(', ', $filtered) . ')';
  4682.             case Type::T_INTERPOLATED:
  4683.                 // node created by extractInterpolation
  4684.                 list(, $interpolate, $left, $right) = $value;
  4685.                 list(,, $whiteLeft, $whiteRight) = $interpolate;
  4687.                 $delim = $left[1];
  4689.                 if ($delim && $delim !== ' ' && ! $whiteLeft) {
  4690.                     $delim .= ' ';
  4691.                 }
  4693.                 $left = \count($left[2]) > 0
  4694.                     ?  $this->compileValue($left, $quote) . $delim . $whiteLeft
  4695.                     : '';
  4697.                 $delim = $right[1];
  4699.                 if ($delim && $delim !== ' ') {
  4700.                     $delim .= ' ';
  4701.                 }
  4703.                 $right = \count($right[2]) > 0 ?
  4704.                     $whiteRight . $delim . $this->compileValue($right, $quote) : '';
  4706.                 return $left . $this->compileValue($interpolate, $quote) . $right;
  4708.             case Type::T_INTERPOLATE:
  4709.                 // strip quotes if it's a string
  4710.                 $reduced = $this->reduce($value[1]);
  4712.                 if ($reduced instanceof Number) {
  4713.                     return $this->compileValue($reduced, $quote);
  4714.                 }
  4716.                 switch ($reduced[0]) {
  4717.                     case Type::T_LIST:
  4718.                         $reduced = $this->extractInterpolation($reduced);
  4720.                         if ($reduced[0] !== Type::T_LIST) {
  4721.                             break;
  4722.                         }
  4724.                         list(, $delim, $items) = $reduced;
  4726.                         if ($delim !== ' ') {
  4727.                             $delim .= ' ';
  4728.                         }
  4730.                         $filtered = [];
  4732.                         foreach ($items as $item) {
  4733.                             if ($item[0] === Type::T_NULL) {
  4734.                                 continue;
  4735.                             }
  4737.                             if ($item[0] === Type::T_STRING) {
  4738.                                 $filtered[] = $this->compileStringContent($item, $quote);
  4739.                             } elseif ($item[0] === Type::T_KEYWORD) {
  4740.                                 $filtered[] = $item[1];
  4741.                             } else {
  4742.                                 $filtered[] = $this->compileValue($item, $quote);
  4743.                             }
  4744.                         }
  4746.                         $reduced = [Type::T_KEYWORD, implode("$delim", $filtered)];
  4747.                         break;
  4749.                     case Type::T_STRING:
  4750.                         $reduced = [Type::T_STRING, '', [$this->compileStringContent($reduced)]];
  4751.                         break;
  4753.                     case Type::T_NULL:
  4754.                         $reduced = [Type::T_KEYWORD, ''];
  4755.                 }
  4757.                 return $this->compileValue($reduced, $quote);
  4759.             case Type::T_NULL:
  4760.                 return 'null';
  4762.             case Type::T_COMMENT:
  4763.                 return $this->compileCommentValue($value);
  4765.             default:
  4766.                 throw $this->error('unknown value type: ' . json_encode($value));
  4767.         }
  4768.     }
  4770.     /**
  4771.      * @param array|Number $value
  4772.      *
  4773.      * @return string
  4774.      */
  4775.     protected function compileDebugValue($value)
  4776.     {
  4777.         $value = $this->reduce($value, true);
  4779.         if ($value instanceof Number) {
  4780.             return $this->compileValue($value);
  4781.         }
  4783.         switch ($value[0]) {
  4784.             case Type::T_STRING:
  4785.                 return $this->compileStringContent($value);
  4787.             default:
  4788.                 return $this->compileValue($value);
  4789.         }
  4790.     }
  4792.     /**
  4793.      * Flatten list
  4794.      *
  4795.      * @param array $list
  4796.      *
  4797.      * @return string
  4798.      *
  4799.      * @deprecated
  4800.      */
  4801.     protected function flattenList($list)
  4802.     {
  4803.         @trigger_error(sprintf('The "%s" method is deprecated.', __METHOD__), E_USER_DEPRECATED);
  4805.         return $this->compileValue($list);
  4806.     }
  4808.     /**
  4809.      * Gets the text of a Sass string
  4810.      *
  4811.      * Calling this method on anything else than a SassString is unsupported. Use {@see assertString} first
  4812.      * to ensure that the value is indeed a string.
  4813.      *
  4814.      * @param array $value
  4815.      *
  4816.      * @return string
  4817.      */
  4818.     public function getStringText(array $value)
  4819.     {
  4820.         if ($value[0] !== Type::T_STRING) {
  4821.             throw new \InvalidArgumentException('The argument is not a sass string. Did you forgot to use "assertString"?');
  4822.         }
  4824.         return $this->compileStringContent($value);
  4825.     }
  4827.     /**
  4828.      * Compile string content
  4829.      *
  4830.      * @param array $string
  4831.      * @param bool  $quote
  4832.      *
  4833.      * @return string
  4834.      */
  4835.     protected function compileStringContent($string, $quote = true)
  4836.     {
  4837.         $parts = [];
  4839.         foreach ($string[2] as $part) {
  4840.             if (\is_array($part) || $part instanceof Number) {
  4841.                 $parts[] = $this->compileValue($part, $quote);
  4842.             } else {
  4843.                 $parts[] = $part;
  4844.             }
  4845.         }
  4847.         return implode($parts);
  4848.     }
  4850.     /**
  4851.      * Extract interpolation; it doesn't need to be recursive, compileValue will handle that
  4852.      *
  4853.      * @param array $list
  4854.      *
  4855.      * @return array
  4856.      */
  4857.     protected function extractInterpolation($list)
  4858.     {
  4859.         $items = $list[2];
  4861.         foreach ($items as $i => $item) {
  4862.             if ($item[0] === Type::T_INTERPOLATE) {
  4863.                 $before = [Type::T_LIST, $list[1], \array_slice($items, 0, $i)];
  4864.                 $after  = [Type::T_LIST, $list[1], \array_slice($items, $i + 1)];
  4866.                 return [Type::T_INTERPOLATED, $item, $before, $after];
  4867.             }
  4868.         }
  4870.         return $list;
  4871.     }
  4873.     /**
  4874.      * Find the final set of selectors
  4875.      *
  4876.      * @param \ScssPhp\ScssPhp\Compiler\Environment $env
  4877.      * @param \ScssPhp\ScssPhp\Block                $selfParent
  4878.      *
  4879.      * @return array
  4880.      */
  4881.     protected function multiplySelectors(Environment $env, $selfParent = null)
  4882.     {
  4883.         $envs            = $this->compactEnv($env);
  4884.         $selectors       = [];
  4885.         $parentSelectors = [[]];
  4887.         $selfParentSelectors = null;
  4889.         if (! \is_null($selfParent) && $selfParent->selectors) {
  4890.             $selfParentSelectors = $this->evalSelectors($selfParent->selectors);
  4891.         }
  4893.         while ($env = array_pop($envs)) {
  4894.             if (empty($env->selectors)) {
  4895.                 continue;
  4896.             }
  4898.             $selectors = $env->selectors;
  4900.             do {
  4901.                 $stillHasSelf  = false;
  4902.                 $prevSelectors = $selectors;
  4903.                 $selectors     = [];
  4905.                 foreach ($parentSelectors as $parent) {
  4906.                     foreach ($prevSelectors as $selector) {
  4907.                         if ($selfParentSelectors) {
  4908.                             foreach ($selfParentSelectors as $selfParent) {
  4909.                                 // if no '&' in the selector, each call will give same result, only add once
  4910.                                 $s = $this->joinSelectors($parent, $selector, $stillHasSelf, $selfParent);
  4911.                                 $selectors[serialize($s)] = $s;
  4912.                             }
  4913.                         } else {
  4914.                             $s = $this->joinSelectors($parent, $selector, $stillHasSelf);
  4915.                             $selectors[serialize($s)] = $s;
  4916.                         }
  4917.                     }
  4918.                 }
  4919.             } while ($stillHasSelf);
  4921.             $parentSelectors = $selectors;
  4922.         }
  4924.         $selectors = array_values($selectors);
  4926.         // case we are just starting a at-root : nothing to multiply but parentSelectors
  4927.         if (! $selectors && $selfParentSelectors) {
  4928.             $selectors = $selfParentSelectors;
  4929.         }
  4931.         return $selectors;
  4932.     }
  4934.     /**
  4935.      * Join selectors; looks for & to replace, or append parent before child
  4936.      *
  4937.      * @param array $parent
  4938.      * @param array $child
  4939.      * @param bool  $stillHasSelf
  4940.      * @param array $selfParentSelectors
  4942.      * @return array
  4943.      */
  4944.     protected function joinSelectors($parent, $child, &$stillHasSelf, $selfParentSelectors = null)
  4945.     {
  4946.         $setSelf = false;
  4947.         $out = [];
  4949.         foreach ($child as $part) {
  4950.             $newPart = [];
  4952.             foreach ($part as $p) {
  4953.                 // only replace & once and should be recalled to be able to make combinations
  4954.                 if ($p === static::$selfSelector && $setSelf) {
  4955.                     $stillHasSelf = true;
  4956.                 }
  4958.                 if ($p === static::$selfSelector && ! $setSelf) {
  4959.                     $setSelf = true;
  4961.                     if (\is_null($selfParentSelectors)) {
  4962.                         $selfParentSelectors = $parent;
  4963.                     }
  4965.                     foreach ($selfParentSelectors as $i => $parentPart) {
  4966.                         if ($i > 0) {
  4967.                             $out[] = $newPart;
  4968.                             $newPart = [];
  4969.                         }
  4971.                         foreach ($parentPart as $pp) {
  4972.                             if (\is_array($pp)) {
  4973.                                 $flatten = [];
  4975.                                 array_walk_recursive($pp, function ($a) use (&$flatten) {
  4976.                                     $flatten[] = $a;
  4977.                                 });
  4979.                                 $pp = implode($flatten);
  4980.                             }
  4982.                             $newPart[] = $pp;
  4983.                         }
  4984.                     }
  4985.                 } else {
  4986.                     $newPart[] = $p;
  4987.                 }
  4988.             }
  4990.             $out[] = $newPart;
  4991.         }
  4993.         return $setSelf ? $out : array_merge($parent, $child);
  4994.     }
  4996.     /**
  4997.      * Multiply media
  4998.      *
  4999.      * @param \ScssPhp\ScssPhp\Compiler\Environment $env
  5000.      * @param array                                 $childQueries
  5001.      *
  5002.      * @return array
  5003.      */
  5004.     protected function multiplyMedia(Environment $env = null, $childQueries = null)
  5005.     {
  5006.         if (
  5007.             ! isset($env) ||
  5008.             ! empty($env->block->type) && $env->block->type !== Type::T_MEDIA
  5009.         ) {
  5010.             return $childQueries;
  5011.         }
  5013.         // plain old block, skip
  5014.         if (empty($env->block->type)) {
  5015.             return $this->multiplyMedia($env->parent, $childQueries);
  5016.         }
  5018.         assert($env->block instanceof MediaBlock);
  5020.         $parentQueries = isset($env->block->queryList)
  5021.             ? $env->block->queryList
  5022.             : [[[Type::T_MEDIA_VALUE, $env->block->value]]];
  5024.         $store = [$this->env, $this->storeEnv];
  5026.         $this->env      = $env;
  5027.         $this->storeEnv = null;
  5028.         $parentQueries  = $this->evaluateMediaQuery($parentQueries);
  5030.         list($this->env, $this->storeEnv) = $store;
  5032.         if (\is_null($childQueries)) {
  5033.             $childQueries = $parentQueries;
  5034.         } else {
  5035.             $originalQueries = $childQueries;
  5036.             $childQueries = [];
  5038.             foreach ($parentQueries as $parentQuery) {
  5039.                 foreach ($originalQueries as $childQuery) {
  5040.                     $childQueries[] = array_merge(
  5041.                         $parentQuery,
  5042.                         [[Type::T_MEDIA_TYPE, [Type::T_KEYWORD, 'all']]],
  5043.                         $childQuery
  5044.                     );
  5045.                 }
  5046.             }
  5047.         }
  5049.         return $this->multiplyMedia($env->parent, $childQueries);
  5050.     }
  5052.     /**
  5053.      * Convert env linked list to stack
  5054.      *
  5055.      * @param Environment $env
  5056.      *
  5057.      * @return Environment[]
  5058.      *
  5059.      * @phpstan-return non-empty-array<Environment>
  5060.      */
  5061.     protected function compactEnv(Environment $env)
  5062.     {
  5063.         for ($envs = []; $env; $env = $env->parent) {
  5064.             $envs[] = $env;
  5065.         }
  5067.         return $envs;
  5068.     }
  5070.     /**
  5071.      * Convert env stack to singly linked list
  5072.      *
  5073.      * @param Environment[] $envs
  5074.      *
  5075.      * @return Environment
  5076.      *
  5077.      * @phpstan-param  non-empty-array<Environment> $envs
  5078.      */
  5079.     protected function extractEnv($envs)
  5080.     {
  5081.         for ($env = null; $e = array_pop($envs);) {
  5082.             $e->parent = $env;
  5083.             $env = $e;
  5084.         }
  5086.         return $env;
  5087.     }
  5089.     /**
  5090.      * Push environment
  5091.      *
  5092.      * @param \ScssPhp\ScssPhp\Block $block
  5093.      *
  5094.      * @return \ScssPhp\ScssPhp\Compiler\Environment
  5095.      */
  5096.     protected function pushEnv(Block $block = null)
  5097.     {
  5098.         $env = new Environment();
  5099.         $env->parent = $this->env;
  5100.         $env->parentStore = $this->storeEnv;
  5101.         $env->store  = [];
  5102.         $env->block  = $block;
  5103.         $env->depth  = isset($this->env->depth) ? $this->env->depth + 1 : 0;
  5105.         $this->env = $env;
  5106.         $this->storeEnv = null;
  5108.         return $env;
  5109.     }
  5111.     /**
  5112.      * Pop environment
  5113.      *
  5114.      * @return void
  5115.      */
  5116.     protected function popEnv()
  5117.     {
  5118.         $this->storeEnv = $this->env->parentStore;
  5119.         $this->env = $this->env->parent;
  5120.     }
  5122.     /**
  5123.      * Propagate vars from a just poped Env (used in @each and @for)
  5124.      *
  5125.      * @param array         $store
  5126.      * @param null|string[] $excludedVars
  5127.      *
  5128.      * @return void
  5129.      */
  5130.     protected function backPropagateEnv($store, $excludedVars = null)
  5131.     {
  5132.         foreach ($store as $key => $value) {
  5133.             if (empty($excludedVars) || ! \in_array($key, $excludedVars)) {
  5134.                 $this->set($key, $value, true);
  5135.             }
  5136.         }
  5137.     }
  5139.     /**
  5140.      * Get store environment
  5141.      *
  5142.      * @return \ScssPhp\ScssPhp\Compiler\Environment
  5143.      */
  5144.     protected function getStoreEnv()
  5145.     {
  5146.         return isset($this->storeEnv) ? $this->storeEnv : $this->env;
  5147.     }
  5149.     /**
  5150.      * Set variable
  5151.      *
  5152.      * @param string                                $name
  5153.      * @param mixed                                 $value
  5154.      * @param bool                                  $shadow
  5155.      * @param \ScssPhp\ScssPhp\Compiler\Environment $env
  5156.      * @param mixed                                 $valueUnreduced
  5157.      *
  5158.      * @return void
  5159.      */
  5160.     protected function set($name, $value, $shadow = false, Environment $env = null, $valueUnreduced = null)
  5161.     {
  5162.         $name = $this->normalizeName($name);
  5164.         if (! isset($env)) {
  5165.             $env = $this->getStoreEnv();
  5166.         }
  5168.         if ($shadow) {
  5169.             $this->setRaw($name, $value, $env, $valueUnreduced);
  5170.         } else {
  5171.             $this->setExisting($name, $value, $env, $valueUnreduced);
  5172.         }
  5173.     }
  5175.     /**
  5176.      * Set existing variable
  5177.      *
  5178.      * @param string                                $name
  5179.      * @param mixed                                 $value
  5180.      * @param \ScssPhp\ScssPhp\Compiler\Environment $env
  5181.      * @param mixed                                 $valueUnreduced
  5182.      *
  5183.      * @return void
  5184.      */
  5185.     protected function setExisting($name, $value, Environment $env, $valueUnreduced = null)
  5186.     {
  5187.         $storeEnv = $env;
  5188.         $specialContentKey = static::$namespaces['special'] . 'content';
  5190.         $hasNamespace = $name[0] === '^' || $name[0] === '@' || $name[0] === '%';
  5192.         $maxDepth = 10000;
  5194.         for (;;) {
  5195.             if ($maxDepth-- <= 0) {
  5196.                 break;
  5197.             }
  5199.             if (\array_key_exists($name, $env->store)) {
  5200.                 break;
  5201.             }
  5203.             if (! $hasNamespace && isset($env->marker)) {
  5204.                 if (! empty($env->store[$specialContentKey])) {
  5205.                     $env = $env->store[$specialContentKey]->scope;
  5206.                     continue;
  5207.                 }
  5209.                 if (! empty($env->declarationScopeParent)) {
  5210.                     $env = $env->declarationScopeParent;
  5211.                     continue;
  5212.                 } else {
  5213.                     $env = $storeEnv;
  5214.                     break;
  5215.                 }
  5216.             }
  5218.             if (isset($env->parentStore)) {
  5219.                 $env = $env->parentStore;
  5220.             } elseif (isset($env->parent)) {
  5221.                 $env = $env->parent;
  5222.             } else {
  5223.                 $env = $storeEnv;
  5224.                 break;
  5225.             }
  5226.         }
  5228.         $env->store[$name] = $value;
  5230.         if ($valueUnreduced) {
  5231.             $env->storeUnreduced[$name] = $valueUnreduced;
  5232.         }
  5233.     }
  5235.     /**
  5236.      * Set raw variable
  5237.      *
  5238.      * @param string                                $name
  5239.      * @param mixed                                 $value
  5240.      * @param \ScssPhp\ScssPhp\Compiler\Environment $env
  5241.      * @param mixed                                 $valueUnreduced
  5242.      *
  5243.      * @return void
  5244.      */
  5245.     protected function setRaw($name, $value, Environment $env, $valueUnreduced = null)
  5246.     {
  5247.         $env->store[$name] = $value;
  5249.         if ($valueUnreduced) {
  5250.             $env->storeUnreduced[$name] = $valueUnreduced;
  5251.         }
  5252.     }
  5254.     /**
  5255.      * Get variable
  5256.      *
  5257.      * @internal
  5258.      *
  5259.      * @param string                                $name
  5260.      * @param bool                                  $shouldThrow
  5261.      * @param \ScssPhp\ScssPhp\Compiler\Environment $env
  5262.      * @param bool                                  $unreduced
  5263.      *
  5264.      * @return mixed|null
  5265.      */
  5266.     public function get($name, $shouldThrow = true, Environment $env = null, $unreduced = false)
  5267.     {
  5268.         $normalizedName = $this->normalizeName($name);
  5269.         $specialContentKey = static::$namespaces['special'] . 'content';
  5271.         if (! isset($env)) {
  5272.             $env = $this->getStoreEnv();
  5273.         }
  5275.         $hasNamespace = $normalizedName[0] === '^' || $normalizedName[0] === '@' || $normalizedName[0] === '%';
  5277.         $maxDepth = 10000;
  5279.         for (;;) {
  5280.             if ($maxDepth-- <= 0) {
  5281.                 break;
  5282.             }
  5284.             if (\array_key_exists($normalizedName, $env->store)) {
  5285.                 if ($unreduced && isset($env->storeUnreduced[$normalizedName])) {
  5286.                     return $env->storeUnreduced[$normalizedName];
  5287.                 }
  5289.                 return $env->store[$normalizedName];
  5290.             }
  5292.             if (! $hasNamespace && isset($env->marker)) {
  5293.                 if (! empty($env->store[$specialContentKey])) {
  5294.                     $env = $env->store[$specialContentKey]->scope;
  5295.                     continue;
  5296.                 }
  5298.                 if (! empty($env->declarationScopeParent)) {
  5299.                     $env = $env->declarationScopeParent;
  5300.                 } else {
  5301.                     $env = $this->rootEnv;
  5302.                 }
  5303.                 continue;
  5304.             }
  5306.             if (isset($env->parentStore)) {
  5307.                 $env = $env->parentStore;
  5308.             } elseif (isset($env->parent)) {
  5309.                 $env = $env->parent;
  5310.             } else {
  5311.                 break;
  5312.             }
  5313.         }
  5315.         if ($shouldThrow) {
  5316.             throw $this->error("Undefined variable \$$name" . ($maxDepth <= 0 ? ' (infinite recursion)' : ''));
  5317.         }
  5319.         // found nothing
  5320.         return null;
  5321.     }
  5323.     /**
  5324.      * Has variable?
  5325.      *
  5326.      * @param string                                $name
  5327.      * @param \ScssPhp\ScssPhp\Compiler\Environment $env
  5328.      *
  5329.      * @return bool
  5330.      */
  5331.     protected function has($name, Environment $env = null)
  5332.     {
  5333.         return ! \is_null($this->get($name, false, $env));
  5334.     }
  5336.     /**
  5337.      * Inject variables
  5338.      *
  5339.      * @param array $args
  5340.      *
  5341.      * @return void
  5342.      */
  5343.     protected function injectVariables(array $args)
  5344.     {
  5345.         if (empty($args)) {
  5346.             return;
  5347.         }
  5349.         $parser = $this->parserFactory(__METHOD__);
  5351.         foreach ($args as $name => $strValue) {
  5352.             if ($name[0] === '$') {
  5353.                 $name = substr($name, 1);
  5354.             }
  5356.             if (!\is_string($strValue) || ! $parser->parseValue($strValue, $value)) {
  5357.                 $value = $this->coerceValue($strValue);
  5358.             }
  5360.             $this->set($name, $value);
  5361.         }
  5362.     }
  5364.     /**
  5365.      * Replaces variables.
  5366.      *
  5367.      * @param array<string, mixed> $variables
  5368.      *
  5369.      * @return void
  5370.      */
  5371.     public function replaceVariables(array $variables)
  5372.     {
  5373.         $this->registeredVars = [];
  5374.         $this->addVariables($variables);
  5375.     }
  5377.     /**
  5378.      * Replaces variables.
  5379.      *
  5380.      * @param array<string, mixed> $variables
  5381.      *
  5382.      * @return void
  5383.      */
  5384.     public function addVariables(array $variables)
  5385.     {
  5386.         $triggerWarning = false;
  5388.         foreach ($variables as $name => $value) {
  5389.             if (!$value instanceof Number && !\is_array($value)) {
  5390.                 $triggerWarning = true;
  5391.             }
  5393.             $this->registeredVars[$name] = $value;
  5394.         }
  5396.         if ($triggerWarning) {
  5397.             @trigger_error('Passing raw values to as custom variables to the Compiler is deprecated. Use "\ScssPhp\ScssPhp\ValueConverter::parseValue" or "\ScssPhp\ScssPhp\ValueConverter::fromPhp" to convert them instead.', E_USER_DEPRECATED);
  5398.         }
  5399.     }
  5401.     /**
  5402.      * Set variables
  5403.      *
  5404.      * @api
  5405.      *
  5406.      * @param array $variables
  5407.      *
  5408.      * @return void
  5409.      *
  5410.      * @deprecated Use "addVariables" or "replaceVariables" instead.
  5411.      */
  5412.     public function setVariables(array $variables)
  5413.     {
  5414.         @trigger_error('The method "setVariables" of the Compiler is deprecated. Use the "addVariables" method for the equivalent behavior or "replaceVariables" if merging with previous variables was not desired.');
  5416.         $this->addVariables($variables);
  5417.     }
  5419.     /**
  5420.      * Unset variable
  5421.      *
  5422.      * @api
  5423.      *
  5424.      * @param string $name
  5425.      *
  5426.      * @return void
  5427.      */
  5428.     public function unsetVariable($name)
  5429.     {
  5430.         unset($this->registeredVars[$name]);
  5431.     }
  5433.     /**
  5434.      * Returns list of variables
  5435.      *
  5436.      * @api
  5437.      *
  5438.      * @return array
  5439.      */
  5440.     public function getVariables()
  5441.     {
  5442.         return $this->registeredVars;
  5443.     }
  5445.     /**
  5446.      * Adds to list of parsed files
  5447.      *
  5448.      * @internal
  5449.      *
  5450.      * @param string|null $path
  5451.      *
  5452.      * @return void
  5453.      */
  5454.     public function addParsedFile($path)
  5455.     {
  5456.         if (! \is_null($path) && is_file($path)) {
  5457.             $this->parsedFiles[realpath($path)] = filemtime($path);
  5458.         }
  5459.     }
  5461.     /**
  5462.      * Returns list of parsed files
  5463.      *
  5464.      * @deprecated
  5465.      * @return array<string, int>
  5466.      */
  5467.     public function getParsedFiles()
  5468.     {
  5469.         @trigger_error('The method "getParsedFiles" of the Compiler is deprecated. Use the "getIncludedFiles" method on the CompilationResult instance returned by compileString() instead. Be careful that the signature of the method is different.', E_USER_DEPRECATED);
  5470.         return $this->parsedFiles;
  5471.     }
  5473.     /**
  5474.      * Add import path
  5475.      *
  5476.      * @api
  5477.      *
  5478.      * @param string|callable $path
  5479.      *
  5480.      * @return void
  5481.      */
  5482.     public function addImportPath($path)
  5483.     {
  5484.         if (! \in_array($path, $this->importPaths)) {
  5485.             $this->importPaths[] = $path;
  5486.         }
  5487.     }
  5489.     /**
  5490.      * Set import paths
  5491.      *
  5492.      * @api
  5493.      *
  5494.      * @param string|array<string|callable> $path
  5495.      *
  5496.      * @return void
  5497.      */
  5498.     public function setImportPaths($path)
  5499.     {
  5500.         $paths = (array) $path;
  5501.         $actualImportPaths = array_filter($paths, function ($path) {
  5502.             return $path !== '';
  5503.         });
  5505.         $this->legacyCwdImportPath = \count($actualImportPaths) !== \count($paths);
  5507.         if ($this->legacyCwdImportPath) {
  5508.             @trigger_error('Passing an empty string in the import paths to refer to the current working directory is deprecated. If that\'s the intended behavior, the value of "getcwd()" should be used directly instead. If this was used for resolving relative imports of the input alongside "chdir" with the source directory, the path of the input file should be passed to "compileString()" instead.', E_USER_DEPRECATED);
  5509.         }
  5511.         $this->importPaths = $actualImportPaths;
  5512.     }
  5514.     /**
  5515.      * Set number precision
  5516.      *
  5517.      * @api
  5518.      *
  5519.      * @param int $numberPrecision
  5520.      *
  5521.      * @return void
  5522.      *
  5523.      * @deprecated The number precision is not configurable anymore. The default is enough for all browsers.
  5524.      */
  5525.     public function setNumberPrecision($numberPrecision)
  5526.     {
  5527.         @trigger_error('The number precision is not configurable anymore. '
  5528.             . 'The default is enough for all browsers.', E_USER_DEPRECATED);
  5529.     }
  5531.     /**
  5532.      * Sets the output style.
  5533.      *
  5534.      * @api
  5535.      *
  5536.      * @param string $style One of the OutputStyle constants
  5537.      *
  5538.      * @return void
  5539.      *
  5540.      * @phpstan-param OutputStyle::* $style
  5541.      */
  5542.     public function setOutputStyle($style)
  5543.     {
  5544.         switch ($style) {
  5545.             case OutputStyle::EXPANDED:
  5546.                 $this->configuredFormatter = Expanded::class;
  5547.                 break;
  5549.             case OutputStyle::COMPRESSED:
  5550.                 $this->configuredFormatter = Compressed::class;
  5551.                 break;
  5553.             default:
  5554.                 throw new \InvalidArgumentException(sprintf('Invalid output style "%s".', $style));
  5555.         }
  5556.     }
  5558.     /**
  5559.      * Set formatter
  5560.      *
  5561.      * @api
  5562.      *
  5563.      * @param string $formatterName
  5564.      *
  5565.      * @return void
  5566.      *
  5567.      * @deprecated Use {@see setOutputStyle} instead.
  5568.      *
  5569.      * @phpstan-param class-string<Formatter> $formatterName
  5570.      */
  5571.     public function setFormatter($formatterName)
  5572.     {
  5573.         if (!\in_array($formatterName, [Expanded::class, Compressed::class], true)) {
  5574.             @trigger_error('Formatters other than Expanded and Compressed are deprecated.', E_USER_DEPRECATED);
  5575.         }
  5576.         @trigger_error('The method "setFormatter" is deprecated. Use "setOutputStyle" instead.', E_USER_DEPRECATED);
  5578.         $this->configuredFormatter = $formatterName;
  5579.     }
  5581.     /**
  5582.      * Set line number style
  5583.      *
  5584.      * @api
  5585.      *
  5586.      * @param string $lineNumberStyle
  5587.      *
  5588.      * @return void
  5589.      *
  5590.      * @deprecated The line number output is not supported anymore. Use source maps instead.
  5591.      */
  5592.     public function setLineNumberStyle($lineNumberStyle)
  5593.     {
  5594.         @trigger_error('The line number output is not supported anymore. '
  5595.                        . 'Use source maps instead.', E_USER_DEPRECATED);
  5596.     }
  5598.     /**
  5599.      * Configures the handling of non-ASCII outputs.
  5600.      *
  5601.      * If $charset is `true`, this will include a `@charset` declaration or a
  5602.      * UTF-8 [byte-order mark][] if the stylesheet contains any non-ASCII
  5603.      * characters. Otherwise, it will never include a `@charset` declaration or a
  5604.      * byte-order mark.
  5605.      *
  5606.      * [byte-order mark]: https://en.wikipedia.org/wiki/Byte_order_mark#UTF-8
  5607.      *
  5608.      * @param bool $charset
  5609.      *
  5610.      * @return void
  5611.      */
  5612.     public function setCharset($charset)
  5613.     {
  5614.         $this->charset = $charset;
  5615.     }
  5617.     /**
  5618.      * Enable/disable source maps
  5619.      *
  5620.      * @api
  5621.      *
  5622.      * @param int $sourceMap
  5623.      *
  5624.      * @return void
  5625.      *
  5626.      * @phpstan-param self::SOURCE_MAP_* $sourceMap
  5627.      */
  5628.     public function setSourceMap($sourceMap)
  5629.     {
  5630.         $this->sourceMap = $sourceMap;
  5631.     }
  5633.     /**
  5634.      * Set source map options
  5635.      *
  5636.      * @api
  5637.      *
  5638.      * @param array $sourceMapOptions
  5639.      *
  5640.      * @phpstan-param  array{sourceRoot?: string, sourceMapFilename?: string|null, sourceMapURL?: string|null, sourceMapWriteTo?: string|null, outputSourceFiles?: bool, sourceMapRootpath?: string, sourceMapBasepath?: string} $sourceMapOptions
  5641.      *
  5642.      * @return void
  5643.      */
  5644.     public function setSourceMapOptions($sourceMapOptions)
  5645.     {
  5646.         $this->sourceMapOptions = $sourceMapOptions;
  5647.     }
  5649.     /**
  5650.      * Register function
  5651.      *
  5652.      * @api
  5653.      *
  5654.      * @param string        $name
  5655.      * @param callable      $callback
  5656.      * @param string[]|null $argumentDeclaration
  5657.      *
  5658.      * @return void
  5659.      */
  5660.     public function registerFunction($name, $callback, $argumentDeclaration = null)
  5661.     {
  5662.         if (self::isNativeFunction($name)) {
  5663.             @trigger_error(sprintf('The "%s" function is a core sass function. Overriding it with a custom implementation through "%s" is deprecated and won\'t be supported in ScssPhp 2.0 anymore.', $name, __METHOD__), E_USER_DEPRECATED);
  5664.         }
  5666.         if ($argumentDeclaration === null) {
  5667.             @trigger_error('Omitting the argument declaration when registering custom function is deprecated and won\'t be supported in ScssPhp 2.0 anymore.', E_USER_DEPRECATED);
  5668.         }
  5670.         $this->userFunctions[$this->normalizeName($name)] = [$callback, $argumentDeclaration];
  5671.     }
  5673.     /**
  5674.      * Unregister function
  5675.      *
  5676.      * @api
  5677.      *
  5678.      * @param string $name
  5679.      *
  5680.      * @return void
  5681.      */
  5682.     public function unregisterFunction($name)
  5683.     {
  5684.         unset($this->userFunctions[$this->normalizeName($name)]);
  5685.     }
  5687.     /**
  5688.      * Add feature
  5689.      *
  5690.      * @api
  5691.      *
  5692.      * @param string $name
  5693.      *
  5694.      * @return void
  5695.      *
  5696.      * @deprecated Registering additional features is deprecated.
  5697.      */
  5698.     public function addFeature($name)
  5699.     {
  5700.         @trigger_error('Registering additional features is deprecated.', E_USER_DEPRECATED);
  5702.         $this->registeredFeatures[$name] = true;
  5703.     }
  5705.     /**
  5706.      * Import file
  5707.      *
  5708.      * @param string                                 $path
  5709.      * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
  5710.      *
  5711.      * @return void
  5712.      */
  5713.     protected function importFile($path, OutputBlock $out)
  5714.     {
  5715.         $this->pushCallStack('import ' . $this->getPrettyPath($path));
  5716.         // see if tree is cached
  5717.         $realPath = realpath($path);
  5719.         if ($realPath === false) {
  5720.             $realPath = $path;
  5721.         }
  5723.         if (substr($path, -5) === '.sass') {
  5724.             $this->sourceIndex = \count($this->sourceNames);
  5725.             $this->sourceNames[] = $path;
  5726.             $this->sourceLine = 1;
  5727.             $this->sourceColumn = 1;
  5729.             throw $this->error('The Sass indented syntax is not implemented.');
  5730.         }
  5732.         if (isset($this->importCache[$realPath])) {
  5733.             $this->handleImportLoop($realPath);
  5735.             $tree = $this->importCache[$realPath];
  5736.         } else {
  5737.             $code   = file_get_contents($path);
  5738.             $parser = $this->parserFactory($path);
  5739.             $tree   = $parser->parse($code);
  5741.             $this->importCache[$realPath] = $tree;
  5742.         }
  5744.         $currentDirectory = $this->currentDirectory;
  5745.         $this->currentDirectory = dirname($path);
  5747.         $this->compileChildrenNoReturn($tree->children, $out);
  5748.         $this->currentDirectory = $currentDirectory;
  5749.         $this->popCallStack();
  5750.     }
  5752.     /**
  5753.      * Save the imported files with their resolving path context
  5754.      *
  5755.      * @param string|null $currentDirectory
  5756.      * @param string      $path
  5757.      * @param string      $filePath
  5758.      *
  5759.      * @return void
  5760.      */
  5761.     private function registerImport($currentDirectory, $path, $filePath)
  5762.     {
  5763.         $this->resolvedImports[] = ['currentDir' => $currentDirectory, 'path' => $path, 'filePath' => $filePath];
  5764.     }
  5766.     /**
  5767.      * Detects whether the import is a CSS import.
  5768.      *
  5769.      * For legacy reasons, custom importers are called for those, allowing them
  5770.      * to replace them with an actual Sass import. However this behavior is
  5771.      * deprecated. Custom importers are expected to return null when they receive
  5772.      * a CSS import.
  5773.      *
  5774.      * @param string $url
  5775.      *
  5776.      * @return bool
  5777.      */
  5778.     public static function isCssImport($url)
  5779.     {
  5780.         return 1 === preg_match('~\.css$|^https?://|^//~', $url);
  5781.     }
  5783.     /**
  5784.      * Return the file path for an import url if it exists
  5785.      *
  5786.      * @internal
  5787.      *
  5788.      * @param string      $url
  5789.      * @param string|null $currentDir
  5790.      *
  5791.      * @return string|null
  5792.      */
  5793.     public function findImport($url, $currentDir = null)
  5794.     {
  5795.         // Vanilla css and external requests. These are not meant to be Sass imports.
  5796.         // Callback importers are still called for BC.
  5797.         if (self::isCssImport($url)) {
  5798.             foreach ($this->importPaths as $dir) {
  5799.                 if (\is_string($dir)) {
  5800.                     continue;
  5801.                 }
  5803.                 if (\is_callable($dir)) {
  5804.                     // check custom callback for import path
  5805.                     $file = \call_user_func($dir, $url);
  5807.                     if (! \is_null($file)) {
  5808.                         if (\is_array($dir)) {
  5809.                             $callableDescription = (\is_object($dir[0]) ? \get_class($dir[0]) : $dir[0]).'::'.$dir[1];
  5810.                         } elseif ($dir instanceof \Closure) {
  5811.                             $r = new \ReflectionFunction($dir);
  5812.                             if (false !== strpos($r->name, '{closure}')) {
  5813.                                 $callableDescription = sprintf('closure{%s:%s}', $r->getFileName(), $r->getStartLine());
  5814.                             } elseif ($class = $r->getClosureScopeClass()) {
  5815.                                 $callableDescription = $class->name.'::'.$r->name;
  5816.                             } else {
  5817.                                 $callableDescription = $r->name;
  5818.                             }
  5819.                         } elseif (\is_object($dir)) {
  5820.                             $callableDescription = \get_class($dir) . '::__invoke';
  5821.                         } else {
  5822.                             $callableDescription = 'callable'; // Fallback if we don't have a dedicated description
  5823.                         }
  5824.                         @trigger_error(sprintf('Returning a file to import for CSS or external references in custom importer callables is deprecated and will not be supported anymore in ScssPhp 2.0. This behavior is not compliant with the Sass specification. Update your "%s" importer.', $callableDescription), E_USER_DEPRECATED);
  5826.                         return $file;
  5827.                     }
  5828.                 }
  5829.             }
  5830.             return null;
  5831.         }
  5833.         if (!\is_null($currentDir)) {
  5834.             $relativePath = $this->resolveImportPath($url, $currentDir);
  5836.             if (!\is_null($relativePath)) {
  5837.                 return $relativePath;
  5838.             }
  5839.         }
  5841.         foreach ($this->importPaths as $dir) {
  5842.             if (\is_string($dir)) {
  5843.                 $path = $this->resolveImportPath($url, $dir);
  5845.                 if (!\is_null($path)) {
  5846.                     return $path;
  5847.                 }
  5848.             } elseif (\is_callable($dir)) {
  5849.                 // check custom callback for import path
  5850.                 $file = \call_user_func($dir, $url);
  5852.                 if (! \is_null($file)) {
  5853.                     return $file;
  5854.                 }
  5855.             }
  5856.         }
  5858.         if ($this->legacyCwdImportPath) {
  5859.             $path = $this->resolveImportPath($url, getcwd());
  5861.             if (!\is_null($path)) {
  5862.                 @trigger_error('Resolving imports relatively to the current working directory is deprecated. If that\'s the intended behavior, the value of "getcwd()" should be added as an import path explicitly instead. If this was used for resolving relative imports of the input alongside "chdir" with the source directory, the path of the input file should be passed to "compileString()" instead.', E_USER_DEPRECATED);
  5864.                 return $path;
  5865.             }
  5866.         }
  5868.         throw $this->error("`$url` file not found for @import");
  5869.     }
  5871.     /**
  5872.      * @param string $url
  5873.      * @param string $baseDir
  5874.      *
  5875.      * @return string|null
  5876.      */
  5877.     private function resolveImportPath($url, $baseDir)
  5878.     {
  5879.         $path = Path::join($baseDir, $url);
  5881.         $hasExtension = preg_match('/.s[ac]ss$/', $url);
  5883.         if ($hasExtension) {
  5884.             return $this->checkImportPathConflicts($this->tryImportPath($path));
  5885.         }
  5887.         $result = $this->checkImportPathConflicts($this->tryImportPathWithExtensions($path));
  5889.         if (!\is_null($result)) {
  5890.             return $result;
  5891.         }
  5893.         return $this->tryImportPathAsDirectory($path);
  5894.     }
  5896.     /**
  5897.      * @param string[] $paths
  5898.      *
  5899.      * @return string|null
  5900.      */
  5901.     private function checkImportPathConflicts(array $paths)
  5902.     {
  5903.         if (\count($paths) === 0) {
  5904.             return null;
  5905.         }
  5907.         if (\count($paths) === 1) {
  5908.             return $paths[0];
  5909.         }
  5911.         $formattedPrettyPaths = [];
  5913.         foreach ($paths as $path) {
  5914.             $formattedPrettyPaths[] = '  ' . $this->getPrettyPath($path);
  5915.         }
  5917.         throw $this->error("It's not clear which file to import. Found:\n" . implode("\n", $formattedPrettyPaths));
  5918.     }
  5920.     /**
  5921.      * @param string $path
  5922.      *
  5923.      * @return string[]
  5924.      */
  5925.     private function tryImportPathWithExtensions($path)
  5926.     {
  5927.         $result = array_merge(
  5928.             $this->tryImportPath($path.'.sass'),
  5929.             $this->tryImportPath($path.'.scss')
  5930.         );
  5932.         if ($result) {
  5933.             return $result;
  5934.         }
  5936.         return $this->tryImportPath($path.'.css');
  5937.     }
  5939.     /**
  5940.      * @param string $path
  5941.      *
  5942.      * @return string[]
  5943.      */
  5944.     private function tryImportPath($path)
  5945.     {
  5946.         $partial = dirname($path).'/_'.basename($path);
  5948.         $candidates = [];
  5950.         if (is_file($partial)) {
  5951.             $candidates[] = $partial;
  5952.         }
  5954.         if (is_file($path)) {
  5955.             $candidates[] = $path;
  5956.         }
  5958.         return $candidates;
  5959.     }
  5961.     /**
  5962.      * @param string $path
  5963.      *
  5964.      * @return string|null
  5965.      */
  5966.     private function tryImportPathAsDirectory($path)
  5967.     {
  5968.         if (!is_dir($path)) {
  5969.             return null;
  5970.         }
  5972.         return $this->checkImportPathConflicts($this->tryImportPathWithExtensions($path.'/index'));
  5973.     }
  5975.     /**
  5976.      * @param string|null $path
  5977.      *
  5978.      * @return string
  5979.      */
  5980.     private function getPrettyPath($path)
  5981.     {
  5982.         if ($path === null) {
  5983.             return '(unknown file)';
  5984.         }
  5986.         $normalizedPath = $path;
  5987.         $normalizedRootDirectory = $this->rootDirectory.'/';
  5989.         if (\DIRECTORY_SEPARATOR === '\\') {
  5990.             $normalizedRootDirectory = str_replace('\\', '/', $normalizedRootDirectory);
  5991.             $normalizedPath = str_replace('\\', '/', $path);
  5992.         }
  5994.         if (0 === strpos($normalizedPath, $normalizedRootDirectory)) {
  5995.             return substr($path, \strlen($normalizedRootDirectory));
  5996.         }
  5998.         return $path;
  5999.     }
  6001.     /**
  6002.      * Set encoding
  6003.      *
  6004.      * @api
  6005.      *
  6006.      * @param string|null $encoding
  6007.      *
  6008.      * @return void
  6009.      *
  6010.      * @deprecated Non-compliant support for other encodings than UTF-8 is deprecated.
  6011.      */
  6012.     public function setEncoding($encoding)
  6013.     {
  6014.         if (!$encoding || strtolower($encoding) === 'utf-8') {
  6015.             @trigger_error(sprintf('The "%s" method is deprecated.', __METHOD__), E_USER_DEPRECATED);
  6016.         } else {
  6017.             @trigger_error(sprintf('The "%s" method is deprecated. Parsing will only support UTF-8 in ScssPhp 2.0. The non-UTF-8 parsing of ScssPhp 1.x is not spec compliant.', __METHOD__), E_USER_DEPRECATED);
  6018.         }
  6020.         $this->encoding = $encoding;
  6021.     }
  6023.     /**
  6024.      * Ignore errors?
  6025.      *
  6026.      * @api
  6027.      *
  6028.      * @param bool $ignoreErrors
  6029.      *
  6030.      * @return \ScssPhp\ScssPhp\Compiler
  6031.      *
  6032.      * @deprecated Ignoring Sass errors is not longer supported.
  6033.      */
  6034.     public function setIgnoreErrors($ignoreErrors)
  6035.     {
  6036.         @trigger_error('Ignoring Sass errors is not longer supported.', E_USER_DEPRECATED);
  6038.         return $this;
  6039.     }
  6041.     /**
  6042.      * Get source position
  6043.      *
  6044.      * @api
  6045.      *
  6046.      * @return array
  6047.      *
  6048.      * @deprecated
  6049.      */
  6050.     public function getSourcePosition()
  6051.     {
  6052.         @trigger_error(sprintf('The "%s" method is deprecated.', __METHOD__), E_USER_DEPRECATED);
  6054.         $sourceFile = isset($this->sourceNames[$this->sourceIndex]) ? $this->sourceNames[$this->sourceIndex] : '';
  6056.         return [$sourceFile, $this->sourceLine, $this->sourceColumn];
  6057.     }
  6059.     /**
  6060.      * Throw error (exception)
  6061.      *
  6062.      * @api
  6063.      *
  6064.      * @param string $msg Message with optional sprintf()-style vararg parameters
  6065.      *
  6066.      * @return never
  6067.      *
  6068.      * @throws \ScssPhp\ScssPhp\Exception\CompilerException
  6069.      *
  6070.      * @deprecated use "error" and throw the exception in the caller instead.
  6071.      */
  6072.     public function throwError($msg)
  6073.     {
  6074.         @trigger_error(
  6075.             'The method "throwError" is deprecated. Use "error" and throw the exception in the caller instead',
  6076.             E_USER_DEPRECATED
  6077.         );
  6079.         throw $this->error(...func_get_args());
  6080.     }
  6082.     /**
  6083.      * Build an error (exception)
  6084.      *
  6085.      * @internal
  6086.      *
  6087.      * @param string                     $msg Message with optional sprintf()-style vararg parameters
  6088.      * @param bool|float|int|string|null ...$args
  6089.      *
  6090.      * @return CompilerException
  6091.      */
  6092.     public function error($msg, ...$args)
  6093.     {
  6094.         if ($args) {
  6095.             $msg = sprintf($msg, ...$args);
  6096.         }
  6098.         if (! $this->ignoreCallStackMessage) {
  6099.             $msg = $this->addLocationToMessage($msg);
  6100.         }
  6102.         return new CompilerException($msg);
  6103.     }
  6105.     /**
  6106.      * @param string $msg
  6107.      *
  6108.      * @return string
  6109.      */
  6110.     private function addLocationToMessage($msg)
  6111.     {
  6112.         $line   = $this->sourceLine;
  6113.         $column = $this->sourceColumn;
  6115.         $loc = isset($this->sourceNames[$this->sourceIndex])
  6116.             ? $this->getPrettyPath($this->sourceNames[$this->sourceIndex]) . " on line $line, at column $column"
  6117.             : "line: $line, column: $column";
  6119.         $msg = "$msg: $loc";
  6121.         $callStackMsg = $this->callStackMessage();
  6123.         if ($callStackMsg) {
  6124.             $msg .= "\nCall Stack:\n" . $callStackMsg;
  6125.         }
  6127.         return $msg;
  6128.     }
  6130.     /**
  6131.      * @param string $functionName
  6132.      * @param array $ExpectedArgs
  6133.      * @param int $nbActual
  6134.      * @return CompilerException
  6135.      *
  6136.      * @deprecated
  6137.      */
  6138.     public function errorArgsNumber($functionName, $ExpectedArgs, $nbActual)
  6139.     {
  6140.         @trigger_error(sprintf('The "%s" method is deprecated.', __METHOD__), E_USER_DEPRECATED);
  6142.         $nbExpected = \count($ExpectedArgs);
  6144.         if ($nbActual > $nbExpected) {
  6145.             return $this->error(
  6146.                 'Error: Only %d arguments allowed in %s(), but %d were passed.',
  6147.                 $nbExpected,
  6148.                 $functionName,
  6149.                 $nbActual
  6150.             );
  6151.         } else {
  6152.             $missing = [];
  6154.             while (count($ExpectedArgs) && count($ExpectedArgs) > $nbActual) {
  6155.                 array_unshift($missing, array_pop($ExpectedArgs));
  6156.             }
  6158.             return $this->error(
  6159.                 'Error: %s() argument%s %s missing.',
  6160.                 $functionName,
  6161.                 count($missing) > 1 ? 's' : '',
  6162.                 implode(', ', $missing)
  6163.             );
  6164.         }
  6165.     }
  6167.     /**
  6168.      * Beautify call stack for output
  6169.      *
  6170.      * @param bool     $all
  6171.      * @param int|null $limit
  6172.      *
  6173.      * @return string
  6174.      */
  6175.     protected function callStackMessage($all = false, $limit = null)
  6176.     {
  6177.         $callStackMsg = [];
  6178.         $ncall = 0;
  6180.         if ($this->callStack) {
  6181.             foreach (array_reverse($this->callStack) as $call) {
  6182.                 if ($all || (isset($call['n']) && $call['n'])) {
  6183.                     $msg = '#' . $ncall++ . ' ' . $call['n'] . ' ';
  6184.                     $msg .= (isset($this->sourceNames[$call[Parser::SOURCE_INDEX]])
  6185.                           ? $this->getPrettyPath($this->sourceNames[$call[Parser::SOURCE_INDEX]])
  6186.                           : '(unknown file)');
  6187.                     $msg .= ' on line ' . $call[Parser::SOURCE_LINE];
  6189.                     $callStackMsg[] = $msg;
  6191.                     if (! \is_null($limit) && $ncall > $limit) {
  6192.                         break;
  6193.                     }
  6194.                 }
  6195.             }
  6196.         }
  6198.         return implode("\n", $callStackMsg);
  6199.     }
  6201.     /**
  6202.      * Handle import loop
  6203.      *
  6204.      * @param string $name
  6205.      *
  6206.      * @return void
  6207.      *
  6208.      * @throws \Exception
  6209.      */
  6210.     protected function handleImportLoop($name)
  6211.     {
  6212.         for ($env = $this->env; $env; $env = $env->parent) {
  6213.             if (! $env->block) {
  6214.                 continue;
  6215.             }
  6217.             $file = $this->sourceNames[$env->block->sourceIndex];
  6219.             if ($file === null) {
  6220.                 continue;
  6221.             }
  6223.             if (realpath($file) === $name) {
  6224.                 throw $this->error('An @import loop has been found: %s imports %s', $file, basename($file));
  6225.             }
  6226.         }
  6227.     }
  6229.     /**
  6230.      * Call SCSS @function
  6231.      *
  6232.      * @param CallableBlock|null $func
  6233.      * @param array              $argValues
  6234.      *
  6235.      * @return array|Number
  6236.      */
  6237.     protected function callScssFunction($func, $argValues)
  6238.     {
  6239.         if (! $func) {
  6240.             return static::$defaultValue;
  6241.         }
  6242.         $name = $func->name;
  6244.         $this->pushEnv();
  6246.         // set the args
  6247.         if (isset($func->args)) {
  6248.             $this->applyArguments($func->args, $argValues);
  6249.         }
  6251.         // throw away lines and children
  6252.         $tmp = new OutputBlock();
  6253.         $tmp->lines    = [];
  6254.         $tmp->children = [];
  6256.         $this->env->marker = 'function';
  6258.         if (! empty($func->parentEnv)) {
  6259.             $this->env->declarationScopeParent = $func->parentEnv;
  6260.         } else {
  6261.             throw $this->error("@function $name() without parentEnv");
  6262.         }
  6264.         $ret = $this->compileChildren($func->children, $tmp, $this->env->marker . ' ' . $name);
  6266.         $this->popEnv();
  6268.         return ! isset($ret) ? static::$defaultValue : $ret;
  6269.     }
  6271.     /**
  6272.      * Call built-in and registered (PHP) functions
  6273.      *
  6274.      * @param string $name
  6275.      * @param callable $function
  6276.      * @param array  $prototype
  6277.      * @param array  $args
  6278.      *
  6279.      * @return array|Number|null
  6280.      */
  6281.     protected function callNativeFunction($name, $function, $prototype, $args)
  6282.     {
  6283.         $libName = (is_array($function) ? end($function) : null);
  6284.         $sorted_kwargs = $this->sortNativeFunctionArgs($libName, $prototype, $args);
  6286.         if (\is_null($sorted_kwargs)) {
  6287.             return null;
  6288.         }
  6289.         @list($sorted, $kwargs) = $sorted_kwargs;
  6291.         if ($name !== 'if') {
  6292.             foreach ($sorted as &$val) {
  6293.                 if ($val !== null) {
  6294.                     $val = $this->reduce($val, true);
  6295.                 }
  6296.             }
  6297.         }
  6299.         $returnValue = \call_user_func($function, $sorted, $kwargs);
  6301.         if (! isset($returnValue)) {
  6302.             return null;
  6303.         }
  6305.         if (\is_array($returnValue) || $returnValue instanceof Number) {
  6306.             return $returnValue;
  6307.         }
  6309.         @trigger_error(sprintf('Returning a PHP value from the "%s" custom function is deprecated. A sass value must be returned instead.', $name), E_USER_DEPRECATED);
  6311.         return $this->coerceValue($returnValue);
  6312.     }
  6314.     /**
  6315.      * Get built-in function
  6316.      *
  6317.      * @param string $name Normalized name
  6318.      *
  6319.      * @return array
  6320.      */
  6321.     protected function getBuiltinFunction($name)
  6322.     {
  6323.         $libName = self::normalizeNativeFunctionName($name);
  6324.         return [$this, $libName];
  6325.     }
  6327.     /**
  6328.      * Normalize native function name
  6329.      *
  6330.      * @internal
  6331.      *
  6332.      * @param string $name
  6333.      *
  6334.      * @return string
  6335.      */
  6336.     public static function normalizeNativeFunctionName($name)
  6337.     {
  6338.         $name = str_replace("-", "_", $name);
  6339.         $libName = 'lib' . preg_replace_callback(
  6340.             '/_(.)/',
  6341.             function ($m) {
  6342.                 return ucfirst($m[1]);
  6343.             },
  6344.             ucfirst($name)
  6345.         );
  6346.         return $libName;
  6347.     }
  6349.     /**
  6350.      * Check if a function is a native built-in scss function, for css parsing
  6351.      *
  6352.      * @internal
  6353.      *
  6354.      * @param string $name
  6355.      *
  6356.      * @return bool
  6357.      */
  6358.     public static function isNativeFunction($name)
  6359.     {
  6360.         return method_exists(Compiler::class, self::normalizeNativeFunctionName($name));
  6361.     }
  6363.     /**
  6364.      * Sorts keyword arguments
  6365.      *
  6366.      * @param string $functionName
  6367.      * @param array|null  $prototypes
  6368.      * @param array  $args
  6369.      *
  6370.      * @return array|null
  6371.      */
  6372.     protected function sortNativeFunctionArgs($functionName, $prototypes, $args)
  6373.     {
  6374.         static $parser = null;
  6376.         if (! isset($prototypes)) {
  6377.             $keyArgs = [];
  6378.             $posArgs = [];
  6380.             if (\is_array($args) && \count($args) && \end($args) === static::$null) {
  6381.                 array_pop($args);
  6382.             }
  6384.             // separate positional and keyword arguments
  6385.             foreach ($args as $arg) {
  6386.                 list($key, $value) = $arg;
  6388.                 if (empty($key) or empty($key[1])) {
  6389.                     $posArgs[] = empty($arg[2]) ? $value : $arg;
  6390.                 } else {
  6391.                     $keyArgs[$key[1]] = $value;
  6392.                 }
  6393.             }
  6395.             return [$posArgs, $keyArgs];
  6396.         }
  6398.         // specific cases ?
  6399.         if (\in_array($functionName, ['libRgb', 'libRgba', 'libHsl', 'libHsla'])) {
  6400.             // notation 100 127 255 / 0 is in fact a simple list of 4 values
  6401.             foreach ($args as $k => $arg) {
  6402.                 if (!isset($arg[1])) {
  6403.                     continue; // This happens when using a trailing comma
  6404.                 }
  6405.                 if ($arg[1][0] === Type::T_LIST && \count($arg[1][2]) === 3) {
  6406.                     $args[$k][1][2] = $this->extractSlashAlphaInColorFunction($arg[1][2]);
  6407.                 }
  6408.             }
  6409.         }
  6411.         list($positionalArgs, $namedArgs, $names, $separator, $hasSplat) = $this->evaluateArguments($args, false);
  6413.         if (! \is_array(reset($prototypes))) {
  6414.             $prototypes = [$prototypes];
  6415.         }
  6417.         $parsedPrototypes = array_map([$this, 'parseFunctionPrototype'], $prototypes);
  6418.         assert(!empty($parsedPrototypes));
  6419.         $matchedPrototype = $this->selectFunctionPrototype($parsedPrototypes, \count($positionalArgs), $names);
  6421.         $this->verifyPrototype($matchedPrototype, \count($positionalArgs), $names, $hasSplat);
  6423.         $vars = $this->applyArgumentsToDeclaration($matchedPrototype, $positionalArgs, $namedArgs, $separator);
  6425.         $finalArgs = [];
  6426.         $keyArgs = [];
  6428.         foreach ($matchedPrototype['arguments'] as $argument) {
  6429.             list($normalizedName, $originalName, $default) = $argument;
  6431.             if (isset($vars[$normalizedName])) {
  6432.                 $value = $vars[$normalizedName];
  6433.             } else {
  6434.                 $value = $default;
  6435.             }
  6437.             // special null value as default: translate to real null here
  6438.             if ($value === [Type::T_KEYWORD, 'null']) {
  6439.                 $value = null;
  6440.             }
  6442.             $finalArgs[] = $value;
  6443.             $keyArgs[$originalName] = $value;
  6444.         }
  6446.         if ($matchedPrototype['rest_argument'] !== null) {
  6447.             $value = $vars[$matchedPrototype['rest_argument']];
  6449.             $finalArgs[] = $value;
  6450.             $keyArgs[$matchedPrototype['rest_argument']] = $value;
  6451.         }
  6453.         return [$finalArgs, $keyArgs];
  6454.     }
  6456.     /**
  6457.      * Parses a function prototype to the internal representation of arguments.
  6458.      *
  6459.      * The input is an array of strings describing each argument, as supported
  6460.      * in {@see registerFunction}. Argument names don't include the `$`.
  6461.      * The output contains the list of positional argument, with their normalized
  6462.      * name (underscores are replaced by dashes), their original name (to be used
  6463.      * in case of error reporting) and their default value. The output also contains
  6464.      * the normalized name of the rest argument, or null if the function prototype
  6465.      * is not variadic.
  6466.      *
  6467.      * @param string[] $prototype
  6468.      *
  6469.      * @return array
  6470.      * @phpstan-return array{arguments: list<array{0: string, 1: string, 2: array|Number|null}>, rest_argument: string|null}
  6471.      */
  6472.     private function parseFunctionPrototype(array $prototype)
  6473.     {
  6474.         static $parser = null;
  6476.         $arguments = [];
  6477.         $restArgument = null;
  6479.         foreach ($prototype as $p) {
  6480.             if (null !== $restArgument) {
  6481.                 throw new \InvalidArgumentException('The argument declaration is invalid. The rest argument must be the last one.');
  6482.             }
  6484.             $default = null;
  6485.             $p = explode(':', $p, 2);
  6486.             $name = str_replace('_', '-', $p[0]);
  6488.             if (isset($p[1])) {
  6489.                 $defaultSource = trim($p[1]);
  6491.                 if ($defaultSource === 'null') {
  6492.                     // differentiate this null from the static::$null
  6493.                     $default = [Type::T_KEYWORD, 'null'];
  6494.                 } else {
  6495.                     if (\is_null($parser)) {
  6496.                         $parser = $this->parserFactory(__METHOD__);
  6497.                     }
  6499.                     $parser->parseValue($defaultSource, $default);
  6500.                 }
  6501.             }
  6503.             if (substr($name, -3) === '...') {
  6504.                 $restArgument = substr($name, 0, -3);
  6505.             } else {
  6506.                 $arguments[] = [$name, $p[0], $default];
  6507.             }
  6508.         }
  6510.         return [
  6511.             'arguments' => $arguments,
  6512.             'rest_argument' => $restArgument,
  6513.         ];
  6514.     }
  6516.     /**
  6517.      * Returns the function prototype for the given positional and named arguments.
  6518.      *
  6519.      * If no exact match is found, finds the closest approximation. Note that this
  6520.      * doesn't guarantee that $positional and $names are valid for the returned
  6521.      * prototype.
  6522.      *
  6523.      * @param array[]               $prototypes
  6524.      * @param int                   $positional
  6525.      * @param array<string, string> $names A set of names, as both keys and values
  6526.      *
  6527.      * @return array
  6528.      *
  6529.      * @phpstan-param non-empty-list<array{arguments: list<array{0: string, 1: string, 2: array|Number|null}>, rest_argument: string|null}> $prototypes
  6530.      * @phpstan-return array{arguments: list<array{0: string, 1: string, 2: array|Number|null}>, rest_argument: string|null}
  6531.      */
  6532.     private function selectFunctionPrototype(array $prototypes, $positional, array $names)
  6533.     {
  6534.         $fuzzyMatch = null;
  6535.         $minMismatchDistance = null;
  6537.         foreach ($prototypes as $prototype) {
  6538.             // Ideally, find an exact match.
  6539.             if ($this->checkPrototypeMatches($prototype, $positional, $names)) {
  6540.                 return $prototype;
  6541.             }
  6543.             $mismatchDistance = \count($prototype['arguments']) - $positional;
  6545.             if ($minMismatchDistance !== null) {
  6546.                 if (abs($mismatchDistance) > abs($minMismatchDistance)) {
  6547.                     continue;
  6548.                 }
  6550.                 // If two overloads have the same mismatch distance, favor the overload
  6551.                 // that has more arguments.
  6552.                 if (abs($mismatchDistance) === abs($minMismatchDistance) && $mismatchDistance < 0) {
  6553.                     continue;
  6554.                 }
  6555.             }
  6557.             $minMismatchDistance = $mismatchDistance;
  6558.             $fuzzyMatch = $prototype;
  6559.         }
  6561.         return $fuzzyMatch;
  6562.     }
  6564.     /**
  6565.      * Checks whether the argument invocation matches the callable prototype.
  6566.      *
  6567.      * The rules are similar to {@see verifyPrototype}. The boolean return value
  6568.      * avoids the overhead of building and catching exceptions when the reason of
  6569.      * not matching the prototype does not need to be known.
  6570.      *
  6571.      * @param array                 $prototype
  6572.      * @param int                   $positional
  6573.      * @param array<string, string> $names
  6574.      *
  6575.      * @return bool
  6576.      *
  6577.      * @phpstan-param array{arguments: list<array{0: string, 1: string, 2: array|Number|null}>, rest_argument: string|null} $prototype
  6578.      */
  6579.     private function checkPrototypeMatches(array $prototype, $positional, array $names)
  6580.     {
  6581.         $nameUsed = 0;
  6583.         foreach ($prototype['arguments'] as $i => $argument) {
  6584.             list ($name, $originalName, $default) = $argument;
  6586.             if ($i < $positional) {
  6587.                 if (isset($names[$name])) {
  6588.                     return false;
  6589.                 }
  6590.             } elseif (isset($names[$name])) {
  6591.                 $nameUsed++;
  6592.             } elseif ($default === null) {
  6593.                 return false;
  6594.             }
  6595.         }
  6597.         if ($prototype['rest_argument'] !== null) {
  6598.             return true;
  6599.         }
  6601.         if ($positional > \count($prototype['arguments'])) {
  6602.             return false;
  6603.         }
  6605.         if ($nameUsed < \count($names)) {
  6606.             return false;
  6607.         }
  6609.         return true;
  6610.     }
  6612.     /**
  6613.      * Verifies that the argument invocation is valid for the callable prototype.
  6614.      *
  6615.      * @param array                 $prototype
  6616.      * @param int                   $positional
  6617.      * @param array<string, string> $names
  6618.      * @param bool                  $hasSplat
  6619.      *
  6620.      * @return void
  6621.      *
  6622.      * @throws SassScriptException
  6623.      *
  6624.      * @phpstan-param array{arguments: list<array{0: string, 1: string, 2: array|Number|null}>, rest_argument: string|null} $prototype
  6625.      */
  6626.     private function verifyPrototype(array $prototype, $positional, array $names, $hasSplat)
  6627.     {
  6628.         $nameUsed = 0;
  6630.         foreach ($prototype['arguments'] as $i => $argument) {
  6631.             list ($name, $originalName, $default) = $argument;
  6633.             if ($i < $positional) {
  6634.                 if (isset($names[$name])) {
  6635.                     throw new SassScriptException(sprintf('Argument $%s was passed both by position and by name.', $originalName));
  6636.                 }
  6637.             } elseif (isset($names[$name])) {
  6638.                 $nameUsed++;
  6639.             } elseif ($default === null) {
  6640.                 throw new SassScriptException(sprintf('Missing argument $%s', $originalName));
  6641.             }
  6642.         }
  6644.         if ($prototype['rest_argument'] !== null) {
  6645.             return;
  6646.         }
  6648.         if ($positional > \count($prototype['arguments'])) {
  6649.             $message = sprintf(
  6650.                 'Only %d %sargument%s allowed, but %d %s passed.',
  6651.                 \count($prototype['arguments']),
  6652.                 empty($names) ? '' : 'positional ',
  6653.                 \count($prototype['arguments']) === 1 ? '' : 's',
  6654.                 $positional,
  6655.                 $positional === 1 ? 'was' : 'were'
  6656.             );
  6657.             if (!$hasSplat) {
  6658.                 throw new SassScriptException($message);
  6659.             }
  6661.             $message = $this->addLocationToMessage($message);
  6662.             $message .= "\nThis will be an error in future versions of Sass.";
  6663.             $this->logger->warn($message, true);
  6664.         }
  6666.         if ($nameUsed < \count($names)) {
  6667.             $unknownNames = array_values(array_diff($names, array_column($prototype['arguments'], 0)));
  6668.             $lastName = array_pop($unknownNames);
  6669.             $message = sprintf(
  6670.                 'No argument%s named $%s%s.',
  6671.                 $unknownNames ? 's' : '',
  6672.                 $unknownNames ? implode(', $', $unknownNames) . ' or $' : '',
  6673.                 $lastName
  6674.             );
  6675.             throw new SassScriptException($message);
  6676.         }
  6677.     }
  6679.     /**
  6680.      * Evaluates the argument from the invocation.
  6681.      *
  6682.      * This returns several things about this invocation:
  6683.      * - the list of positional arguments
  6684.      * - the map of named arguments, indexed by normalized names
  6685.      * - the set of names used in the arguments (that's an array using the normalized names as keys for O(1) access)
  6686.      * - the separator used by the list using the splat operator, if any
  6687.      * - a boolean indicator whether any splat argument (list or map) was used, to support the incomplete error reporting.
  6688.      *
  6689.      * @param array[] $args
  6690.      * @param bool    $reduce Whether arguments should be reduced to their value
  6691.      *
  6692.      * @return array
  6693.      *
  6694.      * @throws SassScriptException
  6695.      *
  6696.      * @phpstan-return array{0: list<array|Number>, 1: array<string, array|Number>, 2: array<string, string>, 3: string|null, 4: bool}
  6697.      */
  6698.     private function evaluateArguments(array $args, $reduce = true)
  6699.     {
  6700.         // this represents trailing commas
  6701.         if (\count($args) && end($args) === static::$null) {
  6702.             array_pop($args);
  6703.         }
  6705.         $splatSeparator = null;
  6706.         $keywordArgs = [];
  6707.         $names = [];
  6708.         $positionalArgs = [];
  6709.         $hasKeywordArgument = false;
  6710.         $hasSplat = false;
  6712.         foreach ($args as $arg) {
  6713.             if (!empty($arg[0])) {
  6714.                 $hasKeywordArgument = true;
  6716.                 assert(\is_string($arg[0][1]));
  6717.                 $name = str_replace('_', '-', $arg[0][1]);
  6719.                 if (isset($keywordArgs[$name])) {
  6720.                     throw new SassScriptException(sprintf('Duplicate named argument $%s.', $arg[0][1]));
  6721.                 }
  6723.                 $keywordArgs[$name] = $this->maybeReduce($reduce, $arg[1]);
  6724.                 $names[$name] = $name;
  6725.             } elseif (! empty($arg[2])) {
  6726.                 // $arg[2] means a var followed by ... in the arg ($list... )
  6727.                 $val = $this->reduce($arg[1], true);
  6728.                 $hasSplat = true;
  6730.                 if ($val[0] === Type::T_LIST) {
  6731.                     foreach ($val[2] as $item) {
  6732.                         if (\is_null($splatSeparator)) {
  6733.                             $splatSeparator = $val[1];
  6734.                         }
  6736.                         $positionalArgs[] = $this->maybeReduce($reduce, $item);
  6737.                     }
  6739.                     if (isset($val[3]) && \is_array($val[3])) {
  6740.                         foreach ($val[3] as $name => $item) {
  6741.                             assert(\is_string($name));
  6743.                             $normalizedName = str_replace('_', '-', $name);
  6745.                             if (isset($keywordArgs[$normalizedName])) {
  6746.                                 throw new SassScriptException(sprintf('Duplicate named argument $%s.', $name));
  6747.                             }
  6749.                             $keywordArgs[$normalizedName] = $this->maybeReduce($reduce, $item);
  6750.                             $names[$normalizedName] = $normalizedName;
  6751.                             $hasKeywordArgument = true;
  6752.                         }
  6753.                     }
  6754.                 } elseif ($val[0] === Type::T_MAP) {
  6755.                     foreach ($val[1] as $i => $name) {
  6756.                         $name = $this->compileStringContent($this->coerceString($name));
  6757.                         $item = $val[2][$i];
  6759.                         if (! is_numeric($name)) {
  6760.                             $normalizedName = str_replace('_', '-', $name);
  6762.                             if (isset($keywordArgs[$normalizedName])) {
  6763.                                 throw new SassScriptException(sprintf('Duplicate named argument $%s.', $name));
  6764.                             }
  6766.                             $keywordArgs[$normalizedName] = $this->maybeReduce($reduce, $item);
  6767.                             $names[$normalizedName] = $normalizedName;
  6768.                             $hasKeywordArgument = true;
  6769.                         } else {
  6770.                             if (\is_null($splatSeparator)) {
  6771.                                 $splatSeparator = $val[1];
  6772.                             }
  6774.                             $positionalArgs[] = $this->maybeReduce($reduce, $item);
  6775.                         }
  6776.                     }
  6777.                 } elseif ($val[0] !== Type::T_NULL) { // values other than null are treated a single-element lists, while null is the empty list
  6778.                     $positionalArgs[] = $this->maybeReduce($reduce, $val);
  6779.                 }
  6780.             } elseif ($hasKeywordArgument) {
  6781.                 throw new SassScriptException('Positional arguments must come before keyword arguments.');
  6782.             } else {
  6783.                 $positionalArgs[] = $this->maybeReduce($reduce, $arg[1]);
  6784.             }
  6785.         }
  6787.         return [$positionalArgs, $keywordArgs, $names, $splatSeparator, $hasSplat];
  6788.     }
  6790.     /**
  6791.      * @param bool         $reduce
  6792.      * @param array|Number $value
  6793.      *
  6794.      * @return array|Number
  6795.      */
  6796.     private function maybeReduce($reduce, $value)
  6797.     {
  6798.         if ($reduce) {
  6799.             return $this->reduce($value, true);
  6800.         }
  6802.         return $value;
  6803.     }
  6805.     /**
  6806.      * Apply argument values per definition
  6807.      *
  6808.      * @param array[]    $argDef
  6809.      * @param array|null $argValues
  6810.      * @param bool       $storeInEnv
  6811.      * @param bool       $reduce     only used if $storeInEnv = false
  6812.      *
  6813.      * @return array<string, array|Number>
  6814.      *
  6815.      * @phpstan-param list<array{0: string, 1: array|Number|null, 2: bool}> $argDef
  6816.      *
  6817.      * @throws \Exception
  6818.      */
  6819.     protected function applyArguments($argDef, $argValues, $storeInEnv = true, $reduce = true)
  6820.     {
  6821.         $output = [];
  6823.         if (\is_null($argValues)) {
  6824.             $argValues = [];
  6825.         }
  6827.         if ($storeInEnv) {
  6828.             $storeEnv = $this->getStoreEnv();
  6830.             $env = new Environment();
  6831.             $env->store = $storeEnv->store;
  6832.         }
  6834.         $prototype = ['arguments' => [], 'rest_argument' => null];
  6835.         $originalRestArgumentName = null;
  6837.         foreach ($argDef as $arg) {
  6838.             list($name, $default, $isVariable) = $arg;
  6839.             $normalizedName = str_replace('_', '-', $name);
  6841.             if ($isVariable) {
  6842.                 $originalRestArgumentName = $name;
  6843.                 $prototype['rest_argument'] = $normalizedName;
  6844.             } else {
  6845.                 $prototype['arguments'][] = [$normalizedName, $name, !empty($default) ? $default : null];
  6846.             }
  6847.         }
  6849.         list($positionalArgs, $namedArgs, $names, $splatSeparator, $hasSplat) = $this->evaluateArguments($argValues, $reduce);
  6851.         $this->verifyPrototype($prototype, \count($positionalArgs), $names, $hasSplat);
  6853.         $vars = $this->applyArgumentsToDeclaration($prototype, $positionalArgs, $namedArgs, $splatSeparator);
  6855.         foreach ($prototype['arguments'] as $argument) {
  6856.             list($normalizedName, $name) = $argument;
  6858.             if (!isset($vars[$normalizedName])) {
  6859.                 continue;
  6860.             }
  6862.             $val = $vars[$normalizedName];
  6864.             if ($storeInEnv) {
  6865.                 $this->set($name, $this->reduce($val, true), true, $env);
  6866.             } else {
  6867.                 $output[$name] = ($reduce ? $this->reduce($val, true) : $val);
  6868.             }
  6869.         }
  6871.         if ($prototype['rest_argument'] !== null) {
  6872.             assert($originalRestArgumentName !== null);
  6873.             $name = $originalRestArgumentName;
  6874.             $val = $vars[$prototype['rest_argument']];
  6876.             if ($storeInEnv) {
  6877.                 $this->set($name, $this->reduce($val, true), true, $env);
  6878.             } else {
  6879.                 $output[$name] = ($reduce ? $this->reduce($val, true) : $val);
  6880.             }
  6881.         }
  6883.         if ($storeInEnv) {
  6884.             $storeEnv->store = $env->store;
  6885.         }
  6887.         foreach ($prototype['arguments'] as $argument) {
  6888.             list($normalizedName, $name, $default) = $argument;
  6890.             if (isset($vars[$normalizedName])) {
  6891.                 continue;
  6892.             }
  6893.             assert($default !== null);
  6895.             if ($storeInEnv) {
  6896.                 $this->set($name, $this->reduce($default, true), true);
  6897.             } else {
  6898.                 $output[$name] = ($reduce ? $this->reduce($default, true) : $default);
  6899.             }
  6900.         }
  6902.         return $output;
  6903.     }
  6905.     /**
  6906.      * Apply argument values per definition.
  6907.      *
  6908.      * This method assumes that the arguments are valid for the provided prototype.
  6909.      * The validation with {@see verifyPrototype} must have been run before calling
  6910.      * it.
  6911.      * Arguments are returned as a map from the normalized argument names to the
  6912.      * value. Additional arguments are collected in a sass argument list available
  6913.      * under the name of the rest argument in the result.
  6914.      *
  6915.      * Defaults are not applied as they are resolved in a different environment.
  6916.      *
  6917.      * @param array                       $prototype
  6918.      * @param array<array|Number>         $positionalArgs
  6919.      * @param array<string, array|Number> $namedArgs
  6920.      * @param string|null                 $splatSeparator
  6921.      *
  6922.      * @return array<string, array|Number>
  6923.      *
  6924.      * @phpstan-param array{arguments: list<array{0: string, 1: string, 2: array|Number|null}>, rest_argument: string|null} $prototype
  6925.      */
  6926.     private function applyArgumentsToDeclaration(array $prototype, array $positionalArgs, array $namedArgs, $splatSeparator)
  6927.     {
  6928.         $output = [];
  6929.         $minLength = min(\count($positionalArgs), \count($prototype['arguments']));
  6931.         for ($i = 0; $i < $minLength; $i++) {
  6932.             list($name) = $prototype['arguments'][$i];
  6933.             $val = $positionalArgs[$i];
  6935.             $output[$name] = $val;
  6936.         }
  6938.         $restNamed = $namedArgs;
  6940.         for ($i = \count($positionalArgs); $i < \count($prototype['arguments']); $i++) {
  6941.             $argument = $prototype['arguments'][$i];
  6942.             list($name) = $argument;
  6944.             if (isset($namedArgs[$name])) {
  6945.                 $val = $namedArgs[$name];
  6946.                 unset($restNamed[$name]);
  6947.             } else {
  6948.                 continue;
  6949.             }
  6951.             $output[$name] = $val;
  6952.         }
  6954.         if ($prototype['rest_argument'] !== null) {
  6955.             $name = $prototype['rest_argument'];
  6956.             $rest = array_values(array_slice($positionalArgs, \count($prototype['arguments'])));
  6958.             $val = [Type::T_LIST, \is_null($splatSeparator) ? ',' : $splatSeparator , $rest, $restNamed];
  6960.             $output[$name] = $val;
  6961.         }
  6963.         return $output;
  6964.     }
  6966.     /**
  6967.      * Coerce a php value into a scss one
  6968.      *
  6969.      * @param mixed $value
  6970.      *
  6971.      * @return array|Number
  6972.      */
  6973.     protected function coerceValue($value)
  6974.     {
  6975.         if (\is_array($value) || $value instanceof Number) {
  6976.             return $value;
  6977.         }
  6979.         if (\is_bool($value)) {
  6980.             return $this->toBool($value);
  6981.         }
  6983.         if (\is_null($value)) {
  6984.             return static::$null;
  6985.         }
  6987.         if (is_numeric($value)) {
  6988.             return new Number($value, '');
  6989.         }
  6991.         if ($value === '') {
  6992.             return static::$emptyString;
  6993.         }
  6995.         $value = [Type::T_KEYWORD, $value];
  6996.         $color = $this->coerceColor($value);
  6998.         if ($color) {
  6999.             return $color;
  7000.         }
  7002.         return $value;
  7003.     }
  7005.     /**
  7006.      * Tries to convert an item to a Sass map
  7007.      *
  7008.      * @param Number|array $item
  7009.      *
  7010.      * @return array|null
  7011.      */
  7012.     private function tryMap($item)
  7013.     {
  7014.         if ($item instanceof Number) {
  7015.             return null;
  7016.         }
  7018.         if ($item[0] === Type::T_MAP) {
  7019.             return $item;
  7020.         }
  7022.         if (
  7023.             $item[0] === Type::T_LIST &&
  7024.             $item[2] === []
  7025.         ) {
  7026.             return static::$emptyMap;
  7027.         }
  7029.         return null;
  7030.     }
  7032.     /**
  7033.      * Coerce something to map
  7034.      *
  7035.      * @param array|Number $item
  7036.      *
  7037.      * @return array|Number
  7038.      */
  7039.     protected function coerceMap($item)
  7040.     {
  7041.         $map = $this->tryMap($item);
  7043.         if ($map !== null) {
  7044.             return $map;
  7045.         }
  7047.         return $item;
  7048.     }
  7050.     /**
  7051.      * Coerce something to list
  7052.      *
  7053.      * @param array|Number $item
  7054.      * @param string       $delim
  7055.      * @param bool         $removeTrailingNull
  7056.      *
  7057.      * @return array
  7058.      */
  7059.     protected function coerceList($item, $delim = ',', $removeTrailingNull = false)
  7060.     {
  7061.         if ($item instanceof Number) {
  7062.             return [Type::T_LIST, '', [$item]];
  7063.         }
  7065.         if ($item[0] === Type::T_LIST) {
  7066.             // remove trailing null from the list
  7067.             if ($removeTrailingNull && end($item[2]) === static::$null) {
  7068.                 array_pop($item[2]);
  7069.             }
  7071.             return $item;
  7072.         }
  7074.         if ($item[0] === Type::T_MAP) {
  7075.             $keys = $item[1];
  7076.             $values = $item[2];
  7077.             $list = [];
  7079.             for ($i = 0, $s = \count($keys); $i < $s; $i++) {
  7080.                 $key = $keys[$i];
  7081.                 $value = $values[$i];
  7083.                 $list[] = [
  7084.                     Type::T_LIST,
  7085.                     ' ',
  7086.                     [$key, $value]
  7087.                 ];
  7088.             }
  7090.             return [Type::T_LIST, $list ? ',' : '', $list];
  7091.         }
  7093.         return [Type::T_LIST, '', [$item]];
  7094.     }
  7096.     /**
  7097.      * Coerce color for expression
  7098.      *
  7099.      * @param array|Number $value
  7100.      *
  7101.      * @return array|Number
  7102.      */
  7103.     protected function coerceForExpression($value)
  7104.     {
  7105.         if ($color = $this->coerceColor($value)) {
  7106.             return $color;
  7107.         }
  7109.         return $value;
  7110.     }
  7112.     /**
  7113.      * Coerce value to color
  7114.      *
  7115.      * @param array|Number $value
  7116.      * @param bool         $inRGBFunction
  7117.      *
  7118.      * @return array|null
  7119.      */
  7120.     protected function coerceColor($value, $inRGBFunction = false)
  7121.     {
  7122.         if ($value instanceof Number) {
  7123.             return null;
  7124.         }
  7126.         switch ($value[0]) {
  7127.             case Type::T_COLOR:
  7128.                 for ($i = 1; $i <= 3; $i++) {
  7129.                     if (! is_numeric($value[$i])) {
  7130.                         $cv = $this->compileRGBAValue($value[$i]);
  7132.                         if (! is_numeric($cv)) {
  7133.                             return null;
  7134.                         }
  7136.                         $value[$i] = $cv;
  7137.                     }
  7139.                     if (isset($value[4])) {
  7140.                         if (! is_numeric($value[4])) {
  7141.                             $cv = $this->compileRGBAValue($value[4], true);
  7143.                             if (! is_numeric($cv)) {
  7144.                                 return null;
  7145.                             }
  7147.                             $value[4] = $cv;
  7148.                         }
  7149.                     }
  7150.                 }
  7152.                 return $value;
  7154.             case Type::T_LIST:
  7155.                 if ($inRGBFunction) {
  7156.                     if (\count($value[2]) == 3 || \count($value[2]) == 4) {
  7157.                         $color = $value[2];
  7158.                         array_unshift($color, Type::T_COLOR);
  7160.                         return $this->coerceColor($color);
  7161.                     }
  7162.                 }
  7164.                 return null;
  7166.             case Type::T_KEYWORD:
  7167.                 if (! \is_string($value[1])) {
  7168.                     return null;
  7169.                 }
  7171.                 $name = strtolower($value[1]);
  7173.                 // hexa color?
  7174.                 if (preg_match('/^#([0-9a-f]+)$/i', $name, $m)) {
  7175.                     $nofValues = \strlen($m[1]);
  7177.                     if (\in_array($nofValues, [3, 4, 6, 8])) {
  7178.                         $nbChannels = 3;
  7179.                         $color      = [];
  7180.                         $num        = hexdec($m[1]);
  7182.                         switch ($nofValues) {
  7183.                             case 4:
  7184.                                 $nbChannels = 4;
  7185.                                 // then continuing with the case 3:
  7186.                             case 3:
  7187.                                 for ($i = 0; $i < $nbChannels; $i++) {
  7188.                                     $t = $num & 0xf;
  7189.                                     array_unshift($color, $t << 4 | $t);
  7190.                                     $num >>= 4;
  7191.                                 }
  7193.                                 break;
  7195.                             case 8:
  7196.                                 $nbChannels = 4;
  7197.                                 // then continuing with the case 6:
  7198.                             case 6:
  7199.                                 for ($i = 0; $i < $nbChannels; $i++) {
  7200.                                     array_unshift($color, $num & 0xff);
  7201.                                     $num >>= 8;
  7202.                                 }
  7204.                                 break;
  7205.                         }
  7207.                         if ($nbChannels === 4) {
  7208.                             if ($color[3] === 255) {
  7209.                                 $color[3] = 1; // fully opaque
  7210.                             } else {
  7211.                                 $color[3] = round($color[3] / 255, Number::PRECISION);
  7212.                             }
  7213.                         }
  7215.                         array_unshift($color, Type::T_COLOR);
  7217.                         return $color;
  7218.                     }
  7219.                 }
  7221.                 if ($rgba = Colors::colorNameToRGBa($name)) {
  7222.                     return isset($rgba[3])
  7223.                         ? [Type::T_COLOR, $rgba[0], $rgba[1], $rgba[2], $rgba[3]]
  7224.                         : [Type::T_COLOR, $rgba[0], $rgba[1], $rgba[2]];
  7225.                 }
  7227.                 return null;
  7228.         }
  7230.         return null;
  7231.     }
  7233.     /**
  7234.      * @param int|Number $value
  7235.      * @param bool       $isAlpha
  7236.      *
  7237.      * @return int|mixed
  7238.      */
  7239.     protected function compileRGBAValue($value, $isAlpha = false)
  7240.     {
  7241.         if ($isAlpha) {
  7242.             return $this->compileColorPartValue($value, 0, 1, false);
  7243.         }
  7245.         return $this->compileColorPartValue($value, 0, 255, true);
  7246.     }
  7248.     /**
  7249.      * @param mixed     $value
  7250.      * @param int|float $min
  7251.      * @param int|float $max
  7252.      * @param bool      $isInt
  7253.      *
  7254.      * @return int|mixed
  7255.      */
  7256.     protected function compileColorPartValue($value, $min, $max, $isInt = true)
  7257.     {
  7258.         if (! is_numeric($value)) {
  7259.             if (\is_array($value)) {
  7260.                 $reduced = $this->reduce($value);
  7262.                 if ($reduced instanceof Number) {
  7263.                     $value = $reduced;
  7264.                 }
  7265.             }
  7267.             if ($value instanceof Number) {
  7268.                 if ($value->unitless()) {
  7269.                     $num = $value->getDimension();
  7270.                 } elseif ($value->hasUnit('%')) {
  7271.                     $num = $max * $value->getDimension() / 100;
  7272.                 } else {
  7273.                     throw $this->error('Expected %s to have no units or "%%".', $value);
  7274.                 }
  7276.                 $value = $num;
  7277.             } elseif (\is_array($value)) {
  7278.                 $value = $this->compileValue($value);
  7279.             }
  7280.         }
  7282.         if (is_numeric($value)) {
  7283.             if ($isInt) {
  7284.                 $value = round($value);
  7285.             }
  7287.             $value = min($max, max($min, $value));
  7289.             return $value;
  7290.         }
  7292.         return $value;
  7293.     }
  7295.     /**
  7296.      * Coerce value to string
  7297.      *
  7298.      * @param array|Number $value
  7299.      *
  7300.      * @return array
  7301.      */
  7302.     protected function coerceString($value)
  7303.     {
  7304.         if ($value[0] === Type::T_STRING) {
  7305.             assert(\is_array($value));
  7307.             return $value;
  7308.         }
  7310.         return [Type::T_STRING, '', [$this->compileValue($value)]];
  7311.     }
  7313.     /**
  7314.      * Assert value is a string
  7315.      *
  7316.      * This method deals with internal implementation details of the value
  7317.      * representation where unquoted strings can sometimes be stored under
  7318.      * other types.
  7319.      * The returned value is always using the T_STRING type.
  7320.      *
  7321.      * @api
  7322.      *
  7323.      * @param array|Number $value
  7324.      * @param string|null  $varName
  7325.      *
  7326.      * @return array
  7327.      *
  7328.      * @throws SassScriptException
  7329.      */
  7330.     public function assertString($value, $varName = null)
  7331.     {
  7332.         // case of url(...) parsed a a function
  7333.         if ($value[0] === Type::T_FUNCTION) {
  7334.             $value = $this->coerceString($value);
  7335.         }
  7337.         if (! \in_array($value[0], [Type::T_STRING, Type::T_KEYWORD])) {
  7338.             $value = $this->compileValue($value);
  7339.             throw SassScriptException::forArgument("$value is not a string.", $varName);
  7340.         }
  7342.         return $this->coerceString($value);
  7343.     }
  7345.     /**
  7346.      * Coerce value to a percentage
  7347.      *
  7348.      * @param array|Number $value
  7349.      *
  7350.      * @return int|float
  7351.      *
  7352.      * @deprecated
  7353.      */
  7354.     protected function coercePercent($value)
  7355.     {
  7356.         @trigger_error(sprintf('"%s" is deprecated since 1.7.0.', __METHOD__), E_USER_DEPRECATED);
  7358.         if ($value instanceof Number) {
  7359.             if ($value->hasUnit('%')) {
  7360.                 return $value->getDimension() / 100;
  7361.             }
  7363.             return $value->getDimension();
  7364.         }
  7366.         return 0;
  7367.     }
  7369.     /**
  7370.      * Assert value is a map
  7371.      *
  7372.      * @api
  7373.      *
  7374.      * @param array|Number $value
  7375.      * @param string|null  $varName
  7376.      *
  7377.      * @return array
  7378.      *
  7379.      * @throws SassScriptException
  7380.      */
  7381.     public function assertMap($value, $varName = null)
  7382.     {
  7383.         $map = $this->tryMap($value);
  7385.         if ($map === null) {
  7386.             $value = $this->compileValue($value);
  7388.             throw SassScriptException::forArgument("$value is not a map.", $varName);
  7389.         }
  7391.         return $map;
  7392.     }
  7394.     /**
  7395.      * Assert value is a list
  7396.      *
  7397.      * @api
  7398.      *
  7399.      * @param array|Number $value
  7400.      *
  7401.      * @return array
  7402.      *
  7403.      * @throws \Exception
  7404.      */
  7405.     public function assertList($value)
  7406.     {
  7407.         if ($value[0] !== Type::T_LIST) {
  7408.             throw $this->error('expecting list, %s received', $value[0]);
  7409.         }
  7410.         assert(\is_array($value));
  7412.         return $value;
  7413.     }
  7415.     /**
  7416.      * Gets the keywords of an argument list.
  7417.      *
  7418.      * Keys in the returned array are normalized names (underscores are replaced with dashes)
  7419.      * without the leading `$`.
  7420.      * Calling this helper with anything that an argument list received for a rest argument
  7421.      * of the function argument declaration is not supported.
  7422.      *
  7423.      * @param array|Number $value
  7424.      *
  7425.      * @return array<string, array|Number>
  7426.      */
  7427.     public function getArgumentListKeywords($value)
  7428.     {
  7429.         if ($value[0] !== Type::T_LIST || !isset($value[3]) || !\is_array($value[3])) {
  7430.             throw new \InvalidArgumentException('The argument is not a sass argument list.');
  7431.         }
  7433.         return $value[3];
  7434.     }
  7436.     /**
  7437.      * Assert value is a color
  7438.      *
  7439.      * @api
  7440.      *
  7441.      * @param array|Number $value
  7442.      * @param string|null  $varName
  7443.      *
  7444.      * @return array
  7445.      *
  7446.      * @throws SassScriptException
  7447.      */
  7448.     public function assertColor($value, $varName = null)
  7449.     {
  7450.         if ($color = $this->coerceColor($value)) {
  7451.             return $color;
  7452.         }
  7454.         $value = $this->compileValue($value);
  7456.         throw SassScriptException::forArgument("$value is not a color.", $varName);
  7457.     }
  7459.     /**
  7460.      * Assert value is a number
  7461.      *
  7462.      * @api
  7463.      *
  7464.      * @param array|Number $value
  7465.      * @param string|null  $varName
  7466.      *
  7467.      * @return Number
  7468.      *
  7469.      * @throws SassScriptException
  7470.      */
  7471.     public function assertNumber($value, $varName = null)
  7472.     {
  7473.         if (!$value instanceof Number) {
  7474.             $value = $this->compileValue($value);
  7475.             throw SassScriptException::forArgument("$value is not a number.", $varName);
  7476.         }
  7478.         return $value;
  7479.     }
  7481.     /**
  7482.      * Assert value is a integer
  7483.      *
  7484.      * @api
  7485.      *
  7486.      * @param array|Number $value
  7487.      * @param string|null  $varName
  7488.      *
  7489.      * @return int
  7490.      *
  7491.      * @throws SassScriptException
  7492.      */
  7493.     public function assertInteger($value, $varName = null)
  7494.     {
  7495.         $value = $this->assertNumber($value, $varName)->getDimension();
  7496.         if (round($value - \intval($value), Number::PRECISION) > 0) {
  7497.             throw SassScriptException::forArgument("$value is not an integer.", $varName);
  7498.         }
  7500.         return intval($value);
  7501.     }
  7503.     /**
  7504.      * Extract the  ... / alpha on the last argument of channel arg
  7505.      * in color functions
  7506.      *
  7507.      * @param array $args
  7508.      * @return array
  7509.      */
  7510.     private function extractSlashAlphaInColorFunction($args)
  7511.     {
  7512.         $last = end($args);
  7513.         if (\count($args) === 3 && $last[0] === Type::T_EXPRESSION && $last[1] === '/') {
  7514.             array_pop($args);
  7515.             $args[] = $last[2];
  7516.             $args[] = $last[3];
  7517.         }
  7518.         return $args;
  7519.     }
  7522.     /**
  7523.      * Make sure a color's components don't go out of bounds
  7524.      *
  7525.      * @param array $c
  7526.      *
  7527.      * @return array
  7528.      */
  7529.     protected function fixColor($c)
  7530.     {
  7531.         foreach ([1, 2, 3] as $i) {
  7532.             if ($c[$i] < 0) {
  7533.                 $c[$i] = 0;
  7534.             }
  7536.             if ($c[$i] > 255) {
  7537.                 $c[$i] = 255;
  7538.             }
  7540.             if (!\is_int($c[$i])) {
  7541.                 $c[$i] = round($c[$i]);
  7542.             }
  7543.         }
  7545.         return $c;
  7546.     }
  7548.     /**
  7549.      * Convert RGB to HSL
  7550.      *
  7551.      * @internal
  7552.      *
  7553.      * @param int $red
  7554.      * @param int $green
  7555.      * @param int $blue
  7556.      *
  7557.      * @return array
  7558.      */
  7559.     public function toHSL($red, $green, $blue)
  7560.     {
  7561.         $min = min($red, $green, $blue);
  7562.         $max = max($red, $green, $blue);
  7564.         $l = $min + $max;
  7565.         $d = $max - $min;
  7567.         if ((int) $d === 0) {
  7568.             $h = $s = 0;
  7569.         } else {
  7570.             if ($l < 255) {
  7571.                 $s = $d / $l;
  7572.             } else {
  7573.                 $s = $d / (510 - $l);
  7574.             }
  7576.             if ($red == $max) {
  7577.                 $h = 60 * ($green - $blue) / $d;
  7578.             } elseif ($green == $max) {
  7579.                 $h = 60 * ($blue - $red) / $d + 120;
  7580.             } else {
  7581.                 $h = 60 * ($red - $green) / $d + 240;
  7582.             }
  7583.         }
  7585.         return [Type::T_HSL, fmod($h + 360, 360), $s * 100, $l / 5.1];
  7586.     }
  7588.     /**
  7589.      * Hue to RGB helper
  7590.      *
  7591.      * @param float $m1
  7592.      * @param float $m2
  7593.      * @param float $h
  7594.      *
  7595.      * @return float
  7596.      */
  7597.     protected function hueToRGB($m1, $m2, $h)
  7598.     {
  7599.         if ($h < 0) {
  7600.             $h += 1;
  7601.         } elseif ($h > 1) {
  7602.             $h -= 1;
  7603.         }
  7605.         if ($h * 6 < 1) {
  7606.             return $m1 + ($m2 - $m1) * $h * 6;
  7607.         }
  7609.         if ($h * 2 < 1) {
  7610.             return $m2;
  7611.         }
  7613.         if ($h * 3 < 2) {
  7614.             return $m1 + ($m2 - $m1) * (2 / 3 - $h) * 6;
  7615.         }
  7617.         return $m1;
  7618.     }
  7620.     /**
  7621.      * Convert HSL to RGB
  7622.      *
  7623.      * @internal
  7624.      *
  7625.      * @param int|float $hue        H from 0 to 360
  7626.      * @param int|float $saturation S from 0 to 100
  7627.      * @param int|float $lightness  L from 0 to 100
  7628.      *
  7629.      * @return array
  7630.      */
  7631.     public function toRGB($hue, $saturation, $lightness)
  7632.     {
  7633.         if ($hue < 0) {
  7634.             $hue += 360;
  7635.         }
  7637.         $h = $hue / 360;
  7638.         $s = min(100, max(0, $saturation)) / 100;
  7639.         $l = min(100, max(0, $lightness)) / 100;
  7641.         $m2 = $l <= 0.5 ? $l * ($s + 1) : $l + $s - $l * $s;
  7642.         $m1 = $l * 2 - $m2;
  7644.         $r = $this->hueToRGB($m1, $m2, $h + 1 / 3) * 255;
  7645.         $g = $this->hueToRGB($m1, $m2, $h) * 255;
  7646.         $b = $this->hueToRGB($m1, $m2, $h - 1 / 3) * 255;
  7648.         $out = [Type::T_COLOR, $r, $g, $b];
  7650.         return $out;
  7651.     }
  7653.     /**
  7654.      * Convert HWB to RGB
  7655.      * https://www.w3.org/TR/css-color-4/#hwb-to-rgb
  7656.      *
  7657.      * @api
  7658.      *
  7659.      * @param int|float $hue        H from 0 to 360
  7660.      * @param int|float $whiteness  W from 0 to 100
  7661.      * @param int|float $blackness  B from 0 to 100
  7662.      *
  7663.      * @return array
  7664.      */
  7665.     private function HWBtoRGB($hue, $whiteness, $blackness)
  7666.     {
  7667.         $w = min(100, max(0, $whiteness)) / 100;
  7668.         $b = min(100, max(0, $blackness)) / 100;
  7670.         $sum = $w + $b;
  7671.         if ($sum > 1.0) {
  7672.             $w = $w / $sum;
  7673.             $b = $b / $sum;
  7674.         }
  7675.         $b = min(1.0 - $w, $b);
  7677.         $rgb = $this->toRGB($hue, 100, 50);
  7678.         for($i = 1; $i < 4; $i++) {
  7679.           $rgb[$i] *= (1.0 - $w - $b);
  7680.           $rgb[$i] = round($rgb[$i] + 255 * $w + 0.0001);
  7681.         }
  7683.         return $rgb;
  7684.     }
  7686.     /**
  7687.      * Convert RGB to HWB
  7688.      *
  7689.      * @api
  7690.      *
  7691.      * @param int $red
  7692.      * @param int $green
  7693.      * @param int $blue
  7694.      *
  7695.      * @return array
  7696.      */
  7697.     private function RGBtoHWB($red, $green, $blue)
  7698.     {
  7699.         $min = min($red, $green, $blue);
  7700.         $max = max($red, $green, $blue);
  7702.         $d = $max - $min;
  7704.         if ((int) $d === 0) {
  7705.             $h = 0;
  7706.         } else {
  7708.             if ($red == $max) {
  7709.                 $h = 60 * ($green - $blue) / $d;
  7710.             } elseif ($green == $max) {
  7711.                 $h = 60 * ($blue - $red) / $d + 120;
  7712.             } else {
  7713.                 $h = 60 * ($red - $green) / $d + 240;
  7714.             }
  7715.         }
  7717.         return [Type::T_HWB, fmod($h, 360), $min / 255 * 100, 100 - $max / 255 *100];
  7718.     }
  7721.     // Built in functions
  7723.     protected static $libCall = ['function', 'args...'];
  7724.     protected function libCall($args)
  7725.     {
  7726.         $functionReference = $args[0];
  7728.         if (in_array($functionReference[0], [Type::T_STRING, Type::T_KEYWORD])) {
  7729.             $name = $this->compileStringContent($this->coerceString($functionReference));
  7730.             $warning = "Passing a string to call() is deprecated and will be illegal\n"
  7731.                 . "in Sass 4.0. Use call(function-reference($name)) instead.";
  7732.             Warn::deprecation($warning);
  7733.             $functionReference = $this->libGetFunction([$this->assertString($functionReference, 'function')]);
  7734.         }
  7736.         if ($functionReference === static::$null) {
  7737.             return static::$null;
  7738.         }
  7740.         if (! in_array($functionReference[0], [Type::T_FUNCTION_REFERENCE, Type::T_FUNCTION])) {
  7741.             throw $this->error('Function reference expected, got ' . $functionReference[0]);
  7742.         }
  7744.         $callArgs = [
  7745.             [null, $args[1], true]
  7746.         ];
  7748.         return $this->reduce([Type::T_FUNCTION_CALL, $functionReference, $callArgs]);
  7749.     }
  7752.     protected static $libGetFunction = [
  7753.         ['name'],
  7754.         ['name', 'css']
  7755.     ];
  7756.     protected function libGetFunction($args)
  7757.     {
  7758.         $name = $this->compileStringContent($this->assertString(array_shift($args), 'name'));
  7759.         $isCss = false;
  7761.         if (count($args)) {
  7762.             $isCss = array_shift($args);
  7763.             $isCss = (($isCss === static::$true) ? true : false);
  7764.         }
  7766.         if ($isCss) {
  7767.             return [Type::T_FUNCTION, $name, [Type::T_LIST, ',', []]];
  7768.         }
  7770.         return $this->getFunctionReference($name, true);
  7771.     }
  7773.     protected static $libIf = ['condition', 'if-true', 'if-false:'];
  7774.     protected function libIf($args)
  7775.     {
  7776.         list($cond, $t, $f) = $args;
  7778.         if (! $this->isTruthy($this->reduce($cond, true))) {
  7779.             return $this->reduce($f, true);
  7780.         }
  7782.         return $this->reduce($t, true);
  7783.     }
  7785.     protected static $libIndex = ['list', 'value'];
  7786.     protected function libIndex($args)
  7787.     {
  7788.         list($list, $value) = $args;
  7790.         if (
  7791.             $list[0] === Type::T_MAP ||
  7792.             $list[0] === Type::T_STRING ||
  7793.             $list[0] === Type::T_KEYWORD ||
  7794.             $list[0] === Type::T_INTERPOLATE
  7795.         ) {
  7796.             $list = $this->coerceList($list, ' ');
  7797.         }
  7799.         if ($list[0] !== Type::T_LIST) {
  7800.             return static::$null;
  7801.         }
  7803.         // Numbers are represented with value objects, for which the PHP equality operator does not
  7804.         // match the Sass rules (and we cannot overload it). As they are the only type of values
  7805.         // represented with a value object for now, they require a special case.
  7806.         if ($value instanceof Number) {
  7807.             $key = 0;
  7808.             foreach ($list[2] as $item) {
  7809.                 $key++;
  7810.                 $itemValue = $this->normalizeValue($item);
  7812.                 if ($itemValue instanceof Number && $value->equals($itemValue)) {
  7813.                     return new Number($key, '');
  7814.                 }
  7815.             }
  7816.             return static::$null;
  7817.         }
  7819.         $values = [];
  7821.         foreach ($list[2] as $item) {
  7822.             $values[] = $this->normalizeValue($item);
  7823.         }
  7825.         $key = array_search($this->normalizeValue($value), $values);
  7827.         return false === $key ? static::$null : new Number($key + 1, '');
  7828.     }
  7830.     protected static $libRgb = [
  7831.         ['color'],
  7832.         ['color', 'alpha'],
  7833.         ['channels'],
  7834.         ['red', 'green', 'blue'],
  7835.         ['red', 'green', 'blue', 'alpha'] ];
  7837.     /**
  7838.      * @param array $args
  7839.      * @param array $kwargs
  7840.      * @param string $funcName
  7841.      *
  7842.      * @return array
  7843.      */
  7844.     protected function libRgb($args, $kwargs, $funcName = 'rgb')
  7845.     {
  7846.         switch (\count($args)) {
  7847.             case 1:
  7848.                 if (! $color = $this->coerceColor($args[0], true)) {
  7849.                     $color = [Type::T_STRING, '', [$funcName . '(', $args[0], ')']];
  7850.                 }
  7851.                 break;
  7853.             case 3:
  7854.                 $color = [Type::T_COLOR, $args[0], $args[1], $args[2]];
  7856.                 if (! $color = $this->coerceColor($color)) {
  7857.                     $color = [Type::T_STRING, '', [$funcName . '(', $args[0], ', ', $args[1], ', ', $args[2], ')']];
  7858.                 }
  7860.                 return $color;
  7862.             case 2:
  7863.                 if ($color = $this->coerceColor($args[0], true)) {
  7864.                     $alpha = $this->compileRGBAValue($args[1], true);
  7866.                     if (is_numeric($alpha)) {
  7867.                         $color[4] = $alpha;
  7868.                     } else {
  7869.                         $color = [Type::T_STRING, '',
  7870.                             [$funcName . '(', $color[1], ', ', $color[2], ', ', $color[3], ', ', $alpha, ')']];
  7871.                     }
  7872.                 } else {
  7873.                     $color = [Type::T_STRING, '', [$funcName . '(', $args[0], ', ', $args[1], ')']];
  7874.                 }
  7875.                 break;
  7877.             case 4:
  7878.             default:
  7879.                 $color = [Type::T_COLOR, $args[0], $args[1], $args[2], $args[3]];
  7881.                 if (! $color = $this->coerceColor($color)) {
  7882.                     $color = [Type::T_STRING, '',
  7883.                         [$funcName . '(', $args[0], ', ', $args[1], ', ', $args[2], ', ', $args[3], ')']];
  7884.                 }
  7885.                 break;
  7886.         }
  7888.         return $color;
  7889.     }
  7891.     protected static $libRgba = [
  7892.         ['color'],
  7893.         ['color', 'alpha'],
  7894.         ['channels'],
  7895.         ['red', 'green', 'blue'],
  7896.         ['red', 'green', 'blue', 'alpha'] ];
  7897.     protected function libRgba($args, $kwargs)
  7898.     {
  7899.         return $this->libRgb($args, $kwargs, 'rgba');
  7900.     }
  7902.     /**
  7903.      * Helper function for adjust_color, change_color, and scale_color
  7904.      *
  7905.      * @param array<array|Number> $args
  7906.      * @param string $operation
  7907.      * @param callable $fn
  7908.      *
  7909.      * @return array
  7910.      *
  7911.      * @phpstan-param callable(float|int, float|int|null, float|int): (float|int) $fn
  7912.      */
  7913.     protected function alterColor(array $args, $operation, $fn)
  7914.     {
  7915.         $color = $this->assertColor($args[0], 'color');
  7917.         if ($args[1][2]) {
  7918.             throw new SassScriptException('Only one positional argument is allowed. All other arguments must be passed by name.');
  7919.         }
  7921.         $kwargs = $this->getArgumentListKeywords($args[1]);
  7923.         $scale = $operation === 'scale';
  7924.         $change = $operation === 'change';
  7926.         /** @phpstan-var callable(string, float|int, bool=, bool=): (float|int|null) $getParam */
  7927.         $getParam = function ($name, $max, $checkPercent = false, $assertPercent = false) use (&$kwargs, $scale, $change) {
  7928.             if (!isset($kwargs[$name])) {
  7929.                 return null;
  7930.             }
  7932.             $number = $this->assertNumber($kwargs[$name], $name);
  7933.             unset($kwargs[$name]);
  7935.             if (!$scale && $checkPercent) {
  7936.                 if (!$number->hasUnit('%')) {
  7937.                     $warning = $this->error("{$name} Passing a number `$number` without unit % is deprecated.");
  7938.                     $this->logger->warn($warning->getMessage(), true);
  7939.                 }
  7940.             }
  7942.             if ($scale || $assertPercent) {
  7943.                 $number->assertUnit('%', $name);
  7944.             }
  7946.             if ($scale) {
  7947.                 $max = 100;
  7948.             }
  7950.             return $number->valueInRange($change ? 0 : -$max, $max, $name);
  7951.         };
  7953.         $alpha = $getParam('alpha', 1);
  7954.         $red = $getParam('red', 255);
  7955.         $green = $getParam('green', 255);
  7956.         $blue = $getParam('blue', 255);
  7958.         if ($scale || !isset($kwargs['hue'])) {
  7959.             $hue = null;
  7960.         } else {
  7961.             $hueNumber = $this->assertNumber($kwargs['hue'], 'hue');
  7962.             unset($kwargs['hue']);
  7963.             $hue = $hueNumber->getDimension();
  7964.         }
  7965.         $saturation = $getParam('saturation', 100, true);
  7966.         $lightness = $getParam('lightness', 100, true);
  7967.         $whiteness = $getParam('whiteness', 100, false, true);
  7968.         $blackness = $getParam('blackness', 100, false, true);
  7970.         if (!empty($kwargs)) {
  7971.             $unknownNames = array_keys($kwargs);
  7972.             $lastName = array_pop($unknownNames);
  7973.             $message = sprintf(
  7974.                 'No argument%s named $%s%s.',
  7975.                 $unknownNames ? 's' : '',
  7976.                 $unknownNames ? implode(', $', $unknownNames) . ' or $' : '',
  7977.                 $lastName
  7978.             );
  7979.             throw new SassScriptException($message);
  7980.         }
  7982.         $hasRgb = $red !== null || $green !== null || $blue !== null;
  7983.         $hasSL = $saturation !== null || $lightness !== null;
  7984.         $hasWB = $whiteness !== null || $blackness !== null;
  7986.         if ($hasRgb && ($hasSL || $hasWB || $hue !== null)) {
  7987.             throw new SassScriptException(sprintf('RGB parameters may not be passed along with %s parameters.', $hasWB ? 'HWB' : 'HSL'));
  7988.         }
  7990.         if ($hasWB && $hasSL) {
  7991.             throw new SassScriptException('HSL parameters may not be passed along with HWB parameters.');
  7992.         }
  7994.         if ($hasRgb) {
  7995.             $color[1] = round($fn($color[1], $red, 255));
  7996.             $color[2] = round($fn($color[2], $green, 255));
  7997.             $color[3] = round($fn($color[3], $blue, 255));
  7998.         } elseif ($hasWB) {
  7999.             $hwb = $this->RGBtoHWB($color[1], $color[2], $color[3]);
  8000.             if ($hue !== null) {
  8001.                 $hwb[1] = $change ? $hue : $hwb[1] + $hue;
  8002.             }
  8003.             $hwb[2] = $fn($hwb[2], $whiteness, 100);
  8004.             $hwb[3] = $fn($hwb[3], $blackness, 100);
  8006.             $rgb = $this->HWBtoRGB($hwb[1], $hwb[2], $hwb[3]);
  8008.             if (isset($color[4])) {
  8009.                 $rgb[4] = $color[4];
  8010.             }
  8012.             $color = $rgb;
  8013.         } elseif ($hue !== null || $hasSL) {
  8014.             $hsl = $this->toHSL($color[1], $color[2], $color[3]);
  8016.             if ($hue !== null) {
  8017.                 $hsl[1] = $change ? $hue : $hsl[1] + $hue;
  8018.             }
  8019.             $hsl[2] = $fn($hsl[2], $saturation, 100);
  8020.             $hsl[3] = $fn($hsl[3], $lightness, 100);
  8022.             $rgb = $this->toRGB($hsl[1], $hsl[2], $hsl[3]);
  8024.             if (isset($color[4])) {
  8025.                 $rgb[4] = $color[4];
  8026.             }
  8028.             $color = $rgb;
  8029.         }
  8031.         if ($alpha !== null) {
  8032.             $existingAlpha = isset($color[4]) ? $color[4] : 1;
  8033.             $color[4] = $fn($existingAlpha, $alpha, 1);
  8034.         }
  8036.         return $color;
  8037.     }
  8039.     protected static $libAdjustColor = ['color', 'kwargs...'];
  8040.     protected function libAdjustColor($args)
  8041.     {
  8042.         return $this->alterColor($args, 'adjust', function ($base, $alter, $max) {
  8043.             if ($alter === null) {
  8044.                 return $base;
  8045.             }
  8047.             $new = $base + $alter;
  8049.             if ($new < 0) {
  8050.                 return 0;
  8051.             }
  8053.             if ($new > $max) {
  8054.                 return $max;
  8055.             }
  8057.             return $new;
  8058.         });
  8059.     }
  8061.     protected static $libChangeColor = ['color', 'kwargs...'];
  8062.     protected function libChangeColor($args)
  8063.     {
  8064.         return $this->alterColor($args,'change', function ($base, $alter, $max) {
  8065.             if ($alter === null) {
  8066.                 return $base;
  8067.             }
  8069.             return $alter;
  8070.         });
  8071.     }
  8073.     protected static $libScaleColor = ['color', 'kwargs...'];
  8074.     protected function libScaleColor($args)
  8075.     {
  8076.         return $this->alterColor($args, 'scale', function ($base, $scale, $max) {
  8077.             if ($scale === null) {
  8078.                 return $base;
  8079.             }
  8081.             $scale = $scale / 100;
  8083.             if ($scale < 0) {
  8084.                 return $base * $scale + $base;
  8085.             }
  8087.             return ($max - $base) * $scale + $base;
  8088.         });
  8089.     }
  8091.     protected static $libIeHexStr = ['color'];
  8092.     protected function libIeHexStr($args)
  8093.     {
  8094.         $color = $this->coerceColor($args[0]);
  8096.         if (\is_null($color)) {
  8097.             throw $this->error('Error: argument `$color` of `ie-hex-str($color)` must be a color');
  8098.         }
  8100.         $color[4] = isset($color[4]) ? round(255 * $color[4]) : 255;
  8102.         return [Type::T_STRING, '', [sprintf('#%02X%02X%02X%02X', $color[4], $color[1], $color[2], $color[3])]];
  8103.     }
  8105.     protected static $libRed = ['color'];
  8106.     protected function libRed($args)
  8107.     {
  8108.         $color = $this->coerceColor($args[0]);
  8110.         if (\is_null($color)) {
  8111.             throw $this->error('Error: argument `$color` of `red($color)` must be a color');
  8112.         }
  8114.         return new Number((int) $color[1], '');
  8115.     }
  8117.     protected static $libGreen = ['color'];
  8118.     protected function libGreen($args)
  8119.     {
  8120.         $color = $this->coerceColor($args[0]);
  8122.         if (\is_null($color)) {
  8123.             throw $this->error('Error: argument `$color` of `green($color)` must be a color');
  8124.         }
  8126.         return new Number((int) $color[2], '');
  8127.     }
  8129.     protected static $libBlue = ['color'];
  8130.     protected function libBlue($args)
  8131.     {
  8132.         $color = $this->coerceColor($args[0]);
  8134.         if (\is_null($color)) {
  8135.             throw $this->error('Error: argument `$color` of `blue($color)` must be a color');
  8136.         }
  8138.         return new Number((int) $color[3], '');
  8139.     }
  8141.     protected static $libAlpha = ['color'];
  8142.     protected function libAlpha($args)
  8143.     {
  8144.         if ($color = $this->coerceColor($args[0])) {
  8145.             return new Number(isset($color[4]) ? $color[4] : 1, '');
  8146.         }
  8148.         // this might be the IE function, so return value unchanged
  8149.         return null;
  8150.     }
  8152.     protected static $libOpacity = ['color'];
  8153.     protected function libOpacity($args)
  8154.     {
  8155.         $value = $args[0];
  8157.         if ($value instanceof Number) {
  8158.             return null;
  8159.         }
  8161.         return $this->libAlpha($args);
  8162.     }
  8164.     // mix two colors
  8165.     protected static $libMix = [
  8166.         ['color1', 'color2', 'weight:50%'],
  8167.         ['color-1', 'color-2', 'weight:50%']
  8168.         ];
  8169.     protected function libMix($args)
  8170.     {
  8171.         list($first, $second, $weight) = $args;
  8173.         $first = $this->assertColor($first, 'color1');
  8174.         $second = $this->assertColor($second, 'color2');
  8175.         $weightScale = $this->assertNumber($weight, 'weight')->valueInRange(0, 100, 'weight') / 100;
  8177.         $firstAlpha = isset($first[4]) ? $first[4] : 1;
  8178.         $secondAlpha = isset($second[4]) ? $second[4] : 1;
  8180.         $normalizedWeight = $weightScale * 2 - 1;
  8181.         $alphaDistance = $firstAlpha - $secondAlpha;
  8183.         $combinedWeight = $normalizedWeight * $alphaDistance == -1 ? $normalizedWeight : ($normalizedWeight + $alphaDistance) / (1 + $normalizedWeight * $alphaDistance);
  8184.         $weight1 = ($combinedWeight + 1) / 2.0;
  8185.         $weight2 = 1.0 - $weight1;
  8187.         $new = [Type::T_COLOR,
  8188.             $weight1 * $first[1] + $weight2 * $second[1],
  8189.             $weight1 * $first[2] + $weight2 * $second[2],
  8190.             $weight1 * $first[3] + $weight2 * $second[3],
  8191.         ];
  8193.         if ($firstAlpha != 1.0 || $secondAlpha != 1.0) {
  8194.             $new[] = $firstAlpha * $weightScale + $secondAlpha * (1 - $weightScale);
  8195.         }
  8197.         return $this->fixColor($new);
  8198.     }
  8200.     protected static $libHsl = [
  8201.         ['channels'],
  8202.         ['hue', 'saturation'],
  8203.         ['hue', 'saturation', 'lightness'],
  8204.         ['hue', 'saturation', 'lightness', 'alpha'] ];
  8206.     /**
  8207.      * @param array $args
  8208.      * @param array $kwargs
  8209.      * @param string $funcName
  8210.      *
  8211.      * @return array|null
  8212.      */
  8213.     protected function libHsl($args, $kwargs, $funcName = 'hsl')
  8214.     {
  8215.         $args_to_check = $args;
  8217.         if (\count($args) == 1) {
  8218.             if ($args[0][0] !== Type::T_LIST || \count($args[0][2]) < 3 || \count($args[0][2]) > 4) {
  8219.                 return [Type::T_STRING, '', [$funcName . '(', $args[0], ')']];
  8220.             }
  8222.             $args = $args[0][2];
  8223.             $args_to_check = $kwargs['channels'][2];
  8224.         }
  8226.         if (\count($args) === 2) {
  8227.             // if var() is used as an argument, return as a css function
  8228.             foreach ($args as $arg) {
  8229.                 if ($arg[0] === Type::T_FUNCTION && in_array($arg[1], ['var'])) {
  8230.                     return null;
  8231.                 }
  8232.             }
  8234.             throw new SassScriptException('Missing argument $lightness.');
  8235.         }
  8237.         foreach ($kwargs as $arg) {
  8238.             if (in_array($arg[0], [Type::T_FUNCTION_CALL, Type::T_FUNCTION]) && in_array($arg[1], ['min', 'max'])) {
  8239.                 return null;
  8240.             }
  8241.         }
  8243.         foreach ($args_to_check as $k => $arg) {
  8244.             if (in_array($arg[0], [Type::T_FUNCTION_CALL, Type::T_FUNCTION]) && in_array($arg[1], ['min', 'max'])) {
  8245.                 if (count($kwargs) > 1 || ($k >= 2 && count($args) === 4)) {
  8246.                     return null;
  8247.                 }
  8249.                 $args[$k] = $this->stringifyFncallArgs($arg);
  8250.             }
  8252.             if (
  8253.                 $k >= 2 && count($args) === 4 &&
  8254.                 in_array($arg[0], [Type::T_FUNCTION_CALL, Type::T_FUNCTION]) &&
  8255.                 in_array($arg[1], ['calc','env'])
  8256.             ) {
  8257.                 return null;
  8258.             }
  8259.         }
  8261.         $hue = $this->reduce($args[0]);
  8262.         $saturation = $this->reduce($args[1]);
  8263.         $lightness = $this->reduce($args[2]);
  8264.         $alpha = null;
  8266.         if (\count($args) === 4) {
  8267.             $alpha = $this->compileColorPartValue($args[3], 0, 100, false);
  8269.             if (!$hue instanceof Number || !$saturation instanceof Number || ! $lightness instanceof Number || ! is_numeric($alpha)) {
  8270.                 return [Type::T_STRING, '',
  8271.                     [$funcName . '(', $args[0], ', ', $args[1], ', ', $args[2], ', ', $args[3], ')']];
  8272.             }
  8273.         } else {
  8274.             if (!$hue instanceof Number || !$saturation instanceof Number || ! $lightness instanceof Number) {
  8275.                 return [Type::T_STRING, '', [$funcName . '(', $args[0], ', ', $args[1], ', ', $args[2], ')']];
  8276.             }
  8277.         }
  8279.         $hueValue = fmod($hue->getDimension(), 360);
  8281.         while ($hueValue < 0) {
  8282.             $hueValue += 360;
  8283.         }
  8285.         $color = $this->toRGB($hueValue, max(0, min($saturation->getDimension(), 100)), max(0, min($lightness->getDimension(), 100)));
  8287.         if (! \is_null($alpha)) {
  8288.             $color[4] = $alpha;
  8289.         }
  8291.         return $color;
  8292.     }
  8294.     protected static $libHsla = [
  8295.             ['channels'],
  8296.             ['hue', 'saturation'],
  8297.             ['hue', 'saturation', 'lightness'],
  8298.             ['hue', 'saturation', 'lightness', 'alpha']];
  8299.     protected function libHsla($args, $kwargs)
  8300.     {
  8301.         return $this->libHsl($args, $kwargs, 'hsla');
  8302.     }
  8304.     protected static $libHue = ['color'];
  8305.     protected function libHue($args)
  8306.     {
  8307.         $color = $this->assertColor($args[0], 'color');
  8308.         $hsl = $this->toHSL($color[1], $color[2], $color[3]);
  8310.         return new Number($hsl[1], 'deg');
  8311.     }
  8313.     protected static $libSaturation = ['color'];
  8314.     protected function libSaturation($args)
  8315.     {
  8316.         $color = $this->assertColor($args[0], 'color');
  8317.         $hsl = $this->toHSL($color[1], $color[2], $color[3]);
  8319.         return new Number($hsl[2], '%');
  8320.     }
  8322.     protected static $libLightness = ['color'];
  8323.     protected function libLightness($args)
  8324.     {
  8325.         $color = $this->assertColor($args[0], 'color');
  8326.         $hsl = $this->toHSL($color[1], $color[2], $color[3]);
  8328.         return new Number($hsl[3], '%');
  8329.     }
  8331.     /*
  8332.      * Todo : a integrer dans le futur module color
  8333.     protected static $libHwb = [
  8334.         ['channels'],
  8335.         ['hue', 'whiteness', 'blackness'],
  8336.         ['hue', 'whiteness', 'blackness', 'alpha'] ];
  8337.     protected function libHwb($args, $kwargs, $funcName = 'hwb')
  8338.     {
  8339.         $args_to_check = $args;
  8341.         if (\count($args) == 1) {
  8342.             if ($args[0][0] !== Type::T_LIST) {
  8343.                 throw $this->error("Missing elements \$whiteness and \$blackness");
  8344.             }
  8346.             if (\trim($args[0][1])) {
  8347.                 throw $this->error("\$channels must be a space-separated list.");
  8348.             }
  8350.             if (! empty($args[0]['enclosing'])) {
  8351.                 throw $this->error("\$channels must be an unbracketed list.");
  8352.             }
  8354.             $args = $args[0][2];
  8355.             if (\count($args) > 3) {
  8356.                 throw $this->error("hwb() : Only 3 elements are allowed but ". \count($args) . "were passed");
  8357.             }
  8359.             $args_to_check = $this->extractSlashAlphaInColorFunction($kwargs['channels'][2]);
  8360.             if (\count($args_to_check) !== \count($kwargs['channels'][2])) {
  8361.                 $args = $args_to_check;
  8362.             }
  8363.         }
  8365.         if (\count($args_to_check) < 2) {
  8366.             throw $this->error("Missing elements \$whiteness and \$blackness");
  8367.         }
  8368.         if (\count($args_to_check) < 3) {
  8369.             throw $this->error("Missing element \$blackness");
  8370.         }
  8371.         if (\count($args_to_check) > 4) {
  8372.             throw $this->error("hwb() : Only 4 elements are allowed but ". \count($args) . "were passed");
  8373.         }
  8375.         foreach ($kwargs as $k => $arg) {
  8376.             if (in_array($arg[0], [Type::T_FUNCTION_CALL]) && in_array($arg[1], ['min', 'max'])) {
  8377.                 return null;
  8378.             }
  8379.         }
  8381.         foreach ($args_to_check as $k => $arg) {
  8382.             if (in_array($arg[0], [Type::T_FUNCTION_CALL]) && in_array($arg[1], ['min', 'max'])) {
  8383.                 if (count($kwargs) > 1 || ($k >= 2 && count($args) === 4)) {
  8384.                     return null;
  8385.                 }
  8387.                 $args[$k] = $this->stringifyFncallArgs($arg);
  8388.             }
  8390.             if (
  8391.                 $k >= 2 && count($args) === 4 &&
  8392.                 in_array($arg[0], [Type::T_FUNCTION_CALL, Type::T_FUNCTION]) &&
  8393.                 in_array($arg[1], ['calc','env'])
  8394.             ) {
  8395.                 return null;
  8396.             }
  8397.         }
  8399.         $hue = $this->reduce($args[0]);
  8400.         $whiteness = $this->reduce($args[1]);
  8401.         $blackness = $this->reduce($args[2]);
  8402.         $alpha = null;
  8404.         if (\count($args) === 4) {
  8405.             $alpha = $this->compileColorPartValue($args[3], 0, 1, false);
  8407.             if (! \is_numeric($alpha)) {
  8408.                 $val = $this->compileValue($args[3]);
  8409.                 throw $this->error("\$alpha: $val is not a number");
  8410.             }
  8411.         }
  8413.         $this->assertNumber($hue, 'hue');
  8414.         $this->assertUnit($whiteness, ['%'], 'whiteness');
  8415.         $this->assertUnit($blackness, ['%'], 'blackness');
  8417.         $this->assertRange($whiteness, 0, 100, "0% and 100%", "whiteness");
  8418.         $this->assertRange($blackness, 0, 100, "0% and 100%", "blackness");
  8420.         $w = $whiteness->getDimension();
  8421.         $b = $blackness->getDimension();
  8423.         $hueValue = $hue->getDimension() % 360;
  8425.         while ($hueValue < 0) {
  8426.             $hueValue += 360;
  8427.         }
  8429.         $color = $this->HWBtoRGB($hueValue, $w, $b);
  8431.         if (! \is_null($alpha)) {
  8432.             $color[4] = $alpha;
  8433.         }
  8435.         return $color;
  8436.     }
  8438.     protected static $libWhiteness = ['color'];
  8439.     protected function libWhiteness($args, $kwargs, $funcName = 'whiteness') {
  8441.         $color = $this->assertColor($args[0]);
  8442.         $hwb = $this->RGBtoHWB($color[1], $color[2], $color[3]);
  8444.         return new Number($hwb[2], '%');
  8445.     }
  8447.     protected static $libBlackness = ['color'];
  8448.     protected function libBlackness($args, $kwargs, $funcName = 'blackness') {
  8450.         $color = $this->assertColor($args[0]);
  8451.         $hwb = $this->RGBtoHWB($color[1], $color[2], $color[3]);
  8453.         return new Number($hwb[3], '%');
  8454.     }
  8455.     */
  8457.     /**
  8458.      * @param array     $color
  8459.      * @param int       $idx
  8460.      * @param int|float $amount
  8461.      *
  8462.      * @return array
  8463.      */
  8464.     protected function adjustHsl($color, $idx, $amount)
  8465.     {
  8466.         $hsl = $this->toHSL($color[1], $color[2], $color[3]);
  8467.         $hsl[$idx] += $amount;
  8469.         if ($idx !== 1) {
  8470.             // Clamp the saturation and lightness
  8471.             $hsl[$idx] = min(max(0, $hsl[$idx]), 100);
  8472.         }
  8474.         $out = $this->toRGB($hsl[1], $hsl[2], $hsl[3]);
  8476.         if (isset($color[4])) {
  8477.             $out[4] = $color[4];
  8478.         }
  8480.         return $out;
  8481.     }
  8483.     protected static $libAdjustHue = ['color', 'degrees'];
  8484.     protected function libAdjustHue($args)
  8485.     {
  8486.         $color = $this->assertColor($args[0], 'color');
  8487.         $degrees = $this->assertNumber($args[1], 'degrees')->getDimension();
  8489.         return $this->adjustHsl($color, 1, $degrees);
  8490.     }
  8492.     protected static $libLighten = ['color', 'amount'];
  8493.     protected function libLighten($args)
  8494.     {
  8495.         $color = $this->assertColor($args[0], 'color');
  8496.         $amount = Util::checkRange('amount', new Range(0, 100), $args[1], '%');
  8498.         return $this->adjustHsl($color, 3, $amount);
  8499.     }
  8501.     protected static $libDarken = ['color', 'amount'];
  8502.     protected function libDarken($args)
  8503.     {
  8504.         $color = $this->assertColor($args[0], 'color');
  8505.         $amount = Util::checkRange('amount', new Range(0, 100), $args[1], '%');
  8507.         return $this->adjustHsl($color, 3, -$amount);
  8508.     }
  8510.     protected static $libSaturate = [['color', 'amount'], ['amount']];
  8511.     protected function libSaturate($args)
  8512.     {
  8513.         $value = $args[0];
  8515.         if (count($args) === 1) {
  8516.             $this->assertNumber($args[0], 'amount');
  8518.             return null;
  8519.         }
  8521.         $color = $this->assertColor($args[0], 'color');
  8522.         $amount = $this->assertNumber($args[1], 'amount');
  8524.         return $this->adjustHsl($color, 2, $amount->valueInRange(0, 100, 'amount'));
  8525.     }
  8527.     protected static $libDesaturate = ['color', 'amount'];
  8528.     protected function libDesaturate($args)
  8529.     {
  8530.         $color = $this->assertColor($args[0], 'color');
  8531.         $amount = $this->assertNumber($args[1], 'amount');
  8533.         return $this->adjustHsl($color, 2, -$amount->valueInRange(0, 100, 'amount'));
  8534.     }
  8536.     protected static $libGrayscale = ['color'];
  8537.     protected function libGrayscale($args)
  8538.     {
  8539.         $value = $args[0];
  8541.         if ($value instanceof Number) {
  8542.             return null;
  8543.         }
  8545.         return $this->adjustHsl($this->assertColor($value, 'color'), 2, -100);
  8546.     }
  8548.     protected static $libComplement = ['color'];
  8549.     protected function libComplement($args)
  8550.     {
  8551.         return $this->adjustHsl($this->assertColor($args[0], 'color'), 1, 180);
  8552.     }
  8554.     protected static $libInvert = ['color', 'weight:100%'];
  8555.     protected function libInvert($args)
  8556.     {
  8557.         $value = $args[0];
  8559.         $weight = $this->assertNumber($args[1], 'weight');
  8561.         if ($value instanceof Number) {
  8562.             if ($weight->getDimension() != 100 || !$weight->hasUnit('%')) {
  8563.                 throw new SassScriptException('Only one argument may be passed to the plain-CSS invert() function.');
  8564.             }
  8566.             return null;
  8567.         }
  8569.         $color = $this->assertColor($value, 'color');
  8570.         $inverted = $color;
  8571.         $inverted[1] = 255 - $inverted[1];
  8572.         $inverted[2] = 255 - $inverted[2];
  8573.         $inverted[3] = 255 - $inverted[3];
  8575.         return $this->libMix([$inverted, $color, $weight]);
  8576.     }
  8578.     // increases opacity by amount
  8579.     protected static $libOpacify = ['color', 'amount'];
  8580.     protected function libOpacify($args)
  8581.     {
  8582.         $color = $this->assertColor($args[0], 'color');
  8583.         $amount = $this->assertNumber($args[1], 'amount');
  8585.         $color[4] = (isset($color[4]) ? $color[4] : 1) + $amount->valueInRange(0, 1, 'amount');
  8586.         $color[4] = min(1, max(0, $color[4]));
  8588.         return $color;
  8589.     }
  8591.     protected static $libFadeIn = ['color', 'amount'];
  8592.     protected function libFadeIn($args)
  8593.     {
  8594.         return $this->libOpacify($args);
  8595.     }
  8597.     // decreases opacity by amount
  8598.     protected static $libTransparentize = ['color', 'amount'];
  8599.     protected function libTransparentize($args)
  8600.     {
  8601.         $color = $this->assertColor($args[0], 'color');
  8602.         $amount = $this->assertNumber($args[1], 'amount');
  8604.         $color[4] = (isset($color[4]) ? $color[4] : 1) - $amount->valueInRange(0, 1, 'amount');
  8605.         $color[4] = min(1, max(0, $color[4]));
  8607.         return $color;
  8608.     }
  8610.     protected static $libFadeOut = ['color', 'amount'];
  8611.     protected function libFadeOut($args)
  8612.     {
  8613.         return $this->libTransparentize($args);
  8614.     }
  8616.     protected static $libUnquote = ['string'];
  8617.     protected function libUnquote($args)
  8618.     {
  8619.         try {
  8620.             $str = $this->assertString($args[0], 'string');
  8621.         } catch (SassScriptException $e) {
  8622.             $value = $this->compileValue($args[0]);
  8623.             $fname = $this->getPrettyPath($this->sourceNames[$this->sourceIndex]);
  8624.             $line  = $this->sourceLine;
  8626.             $message = "Passing $value, a non-string value, to unquote()
  8627. will be an error in future versions of Sass.\n         on line $line of $fname";
  8629.             $this->logger->warn($message, true);
  8631.             return $args[0];
  8632.         }
  8634.         $str[1] = '';
  8636.         return $str;
  8637.     }
  8639.     protected static $libQuote = ['string'];
  8640.     protected function libQuote($args)
  8641.     {
  8642.         $value = $this->assertString($args[0], 'string');
  8644.         $value[1] = '"';
  8646.         return $value;
  8647.     }
  8649.     protected static $libPercentage = ['number'];
  8650.     protected function libPercentage($args)
  8651.     {
  8652.         $num = $this->assertNumber($args[0], 'number');
  8653.         $num->assertNoUnits('number');
  8655.         return new Number($num->getDimension() * 100, '%');
  8656.     }
  8658.     protected static $libRound = ['number'];
  8659.     protected function libRound($args)
  8660.     {
  8661.         $num = $this->assertNumber($args[0], 'number');
  8663.         return new Number(round($num->getDimension()), $num->getNumeratorUnits(), $num->getDenominatorUnits());
  8664.     }
  8666.     protected static $libFloor = ['number'];
  8667.     protected function libFloor($args)
  8668.     {
  8669.         $num = $this->assertNumber($args[0], 'number');
  8671.         return new Number(floor($num->getDimension()), $num->getNumeratorUnits(), $num->getDenominatorUnits());
  8672.     }
  8674.     protected static $libCeil = ['number'];
  8675.     protected function libCeil($args)
  8676.     {
  8677.         $num = $this->assertNumber($args[0], 'number');
  8679.         return new Number(ceil($num->getDimension()), $num->getNumeratorUnits(), $num->getDenominatorUnits());
  8680.     }
  8682.     protected static $libAbs = ['number'];
  8683.     protected function libAbs($args)
  8684.     {
  8685.         $num = $this->assertNumber($args[0], 'number');
  8687.         return new Number(abs($num->getDimension()), $num->getNumeratorUnits(), $num->getDenominatorUnits());
  8688.     }
  8690.     protected static $libMin = ['numbers...'];
  8691.     protected function libMin($args)
  8692.     {
  8693.         /**
  8694.          * @var Number|null
  8695.          */
  8696.         $min = null;
  8698.         foreach ($args[0][2] as $arg) {
  8699.             $number = $this->assertNumber($arg);
  8701.             if (\is_null($min) || $min->greaterThan($number)) {
  8702.                 $min = $number;
  8703.             }
  8704.         }
  8706.         if (!\is_null($min)) {
  8707.             return $min;
  8708.         }
  8710.         throw $this->error('At least one argument must be passed.');
  8711.     }
  8713.     protected static $libMax = ['numbers...'];
  8714.     protected function libMax($args)
  8715.     {
  8716.         /**
  8717.          * @var Number|null
  8718.          */
  8719.         $max = null;
  8721.         foreach ($args[0][2] as $arg) {
  8722.             $number = $this->assertNumber($arg);
  8724.             if (\is_null($max) || $max->lessThan($number)) {
  8725.                 $max = $number;
  8726.             }
  8727.         }
  8729.         if (!\is_null($max)) {
  8730.             return $max;
  8731.         }
  8733.         throw $this->error('At least one argument must be passed.');
  8734.     }
  8736.     protected static $libLength = ['list'];
  8737.     protected function libLength($args)
  8738.     {
  8739.         $list = $this->coerceList($args[0], ',', true);
  8741.         return new Number(\count($list[2]), '');
  8742.     }
  8744.     protected static $libListSeparator = ['list'];
  8745.     protected function libListSeparator($args)
  8746.     {
  8747.         if (! \in_array($args[0][0], [Type::T_LIST, Type::T_MAP])) {
  8748.             return [Type::T_KEYWORD, 'space'];
  8749.         }
  8751.         $list = $this->coerceList($args[0]);
  8753.         if ($list[1] === '' && \count($list[2]) <= 1 && empty($list['enclosing'])) {
  8754.             return [Type::T_KEYWORD, 'space'];
  8755.         }
  8757.         if ($list[1] === ',') {
  8758.             return [Type::T_KEYWORD, 'comma'];
  8759.         }
  8761.         if ($list[1] === '/') {
  8762.             return [Type::T_KEYWORD, 'slash'];
  8763.         }
  8765.         return [Type::T_KEYWORD, 'space'];
  8766.     }
  8768.     protected static $libNth = ['list', 'n'];
  8769.     protected function libNth($args)
  8770.     {
  8771.         $list = $this->coerceList($args[0], ',', false);
  8772.         $n = $this->assertNumber($args[1])->getDimension();
  8774.         if ($n > 0) {
  8775.             $n--;
  8776.         } elseif ($n < 0) {
  8777.             $n += \count($list[2]);
  8778.         }
  8780.         return isset($list[2][$n]) ? $list[2][$n] : static::$defaultValue;
  8781.     }
  8783.     protected static $libSetNth = ['list', 'n', 'value'];
  8784.     protected function libSetNth($args)
  8785.     {
  8786.         $list = $this->coerceList($args[0]);
  8787.         $n = $this->assertNumber($args[1])->getDimension();
  8789.         if ($n > 0) {
  8790.             $n--;
  8791.         } elseif ($n < 0) {
  8792.             $n += \count($list[2]);
  8793.         }
  8795.         if (! isset($list[2][$n])) {
  8796.             throw $this->error('Invalid argument for "n"');
  8797.         }
  8799.         $list[2][$n] = $args[2];
  8801.         return $list;
  8802.     }
  8804.     protected static $libMapGet = ['map', 'key', 'keys...'];
  8805.     protected function libMapGet($args)
  8806.     {
  8807.         $map = $this->assertMap($args[0], 'map');
  8808.         if (!isset($args[2])) {
  8809.             // BC layer for usages of the function from PHP code rather than from the Sass function
  8810.             $args[2] = self::$emptyArgumentList;
  8811.         }
  8812.         $keys = array_merge([$args[1]], $args[2][2]);
  8813.         $value = static::$null;
  8815.         foreach ($keys as $key) {
  8816.             if (!\is_array($map) || $map[0] !== Type::T_MAP) {
  8817.                 return static::$null;
  8818.             }
  8820.             $map = $this->mapGet($map, $key);
  8822.             if ($map === null) {
  8823.                 return static::$null;
  8824.             }
  8826.             $value = $map;
  8827.         }
  8829.         return $value;
  8830.     }
  8832.     /**
  8833.      * Gets the value corresponding to that key in the map
  8834.      *
  8835.      * @param array        $map
  8836.      * @param Number|array $key
  8837.      *
  8838.      * @return Number|array|null
  8839.      */
  8840.     private function mapGet(array $map, $key)
  8841.     {
  8842.         $index = $this->mapGetEntryIndex($map, $key);
  8844.         if ($index !== null) {
  8845.             return $map[2][$index];
  8846.         }
  8848.         return null;
  8849.     }
  8851.     /**
  8852.      * Gets the index corresponding to that key in the map entries
  8853.      *
  8854.      * @param array        $map
  8855.      * @param Number|array $key
  8856.      *
  8857.      * @return int|null
  8858.      */
  8859.     private function mapGetEntryIndex(array $map, $key)
  8860.     {
  8861.         $key = $this->compileStringContent($this->coerceString($key));
  8863.         for ($i = \count($map[1]) - 1; $i >= 0; $i--) {
  8864.             if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) {
  8865.                 return $i;
  8866.             }
  8867.         }
  8869.         return null;
  8870.     }
  8872.     protected static $libMapKeys = ['map'];
  8873.     protected function libMapKeys($args)
  8874.     {
  8875.         $map = $this->assertMap($args[0], 'map');
  8876.         $keys = $map[1];
  8878.         return [Type::T_LIST, ',', $keys];
  8879.     }
  8881.     protected static $libMapValues = ['map'];
  8882.     protected function libMapValues($args)
  8883.     {
  8884.         $map = $this->assertMap($args[0], 'map');
  8885.         $values = $map[2];
  8887.         return [Type::T_LIST, ',', $values];
  8888.     }
  8890.     protected static $libMapRemove = [
  8891.         ['map'],
  8892.         ['map', 'key', 'keys...'],
  8893.     ];
  8894.     protected function libMapRemove($args)
  8895.     {
  8896.         $map = $this->assertMap($args[0], 'map');
  8898.         if (\count($args) === 1) {
  8899.             return $map;
  8900.         }
  8902.         $keys = [];
  8903.         $keys[] = $this->compileStringContent($this->coerceString($args[1]));
  8905.         foreach ($args[2][2] as $key) {
  8906.             $keys[] = $this->compileStringContent($this->coerceString($key));
  8907.         }
  8909.         for ($i = \count($map[1]) - 1; $i >= 0; $i--) {
  8910.             if (in_array($this->compileStringContent($this->coerceString($map[1][$i])), $keys)) {
  8911.                 array_splice($map[1], $i, 1);
  8912.                 array_splice($map[2], $i, 1);
  8913.             }
  8914.         }
  8916.         return $map;
  8917.     }
  8919.     protected static $libMapHasKey = ['map', 'key', 'keys...'];
  8920.     protected function libMapHasKey($args)
  8921.     {
  8922.         $map = $this->assertMap($args[0], 'map');
  8923.         if (!isset($args[2])) {
  8924.             // BC layer for usages of the function from PHP code rather than from the Sass function
  8925.             $args[2] = self::$emptyArgumentList;
  8926.         }
  8927.         $keys = array_merge([$args[1]], $args[2][2]);
  8928.         $lastKey = array_pop($keys);
  8930.         foreach ($keys as $key) {
  8931.             $value = $this->mapGet($map, $key);
  8933.             if ($value === null || $value instanceof Number || $value[0] !== Type::T_MAP) {
  8934.                 return self::$false;
  8935.             }
  8937.             $map = $value;
  8938.         }
  8940.         return $this->toBool($this->mapHasKey($map, $lastKey));
  8941.     }
  8943.     /**
  8944.      * @param array|Number $keyValue
  8945.      *
  8946.      * @return bool
  8947.      */
  8948.     private function mapHasKey(array $map, $keyValue)
  8949.     {
  8950.         $key = $this->compileStringContent($this->coerceString($keyValue));
  8952.         for ($i = \count($map[1]) - 1; $i >= 0; $i--) {
  8953.             if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) {
  8954.                 return true;
  8955.             }
  8956.         }
  8958.         return false;
  8959.     }
  8961.     protected static $libMapMerge = [
  8962.         ['map1', 'map2'],
  8963.         ['map-1', 'map-2'],
  8964.         ['map1', 'args...']
  8965.     ];
  8966.     protected function libMapMerge($args)
  8967.     {
  8968.         $map1 = $this->assertMap($args[0], 'map1');
  8969.         $map2 = $args[1];
  8970.         $keys = [];
  8971.         if ($map2[0] === Type::T_LIST && isset($map2[3]) && \is_array($map2[3])) {
  8972.             // This is an argument list for the variadic signature
  8973.             if (\count($map2[2]) === 0) {
  8974.                 throw new SassScriptException('Expected $args to contain a key.');
  8975.             }
  8976.             if (\count($map2[2]) === 1) {
  8977.                 throw new SassScriptException('Expected $args to contain a value.');
  8978.             }
  8979.             $keys = $map2[2];
  8980.             $map2 = array_pop($keys);
  8981.         }
  8982.         $map2 = $this->assertMap($map2, 'map2');
  8984.         return $this->modifyMap($map1, $keys, function ($oldValue) use ($map2) {
  8985.             $nestedMap = $this->tryMap($oldValue);
  8987.             if ($nestedMap === null) {
  8988.                 return $map2;
  8989.             }
  8991.             return $this->mergeMaps($nestedMap, $map2);
  8992.         });
  8993.     }
  8995.     /**
  8996.      * @param array    $map
  8997.      * @param array    $keys
  8998.      * @param callable $modify
  8999.      * @param bool     $addNesting
  9000.      *
  9001.      * @return Number|array
  9002.      *
  9003.      * @phpstan-param array<Number|array> $keys
  9004.      * @phpstan-param callable(Number|array): (Number|array) $modify
  9005.      */
  9006.     private function modifyMap(array $map, array $keys, callable $modify, $addNesting = true)
  9007.     {
  9008.         if ($keys === []) {
  9009.             return $modify($map);
  9010.         }
  9012.         return $this->modifyNestedMap($map, $keys, $modify, $addNesting);
  9013.     }
  9015.     /**
  9016.      * @param array    $map
  9017.      * @param array    $keys
  9018.      * @param callable $modify
  9019.      * @param bool     $addNesting
  9020.      *
  9021.      * @return array
  9022.      *
  9023.      * @phpstan-param non-empty-array<Number|array> $keys
  9024.      * @phpstan-param callable(Number|array): (Number|array) $modify
  9025.      */
  9026.     private function modifyNestedMap(array $map, array $keys, callable $modify, $addNesting)
  9027.     {
  9028.         $key = array_shift($keys);
  9030.         $nestedValueIndex = $this->mapGetEntryIndex($map, $key);
  9032.         if ($keys === []) {
  9033.             if ($nestedValueIndex !== null) {
  9034.                 $map[2][$nestedValueIndex] = $modify($map[2][$nestedValueIndex]);
  9035.             } else {
  9036.                 $map[1][] = $key;
  9037.                 $map[2][] = $modify(self::$null);
  9038.             }
  9040.             return $map;
  9041.         }
  9043.         $nestedMap = $nestedValueIndex !== null ? $this->tryMap($map[2][$nestedValueIndex]) : null;
  9045.         if ($nestedMap === null && !$addNesting) {
  9046.             return $map;
  9047.         }
  9049.         if ($nestedMap === null) {
  9050.             $nestedMap = self::$emptyMap;
  9051.         }
  9053.         $newNestedMap = $this->modifyNestedMap($nestedMap, $keys, $modify, $addNesting);
  9055.         if ($nestedValueIndex !== null) {
  9056.             $map[2][$nestedValueIndex] = $newNestedMap;
  9057.         } else {
  9058.             $map[1][] = $key;
  9059.             $map[2][] = $newNestedMap;
  9060.         }
  9062.         return $map;
  9063.     }
  9065.     /**
  9066.      * Merges 2 Sass maps together
  9067.      *
  9068.      * @param array $map1
  9069.      * @param array $map2
  9070.      *
  9071.      * @return array
  9072.      */
  9073.     private function mergeMaps(array $map1, array $map2)
  9074.     {
  9075.         foreach ($map2[1] as $i2 => $key2) {
  9076.             $map1EntryIndex = $this->mapGetEntryIndex($map1, $key2);
  9078.             if ($map1EntryIndex !== null) {
  9079.                 $map1[2][$map1EntryIndex] = $map2[2][$i2];
  9080.                 continue;
  9081.             }
  9083.             $map1[1][] = $key2;
  9084.             $map1[2][] = $map2[2][$i2];
  9085.         }
  9087.         return $map1;
  9088.     }
  9090.     protected static $libKeywords = ['args'];
  9091.     protected function libKeywords($args)
  9092.     {
  9093.         $value = $args[0];
  9095.         if ($value[0] !== Type::T_LIST || !isset($value[3]) || !\is_array($value[3])) {
  9096.             $compiledValue = $this->compileValue($value);
  9098.             throw SassScriptException::forArgument($compiledValue . ' is not an argument list.', 'args');
  9099.         }
  9101.         $keys = [];
  9102.         $values = [];
  9104.         foreach ($this->getArgumentListKeywords($value) as $name => $arg) {
  9105.             $keys[] = [Type::T_KEYWORD, $name];
  9106.             $values[] = $arg;
  9107.         }
  9109.         return [Type::T_MAP, $keys, $values];
  9110.     }
  9112.     protected static $libIsBracketed = ['list'];
  9113.     protected function libIsBracketed($args)
  9114.     {
  9115.         $list = $args[0];
  9116.         $this->coerceList($list, ' ');
  9118.         if (! empty($list['enclosing']) && $list['enclosing'] === 'bracket') {
  9119.             return self::$true;
  9120.         }
  9122.         return self::$false;
  9123.     }
  9125.     /**
  9126.      * @param array $list1
  9127.      * @param array|Number|null $sep
  9128.      *
  9129.      * @return string
  9130.      * @throws CompilerException
  9131.      *
  9132.      * @deprecated
  9133.      */
  9134.     protected function listSeparatorForJoin($list1, $sep)
  9135.     {
  9136.         @trigger_error(sprintf('The "%s" method is deprecated.', __METHOD__), E_USER_DEPRECATED);
  9138.         if (! isset($sep)) {
  9139.             return $list1[1];
  9140.         }
  9142.         switch ($this->compileValue($sep)) {
  9143.             case 'comma':
  9144.                 return ',';
  9146.             case 'space':
  9147.                 return ' ';
  9149.             default:
  9150.                 return $list1[1];
  9151.         }
  9152.     }
  9154.     protected static $libJoin = ['list1', 'list2', 'separator:auto', 'bracketed:auto'];
  9155.     protected function libJoin($args)
  9156.     {
  9157.         list($list1, $list2, $sep, $bracketed) = $args;
  9159.         $list1 = $this->coerceList($list1, ' ', true);
  9160.         $list2 = $this->coerceList($list2, ' ', true);
  9162.         switch ($this->compileStringContent($this->assertString($sep, 'separator'))) {
  9163.             case 'comma':
  9164.                 $separator = ',';
  9165.                 break;
  9167.             case 'space':
  9168.                 $separator = ' ';
  9169.                 break;
  9171.             case 'slash':
  9172.                 $separator = '/';
  9173.                 break;
  9175.             case 'auto':
  9176.                 if ($list1[1] !== '' || count($list1[2]) > 1 || !empty($list1['enclosing']) && $list1['enclosing'] !== 'parent') {
  9177.                     $separator = $list1[1] ?: ' ';
  9178.                 } elseif ($list2[1] !== '' || count($list2[2]) > 1 || !empty($list2['enclosing']) && $list2['enclosing'] !== 'parent') {
  9179.                     $separator = $list2[1] ?: ' ';
  9180.                 } else {
  9181.                     $separator = ' ';
  9182.                 }
  9183.                 break;
  9185.             default:
  9186.                 throw SassScriptException::forArgument('Must be "space", "comma", "slash", or "auto".', 'separator');
  9187.         }
  9189.         if ($bracketed === static::$true) {
  9190.             $bracketed = true;
  9191.         } elseif ($bracketed === static::$false) {
  9192.             $bracketed = false;
  9193.         } elseif ($bracketed === [Type::T_KEYWORD, 'auto']) {
  9194.             $bracketed = 'auto';
  9195.         } elseif ($bracketed === static::$null) {
  9196.             $bracketed = false;
  9197.         } else {
  9198.             $bracketed = $this->compileValue($bracketed);
  9199.             $bracketed = ! ! $bracketed;
  9201.             if ($bracketed === true) {
  9202.                 $bracketed = true;
  9203.             }
  9204.         }
  9206.         if ($bracketed === 'auto') {
  9207.             $bracketed = false;
  9209.             if (! empty($list1['enclosing']) && $list1['enclosing'] === 'bracket') {
  9210.                 $bracketed = true;
  9211.             }
  9212.         }
  9214.         $res = [Type::T_LIST, $separator, array_merge($list1[2], $list2[2])];
  9216.         if ($bracketed) {
  9217.             $res['enclosing'] = 'bracket';
  9218.         }
  9220.         return $res;
  9221.     }
  9223.     protected static $libAppend = ['list', 'val', 'separator:auto'];
  9224.     protected function libAppend($args)
  9225.     {
  9226.         list($list1, $value, $sep) = $args;
  9228.         $list1 = $this->coerceList($list1, ' ', true);
  9230.         switch ($this->compileStringContent($this->assertString($sep, 'separator'))) {
  9231.             case 'comma':
  9232.                 $separator = ',';
  9233.                 break;
  9235.             case 'space':
  9236.                 $separator = ' ';
  9237.                 break;
  9239.             case 'slash':
  9240.                 $separator = '/';
  9241.                 break;
  9243.             case 'auto':
  9244.                 $separator = $list1[1] === '' && \count($list1[2]) <= 1 && (empty($list1['enclosing']) || $list1['enclosing'] === 'parent') ? ' ' : $list1[1];
  9245.                 break;
  9247.             default:
  9248.                 throw SassScriptException::forArgument('Must be "space", "comma", "slash", or "auto".', 'separator');
  9249.         }
  9251.         $res = [Type::T_LIST, $separator, array_merge($list1[2], [$value])];
  9253.         if (isset($list1['enclosing'])) {
  9254.             $res['enclosing'] = $list1['enclosing'];
  9255.         }
  9257.         return $res;
  9258.     }
  9260.     protected static $libZip = ['lists...'];
  9261.     protected function libZip($args)
  9262.     {
  9263.         $argLists = [];
  9264.         foreach ($args[0][2] as $arg) {
  9265.             $argLists[] = $this->coerceList($arg);
  9266.         }
  9268.         $lists = [];
  9269.         $firstList = array_shift($argLists);
  9271.         $result = [Type::T_LIST, ',', $lists];
  9272.         if (! \is_null($firstList)) {
  9273.             foreach ($firstList[2] as $key => $item) {
  9274.                 $list = [Type::T_LIST, ' ', [$item]];
  9276.                 foreach ($argLists as $arg) {
  9277.                     if (isset($arg[2][$key])) {
  9278.                         $list[2][] = $arg[2][$key];
  9279.                     } else {
  9280.                         break 2;
  9281.                     }
  9282.                 }
  9284.                 $lists[] = $list;
  9285.             }
  9287.             $result[2] = $lists;
  9288.         } else {
  9289.             $result['enclosing'] = 'parent';
  9290.         }
  9292.         return $result;
  9293.     }
  9295.     protected static $libTypeOf = ['value'];
  9296.     protected function libTypeOf($args)
  9297.     {
  9298.         $value = $args[0];
  9300.         return [Type::T_KEYWORD, $this->getTypeOf($value)];
  9301.     }
  9303.     /**
  9304.      * @param array|Number $value
  9305.      *
  9306.      * @return string
  9307.      */
  9308.     private function getTypeOf($value)
  9309.     {
  9310.         switch ($value[0]) {
  9311.             case Type::T_KEYWORD:
  9312.                 if ($value === static::$true || $value === static::$false) {
  9313.                     return 'bool';
  9314.                 }
  9316.                 if ($this->coerceColor($value)) {
  9317.                     return 'color';
  9318.                 }
  9320.                 // fall-thru
  9321.             case Type::T_FUNCTION:
  9322.                 return 'string';
  9324.             case Type::T_FUNCTION_REFERENCE:
  9325.                 return 'function';
  9327.             case Type::T_LIST:
  9328.                 if (isset($value[3]) && \is_array($value[3])) {
  9329.                     return 'arglist';
  9330.                 }
  9332.                 // fall-thru
  9333.             default:
  9334.                 return $value[0];
  9335.         }
  9336.     }
  9338.     protected static $libUnit = ['number'];
  9339.     protected function libUnit($args)
  9340.     {
  9341.         $num = $this->assertNumber($args[0], 'number');
  9343.         return [Type::T_STRING, '"', [$num->unitStr()]];
  9344.     }
  9346.     protected static $libUnitless = ['number'];
  9347.     protected function libUnitless($args)
  9348.     {
  9349.         $value = $this->assertNumber($args[0], 'number');
  9351.         return $this->toBool($value->unitless());
  9352.     }
  9354.     protected static $libComparable = [
  9355.         ['number1', 'number2'],
  9356.         ['number-1', 'number-2']
  9357.     ];
  9358.     protected function libComparable($args)
  9359.     {
  9360.         list($number1, $number2) = $args;
  9362.         if (
  9363.             ! $number1 instanceof Number ||
  9364.             ! $number2 instanceof Number
  9365.         ) {
  9366.             throw $this->error('Invalid argument(s) for "comparable"');
  9367.         }
  9369.         return $this->toBool($number1->isComparableTo($number2));
  9370.     }
  9372.     protected static $libStrIndex = ['string', 'substring'];
  9373.     protected function libStrIndex($args)
  9374.     {
  9375.         $string = $this->assertString($args[0], 'string');
  9376.         $stringContent = $this->compileStringContent($string);
  9378.         $substring = $this->assertString($args[1], 'substring');
  9379.         $substringContent = $this->compileStringContent($substring);
  9381.         if (! \strlen($substringContent)) {
  9382.             $result = 0;
  9383.         } else {
  9384.             $result = Util::mbStrpos($stringContent, $substringContent);
  9385.         }
  9387.         return $result === false ? static::$null : new Number($result + 1, '');
  9388.     }
  9390.     protected static $libStrInsert = ['string', 'insert', 'index'];
  9391.     protected function libStrInsert($args)
  9392.     {
  9393.         $string = $this->assertString($args[0], 'string');
  9394.         $stringContent = $this->compileStringContent($string);
  9396.         $insert = $this->assertString($args[1], 'insert');
  9397.         $insertContent = $this->compileStringContent($insert);
  9399.         $index = $this->assertInteger($args[2], 'index');
  9400.         if ($index > 0) {
  9401.             $index = $index - 1;
  9402.         }
  9403.         if ($index < 0) {
  9404.             $index = max(Util::mbStrlen($stringContent) + 1 + $index, 0);
  9405.         }
  9407.         $string[2] = [
  9408.             Util::mbSubstr($stringContent, 0, $index),
  9409.             $insertContent,
  9410.             Util::mbSubstr($stringContent, $index)
  9411.         ];
  9413.         return $string;
  9414.     }
  9416.     protected static $libStrLength = ['string'];
  9417.     protected function libStrLength($args)
  9418.     {
  9419.         $string = $this->assertString($args[0], 'string');
  9420.         $stringContent = $this->compileStringContent($string);
  9422.         return new Number(Util::mbStrlen($stringContent), '');
  9423.     }
  9425.     protected static $libStrSlice = ['string', 'start-at', 'end-at:-1'];
  9426.     protected function libStrSlice($args)
  9427.     {
  9428.         $string = $this->assertString($args[0], 'string');
  9429.         $stringContent = $this->compileStringContent($string);
  9431.         $start = $this->assertNumber($args[1], 'start-at');
  9432.         $start->assertNoUnits('start-at');
  9433.         $startInt = $this->assertInteger($start, 'start-at');
  9434.         $end = $this->assertNumber($args[2], 'end-at');
  9435.         $end->assertNoUnits('end-at');
  9436.         $endInt = $this->assertInteger($end, 'end-at');
  9438.         if ($endInt === 0) {
  9439.             return [Type::T_STRING, $string[1], []];
  9440.         }
  9442.         if ($startInt > 0) {
  9443.             $startInt--;
  9444.         }
  9446.         if ($endInt < 0) {
  9447.             $endInt = Util::mbStrlen($stringContent) + $endInt;
  9448.         } else {
  9449.             $endInt--;
  9450.         }
  9452.         if ($endInt < $startInt) {
  9453.             return [Type::T_STRING, $string[1], []];
  9454.         }
  9456.         $length = $endInt - $startInt + 1; // The end of the slice is inclusive
  9458.         $string[2] = [Util::mbSubstr($stringContent, $startInt, $length)];
  9460.         return $string;
  9461.     }
  9463.     protected static $libToLowerCase = ['string'];
  9464.     protected function libToLowerCase($args)
  9465.     {
  9466.         $string = $this->assertString($args[0], 'string');
  9467.         $stringContent = $this->compileStringContent($string);
  9469.         $string[2] = [$this->stringTransformAsciiOnly($stringContent, 'strtolower')];
  9471.         return $string;
  9472.     }
  9474.     protected static $libToUpperCase = ['string'];
  9475.     protected function libToUpperCase($args)
  9476.     {
  9477.         $string = $this->assertString($args[0], 'string');
  9478.         $stringContent = $this->compileStringContent($string);
  9480.         $string[2] = [$this->stringTransformAsciiOnly($stringContent, 'strtoupper')];
  9482.         return $string;
  9483.     }
  9485.     /**
  9486.      * Apply a filter on a string content, only on ascii chars
  9487.      * let extended chars untouched
  9488.      *
  9489.      * @param string $stringContent
  9490.      * @param callable $filter
  9491.      * @return string
  9492.      */
  9493.     protected function stringTransformAsciiOnly($stringContent, $filter)
  9494.     {
  9495.         $mblength = Util::mbStrlen($stringContent);
  9496.         if ($mblength === strlen($stringContent)) {
  9497.             return $filter($stringContent);
  9498.         }
  9499.         $filteredString = "";
  9500.         for ($i = 0; $i < $mblength; $i++) {
  9501.             $char = Util::mbSubstr($stringContent, $i, 1);
  9502.             if (strlen($char) > 1) {
  9503.                 $filteredString .= $char;
  9504.             } else {
  9505.                 $filteredString .= $filter($char);
  9506.             }
  9507.         }
  9509.         return $filteredString;
  9510.     }
  9512.     protected static $libFeatureExists = ['feature'];
  9513.     protected function libFeatureExists($args)
  9514.     {
  9515.         $string = $this->assertString($args[0], 'feature');
  9516.         $name = $this->compileStringContent($string);
  9518.         return $this->toBool(
  9519.             \array_key_exists($name, $this->registeredFeatures) ? $this->registeredFeatures[$name] : false
  9520.         );
  9521.     }
  9523.     protected static $libFunctionExists = ['name'];
  9524.     protected function libFunctionExists($args)
  9525.     {
  9526.         $string = $this->assertString($args[0], 'name');
  9527.         $name = $this->compileStringContent($string);
  9529.         // user defined functions
  9530.         if ($this->has(static::$namespaces['function'] . $name)) {
  9531.             return self::$true;
  9532.         }
  9534.         $name = $this->normalizeName($name);
  9536.         if (isset($this->userFunctions[$name])) {
  9537.             return self::$true;
  9538.         }
  9540.         // built-in functions
  9541.         $f = $this->getBuiltinFunction($name);
  9543.         return $this->toBool(\is_callable($f));
  9544.     }
  9546.     protected static $libGlobalVariableExists = ['name'];
  9547.     protected function libGlobalVariableExists($args)
  9548.     {
  9549.         $string = $this->assertString($args[0], 'name');
  9550.         $name = $this->compileStringContent($string);
  9552.         return $this->toBool($this->has($name, $this->rootEnv));
  9553.     }
  9555.     protected static $libMixinExists = ['name'];
  9556.     protected function libMixinExists($args)
  9557.     {
  9558.         $string = $this->assertString($args[0], 'name');
  9559.         $name = $this->compileStringContent($string);
  9561.         return $this->toBool($this->has(static::$namespaces['mixin'] . $name));
  9562.     }
  9564.     protected static $libVariableExists = ['name'];
  9565.     protected function libVariableExists($args)
  9566.     {
  9567.         $string = $this->assertString($args[0], 'name');
  9568.         $name = $this->compileStringContent($string);
  9570.         return $this->toBool($this->has($name));
  9571.     }
  9573.     protected static $libCounter = ['args...'];
  9574.     /**
  9575.      * Workaround IE7's content counter bug.
  9576.      *
  9577.      * @param array $args
  9578.      *
  9579.      * @return array
  9580.      */
  9581.     protected function libCounter($args)
  9582.     {
  9583.         $list = array_map([$this, 'compileValue'], $args[0][2]);
  9585.         return [Type::T_STRING, '', ['counter(' . implode(',', $list) . ')']];
  9586.     }
  9588.     protected static $libRandom = ['limit:null'];
  9589.     protected function libRandom($args)
  9590.     {
  9591.         if (isset($args[0]) && $args[0] !== static::$null) {
  9592.             $n = $this->assertInteger($args[0], 'limit');
  9594.             if ($n < 1) {
  9595.                 throw new SassScriptException("\$limit: Must be greater than 0, was $n.");
  9596.             }
  9598.             return new Number(mt_rand(1, $n), '');
  9599.         }
  9601.         $max = mt_getrandmax();
  9602.         return new Number(mt_rand(0, $max - 1) / $max, '');
  9603.     }
  9605.     protected static $libUniqueId = [];
  9606.     protected function libUniqueId()
  9607.     {
  9608.         static $id;
  9610.         if (! isset($id)) {
  9611.             $id = PHP_INT_SIZE === 4
  9612.                 ? mt_rand(0, pow(36, 5)) . str_pad(mt_rand(0, pow(36, 5)) % 10000000, 7, '0', STR_PAD_LEFT)
  9613.                 : mt_rand(0, pow(36, 8));
  9614.         }
  9616.         $id += mt_rand(0, 10) + 1;
  9618.         return [Type::T_STRING, '', ['u' . str_pad(base_convert($id, 10, 36), 8, '0', STR_PAD_LEFT)]];
  9619.     }
  9621.     /**
  9622.      * @param array|Number $value
  9623.      * @param bool         $force_enclosing_display
  9624.      *
  9625.      * @return array
  9626.      */
  9627.     protected function inspectFormatValue($value, $force_enclosing_display = false)
  9628.     {
  9629.         if ($value === static::$null) {
  9630.             $value = [Type::T_KEYWORD, 'null'];
  9631.         }
  9633.         $stringValue = [$value];
  9635.         if ($value instanceof Number) {
  9636.             return [Type::T_STRING, '', $stringValue];
  9637.         }
  9639.         if ($value[0] === Type::T_LIST) {
  9640.             if (end($value[2]) === static::$null) {
  9641.                 array_pop($value[2]);
  9642.                 $value[2][] = [Type::T_STRING, '', ['']];
  9643.                 $force_enclosing_display = true;
  9644.             }
  9646.             if (
  9647.                 ! empty($value['enclosing']) &&
  9648.                 ($force_enclosing_display ||
  9649.                     ($value['enclosing'] === 'bracket') ||
  9650.                     ! \count($value[2]))
  9651.             ) {
  9652.                 $value['enclosing'] = 'forced_' . $value['enclosing'];
  9653.                 $force_enclosing_display = true;
  9654.             } elseif (! \count($value[2])) {
  9655.                 $value['enclosing'] = 'forced_parent';
  9656.             }
  9658.             foreach ($value[2] as $k => $listelement) {
  9659.                 $value[2][$k] = $this->inspectFormatValue($listelement, $force_enclosing_display);
  9660.             }
  9662.             $stringValue = [$value];
  9663.         }
  9665.         return [Type::T_STRING, '', $stringValue];
  9666.     }
  9668.     protected static $libInspect = ['value'];
  9669.     protected function libInspect($args)
  9670.     {
  9671.         $value = $args[0];
  9673.         return $this->inspectFormatValue($value);
  9674.     }
  9676.     /**
  9677.      * Preprocess selector args
  9678.      *
  9679.      * @param array       $arg
  9680.      * @param string|null $varname
  9681.      * @param bool        $allowParent
  9682.      *
  9683.      * @return array
  9684.      */
  9685.     protected function getSelectorArg($arg, $varname = null, $allowParent = false)
  9686.     {
  9687.         static $parser = null;
  9689.         if (\is_null($parser)) {
  9690.             $parser = $this->parserFactory(__METHOD__);
  9691.         }
  9693.         if (! $this->checkSelectorArgType($arg)) {
  9694.             $var_value = $this->compileValue($arg);
  9695.             throw SassScriptException::forArgument("$var_value is not a valid selector: it must be a string, a list of strings, or a list of lists of strings", $varname);
  9696.         }
  9699.         if ($arg[0] === Type::T_STRING) {
  9700.             $arg[1] = '';
  9701.         }
  9702.         $arg = $this->compileValue($arg);
  9704.         $parsedSelector = [];
  9706.         if ($parser->parseSelector($arg, $parsedSelector, true)) {
  9707.             $selector = $this->evalSelectors($parsedSelector);
  9708.             $gluedSelector = $this->glueFunctionSelectors($selector);
  9710.             if (! $allowParent) {
  9711.                 foreach ($gluedSelector as $selector) {
  9712.                     foreach ($selector as $s) {
  9713.                         if (in_array(static::$selfSelector, $s)) {
  9714.                             throw SassScriptException::forArgument("Parent selectors aren't allowed here.", $varname);
  9715.                         }
  9716.                     }
  9717.                 }
  9718.             }
  9720.             return $gluedSelector;
  9721.         }
  9723.         throw SassScriptException::forArgument("expected more input, invalid selector.", $varname);
  9724.     }
  9726.     /**
  9727.      * Check variable type for getSelectorArg() function
  9728.      * @param array $arg
  9729.      * @param int $maxDepth
  9730.      * @return bool
  9731.      */
  9732.     protected function checkSelectorArgType($arg, $maxDepth = 2)
  9733.     {
  9734.         if ($arg[0] === Type::T_LIST && $maxDepth > 0) {
  9735.             foreach ($arg[2] as $elt) {
  9736.                 if (! $this->checkSelectorArgType($elt, $maxDepth - 1)) {
  9737.                     return false;
  9738.                 }
  9739.             }
  9740.             return true;
  9741.         }
  9742.         if (!in_array($arg[0], [Type::T_STRING, Type::T_KEYWORD])) {
  9743.             return false;
  9744.         }
  9745.         return true;
  9746.     }
  9748.     /**
  9749.      * Postprocess selector to output in right format
  9750.      *
  9751.      * @param array $selectors
  9752.      *
  9753.      * @return array
  9754.      */
  9755.     protected function formatOutputSelector($selectors)
  9756.     {
  9757.         $selectors = $this->collapseSelectorsAsList($selectors);
  9759.         return $selectors;
  9760.     }
  9762.     protected static $libIsSuperselector = ['super', 'sub'];
  9763.     protected function libIsSuperselector($args)
  9764.     {
  9765.         list($super, $sub) = $args;
  9767.         $super = $this->getSelectorArg($super, 'super');
  9768.         $sub = $this->getSelectorArg($sub, 'sub');
  9770.         return $this->toBool($this->isSuperSelector($super, $sub));
  9771.     }
  9773.     /**
  9774.      * Test a $super selector again $sub
  9775.      *
  9776.      * @param array $super
  9777.      * @param array $sub
  9778.      *
  9779.      * @return bool
  9780.      */
  9781.     protected function isSuperSelector($super, $sub)
  9782.     {
  9783.         // one and only one selector for each arg
  9784.         if (! $super) {
  9785.             throw $this->error('Invalid super selector for isSuperSelector()');
  9786.         }
  9788.         if (! $sub) {
  9789.             throw $this->error('Invalid sub selector for isSuperSelector()');
  9790.         }
  9792.         if (count($sub) > 1) {
  9793.             foreach ($sub as $s) {
  9794.                 if (! $this->isSuperSelector($super, [$s])) {
  9795.                     return false;
  9796.                 }
  9797.             }
  9798.             return true;
  9799.         }
  9801.         if (count($super) > 1) {
  9802.             foreach ($super as $s) {
  9803.                 if ($this->isSuperSelector([$s], $sub)) {
  9804.                     return true;
  9805.                 }
  9806.             }
  9807.             return false;
  9808.         }
  9810.         $super = reset($super);
  9811.         $sub = reset($sub);
  9813.         $i = 0;
  9814.         $nextMustMatch = false;
  9816.         foreach ($super as $node) {
  9817.             $compound = '';
  9819.             array_walk_recursive(
  9820.                 $node,
  9821.                 function ($value, $key) use (&$compound) {
  9822.                     $compound .= $value;
  9823.                 }
  9824.             );
  9826.             if ($this->isImmediateRelationshipCombinator($compound)) {
  9827.                 if ($node !== $sub[$i]) {
  9828.                     return false;
  9829.                 }
  9831.                 $nextMustMatch = true;
  9832.                 $i++;
  9833.             } else {
  9834.                 while ($i < \count($sub) && ! $this->isSuperPart($node, $sub[$i])) {
  9835.                     if ($nextMustMatch) {
  9836.                         return false;
  9837.                     }
  9839.                     $i++;
  9840.                 }
  9842.                 if ($i >= \count($sub)) {
  9843.                     return false;
  9844.                 }
  9846.                 $nextMustMatch = false;
  9847.                 $i++;
  9848.             }
  9849.         }
  9851.         return true;
  9852.     }
  9854.     /**
  9855.      * Test a part of super selector again a part of sub selector
  9856.      *
  9857.      * @param array $superParts
  9858.      * @param array $subParts
  9859.      *
  9860.      * @return bool
  9861.      */
  9862.     protected function isSuperPart($superParts, $subParts)
  9863.     {
  9864.         $i = 0;
  9866.         foreach ($superParts as $superPart) {
  9867.             while ($i < \count($subParts) && $subParts[$i] !== $superPart) {
  9868.                 $i++;
  9869.             }
  9871.             if ($i >= \count($subParts)) {
  9872.                 return false;
  9873.             }
  9875.             $i++;
  9876.         }
  9878.         return true;
  9879.     }
  9881.     protected static $libSelectorAppend = ['selector...'];
  9882.     protected function libSelectorAppend($args)
  9883.     {
  9884.         // get the selector... list
  9885.         $args = reset($args);
  9886.         $args = $args[2];
  9888.         if (\count($args) < 1) {
  9889.             throw $this->error('selector-append() needs at least 1 argument');
  9890.         }
  9892.         $selectors = [];
  9893.         foreach ($args as $arg) {
  9894.             $selectors[] = $this->getSelectorArg($arg, 'selector');
  9895.         }
  9897.         return $this->formatOutputSelector($this->selectorAppend($selectors));
  9898.     }
  9900.     /**
  9901.      * Append parts of the last selector in the list to the previous, recursively
  9902.      *
  9903.      * @param array $selectors
  9904.      *
  9905.      * @return array
  9906.      *
  9907.      * @throws \ScssPhp\ScssPhp\Exception\CompilerException
  9908.      */
  9909.     protected function selectorAppend($selectors)
  9910.     {
  9911.         $lastSelectors = array_pop($selectors);
  9913.         if (! $lastSelectors) {
  9914.             throw $this->error('Invalid selector list in selector-append()');
  9915.         }
  9917.         while (\count($selectors)) {
  9918.             $previousSelectors = array_pop($selectors);
  9920.             if (! $previousSelectors) {
  9921.                 throw $this->error('Invalid selector list in selector-append()');
  9922.             }
  9924.             // do the trick, happening $lastSelector to $previousSelector
  9925.             $appended = [];
  9927.             foreach ($previousSelectors as $previousSelector) {
  9928.                 foreach ($lastSelectors as $lastSelector) {
  9929.                     $previous = $previousSelector;
  9930.                     foreach ($previousSelector as $j => $previousSelectorParts) {
  9931.                         foreach ($lastSelector as $lastSelectorParts) {
  9932.                             foreach ($lastSelectorParts as $lastSelectorPart) {
  9933.                                 $previous[$j][] = $lastSelectorPart;
  9934.                             }
  9935.                         }
  9936.                     }
  9938.                     $appended[] = $previous;
  9939.                 }
  9940.             }
  9942.             $lastSelectors = $appended;
  9943.         }
  9945.         return $lastSelectors;
  9946.     }
  9948.     protected static $libSelectorExtend = [
  9949.         ['selector', 'extendee', 'extender'],
  9950.         ['selectors', 'extendee', 'extender']
  9951.     ];
  9952.     protected function libSelectorExtend($args)
  9953.     {
  9954.         list($selectors, $extendee, $extender) = $args;
  9956.         $selectors = $this->getSelectorArg($selectors, 'selector');
  9957.         $extendee  = $this->getSelectorArg($extendee, 'extendee');
  9958.         $extender  = $this->getSelectorArg($extender, 'extender');
  9960.         if (! $selectors || ! $extendee || ! $extender) {
  9961.             throw $this->error('selector-extend() invalid arguments');
  9962.         }
  9964.         $extended = $this->extendOrReplaceSelectors($selectors, $extendee, $extender);
  9966.         return $this->formatOutputSelector($extended);
  9967.     }
  9969.     protected static $libSelectorReplace = [
  9970.         ['selector', 'original', 'replacement'],
  9971.         ['selectors', 'original', 'replacement']
  9972.     ];
  9973.     protected function libSelectorReplace($args)
  9974.     {
  9975.         list($selectors, $original, $replacement) = $args;
  9977.         $selectors   = $this->getSelectorArg($selectors, 'selector');
  9978.         $original    = $this->getSelectorArg($original, 'original');
  9979.         $replacement = $this->getSelectorArg($replacement, 'replacement');
  9981.         if (! $selectors || ! $original || ! $replacement) {
  9982.             throw $this->error('selector-replace() invalid arguments');
  9983.         }
  9985.         $replaced = $this->extendOrReplaceSelectors($selectors, $original, $replacement, true);
  9987.         return $this->formatOutputSelector($replaced);
  9988.     }
  9990.     /**
  9991.      * Extend/replace in selectors
  9992.      * used by selector-extend and selector-replace that use the same logic
  9993.      *
  9994.      * @param array $selectors
  9995.      * @param array $extendee
  9996.      * @param array $extender
  9997.      * @param bool  $replace
  9998.      *
  9999.      * @return array
  10000.      */
  10001.     protected function extendOrReplaceSelectors($selectors, $extendee, $extender, $replace = false)
  10002.     {
  10003.         $saveExtends = $this->extends;
  10004.         $saveExtendsMap = $this->extendsMap;
  10006.         $this->extends = [];
  10007.         $this->extendsMap = [];
  10009.         foreach ($extendee as $es) {
  10010.             if (\count($es) !== 1) {
  10011.                 throw $this->error('Can\'t extend complex selector.');
  10012.             }
  10014.             // only use the first one
  10015.             $this->pushExtends(reset($es), $extender, null);
  10016.         }
  10018.         $extended = [];
  10020.         foreach ($selectors as $selector) {
  10021.             if (! $replace) {
  10022.                 $extended[] = $selector;
  10023.             }
  10025.             $n = \count($extended);
  10027.             $this->matchExtends($selector, $extended);
  10029.             // if didnt match, keep the original selector if we are in a replace operation
  10030.             if ($replace && \count($extended) === $n) {
  10031.                 $extended[] = $selector;
  10032.             }
  10033.         }
  10035.         $this->extends = $saveExtends;
  10036.         $this->extendsMap = $saveExtendsMap;
  10038.         return $extended;
  10039.     }
  10041.     protected static $libSelectorNest = ['selector...'];
  10042.     protected function libSelectorNest($args)
  10043.     {
  10044.         // get the selector... list
  10045.         $args = reset($args);
  10046.         $args = $args[2];
  10048.         if (\count($args) < 1) {
  10049.             throw $this->error('selector-nest() needs at least 1 argument');
  10050.         }
  10052.         $selectorsMap = [];
  10053.         foreach ($args as $arg) {
  10054.             $selectorsMap[] = $this->getSelectorArg($arg, 'selector', true);
  10055.         }
  10057.         assert(!empty($selectorsMap));
  10059.         $envs = [];
  10061.         foreach ($selectorsMap as $selectors) {
  10062.             $env = new Environment();
  10063.             $env->selectors = $selectors;
  10065.             $envs[] = $env;
  10066.         }
  10068.         $envs            = array_reverse($envs);
  10069.         $env             = $this->extractEnv($envs);
  10070.         $outputSelectors = $this->multiplySelectors($env);
  10072.         return $this->formatOutputSelector($outputSelectors);
  10073.     }
  10075.     protected static $libSelectorParse = [
  10076.         ['selector'],
  10077.         ['selectors']
  10078.     ];
  10079.     protected function libSelectorParse($args)
  10080.     {
  10081.         $selectors = reset($args);
  10082.         $selectors = $this->getSelectorArg($selectors, 'selector');
  10084.         return $this->formatOutputSelector($selectors);
  10085.     }
  10087.     protected static $libSelectorUnify = ['selectors1', 'selectors2'];
  10088.     protected function libSelectorUnify($args)
  10089.     {
  10090.         list($selectors1, $selectors2) = $args;
  10092.         $selectors1 = $this->getSelectorArg($selectors1, 'selectors1');
  10093.         $selectors2 = $this->getSelectorArg($selectors2, 'selectors2');
  10095.         if (! $selectors1 || ! $selectors2) {
  10096.             throw $this->error('selector-unify() invalid arguments');
  10097.         }
  10099.         // only consider the first compound of each
  10100.         $compound1 = reset($selectors1);
  10101.         $compound2 = reset($selectors2);
  10103.         // unify them and that's it
  10104.         $unified = $this->unifyCompoundSelectors($compound1, $compound2);
  10106.         return $this->formatOutputSelector($unified);
  10107.     }
  10109.     /**
  10110.      * The selector-unify magic as its best
  10111.      * (at least works as expected on test cases)
  10112.      *
  10113.      * @param array $compound1
  10114.      * @param array $compound2
  10115.      *
  10116.      * @return array
  10117.      */
  10118.     protected function unifyCompoundSelectors($compound1, $compound2)
  10119.     {
  10120.         if (! \count($compound1)) {
  10121.             return $compound2;
  10122.         }
  10124.         if (! \count($compound2)) {
  10125.             return $compound1;
  10126.         }
  10128.         // check that last part are compatible
  10129.         $lastPart1 = array_pop($compound1);
  10130.         $lastPart2 = array_pop($compound2);
  10131.         $last      = $this->mergeParts($lastPart1, $lastPart2);
  10133.         if (! $last) {
  10134.             return [[]];
  10135.         }
  10137.         $unifiedCompound = [$last];
  10138.         $unifiedSelectors = [$unifiedCompound];
  10140.         // do the rest
  10141.         while (\count($compound1) || \count($compound2)) {
  10142.             $part1 = end($compound1);
  10143.             $part2 = end($compound2);
  10145.             if ($part1 && ($match2 = $this->matchPartInCompound($part1, $compound2))) {
  10146.                 list($compound2, $part2, $after2) = $match2;
  10148.                 if ($after2) {
  10149.                     $unifiedSelectors = $this->prependSelectors($unifiedSelectors, $after2);
  10150.                 }
  10152.                 $c = $this->mergeParts($part1, $part2);
  10153.                 $unifiedSelectors = $this->prependSelectors($unifiedSelectors, [$c]);
  10155.                 $part1 = $part2 = null;
  10157.                 array_pop($compound1);
  10158.             }
  10160.             if ($part2 && ($match1 = $this->matchPartInCompound($part2, $compound1))) {
  10161.                 list($compound1, $part1, $after1) = $match1;
  10163.                 if ($after1) {
  10164.                     $unifiedSelectors = $this->prependSelectors($unifiedSelectors, $after1);
  10165.                 }
  10167.                 $c = $this->mergeParts($part2, $part1);
  10168.                 $unifiedSelectors = $this->prependSelectors($unifiedSelectors, [$c]);
  10170.                 $part1 = $part2 = null;
  10172.                 array_pop($compound2);
  10173.             }
  10175.             $new = [];
  10177.             if ($part1 && $part2) {
  10178.                 array_pop($compound1);
  10179.                 array_pop($compound2);
  10181.                 $s   = $this->prependSelectors($unifiedSelectors, [$part2]);
  10182.                 $new = array_merge($new, $this->prependSelectors($s, [$part1]));
  10183.                 $s   = $this->prependSelectors($unifiedSelectors, [$part1]);
  10184.                 $new = array_merge($new, $this->prependSelectors($s, [$part2]));
  10185.             } elseif ($part1) {
  10186.                 array_pop($compound1);
  10188.                 $new = array_merge($new, $this->prependSelectors($unifiedSelectors, [$part1]));
  10189.             } elseif ($part2) {
  10190.                 array_pop($compound2);
  10192.                 $new = array_merge($new, $this->prependSelectors($unifiedSelectors, [$part2]));
  10193.             }
  10195.             if ($new) {
  10196.                 $unifiedSelectors = $new;
  10197.             }
  10198.         }
  10200.         return $unifiedSelectors;
  10201.     }
  10203.     /**
  10204.      * Prepend each selector from $selectors with $parts
  10205.      *
  10206.      * @param array $selectors
  10207.      * @param array $parts
  10208.      *
  10209.      * @return array
  10210.      */
  10211.     protected function prependSelectors($selectors, $parts)
  10212.     {
  10213.         $new = [];
  10215.         foreach ($selectors as $compoundSelector) {
  10216.             array_unshift($compoundSelector, $parts);
  10218.             $new[] = $compoundSelector;
  10219.         }
  10221.         return $new;
  10222.     }
  10224.     /**
  10225.      * Try to find a matching part in a compound:
  10226.      * - with same html tag name
  10227.      * - with some class or id or something in common
  10228.      *
  10229.      * @param array $part
  10230.      * @param array $compound
  10231.      *
  10232.      * @return array|false
  10233.      */
  10234.     protected function matchPartInCompound($part, $compound)
  10235.     {
  10236.         $partTag = $this->findTagName($part);
  10237.         $before  = $compound;
  10238.         $after   = [];
  10240.         // try to find a match by tag name first
  10241.         while (\count($before)) {
  10242.             $p = array_pop($before);
  10244.             if ($partTag && $partTag !== '*' && $partTag == $this->findTagName($p)) {
  10245.                 return [$before, $p, $after];
  10246.             }
  10248.             $after[] = $p;
  10249.         }
  10251.         // try again matching a non empty intersection and a compatible tagname
  10252.         $before = $compound;
  10253.         $after = [];
  10255.         while (\count($before)) {
  10256.             $p = array_pop($before);
  10258.             if ($this->checkCompatibleTags($partTag, $this->findTagName($p))) {
  10259.                 if (\count(array_intersect($part, $p))) {
  10260.                     return [$before, $p, $after];
  10261.                 }
  10262.             }
  10264.             $after[] = $p;
  10265.         }
  10267.         return false;
  10268.     }
  10270.     /**
  10271.      * Merge two part list taking care that
  10272.      * - the html tag is coming first - if any
  10273.      * - the :something are coming last
  10274.      *
  10275.      * @param array $parts1
  10276.      * @param array $parts2
  10277.      *
  10278.      * @return array
  10279.      */
  10280.     protected function mergeParts($parts1, $parts2)
  10281.     {
  10282.         $tag1 = $this->findTagName($parts1);
  10283.         $tag2 = $this->findTagName($parts2);
  10284.         $tag  = $this->checkCompatibleTags($tag1, $tag2);
  10286.         // not compatible tags
  10287.         if ($tag === false) {
  10288.             return [];
  10289.         }
  10291.         if ($tag) {
  10292.             if ($tag1) {
  10293.                 $parts1 = array_diff($parts1, [$tag1]);
  10294.             }
  10296.             if ($tag2) {
  10297.                 $parts2 = array_diff($parts2, [$tag2]);
  10298.             }
  10299.         }
  10301.         $mergedParts = array_merge($parts1, $parts2);
  10302.         $mergedOrderedParts = [];
  10304.         foreach ($mergedParts as $part) {
  10305.             if (strpos($part, ':') === 0) {
  10306.                 $mergedOrderedParts[] = $part;
  10307.             }
  10308.         }
  10310.         $mergedParts = array_diff($mergedParts, $mergedOrderedParts);
  10311.         $mergedParts = array_merge($mergedParts, $mergedOrderedParts);
  10313.         if ($tag) {
  10314.             array_unshift($mergedParts, $tag);
  10315.         }
  10317.         return $mergedParts;
  10318.     }
  10320.     /**
  10321.      * Check the compatibility between two tag names:
  10322.      * if both are defined they should be identical or one has to be '*'
  10323.      *
  10324.      * @param string $tag1
  10325.      * @param string $tag2
  10326.      *
  10327.      * @return array|false
  10328.      */
  10329.     protected function checkCompatibleTags($tag1, $tag2)
  10330.     {
  10331.         $tags = [$tag1, $tag2];
  10332.         $tags = array_unique($tags);
  10333.         $tags = array_filter($tags);
  10335.         if (\count($tags) > 1) {
  10336.             $tags = array_diff($tags, ['*']);
  10337.         }
  10339.         // not compatible nodes
  10340.         if (\count($tags) > 1) {
  10341.             return false;
  10342.         }
  10344.         return $tags;
  10345.     }
  10347.     /**
  10348.      * Find the html tag name in a selector parts list
  10349.      *
  10350.      * @param string[] $parts
  10351.      *
  10352.      * @return string
  10353.      */
  10354.     protected function findTagName($parts)
  10355.     {
  10356.         foreach ($parts as $part) {
  10357.             if (! preg_match('/^[\[.:#%_-]/', $part)) {
  10358.                 return $part;
  10359.             }
  10360.         }
  10362.         return '';
  10363.     }
  10365.     protected static $libSimpleSelectors = ['selector'];
  10366.     protected function libSimpleSelectors($args)
  10367.     {
  10368.         $selector = reset($args);
  10369.         $selector = $this->getSelectorArg($selector, 'selector');
  10371.         // remove selectors list layer, keeping the first one
  10372.         $selector = reset($selector);
  10374.         // remove parts list layer, keeping the first part
  10375.         $part = reset($selector);
  10377.         $listParts = [];
  10379.         foreach ($part as $p) {
  10380.             $listParts[] = [Type::T_STRING, '', [$p]];
  10381.         }
  10383.         return [Type::T_LIST, ',', $listParts];
  10384.     }
  10386.     protected static $libScssphpGlob = ['pattern'];
  10387.     protected function libScssphpGlob($args)
  10388.     {
  10389.         @trigger_error(sprintf('The "scssphp-glob" function is deprecated an will be removed in ScssPhp 2.0. Register your own alternative through "%s::registerFunction', __CLASS__), E_USER_DEPRECATED);
  10391.         $this->logger->warn('The "scssphp-glob" function is deprecated an will be removed in ScssPhp 2.0.', true);
  10393.         $string = $this->assertString($args[0], 'pattern');
  10394.         $pattern = $this->compileStringContent($string);
  10395.         $matches = glob($pattern);
  10396.         $listParts = [];
  10398.         foreach ($matches as $match) {
  10399.             if (! is_file($match)) {
  10400.                 continue;
  10401.             }
  10403.             $listParts[] = [Type::T_STRING, '"', [$match]];
  10404.         }
  10406.         return [Type::T_LIST, ',', $listParts];
  10407.     }
  10408. }