[Summary view]

Differences Between: [Versions 310 and 401] [Versions 311 and 401] [Versions 39 and 401] [Versions 400 and 401]

   1  <?php
   2  
   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   */
  12  
  13  namespace ScssPhp\ScssPhp;
  14  
  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;
  41  
  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   */
  68  
  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;
  86  
  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;
 103  
 104      const SOURCE_MAP_NONE   = 0;
 105      const SOURCE_MAP_INLINE = 1;
 106      const SOURCE_MAP_FILE   = 2;
 107  
 108      /**
 109       * @var array<string, string>
 110       */
 111      protected static $operatorNames = [
 112          '+'   => 'add',
 113          '-'   => 'sub',
 114          '*'   => 'mul',
 115          '/'   => 'div',
 116          '%'   => 'mod',
 117  
 118          '=='  => 'eq',
 119          '!='  => 'neq',
 120          '<'   => 'lt',
 121          '>'   => 'gt',
 122  
 123          '<='  => 'lte',
 124          '>='  => 'gte',
 125      ];
 126  
 127      /**
 128       * @var array<string, string>
 129       */
 130      protected static $namespaces = [
 131          'special'  => '%',
 132          'mixin'    => '@',
 133          'function' => '^',
 134      ];
 135  
 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, '', [], []];
 152  
 153      /**
 154       * @var array<int, string|callable>
 155       */
 156      protected $importPaths = [];
 157      /**
 158       * @var array<string, Block>
 159       */
 160      protected $importCache = [];
 161  
 162      /**
 163       * @var string[]
 164       */
 165      protected $importedFiles = [];
 166  
 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      ];
 185  
 186      /**
 187       * @var string|null
 188       */
 189      protected $encoding = null;
 190      /**
 191       * @var null
 192       * @deprecated
 193       */
 194      protected $lineNumberStyle = null;
 195  
 196      /**
 197       * @var int|SourceMapGenerator
 198       * @phpstan-var self::SOURCE_MAP_*|SourceMapGenerator
 199       */
 200      protected $sourceMap = self::SOURCE_MAP_NONE;
 201  
 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 = [];
 207  
 208      /**
 209       * @var bool
 210       */
 211      private $charset = true;
 212  
 213      /**
 214       * @var Formatter
 215       */
 216      protected $formatter;
 217  
 218      /**
 219       * @var string
 220       * @phpstan-var class-string<Formatter>
 221       */
 222      private $configuredFormatter = Expanded::class;
 223  
 224      /**
 225       * @var Environment
 226       */
 227      protected $rootEnv;
 228      /**
 229       * @var OutputBlock|null
 230       */
 231      protected $rootBlock;
 232  
 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;
 255  
 256      /**
 257       * @var Cache|null
 258       */
 259      protected $cache;
 260  
 261      /**
 262       * @var bool
 263       */
 264      protected $cacheCheckImportResolutions = false;
 265  
 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;
 278  
 279      /**
 280       * @var array<string, int>
 281       */
 282      protected $parsedFiles = [];
 283  
 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;
 313  
 314      /**
 315       * @var array[]
 316       */
 317      protected $callStack = [];
 318  
 319      /**
 320       * @var array
 321       * @phpstan-var list<array{currentDir: string|null, path: string, filePath: string}>
 322       */
 323      private $resolvedImports = [];
 324  
 325      /**
 326       * The directory of the currently processed file
 327       *
 328       * @var string|null
 329       */
 330      private $currentDirectory;
 331  
 332      /**
 333       * The directory of the input file
 334       *
 335       * @var string
 336       */
 337      private $rootDirectory;
 338  
 339      /**
 340       * @var bool
 341       */
 342      private $legacyCwdImportPath = true;
 343  
 344      /**
 345       * @var LoggerInterface
 346       */
 347      private $logger;
 348  
 349      /**
 350       * @var array<string, bool>
 351       */
 352      private $warnedChildFunctions = [];
 353  
 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 = [];
 363  
 364          if ($cacheOptions) {
 365              $this->cache = new Cache($cacheOptions);
 366              if (!empty($cacheOptions['checkImportResolutions'])) {
 367                  $this->cacheCheckImportResolutions = true;
 368              }
 369          }
 370  
 371          $this->logger = new StreamLogger(fopen('php://stderr', 'w'), true);
 372      }
 373  
 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          ];
 393  
 394          return $options;
 395      }
 396  
 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      }
 411  
 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);
 424  
 425          $this->logger = new StreamLogger($handle);
 426      }
 427  
 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);
 443  
 444          $result = $this->compileString($code, $path);
 445  
 446          $sourceMap = $result->getSourceMap();
 447  
 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          }
 456  
 457          return $result->getCss();
 458      }
 459  
 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);
 476  
 477              if ($cachedResult instanceof CachedResult && $this->isFreshCachedResult($cachedResult)) {
 478                  return $cachedResult->getResult();
 479              }
 480          }
 481  
 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 = [];
 496  
 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          }
 505  
 506          try {
 507              $this->parser = $this->parserFactory($path);
 508              $tree         = $this->parser->parse($source);
 509              $this->parser = null;
 510  
 511              $this->formatter = new $this->configuredFormatter();
 512              $this->rootBlock = null;
 513              $this->rootEnv   = $this->pushEnv($tree);
 514  
 515              $warnCallback = function ($message, $deprecation) {
 516                  $this->logger->warn($message, $deprecation);
 517              };
 518              $previousWarnCallback = Warn::setCallback($warnCallback);
 519  
 520              try {
 521                  $this->injectVariables($this->registeredVars);
 522                  $this->compileRoot($tree);
 523                  $this->popEnv();
 524              } finally {
 525                  Warn::setCallback($previousWarnCallback);
 526              }
 527  
 528              $sourceMapGenerator = null;
 529  
 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);
 539  
 540              $out = $this->formatter->format($this->scope, $sourceMapGenerator);
 541  
 542              $prefix = '';
 543  
 544              if ($this->charset && strlen($out) !== Util::mbStrlen($out)) {
 545                  $prefix = '@charset "UTF-8";' . "\n";
 546                  $out = $prefix . $out;
 547              }
 548  
 549              $sourceMap = null;
 550  
 551              if (! empty($out) && $this->sourceMap && $this->sourceMap !== self::SOURCE_MAP_NONE) {
 552                  assert($sourceMapGenerator !== null);
 553                  $sourceMap = $sourceMapGenerator->generateJson($prefix);
 554                  $sourceMapUrl = null;
 555  
 556                  switch ($this->sourceMap) {
 557                      case self::SOURCE_MAP_INLINE:
 558                          $sourceMapUrl = sprintf('data:application/json,%s', Util::encodeURIComponent($sourceMap));
 559                          break;
 560  
 561                      case self::SOURCE_MAP_FILE:
 562                          if (isset($this->sourceMapOptions['sourceMapURL'])) {
 563                              $sourceMapUrl = $this->sourceMapOptions['sourceMapURL'];
 564                          }
 565                          break;
 566                  }
 567  
 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          }
 575  
 576          $includedFiles = [];
 577  
 578          foreach ($this->resolvedImports as $resolvedImport) {
 579              $includedFiles[$resolvedImport['filePath']] = $resolvedImport['filePath'];
 580          }
 581  
 582          $result = new CompilationResult($out, $sourceMap, array_values($includedFiles));
 583  
 584          if ($this->cache && isset($cacheKey) && isset($compileOptions)) {
 585              $this->cache->setCache('compile', $cacheKey, new CachedResult($result, $this->parsedFiles, $this->resolvedImports), $compileOptions);
 586          }
 587  
 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 = [];
 592  
 593          return $result;
 594      }
 595  
 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          }
 609  
 610          if ($this->cacheCheckImportResolutions) {
 611              $resolvedImports = [];
 612  
 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                  }
 622  
 623                  if ($resolvedImports[$currentDir][$path] !== $import['filePath']) {
 624                      return false;
 625                  }
 626              }
 627          }
 628  
 629          return true;
 630      }
 631  
 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;
 647  
 648          if ($path !== null && substr($path, -4) === '.css') {
 649              $cssOnly = true;
 650          }
 651  
 652          $parser = new Parser($path, \count($this->sourceNames), $this->encoding, $this->cache, $cssOnly, $this->logger);
 653  
 654          $this->sourceNames[] = $path;
 655          $this->addParsedFile($path);
 656  
 657          return $parser;
 658      }
 659  
 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          }
 675  
 676          return false;
 677      }
 678  
 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];
 692  
 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      }
 701  
 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;
 719  
 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          }
 729  
 730          return $out;
 731      }
 732  
 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);
 743  
 744          $this->compileChildrenNoReturn($rootBlock->children, $this->scope);
 745          assert($this->scope !== null);
 746          $this->flattenSelectors($this->scope);
 747          $this->missingSelectors();
 748      }
 749  
 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              }
 761  
 762              list($target, $origin, $block) = $extend;
 763  
 764              // ignore if !optional
 765              if ($block[2]) {
 766                  continue;
 767              }
 768  
 769              $target = implode(' ', $target);
 770              $origin = $this->collapseSelectors($origin);
 771  
 772              $this->sourceLine = $block[Parser::SOURCE_LINE];
 773              throw $this->error("\"$origin\" failed to @extend \"$target\". The selector \"$target\" was not found.");
 774          }
 775      }
 776  
 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 = [];
 789  
 790              foreach ($block->selectors as $s) {
 791                  $selectors[] = $s;
 792  
 793                  if (! \is_array($s)) {
 794                      continue;
 795                  }
 796  
 797                  // check extends
 798                  if (! empty($this->extendsMap)) {
 799                      $this->matchExtends($s, $selectors);
 800  
 801                      // remove duplicates
 802                      array_walk($selectors, function (&$value) {
 803                          $value = serialize($value);
 804                      });
 805  
 806                      $selectors = array_unique($selectors);
 807  
 808                      array_walk($selectors, function (&$value) {
 809                          $value = unserialize($value);
 810                      });
 811                  }
 812              }
 813  
 814              $block->selectors = [];
 815              $placeholderSelector = false;
 816  
 817              foreach ($selectors as $selector) {
 818                  if ($this->hasSelectorPlaceholder($selector)) {
 819                      $placeholderSelector = true;
 820                      continue;
 821                  }
 822  
 823                  $block->selectors[] = $this->compileSelector($selector);
 824              }
 825  
 826              if ($placeholderSelector && 0 === \count($block->selectors) && null !== $parentKey) {
 827                  assert($block->parent !== null);
 828                  unset($block->parent->children[$parentKey]);
 829  
 830                  return;
 831              }
 832          }
 833  
 834          foreach ($block->children as $key => $child) {
 835              $this->flattenSelectors($child, $key);
 836          }
 837      }
 838  
 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 = [];
 849  
 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          }
 870  
 871          return $new;
 872      }
 873  
 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);
 888  
 889          if (\count($selector) == 1 && \in_array(reset($selector), $partsPile)) {
 890              return;
 891          }
 892  
 893          $outRecurs = [];
 894  
 895          foreach ($selector as $i => $part) {
 896              if ($i < $from) {
 897                  continue;
 898              }
 899  
 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              }
 909  
 910              $partsPile[] = $part;
 911  
 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);
 916  
 917                  foreach ($origin as $new) {
 918                      $k = 0;
 919  
 920                      // remove shared parts
 921                      if (\count($new) > 1) {
 922                          while ($k < $i && isset($new[$k]) && $selector[$k] === $new[$k]) {
 923                              $k++;
 924                          }
 925                      }
 926  
 927                      if (\count($nonBreakableBefore) && $k === \count($new)) {
 928                          $k--;
 929                      }
 930  
 931                      $replacement = [];
 932                      $tempReplacement = $k > 0 ? \array_slice($new, $k) : $new;
 933  
 934                      for ($l = \count($tempReplacement) - 1; $l >= 0; $l--) {
 935                          $slice = [];
 936  
 937                          foreach ($tempReplacement[$l] as $chunk) {
 938                              if (! \in_array($chunk, $slice)) {
 939                                  $slice[] = $chunk;
 940                              }
 941                          }
 942  
 943                          array_unshift($replacement, $slice);
 944  
 945                          if (! $this->isImmediateRelationshipCombinator(end($slice))) {
 946                              break;
 947                          }
 948                      }
 949  
 950                      $afterBefore = $l != 0 ? \array_slice($tempReplacement, 0, $l) : [];
 951  
 952                      // Merge shared direct relationships.
 953                      $mergedBefore = $this->mergeDirectRelationships($afterBefore, $nonBreakableBefore);
 954  
 955                      $result = array_merge(
 956                          $before,
 957                          $mergedBefore,
 958                          $replacement,
 959                          $after
 960                      );
 961  
 962                      if ($result === $selector) {
 963                          continue;
 964                      }
 965  
 966                      $this->pushOrMergeExtentedSelector($out, $result);
 967  
 968                      // recursively check for more matches
 969                      $startRecurseFrom = \count($before) + min(\count($nonBreakableBefore), \count($mergedBefore));
 970  
 971                      if (\count($origin) > 1) {
 972                          $this->matchExtends($result, $out, $startRecurseFrom, false);
 973                      } else {
 974                          $this->matchExtends($result, $outRecurs, $startRecurseFrom, false);
 975                      }
 976  
 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;
 981  
 982                          list($betweenSharedParts, $nonBreakabl2) = $this->extractRelationshipFromFragment($afterBefore);
 983  
 984                          $result2 = array_merge(
 985                              $preSharedParts,
 986                              $betweenSharedParts,
 987                              $postSharedParts,
 988                              $nonBreakabl2,
 989                              $nonBreakableBefore,
 990                              $replacement,
 991                              $after
 992                          );
 993  
 994                          $this->pushOrMergeExtentedSelector($out, $result2);
 995                      }
 996                  }
 997              }
 998              array_pop($partsPile);
 999          }
1000  
1001          while (\count($outRecurs)) {
1002              $result = array_shift($outRecurs);
1003              $this->pushOrMergeExtentedSelector($out, $result);
1004          }
1005      }
1006  
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          }
1023  
1024          return false;
1025      }
1026  
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);
1044  
1045              if (
1046                  $this->isPseudoSelector($part, $matchesExtended) &&
1047                  \in_array($matchesExtended[1], [ 'slotted' ])
1048              ) {
1049                  $prev = end($out);
1050                  $prev = $this->glueFunctionSelectors($prev);
1051  
1052                  if (\count($prev) === 1 && \count(reset($prev)) === 1) {
1053                      $single = reset($prev);
1054                      $part = reset($single);
1055  
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      }
1071  
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 = [];
1085  
1086          // simple usual cases, no need to do the whole trick
1087          if (\in_array($rawSingle, [['>'],['+'],['~']])) {
1088              return false;
1089          }
1090  
1091          foreach ($rawSingle as $part) {
1092              // matches Number
1093              if (! \is_string($part)) {
1094                  return false;
1095              }
1096  
1097              if (! preg_match('/^[\[.:#%]/', $part) && \count($single)) {
1098                  $single[\count($single) - 1] .= $part;
1099              } else {
1100                  $single[] = $part;
1101              }
1102          }
1103  
1104          $extendingDecoratedTag = false;
1105  
1106          if (\count($single) > 1) {
1107              $matches = null;
1108              $extendingDecoratedTag = preg_match('/^[a-z0-9]+$/i', $single[0], $matches) ? $matches[0] : false;
1109          }
1110  
1111          $outOrigin = [];
1112          $found = false;
1113  
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              }
1120  
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__);
1128  
1129                  if ($parser->parseSelector($buffer, $subSelectors, false)) {
1130                      foreach ($subSelectors as $ksub => $subSelector) {
1131                          $subExtended = [];
1132                          $this->matchExtends($subSelector, $subExtended, 0, false);
1133  
1134                          if ($subExtended) {
1135                              $subSelectorsExtended = $subSelectors;
1136                              $subSelectorsExtended[$ksub] = $subExtended;
1137  
1138                              foreach ($subSelectorsExtended as $ksse => $sse) {
1139                                  $subSelectorsExtended[$ksse] = $this->collapseSelectors($sse);
1140                              }
1141  
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          }
1152  
1153          foreach ($counts as $idx => $count) {
1154              list($target, $origin, /* $block */) = $this->extends[$idx];
1155  
1156              $origin = $this->glueFunctionSelectors($origin);
1157  
1158              // check count
1159              if ($count !== \count($target)) {
1160                  continue;
1161              }
1162  
1163              $this->extends[$idx][3] = true;
1164  
1165              $rem = array_diff($single, $target);
1166  
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                  }
1172  
1173                  $replacement = end($new);
1174  
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                  }
1183  
1184                  $combined = $this->combineSelectorSingle($replacement, $rem);
1185  
1186                  if (\count(array_diff($combined, $origin[$j][\count($origin[$j]) - 1]))) {
1187                      $origin[$j][\count($origin[$j]) - 1] = $combined;
1188                  }
1189              }
1190  
1191              $outOrigin = array_merge($outOrigin, $origin);
1192  
1193              $found = true;
1194          }
1195  
1196          return $found;
1197      }
1198  
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 = [];
1215  
1216          $j = $i = \count($fragment);
1217  
1218          for (;;) {
1219              $children = $j != $i ? \array_slice($fragment, $j, $i - $j) : [];
1220              $parents  = \array_slice($fragment, 0, $j);
1221              $slice    = end($parents);
1222  
1223              if (empty($slice) || ! $this->isImmediateRelationshipCombinator($slice[0])) {
1224                  break;
1225              }
1226  
1227              $j -= 2;
1228          }
1229  
1230          return [$parents, $children];
1231      }
1232  
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 = [];
1247  
1248          while (\count($other) && strpos(end($other), ':') === 0) {
1249              array_unshift($pseudo, array_pop($other));
1250          }
1251  
1252          foreach ([array_reverse($base), array_reverse($other)] as $single) {
1253              $rang = count($single);
1254  
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          }
1273  
1274          if (\count($tag)) {
1275              array_unshift($out, $tag[0]);
1276          }
1277  
1278          while (\count($pseudo)) {
1279              $out[] = array_shift($pseudo);
1280          }
1281  
1282          return $out;
1283      }
1284  
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);
1296  
1297          $mediaQueries = $this->compileMediaQuery($this->multiplyMedia($this->env));
1298  
1299          if (! empty($mediaQueries)) {
1300              assert($this->scope !== null);
1301              $previousScope = $this->scope;
1302              $parentScope = $this->mediaParent($this->scope);
1303  
1304              foreach ($mediaQueries as $mediaQuery) {
1305                  $this->scope = $this->makeOutputBlock(Type::T_MEDIA, [$mediaQuery]);
1306  
1307                  $parentScope->children[] = $this->scope;
1308                  $parentScope = $this->scope;
1309              }
1310  
1311              // top level properties in a media cause it to be wrapped
1312              $needsWrap = false;
1313  
1314              foreach ($media->children as $child) {
1315                  $type = $child[0];
1316  
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              }
1327  
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;
1338  
1339                  $media->children = [[Type::T_BLOCK, $wrapped]];
1340              }
1341  
1342              $this->compileChildrenNoReturn($media->children, $this->scope);
1343  
1344              $this->scope = $previousScope;
1345          }
1346  
1347          $this->popEnv();
1348      }
1349  
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              }
1363  
1364              $scope = $scope->parent;
1365          }
1366  
1367          return $scope;
1368      }
1369  
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;
1383  
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              }
1392  
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;
1401  
1402              if (! empty($directive->value)) {
1403                  $s .= ' ' . $this->compileValue($directive->value);
1404              }
1405  
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      }
1413  
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          }
1426  
1427          return $this->compileValue($directiveName);
1428      }
1429  
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);
1443  
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;
1456  
1457              $block->children = [[Type::T_BLOCK, $wrapped]];
1458              $block->selector = null;
1459          }
1460  
1461          $selfParent = $block->selfParent;
1462          assert($selfParent !== null, 'at-root blocks must have a selfParent set.');
1463  
1464          if (
1465              ! $selfParent->selectors &&
1466              isset($block->parent) &&
1467              isset($block->parent->selectors) && $block->parent->selectors
1468          ) {
1469              $selfParent = $block->parent;
1470          }
1471  
1472          $this->env = $this->filterWithWithout($envs, $with, $without);
1473  
1474          assert($this->scope !== null);
1475          $saveScope   = $this->scope;
1476          $this->scope = $this->filterScopeWithWithout($saveScope, $with, $without);
1477  
1478          // propagate selfParent to the children where they still can be useful
1479          $this->compileChildrenNoReturn($block->children, $this->scope, $selfParent);
1480  
1481          assert($this->scope !== null);
1482          $this->completeScope($this->scope, $saveScope);
1483          $this->scope = $saveScope;
1484          $this->env   = $this->extractEnv($envs);
1485  
1486          $this->popEnv();
1487      }
1488  
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 = [];
1502  
1503          if ($scope->type === Type::T_ROOT) {
1504              return $scope;
1505          }
1506          assert($this->rootBlock !== null);
1507  
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          }
1513  
1514          for (;;) {
1515              if (! $scope) {
1516                  break;
1517              }
1518  
1519              if ($this->isWith($scope, $with, $without)) {
1520                  $s = clone $scope;
1521                  $s->children = [];
1522                  $s->lines    = [];
1523                  $s->parent   = null;
1524  
1525                  if ($s->type !== Type::T_MEDIA && $s->type !== Type::T_DIRECTIVE) {
1526                      $s->selectors = [];
1527                  }
1528  
1529                  $filteredScopes[] = $s;
1530              }
1531  
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          }
1540  
1541          if (! \count($filteredScopes)) {
1542              return $this->rootBlock;
1543          }
1544  
1545          $newScope = array_shift($filteredScopes);
1546          $newScope->parent = $this->rootBlock;
1547  
1548          $this->rootBlock->children[] = $newScope;
1549  
1550          $p = &$newScope;
1551  
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          }
1559  
1560          return $newScope;
1561      }
1562  
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          }
1577  
1578          if ($scope->children) {
1579              foreach ($scope->children as $k => $c) {
1580                  $scope->children[$k] = $this->completeScope($c, $previousScope);
1581              }
1582          }
1583  
1584          return $scope;
1585      }
1586  
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          }
1600  
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          }
1608  
1609          return [];
1610      }
1611  
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];
1626  
1627          if ($withCondition) {
1628              if ($withCondition[0] === Type::T_INTERPOLATE) {
1629                  $w = $this->compileValue($withCondition);
1630  
1631                  $buffer = "($w)";
1632                  $parser = $this->parserFactory(__METHOD__);
1633  
1634                  if ($parser->parseValue($buffer, $reParsedWith)) {
1635                      $withCondition = $reParsedWith;
1636                  }
1637              }
1638  
1639              $withConfig = $this->mapGet($withCondition, static::$with);
1640              if ($withConfig !== null) {
1641                  $without = []; // cancel the default
1642                  $list = $this->coerceList($withConfig);
1643  
1644                  foreach ($list[2] as $item) {
1645                      $keyword = $this->compileStringContent($this->coerceString($item));
1646  
1647                      $with[$keyword] = true;
1648                  }
1649              }
1650  
1651              $withoutConfig = $this->mapGet($withCondition, static::$without);
1652              if ($withoutConfig !== null) {
1653                  $without = []; // cancel the default
1654                  $list = $this->coerceList($withoutConfig);
1655  
1656                  foreach ($list[2] as $item) {
1657                      $keyword = $this->compileStringContent($this->coerceString($item));
1658  
1659                      $without[$keyword] = true;
1660                  }
1661              }
1662          }
1663  
1664          return [$with, $without];
1665      }
1666  
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 = [];
1681  
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 = [];
1687  
1688                  $filtered[] = $ec;
1689              } else {
1690                  $filtered[] = $e;
1691              }
1692          }
1693  
1694          return $this->extractEnv($filtered);
1695      }
1696  
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              }
1712  
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);
1727  
1728                  while (\is_array($s)) {
1729                      $s = reset($s);
1730                  }
1731  
1732                  if (\is_object($s) && $s instanceof Number) {
1733                      return $this->testWithWithout('keyframes', $with, $without);
1734                  }
1735              }
1736  
1737              return $this->testWithWithout('rule', $with, $without);
1738          }
1739  
1740          return true;
1741      }
1742  
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          }
1759  
1760          // otherwise reject all what is not in the with list
1761          return (isset($with[$what]) || isset($with['all'])) ? true : false;
1762      }
1763  
1764  
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);
1776  
1777          $envs = $this->compactEnv($env);
1778  
1779          $this->env = $this->extractEnv(array_filter($envs, function (Environment $e) {
1780              return ! isset($e->block->selectors);
1781          }));
1782  
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;
1787  
1788          $this->compileChildrenNoReturn($block->children, $this->scope);
1789  
1790          assert($this->scope !== null);
1791          $this->scope = $this->scope->parent;
1792          $this->env   = $this->extractEnv($envs);
1793  
1794          $this->popEnv();
1795      }
1796  
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) . '-';
1809  
1810          $nested = $this->makeOutputBlock($block->type);
1811          $nested->parent = $out;
1812  
1813          if ($block->hasValue) {
1814              $nested->depth = $out->depth + 1;
1815          }
1816  
1817          $out->children[] = $nested;
1818  
1819          foreach ($block->children as $child) {
1820              switch ($child[0]) {
1821                  case Type::T_ASSIGN:
1822                      array_unshift($child[1][2], $prefix);
1823                      break;
1824  
1825                  case Type::T_NESTED_PROPERTY:
1826                      assert($child[1] instanceof NestedPropertyBlock);
1827                      array_unshift($child[1]->prefix[2], $prefix);
1828                      break;
1829              }
1830  
1831              $this->compileChild($child, $nested);
1832          }
1833      }
1834  
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);
1846  
1847          $this->scope = $this->makeOutputBlock($block->type, $selectors);
1848          assert($this->scope->parent !== null);
1849          $this->scope->parent->children[] = $this->scope;
1850  
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;
1856  
1857              foreach ($block->children as $child) {
1858                  if ($child[0] === Type::T_ASSIGN) {
1859                      $needWrapping = true;
1860                      break;
1861                  }
1862              }
1863  
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;
1875  
1876                  $block->children = [[Type::T_BLOCK, $wrapped]];
1877              }
1878          }
1879  
1880          $this->compileChildrenNoReturn($block->children, $this->scope);
1881  
1882          assert($this->scope !== null);
1883          $this->scope = $this->scope->parent;
1884  
1885          $this->popEnv();
1886      }
1887  
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);
1913  
1914          $out = $this->makeOutputBlock(null);
1915  
1916          assert($this->scope !== null);
1917          $this->scope->children[] = $out;
1918  
1919          if (\count($block->children)) {
1920              $out->selectors = $this->multiplySelectors($env, $block->selfParent);
1921  
1922              // propagate selfParent to the children where they still can be useful
1923              $selfParentSelectors = null;
1924  
1925              if (isset($block->selfParent->selectors)) {
1926                  $selfParentSelectors = $block->selfParent->selectors;
1927                  $block->selfParent->selectors = $out->selectors;
1928              }
1929  
1930              $this->compileChildrenNoReturn($block->children, $out, $block->selfParent);
1931  
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          }
1938  
1939          $this->popEnv();
1940      }
1941  
1942  
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];
1954  
1955          if (isset($value[2])) {
1956              if ($pushEnv) {
1957                  $this->pushEnv();
1958              }
1959  
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              }
1969  
1970              if ($pushEnv) {
1971                  $this->popEnv();
1972              }
1973          }
1974  
1975          return $c;
1976      }
1977  
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);
1989  
1990          assert($this->scope !== null);
1991          $this->scope->children[] = $out;
1992      }
1993  
1994      /**
1995       * Evaluate selectors
1996       *
1997       * @param array $selectors
1998       *
1999       * @return array
2000       */
2001      protected function evalSelectors($selectors)
2002      {
2003          $this->shouldEvaluate = false;
2004  
2005          $evaluatedSelectors = [];
2006          foreach ($selectors as $selector) {
2007              $evaluatedSelectors[] = $this->evalSelector($selector);
2008          }
2009          $selectors = $evaluatedSelectors;
2010  
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__);
2016  
2017              try {
2018                  $isValid = $parser->parseSelector($buffer, $newSelectors, true);
2019              } catch (ParserException $e) {
2020                  throw $this->error($e->getMessage());
2021              }
2022  
2023              if ($isValid) {
2024                  $selectors = array_map([$this, 'evalSelector'], $newSelectors);
2025              }
2026          }
2027  
2028          return $selectors;
2029      }
2030  
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      }
2044  
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);
2059  
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          }
2072  
2073          return $this->flattenSelectorSingle($part);
2074      }
2075  
2076      /**
2077       * Collapse selectors
2078       *
2079       * @param array $selectors
2080       *
2081       * @return string
2082       */
2083      protected function collapseSelectors($selectors)
2084      {
2085          $parts = [];
2086  
2087          foreach ($selectors as $selector) {
2088              $output = [];
2089  
2090              foreach ($selector as $node) {
2091                  $compound = '';
2092  
2093                  array_walk_recursive(
2094                      $node,
2095                      function ($value, $key) use (&$compound) {
2096                          $compound .= $value;
2097                      }
2098                  );
2099  
2100                  $output[] = $compound;
2101              }
2102  
2103              $parts[] = implode(' ', $output);
2104          }
2105  
2106          return implode(', ', $parts);
2107      }
2108  
2109      /**
2110       * Collapse selectors
2111       *
2112       * @param array $selectors
2113       *
2114       * @return array
2115       */
2116      private function collapseSelectorsAsList($selectors)
2117      {
2118          $parts = [];
2119  
2120          foreach ($selectors as $selector) {
2121              $output = [];
2122              $glueNext = false;
2123  
2124              foreach ($selector as $node) {
2125                  $compound = '';
2126  
2127                  array_walk_recursive(
2128                      $node,
2129                      function ($value, $key) use (&$compound) {
2130                          $compound .= $value;
2131                      }
2132                  );
2133  
2134                  if ($this->isImmediateRelationshipCombinator($compound)) {
2135                      if (\count($output)) {
2136                          $output[\count($output) - 1] .= ' ' . $compound;
2137                      } else {
2138                          $output[] = $compound;
2139                      }
2140  
2141                      $glueNext = true;
2142                  } elseif ($glueNext) {
2143                      $output[\count($output) - 1] .= ' ' . $compound;
2144                      $glueNext = false;
2145                  } else {
2146                      $output[] = $compound;
2147                  }
2148              }
2149  
2150              foreach ($output as &$o) {
2151                  $o = [Type::T_STRING, '', [$o]];
2152              }
2153  
2154              $parts[] = [Type::T_LIST, ' ', $output];
2155          }
2156  
2157          return [Type::T_LIST, ',', $parts];
2158      }
2159  
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          }
2183  
2184          return $selectors;
2185      }
2186  
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 = [];
2197  
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              }
2207  
2208              if (\is_array(end($joined))) {
2209                  $joined[] = $part;
2210              } else {
2211                  $joined[\count($joined) - 1] .= $part;
2212              }
2213          }
2214  
2215          return $joined;
2216      }
2217  
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          }
2230  
2231          return implode(
2232              ' ',
2233              array_map(
2234                  [$this, 'compileSelectorPart'],
2235                  $selector
2236              )
2237          );
2238      }
2239  
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              }
2253  
2254              switch ($p[0]) {
2255                  case Type::T_SELF:
2256                      $p = '&';
2257                      break;
2258  
2259                  default:
2260                      $p = $this->compileValue($p);
2261                      break;
2262              }
2263          }
2264  
2265          return implode($piece);
2266      }
2267  
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          }
2280  
2281          foreach ($selector as $parts) {
2282              foreach ($parts as $part) {
2283                  if (\strlen($part) && '%' === $part[0]) {
2284                      return true;
2285                  }
2286              }
2287          }
2288  
2289          return false;
2290      }
2291  
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          ];
2305  
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';
2311  
2312              throw $this->error($msg);
2313          }
2314      }
2315  
2316      /**
2317       * @return void
2318       */
2319      protected function popCallStack()
2320      {
2321          array_pop($this->callStack);
2322      }
2323  
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);
2336  
2337          foreach ($stms as $stm) {
2338              $ret = $this->compileChild($stm, $out);
2339  
2340              if (isset($ret)) {
2341                  $this->popCallStack();
2342  
2343                  return $ret;
2344              }
2345          }
2346  
2347          $this->popCallStack();
2348  
2349          return null;
2350      }
2351  
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);
2367  
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              }
2380  
2381              if (isset($ret)) {
2382                  throw $this->error('@return may only be used within a function');
2383              }
2384          }
2385  
2386          $this->popCallStack();
2387      }
2388  
2389  
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;
2400  
2401          $outQueryList = [];
2402  
2403          foreach ($queryList as $kql => $query) {
2404              $shouldReparse = false;
2405  
2406              foreach ($query as $kq => $q) {
2407                  for ($i = 1; $i < \count($q); $i++) {
2408                      $value = $this->compileValue($q[$i]);
2409  
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                      }
2421  
2422                      $queryList[$kql][$kq][$i] = [Type::T_KEYWORD, $value];
2423                  }
2424              }
2425  
2426              if ($shouldReparse) {
2427                  if (\is_null($parser)) {
2428                      $parser = $this->parserFactory(__METHOD__);
2429                  }
2430  
2431                  $queryString = $this->compileMediaQuery([$queryList[$kql]]);
2432                  $queryString = reset($queryString);
2433  
2434                  if ($queryString !== false && strpos($queryString, '@media ') === 0) {
2435                      $queryString = substr($queryString, 7);
2436                      $queries = [];
2437  
2438                      if ($parser->parseMediaQueryList($queryString, $queries)) {
2439                          $queries = $this->evaluateMediaQuery($queries[2]);
2440  
2441                          while (\count($queries)) {
2442                              $outQueryList[] = array_shift($queries);
2443                          }
2444  
2445                          continue;
2446                      }
2447                  }
2448              }
2449  
2450              $outQueryList[] = $queryList[$kql];
2451          }
2452  
2453          return $outQueryList;
2454      }
2455  
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 = '';
2469  
2470          foreach ($queryList as $query) {
2471              $type = null;
2472              $parts = [];
2473  
2474              $mediaTypeOnly = true;
2475  
2476              foreach ($query as $q) {
2477                  if ($q[0] !== Type::T_MEDIA_TYPE) {
2478                      $mediaTypeOnly = false;
2479                      break;
2480                  }
2481              }
2482  
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));
2487  
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                                  }
2494  
2495                                  if (! empty($parts)) {
2496                                      if (\strlen($current)) {
2497                                          $current .= $this->formatter->tagSeparator;
2498                                      }
2499  
2500                                      $current .= implode(' and ', $parts);
2501                                  }
2502  
2503                                  if ($current) {
2504                                      $out[] = $start . $current;
2505                                  }
2506  
2507                                  $current = '';
2508                                  $type    = null;
2509                                  $parts   = [];
2510                              }
2511                          }
2512  
2513                          if ($newType === ['all'] && $default) {
2514                              $default = $start . 'all';
2515                          }
2516  
2517                          // all can be safely ignored and mixed with whatever else
2518                          if ($newType !== ['all']) {
2519                              if ($type) {
2520                                  $type = $this->mergeMediaTypes($type, $newType);
2521  
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;
2533  
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;
2547  
2548                      case Type::T_MEDIA_VALUE:
2549                          $parts[] = $this->compileValue($q[1]);
2550                          break;
2551                  }
2552              }
2553  
2554              if ($type) {
2555                  array_unshift($parts, implode(' ', array_filter($type)));
2556              }
2557  
2558              if (! empty($parts)) {
2559                  if (\strlen($current)) {
2560                      $current .= $this->formatter->tagSeparator;
2561                  }
2562  
2563                  $current .= implode(' and ', $parts);
2564              }
2565          }
2566  
2567          if ($current) {
2568              $out[] = $start . $current;
2569          }
2570  
2571          // no @media type except all, and no conflict?
2572          if (! $out && $default) {
2573              $out[] = $default;
2574          }
2575  
2576          return $out;
2577      }
2578  
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          }
2592  
2593          $part1 = end($selectors1);
2594          $part2 = end($selectors2);
2595  
2596          if (! $this->isImmediateRelationshipCombinator($part1[0]) && $part1 !== $part2) {
2597              return array_merge($selectors1, $selectors2);
2598          }
2599  
2600          $merged = [];
2601  
2602          do {
2603              $part1 = array_pop($selectors1);
2604              $part2 = array_pop($selectors2);
2605  
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                  }
2613  
2614                  break;
2615              }
2616  
2617              array_unshift($merged, $part1);
2618          } while (! empty($selectors1) && ! empty($selectors2));
2619  
2620          return $merged;
2621      }
2622  
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          }
2636  
2637          if (empty($type2)) {
2638              return $type1;
2639          }
2640  
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          }
2648  
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          }
2656  
2657          if (($m1 === Type::T_NOT) ^ ($m2 === Type::T_NOT)) {
2658              if ($t1 === $t2) {
2659                  return null;
2660              }
2661  
2662              return [
2663                  $m1 === Type::T_NOT ? $m2 : $m1,
2664                  $m1 === Type::T_NOT ? $t2 : $t1,
2665              ];
2666          }
2667  
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              }
2673  
2674              return [Type::T_NOT, $t1];
2675          }
2676  
2677          if ($t1 !== $t2) {
2678              return null;
2679          }
2680  
2681          // t1 == t2, neither m1 nor m2 are "not"
2682          return [empty($m1) ? $m2 : $m1, $t1];
2683      }
2684  
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);
2698  
2699              if (strpos($path, 'url(') !== 0 && $filePath = $this->findImport($path, $this->currentDirectory)) {
2700                  $this->registerImport($this->currentDirectory, $path, $filePath);
2701  
2702                  if (! $once || ! \in_array($filePath, $this->importedFiles)) {
2703                      $this->importFile($filePath, $out);
2704                      $this->importedFiles[] = $filePath;
2705                  }
2706  
2707                  return true;
2708              }
2709  
2710              $this->appendRootDirective('@import ' . $this->compileImportPath($rawPath) . ';', $out);
2711  
2712              return false;
2713          }
2714  
2715          if ($rawPath[0] === Type::T_LIST) {
2716              // handle a list of strings
2717              if (\count($rawPath[2]) === 0) {
2718                  return false;
2719              }
2720  
2721              foreach ($rawPath[2] as $path) {
2722                  if ($path[0] !== Type::T_STRING) {
2723                      $this->appendRootDirective('@import ' . $this->compileImportPath($rawPath) . ';', $out);
2724  
2725                      return false;
2726                  }
2727              }
2728  
2729              foreach ($rawPath[2] as $path) {
2730                  $this->compileImport($path, $out, $once);
2731              }
2732  
2733              return true;
2734          }
2735  
2736          $this->appendRootDirective('@import ' . $this->compileImportPath($rawPath) . ';', $out);
2737  
2738          return false;
2739      }
2740  
2741      /**
2742       * @param array $rawPath
2743       * @return string
2744       * @throws CompilerException
2745       */
2746      protected function compileImportPath($rawPath)
2747      {
2748          $path = $this->compileValue($rawPath);
2749  
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          }
2760  
2761          return $path;
2762      }
2763  
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          }
2785  
2786          return $path;
2787      }
2788  
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;
2802  
2803          while ($root->parent) {
2804              $root = $root->parent;
2805          }
2806  
2807          $i = 0;
2808  
2809          while ($i < \count($root->children)) {
2810              if (! isset($root->children[$i]->type) || ! \in_array($root->children[$i]->type, $allowed)) {
2811                  break;
2812              }
2813  
2814              $i++;
2815          }
2816  
2817          // remove incompatible children from the bottom of the list
2818          $saveChildren = [];
2819  
2820          while ($i < \count($root->children)) {
2821              $saveChildren[] = array_pop($root->children);
2822          }
2823  
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;
2830  
2831          $root->children[] = $child;
2832  
2833          // repush children
2834          while (\count($saveChildren)) {
2835              $root->children[] = array_pop($saveChildren);
2836          }
2837      }
2838  
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;
2852  
2853          // check if it's a flat output or not
2854          if (\count($out->children)) {
2855              $lastChild = &$out->children[\count($out->children) - 1];
2856  
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;
2867  
2868                  $out->children[] = $nextLines;
2869                  $outWrite = &$nextLines;
2870              }
2871          }
2872  
2873          $outWrite->lines[] = $line;
2874      }
2875  
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;
2898  
2899              if ($sourceIndex === false) {
2900                  $sourceIndex = null;
2901              }
2902              $this->sourceIndex = $sourceIndex;
2903          }
2904  
2905          switch ($child[0]) {
2906              case Type::T_SCSSPHP_IMPORT_ONCE:
2907                  $rawPath = $this->reduce($child[1]);
2908  
2909                  $this->compileImport($rawPath, $out, true);
2910                  break;
2911  
2912              case Type::T_IMPORT:
2913                  $rawPath = $this->reduce($child[1]);
2914  
2915                  $this->compileImport($rawPath, $out);
2916                  break;
2917  
2918              case Type::T_DIRECTIVE:
2919                  $this->compileDirective($child[1], $out);
2920                  break;
2921  
2922              case Type::T_AT_ROOT:
2923                  $this->compileAtRoot($child[1]);
2924                  break;
2925  
2926              case Type::T_MEDIA:
2927                  $this->compileMedia($child[1]);
2928                  break;
2929  
2930              case Type::T_BLOCK:
2931                  $this->compileBlock($child[1]);
2932                  break;
2933  
2934              case Type::T_CHARSET:
2935                  break;
2936  
2937              case Type::T_CUSTOM_PROPERTY:
2938                  list(, $name, $value) = $child;
2939                  $compiledName = $this->compileValue($name);
2940  
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);
2945  
2946                      if ($value[0] === Type::T_NULL || $value === static::$nullString) {
2947                          break;
2948                      }
2949                  }
2950  
2951                  $compiledValue = $this->compileValue($value);
2952  
2953                  $line = $this->formatter->customProperty(
2954                      $compiledName,
2955                      $compiledValue
2956                  );
2957  
2958                  $this->appendOutputLine($out, Type::T_ASSIGN, $line);
2959                  break;
2960  
2961              case Type::T_ASSIGN:
2962                  list(, $name, $value) = $child;
2963  
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);
2968  
2969                      if ($isGlobal) {
2970                          $this->set($name[1], $this->reduce($value), false, $this->rootEnv, $value);
2971                          break;
2972                      }
2973  
2974                      $shouldSet = $isDefault &&
2975                          (\is_null($result = $this->get($name[1], false)) ||
2976                          $result === static::$null);
2977  
2978                      if (! $isDefault || $shouldSet) {
2979                          $this->set($name[1], $this->reduce($value), true, null, $value);
2980                      }
2981                      break;
2982                  }
2983  
2984                  $compiledName = $this->compileValue($name);
2985  
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                      }
2993  
2994                      $shorthandValue=&$value;
2995  
2996                      $shorthandDividerNeedsUnit = false;
2997                      $maxListElements           = null;
2998                      $maxShorthandDividers      = 1;
2999  
3000                      switch ($compiledName) {
3001                          case 'border-radius':
3002                              $maxListElements = 4;
3003                              $shorthandDividerNeedsUnit = true;
3004                              break;
3005                      }
3006  
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                      }
3012  
3013                      if ($shorthandValue[0] === Type::T_EXPRESSION && $shorthandValue[1] === '/') {
3014                          $revert = true;
3015  
3016                          if ($shorthandDividerNeedsUnit) {
3017                              $divider = $shorthandValue[3];
3018  
3019                              if (\is_array($divider)) {
3020                                  $divider = $this->reduce($divider, true);
3021                              }
3022  
3023                              if ($divider instanceof Number && \intval($divider->getDimension()) && $divider->unitless()) {
3024                                  $revert = false;
3025                              }
3026                          }
3027  
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;
3036  
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];
3042  
3043                                              if (\is_array($divider)) {
3044                                                  $divider = $this->reduce($divider, true);
3045                                              }
3046  
3047                                              if ($divider instanceof Number && \intval($divider->getDimension()) && $divider->unitless()) {
3048                                                  $revert = false;
3049                                              }
3050                                          }
3051                                      }
3052  
3053                                      if ($revert) {
3054                                          $item = $this->expToString($item);
3055                                          $maxShorthandDividers--;
3056                                      }
3057                                  }
3058                              }
3059                          }
3060                      }
3061                  }
3062  
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);
3067  
3068                      if ($value[0] === Type::T_NULL || $value === static::$nullString) {
3069                          break;
3070                      }
3071                  }
3072  
3073                  $compiledValue = $this->compileValue($value);
3074  
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;
3084  
3085              case Type::T_COMMENT:
3086                  if ($out->type === Type::T_ROOT) {
3087                      $this->compileComment($child);
3088                      break;
3089                  }
3090  
3091                  $line = $this->compileCommentValue($child, true);
3092                  $this->appendOutputLine($out, Type::T_COMMENT, $line);
3093                  break;
3094  
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;
3103  
3104              case Type::T_EXTEND:
3105                  foreach ($child[1] as $sel) {
3106                      $replacedSel = $this->replaceSelfSelector($sel);
3107  
3108                      if ($replacedSel !== $sel) {
3109                          throw $this->error('Parent selectors aren\'t allowed here.');
3110                      }
3111  
3112                      $results = $this->evalSelectors([$sel]);
3113  
3114                      foreach ($results as $result) {
3115                          if (\count($result) !== 1) {
3116                              throw $this->error('complex selectors may not be extended.');
3117                          }
3118  
3119                          // only use the first one
3120                          $result = $result[0];
3121                          $selectors = $out->selectors;
3122  
3123                          if (! $selectors && isset($child['selfParent'])) {
3124                              $selectors = $this->multiplySelectors($this->env, $child['selfParent']);
3125                          }
3126                          assert($selectors !== null);
3127  
3128                          if (\count($result) > 1) {
3129                              $replacement = implode(', ', $result);
3130                              $fname = $this->getPrettyPath($this->sourceNames[$this->sourceIndex]);
3131                              $line = $this->sourceLine;
3132  
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;
3139  
3140                              $this->logger->warn($message);
3141                          }
3142  
3143                          $this->pushExtends($result, $selectors, $child);
3144                      }
3145                  }
3146                  break;
3147  
3148              case Type::T_IF:
3149                  list(, $if) = $child;
3150                  assert($if instanceof IfBlock);
3151  
3152                  if ($this->isTruthy($this->reduce($if->cond, true))) {
3153                      return $this->compileChildren($if->children, $out);
3154                  }
3155  
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;
3165  
3166              case Type::T_EACH:
3167                  list(, $each) = $child;
3168                  assert($each instanceof EachBlock);
3169  
3170                  $list = $this->coerceList($this->reduce($each->list), ',', true);
3171  
3172                  $this->pushEnv();
3173  
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);
3179  
3180                          foreach ($each->vars as $i => $var) {
3181                              $this->set($var, isset($values[$i]) ? $values[$i] : static::$null, true);
3182                          }
3183                      }
3184  
3185                      $ret = $this->compileChildren($each->children, $out);
3186  
3187                      if ($ret) {
3188                          $store = $this->env->store;
3189                          $this->popEnv();
3190                          $this->backPropagateEnv($store, $each->vars);
3191  
3192                          return $ret;
3193                      }
3194                  }
3195                  $store = $this->env->store;
3196                  $this->popEnv();
3197                  $this->backPropagateEnv($store, $each->vars);
3198  
3199                  break;
3200  
3201              case Type::T_WHILE:
3202                  list(, $while) = $child;
3203                  assert($while instanceof WhileBlock);
3204  
3205                  while ($this->isTruthy($this->reduce($while->cond, true))) {
3206                      $ret = $this->compileChildren($while->children, $out);
3207  
3208                      if ($ret) {
3209                          return $ret;
3210                      }
3211                  }
3212                  break;
3213  
3214              case Type::T_FOR:
3215                  list(, $for) = $child;
3216                  assert($for instanceof ForBlock);
3217  
3218                  $startNumber = $this->assertNumber($this->reduce($for->start, true));
3219                  $endNumber = $this->assertNumber($this->reduce($for->end, true));
3220  
3221                  $start = $this->assertInteger($startNumber);
3222  
3223                  $numeratorUnits = $startNumber->getNumeratorUnits();
3224                  $denominatorUnits = $startNumber->getDenominatorUnits();
3225  
3226                  $end = $this->assertInteger($endNumber->coerce($numeratorUnits, $denominatorUnits));
3227  
3228                  $d = $start < $end ? 1 : -1;
3229  
3230                  $this->pushEnv();
3231  
3232                  for (;;) {
3233                      if (
3234                          (! $for->until && $start - $d == $end) ||
3235                          ($for->until && $start == $end)
3236                      ) {
3237                          break;
3238                      }
3239  
3240                      $this->set($for->var, new Number($start, $numeratorUnits, $denominatorUnits));
3241                      $start += $d;
3242  
3243                      $ret = $this->compileChildren($for->children, $out);
3244  
3245                      if ($ret) {
3246                          $store = $this->env->store;
3247                          $this->popEnv();
3248                          $this->backPropagateEnv($store, [$for->var]);
3249  
3250                          return $ret;
3251                      }
3252                  }
3253  
3254                  $store = $this->env->store;
3255                  $this->popEnv();
3256                  $this->backPropagateEnv($store, [$for->var]);
3257  
3258                  break;
3259  
3260              case Type::T_RETURN:
3261                  return $this->reduce($child[1], true);
3262  
3263              case Type::T_NESTED_PROPERTY:
3264                  $this->compileNestedPropertiesBlock($child[1], $out);
3265                  break;
3266  
3267              case Type::T_INCLUDE:
3268                  // including a mixin
3269                  list(, $name, $argValues, $content, $argUsing) = $child;
3270  
3271                  $mixin = $this->get(static::$namespaces['mixin'] . $name, false);
3272  
3273                  if (! $mixin) {
3274                      throw $this->error("Undefined mixin $name");
3275                  }
3276  
3277                  assert($mixin instanceof CallableBlock);
3278  
3279                  $callingScope = $this->getStoreEnv();
3280  
3281                  // push scope, apply args
3282                  $this->pushEnv();
3283                  $this->env->depth--;
3284  
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;
3288  
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);
3293  
3294                      if ($parentSelectors) {
3295                          $parent = new Block();
3296                          $parent->selectors = $parentSelectors;
3297  
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                  }
3305  
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;
3311  
3312                      $this->setRaw(static::$namespaces['special'] . 'content', $copyContent, $this->env);
3313                  } else {
3314                      $this->setRaw(static::$namespaces['special'] . 'content', null, $this->env);
3315                  }
3316  
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                  }
3323  
3324                  if (isset($mixin->args)) {
3325                      $this->applyArguments($mixin->args, $argValues);
3326                  }
3327  
3328                  $this->env->marker = 'mixin';
3329  
3330                  if (! empty($mixin->parentEnv)) {
3331                      $this->env->declarationScopeParent = $mixin->parentEnv;
3332                  } else {
3333                      throw $this->error("@mixin $name() without parentEnv");
3334                  }
3335  
3336                  $this->compileChildrenNoReturn($mixin->children, $out, $selfParent, $this->env->marker . ' ' . $name);
3337  
3338                  $this->popEnv();
3339                  break;
3340  
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];
3346  
3347                  if (! $content) {
3348                      break;
3349                  }
3350  
3351                  $storeEnv = $this->storeEnv;
3352                  $varsUsing = [];
3353  
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                  }
3359  
3360                  // restore the scope from the @content
3361                  $this->storeEnv = $content->scope;
3362  
3363                  // append the vars from using if any
3364                  foreach ($varsUsing as $name => $val) {
3365                      $this->set($name, $val, true, $this->storeEnv);
3366                  }
3367  
3368                  $this->compileChildrenNoReturn($content->children, $out);
3369  
3370                  $this->storeEnv = $storeEnv;
3371                  break;
3372  
3373              case Type::T_DEBUG:
3374                  list(, $value) = $child;
3375  
3376                  $fname = $this->getPrettyPath($this->sourceNames[$this->sourceIndex]);
3377                  $line  = $this->sourceLine;
3378                  $value = $this->compileDebugValue($value);
3379  
3380                  $this->logger->debug("$fname:$line DEBUG: $value");
3381                  break;
3382  
3383              case Type::T_WARN:
3384                  list(, $value) = $child;
3385  
3386                  $fname = $this->getPrettyPath($this->sourceNames[$this->sourceIndex]);
3387                  $line  = $this->sourceLine;
3388                  $value = $this->compileDebugValue($value);
3389  
3390                  $this->logger->warn("$value\n         on line $line of $fname");
3391                  break;
3392  
3393              case Type::T_ERROR:
3394                  list(, $value) = $child;
3395  
3396                  $fname = $this->getPrettyPath($this->sourceNames[$this->sourceIndex]);
3397                  $line  = $this->sourceLine;
3398                  $value = $this->compileValue($this->reduce($value, true));
3399  
3400                  throw $this->error("File $fname on line $line ERROR: $value\n");
3401  
3402              default:
3403                  throw $this->error("unknown child type: $child[0]");
3404          }
3405  
3406          return null;
3407      }
3408  
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;
3420  
3421          $content = [];
3422  
3423          if ($keepParens && $inParens) {
3424              $content[] = '(';
3425          }
3426  
3427          $content[] = $this->reduce($left);
3428  
3429          if ($whiteLeft) {
3430              $content[] = ' ';
3431          }
3432  
3433          $content[] = $op;
3434  
3435          if ($whiteRight) {
3436              $content[] = ' ';
3437          }
3438  
3439          $content[] = $this->reduce($right);
3440  
3441          if ($keepParens && $inParens) {
3442              $content[] = ')';
3443          }
3444  
3445          return [Type::T_STRING, '', $content];
3446      }
3447  
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      }
3459  
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      }
3471  
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                  }
3486  
3487                  // fall-thru
3488              case Type::T_VARIABLE:
3489              case Type::T_FUNCTION_CALL:
3490                  return true;
3491          }
3492  
3493          return false;
3494      }
3495  
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          }
3509  
3510          switch ($value[0]) {
3511              case Type::T_EXPRESSION:
3512                  list(, $op, $left, $right, $inParens) = $value;
3513  
3514                  $opName = isset(static::$operatorNames[$op]) ? static::$operatorNames[$op] : $op;
3515                  $inExp = $inExp || $this->shouldEval($left) || $this->shouldEval($right);
3516  
3517                  $left = $this->reduce($left, true);
3518  
3519                  if ($op !== 'and' && $op !== 'or') {
3520                      $right = $this->reduce($right, true);
3521                  }
3522  
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                  }
3531  
3532                  $left  = $this->coerceForExpression($left);
3533                  $right = $this->coerceForExpression($right);
3534                  $ltype = $left[0];
3535                  $rtype = $right[0];
3536  
3537                  $ucOpName = ucfirst($opName);
3538                  $ucLType  = ucfirst($ltype);
3539                  $ucRType  = ucfirst($rtype);
3540  
3541                  $shouldEval = $inParens || $inExp;
3542  
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                  }
3556  
3557                  if (isset($out)) {
3558                      return $out;
3559                  }
3560  
3561                  return $this->expToString($value);
3562  
3563              case Type::T_UNARY:
3564                  list(, $op, $exp, $inParens) = $value;
3565  
3566                  $inExp = $inExp || $this->shouldEval($exp);
3567                  $exp = $this->reduce($exp);
3568  
3569                  if ($exp instanceof Number) {
3570                      switch ($op) {
3571                          case '+':
3572                              return $exp;
3573  
3574                          case '-':
3575                              return $exp->unaryMinus();
3576                      }
3577                  }
3578  
3579                  if ($op === 'not') {
3580                      if ($inExp || $inParens) {
3581                          if ($exp === static::$false || $exp === static::$null) {
3582                              return static::$true;
3583                          }
3584  
3585                          return static::$false;
3586                      }
3587  
3588                      $op = $op . ' ';
3589                  }
3590  
3591                  return [Type::T_STRING, '', [$op, $exp]];
3592  
3593              case Type::T_VARIABLE:
3594                  return $this->reduce($this->get($value[1]));
3595  
3596              case Type::T_LIST:
3597                  foreach ($value[2] as &$item) {
3598                      $item = $this->reduce($item);
3599                  }
3600                  unset($item);
3601  
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                  }
3608  
3609                  return $value;
3610  
3611              case Type::T_MAP:
3612                  foreach ($value[1] as &$item) {
3613                      $item = $this->reduce($item);
3614                  }
3615  
3616                  foreach ($value[2] as &$item) {
3617                      $item = $this->reduce($item);
3618                  }
3619  
3620                  return $value;
3621  
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                  }
3628  
3629                  return $value;
3630  
3631              case Type::T_INTERPOLATE:
3632                  $value[1] = $this->reduce($value[1]);
3633  
3634                  if ($inExp) {
3635                      return [Type::T_KEYWORD, $this->compileValue($value, false)];
3636                  }
3637  
3638                  return $value;
3639  
3640              case Type::T_FUNCTION_CALL:
3641                  return $this->fncall($value[1], $value[2]);
3642  
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);
3647  
3648                  return $selfSelector;
3649  
3650              default:
3651                  return $value;
3652          }
3653      }
3654  
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;
3668  
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          }
3674  
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 = [];
3679  
3680              foreach ((array) $argValues as $arg) {
3681                  if (empty($arg[0]) || count($argValues) === 1) {
3682                      $listArgs[] = $this->reduce($this->stringifyFncallArgs($arg[1]));
3683                  }
3684              }
3685  
3686              return [Type::T_FUNCTION, $functionReference[1], [Type::T_LIST, ',', $listArgs]];
3687          }
3688  
3689          if ($functionReference === static::$null || $functionReference[0] !== Type::T_FUNCTION_REFERENCE) {
3690              return static::$defaultValue;
3691          }
3692  
3693  
3694          switch ($functionReference[1]) {
3695              // SCSS @function
3696              case 'scss':
3697                  return $this->callScssFunction($functionReference[3], $argValues);
3698  
3699              // native PHP functions
3700              case 'user':
3701              case 'native':
3702                  list(,,$name, $fn, $prototype) = $functionReference;
3703  
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);
3716  
3717                  if (! isset($returnValue)) {
3718                      return $this->fncall([Type::T_FUNCTION, $name, [Type::T_LIST, ',', []]], $argValues);
3719                  }
3720  
3721                  return $returnValue;
3722  
3723              default:
3724                  return static::$defaultValue;
3725          }
3726      }
3727  
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          }
3740  
3741          switch ($arg[0]) {
3742              case Type::T_INTERPOLATE:
3743                  return [Type::T_KEYWORD, $this->CompileValue($arg)];
3744  
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;
3758  
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                  }
3775  
3776                  return $this->fncall([Type::T_FUNCTION, $arg[1], [Type::T_LIST, ',', []]], $cssArgs);
3777  
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);
3784  
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;
3800  
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);
3811  
3812              case Type::T_VARIABLE:
3813              case Type::T_SELF:
3814              default:
3815                  return false;
3816          }
3817      }
3818  
3819  
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          }
3832  
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;
3839  
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;
3848  
3849              case Type::T_FUNCTION_CALL:
3850                  $name = strtolower($arg[1]);
3851  
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          }
3858  
3859          return $arg;
3860      }
3861  
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              }
3875  
3876              return [Type::T_FUNCTION_REFERENCE, 'scss', $name, $func];
3877          }
3878  
3879          // native PHP functions
3880  
3881          // try to find a native lib function
3882          $normalizedName = $this->normalizeName($name);
3883  
3884          if (isset($this->userFunctions[$normalizedName])) {
3885              // see if we can find a user function
3886              list($f, $prototype) = $this->userFunctions[$normalizedName];
3887  
3888              return [Type::T_FUNCTION_REFERENCE, 'user', $name, $f, $prototype];
3889          }
3890  
3891          $lowercasedName = strtolower($normalizedName);
3892  
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' || $lowercasedName === 'rgb' || $lowercasedName === 'rgba' || $lowercasedName === 'hsl' || $lowercasedName === 'hsla') {
3896              $normalizedName = $lowercasedName;
3897          }
3898  
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;
3903  
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;
3914  
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");
3924  
3925                      // Use the actual function definition
3926                      $prototype = isset(static::$$actualLibName) ? static::$$actualLibName : null;
3927                      $f[1] = $libName = $actualLibName;
3928                  }
3929              }
3930  
3931              if (\get_class($this) !== __CLASS__ && !isset($this->warnedChildFunctions[$libName])) {
3932                  $r = new \ReflectionMethod($this, $libName);
3933                  $declaringClass = $r->getDeclaringClass()->name;
3934  
3935                  $needsWarning = $this->warnedChildFunctions[$libName] = $declaringClass !== __CLASS__;
3936  
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              }
3945  
3946              return [Type::T_FUNCTION_REFERENCE, 'native', $name, $f, $prototype];
3947          }
3948  
3949          return static::$null;
3950      }
3951  
3952  
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      }
3964  
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));
3977  
3978          if ($value instanceof Number) {
3979              return $value;
3980          }
3981  
3982          switch ($value[0]) {
3983              case Type::T_LIST:
3984                  $value = $this->extractInterpolation($value);
3985  
3986                  if ($value[0] !== Type::T_LIST) {
3987                      return [Type::T_KEYWORD, $this->compileValue($value)];
3988                  }
3989  
3990                  foreach ($value[2] as $key => $item) {
3991                      $value[2][$key] = $this->normalizeValue($item);
3992                  }
3993  
3994                  if (! empty($value['enclosing'])) {
3995                      unset($value['enclosing']);
3996                  }
3997  
3998                  if ($value[1] === '' && count($value[2]) > 1) {
3999                      $value[1] = ' ';
4000                  }
4001  
4002                  return $value;
4003  
4004              case Type::T_STRING:
4005                  return [$value[0], '"', [$this->compileStringContent($value)]];
4006  
4007              case Type::T_INTERPOLATE:
4008                  return [Type::T_KEYWORD, $this->compileValue($value)];
4009  
4010              default:
4011                  return $value;
4012          }
4013      }
4014  
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      }
4027  
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      }
4040  
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      }
4053  
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      }
4066  
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      }
4079  
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              }
4094  
4095              $strLeft[2][] = $right;
4096  
4097              return $strLeft;
4098          }
4099  
4100          if ($strRight = $this->coerceString($right)) {
4101              if ($left[0] === Type::T_STRING) {
4102                  $left[1] = '';
4103              }
4104  
4105              array_unshift($strRight[2], $left);
4106  
4107              return $strRight;
4108          }
4109  
4110          return null;
4111      }
4112  
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);
4127  
4128          if (! $shouldEval) {
4129              if (! $truthy) {
4130                  return null;
4131              }
4132          }
4133  
4134          if ($left !== static::$false && $left !== static::$null) {
4135              return $this->reduce($right, true);
4136          }
4137  
4138          return $left;
4139      }
4140  
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);
4155  
4156          if (! $shouldEval) {
4157              if (! $truthy) {
4158                  return null;
4159              }
4160          }
4161  
4162          if ($left !== static::$false && $left !== static::$null) {
4163              return $left;
4164          }
4165  
4166          return $this->reduce($right, true);
4167      }
4168  
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;
4185  
4186              Warn::deprecation("$warning\n         on line $line of $fname");
4187          }
4188  
4189          $out = [Type::T_COLOR];
4190  
4191          foreach ([1, 2, 3] as $i) {
4192              $lval = isset($left[$i]) ? $left[$i] : 0;
4193              $rval = isset($right[$i]) ? $right[$i] : 0;
4194  
4195              switch ($op) {
4196                  case '+':
4197                      $out[] = $lval + $rval;
4198                      break;
4199  
4200                  case '-':
4201                      $out[] = $lval - $rval;
4202                      break;
4203  
4204                  case '*':
4205                      $out[] = $lval * $rval;
4206                      break;
4207  
4208                  case '%':
4209                      if ($rval == 0) {
4210                          throw $this->error("color: Can't take modulo by zero");
4211                      }
4212  
4213                      $out[] = $lval % $rval;
4214                      break;
4215  
4216                  case '/':
4217                      if ($rval == 0) {
4218                          throw $this->error("color: Can't divide by zero");
4219                      }
4220  
4221                      $out[] = (int) ($lval / $rval);
4222                      break;
4223  
4224                  case '==':
4225                      return $this->opEq($left, $right);
4226  
4227                  case '!=':
4228                      return $this->opNeq($left, $right);
4229  
4230                  default:
4231                      throw $this->error("color: unknown op $op");
4232              }
4233          }
4234  
4235          if (isset($left[4])) {
4236              $out[4] = $left[4];
4237          } elseif (isset($right[4])) {
4238              $out[4] = $right[4];
4239          }
4240  
4241          return $this->fixColor($out);
4242      }
4243  
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          }
4258  
4259          if ($op === '!=') {
4260              return static::$true;
4261          }
4262  
4263          $value = $right->getDimension();
4264  
4265          return $this->opColorColor(
4266              $op,
4267              $left,
4268              [Type::T_COLOR, $value, $value, $value]
4269          );
4270      }
4271  
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          }
4286  
4287          if ($op === '!=') {
4288              return static::$true;
4289          }
4290  
4291          $value = $left->getDimension();
4292  
4293          return $this->opColorColor(
4294              $op,
4295              [Type::T_COLOR, $value, $value, $value],
4296              $right
4297          );
4298      }
4299  
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] = '';
4313  
4314              $left = $this->compileValue($lStr);
4315              $right = $this->compileValue($rStr);
4316          }
4317  
4318          return $this->toBool($left === $right);
4319      }
4320  
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] = '';
4334  
4335              $left = $this->compileValue($lStr);
4336              $right = $this->compileValue($rStr);
4337          }
4338  
4339          return $this->toBool($left !== $right);
4340      }
4341  
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      }
4354  
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      }
4367  
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      }
4380  
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      }
4393  
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      }
4406  
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      }
4419  
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      }
4433  
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          }
4477  
4478          return $string;
4479      }
4480  
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);
4502  
4503          if ($value instanceof Number) {
4504              return $value->output($this);
4505          }
4506  
4507          switch ($value[0]) {
4508              case Type::T_KEYWORD:
4509                  return $this->escapeNonPrintableChars($value[1], true);
4510  
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;
4517  
4518                  $r = $this->compileRGBAValue($r);
4519                  $g = $this->compileRGBAValue($g);
4520                  $b = $this->compileRGBAValue($b);
4521  
4522                  if (\count($value) === 5) {
4523                      $alpha = $this->compileRGBAValue($value[4], true);
4524  
4525                      if (! is_numeric($alpha) || $alpha < 1) {
4526                          $colorName = Colors::RGBaToColorName($r, $g, $b, $alpha);
4527  
4528                          if (! \is_null($colorName)) {
4529                              return $colorName;
4530                          }
4531  
4532                          if (is_numeric($alpha)) {
4533                              $a = new Number($alpha, '');
4534                          } else {
4535                              $a = $alpha;
4536                          }
4537  
4538                          return 'rgba(' . $r . ', ' . $g . ', ' . $b . ', ' . $a . ')';
4539                      }
4540                  }
4541  
4542                  if (! is_numeric($r) || ! is_numeric($g) || ! is_numeric($b)) {
4543                      return 'rgb(' . $r . ', ' . $g . ', ' . $b . ')';
4544                  }
4545  
4546                  $colorName = Colors::RGBaToColorName($r, $g, $b);
4547  
4548                  if (! \is_null($colorName)) {
4549                      return $colorName;
4550                  }
4551  
4552                  $h = sprintf('#%02x%02x%02x', $r, $g, $b);
4553  
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                  }
4558  
4559                  return $h;
4560  
4561              case Type::T_STRING:
4562                  $content = $this->compileStringContent($value, $quote);
4563  
4564                  if ($value[1] && $quote) {
4565                      $content = str_replace('\\', '\\\\', $content);
4566  
4567                      $content = $this->escapeNonPrintableChars($content);
4568  
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                      }
4581  
4582                      $content = str_replace($value[1], '\\' . $value[1], $content);
4583                  }
4584  
4585                  return $value[1] . $content . $value[1];
4586  
4587              case Type::T_FUNCTION:
4588                  $args = ! empty($value[2]) ? $this->compileValue($value[2], $quote) : '';
4589  
4590                  return "$value[1]($args)";
4591  
4592              case Type::T_FUNCTION_REFERENCE:
4593                  $name = ! empty($value[2]) ? $value[2] : '';
4594  
4595                  return "get-function(\"$name\")";
4596  
4597              case Type::T_LIST:
4598                  $value = $this->extractInterpolation($value);
4599  
4600                  if ($value[0] !== Type::T_LIST) {
4601                      return $this->compileValue($value, $quote);
4602                  }
4603  
4604                  list(, $delim, $items) = $value;
4605                  $pre = $post = '';
4606  
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                  }
4624  
4625                  $separator = $delim === '/' ? ' /' : $delim;
4626  
4627                  $prefix_value = '';
4628  
4629                  if ($delim !== ' ') {
4630                      $prefix_value = ' ';
4631                  }
4632  
4633                  $filtered = [];
4634  
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                      }
4655  
4656                      $compiled = $this->compileValue($item, $quote);
4657  
4658                      if ($prefix_value && \strlen($compiled)) {
4659                          $compiled = $prefix_value . $compiled;
4660                      }
4661  
4662                      $filtered[] = $compiled;
4663                  }
4664  
4665                  return $pre . substr(implode($separator, $filtered), \strlen($prefix_value)) . $post;
4666  
4667              case Type::T_MAP:
4668                  $keys     = $value[1];
4669                  $values   = $value[2];
4670                  $filtered = [];
4671  
4672                  for ($i = 0, $s = \count($keys); $i < $s; $i++) {
4673                      $filtered[$this->compileValue($keys[$i], $quote)] = $this->compileValue($values[$i], $quote);
4674                  }
4675  
4676                  array_walk($filtered, function (&$value, $key) {
4677                      $value = $key . ': ' . $value;
4678                  });
4679  
4680                  return '(' . implode(', ', $filtered) . ')';
4681  
4682              case Type::T_INTERPOLATED:
4683                  // node created by extractInterpolation
4684                  list(, $interpolate, $left, $right) = $value;
4685                  list(,, $whiteLeft, $whiteRight) = $interpolate;
4686  
4687                  $delim = $left[1];
4688  
4689                  if ($delim && $delim !== ' ' && ! $whiteLeft) {
4690                      $delim .= ' ';
4691                  }
4692  
4693                  $left = \count($left[2]) > 0
4694                      ?  $this->compileValue($left, $quote) . $delim . $whiteLeft
4695                      : '';
4696  
4697                  $delim = $right[1];
4698  
4699                  if ($delim && $delim !== ' ') {
4700                      $delim .= ' ';
4701                  }
4702  
4703                  $right = \count($right[2]) > 0 ?
4704                      $whiteRight . $delim . $this->compileValue($right, $quote) : '';
4705  
4706                  return $left . $this->compileValue($interpolate, $quote) . $right;
4707  
4708              case Type::T_INTERPOLATE:
4709                  // strip quotes if it's a string
4710                  $reduced = $this->reduce($value[1]);
4711  
4712                  if ($reduced instanceof Number) {
4713                      return $this->compileValue($reduced, $quote);
4714                  }
4715  
4716                  switch ($reduced[0]) {
4717                      case Type::T_LIST:
4718                          $reduced = $this->extractInterpolation($reduced);
4719  
4720                          if ($reduced[0] !== Type::T_LIST) {
4721                              break;
4722                          }
4723  
4724                          list(, $delim, $items) = $reduced;
4725  
4726                          if ($delim !== ' ') {
4727                              $delim .= ' ';
4728                          }
4729  
4730                          $filtered = [];
4731  
4732                          foreach ($items as $item) {
4733                              if ($item[0] === Type::T_NULL) {
4734                                  continue;
4735                              }
4736  
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                          }
4745  
4746                          $reduced = [Type::T_KEYWORD, implode("$delim", $filtered)];
4747                          break;
4748  
4749                      case Type::T_STRING:
4750                          $reduced = [Type::T_STRING, '', [$this->compileStringContent($reduced)]];
4751                          break;
4752  
4753                      case Type::T_NULL:
4754                          $reduced = [Type::T_KEYWORD, ''];
4755                  }
4756  
4757                  return $this->compileValue($reduced, $quote);
4758  
4759              case Type::T_NULL:
4760                  return 'null';
4761  
4762              case Type::T_COMMENT:
4763                  return $this->compileCommentValue($value);
4764  
4765              default:
4766                  throw $this->error('unknown value type: ' . json_encode($value));
4767          }
4768      }
4769  
4770      /**
4771       * @param array|Number $value
4772       *
4773       * @return string
4774       */
4775      protected function compileDebugValue($value)
4776      {
4777          $value = $this->reduce($value, true);
4778  
4779          if ($value instanceof Number) {
4780              return $this->compileValue($value);
4781          }
4782  
4783          switch ($value[0]) {
4784              case Type::T_STRING:
4785                  return $this->compileStringContent($value);
4786  
4787              default:
4788                  return $this->compileValue($value);
4789          }
4790      }
4791  
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);
4804  
4805          return $this->compileValue($list);
4806      }
4807  
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          }
4823  
4824          return $this->compileStringContent($value);
4825      }
4826  
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 = [];
4838  
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          }
4846  
4847          return implode($parts);
4848      }
4849  
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];
4860  
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)];
4865  
4866                  return [Type::T_INTERPOLATED, $item, $before, $after];
4867              }
4868          }
4869  
4870          return $list;
4871      }
4872  
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 = [[]];
4886  
4887          $selfParentSelectors = null;
4888  
4889          if (! \is_null($selfParent) && $selfParent->selectors) {
4890              $selfParentSelectors = $this->evalSelectors($selfParent->selectors);
4891          }
4892  
4893          while ($env = array_pop($envs)) {
4894              if (empty($env->selectors)) {
4895                  continue;
4896              }
4897  
4898              $selectors = $env->selectors;
4899  
4900              do {
4901                  $stillHasSelf  = false;
4902                  $prevSelectors = $selectors;
4903                  $selectors     = [];
4904  
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);
4920  
4921              $parentSelectors = $selectors;
4922          }
4923  
4924          $selectors = array_values($selectors);
4925  
4926          // case we are just starting a at-root : nothing to multiply but parentSelectors
4927          if (! $selectors && $selfParentSelectors) {
4928              $selectors = $selfParentSelectors;
4929          }
4930  
4931          return $selectors;
4932      }
4933  
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
4941  
4942       * @return array
4943       */
4944      protected function joinSelectors($parent, $child, &$stillHasSelf, $selfParentSelectors = null)
4945      {
4946          $setSelf = false;
4947          $out = [];
4948  
4949          foreach ($child as $part) {
4950              $newPart = [];
4951  
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                  }
4957  
4958                  if ($p === static::$selfSelector && ! $setSelf) {
4959                      $setSelf = true;
4960  
4961                      if (\is_null($selfParentSelectors)) {
4962                          $selfParentSelectors = $parent;
4963                      }
4964  
4965                      foreach ($selfParentSelectors as $i => $parentPart) {
4966                          if ($i > 0) {
4967                              $out[] = $newPart;
4968                              $newPart = [];
4969                          }
4970  
4971                          foreach ($parentPart as $pp) {
4972                              if (\is_array($pp)) {
4973                                  $flatten = [];
4974  
4975                                  array_walk_recursive($pp, function ($a) use (&$flatten) {
4976                                      $flatten[] = $a;
4977                                  });
4978  
4979                                  $pp = implode($flatten);
4980                              }
4981  
4982                              $newPart[] = $pp;
4983                          }
4984                      }
4985                  } else {
4986                      $newPart[] = $p;
4987                  }
4988              }
4989  
4990              $out[] = $newPart;
4991          }
4992  
4993          return $setSelf ? $out : array_merge($parent, $child);
4994      }
4995  
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          }
5012  
5013          // plain old block, skip
5014          if (empty($env->block->type)) {
5015              return $this->multiplyMedia($env->parent, $childQueries);
5016          }
5017  
5018          assert($env->block instanceof MediaBlock);
5019  
5020          $parentQueries = isset($env->block->queryList)
5021              ? $env->block->queryList
5022              : [[[Type::T_MEDIA_VALUE, $env->block->value]]];
5023  
5024          $store = [$this->env, $this->storeEnv];
5025  
5026          $this->env      = $env;
5027          $this->storeEnv = null;
5028          $parentQueries  = $this->evaluateMediaQuery($parentQueries);
5029  
5030          list($this->env, $this->storeEnv) = $store;
5031  
5032          if (\is_null($childQueries)) {
5033              $childQueries = $parentQueries;
5034          } else {
5035              $originalQueries = $childQueries;
5036              $childQueries = [];
5037  
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          }
5048  
5049          return $this->multiplyMedia($env->parent, $childQueries);
5050      }
5051  
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          }
5066  
5067          return $envs;
5068      }
5069  
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          }
5085  
5086          return $env;
5087      }
5088  
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;
5104  
5105          $this->env = $env;
5106          $this->storeEnv = null;
5107  
5108          return $env;
5109      }
5110  
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      }
5121  
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      }
5138  
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      }
5148  
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);
5163  
5164          if (! isset($env)) {
5165              $env = $this->getStoreEnv();
5166          }
5167  
5168          if ($shadow) {
5169              $this->setRaw($name, $value, $env, $valueUnreduced);
5170          } else {
5171              $this->setExisting($name, $value, $env, $valueUnreduced);
5172          }
5173      }
5174  
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';
5189  
5190          $hasNamespace = $name[0] === '^' || $name[0] === '@' || $name[0] === '%';
5191  
5192          $maxDepth = 10000;
5193  
5194          for (;;) {
5195              if ($maxDepth-- <= 0) {
5196                  break;
5197              }
5198  
5199              if (\array_key_exists($name, $env->store)) {
5200                  break;
5201              }
5202  
5203              if (! $hasNamespace && isset($env->marker)) {
5204                  if (! empty($env->store[$specialContentKey])) {
5205                      $env = $env->store[$specialContentKey]->scope;
5206                      continue;
5207                  }
5208  
5209                  if (! empty($env->declarationScopeParent)) {
5210                      $env = $env->declarationScopeParent;
5211                      continue;
5212                  } else {
5213                      $env = $storeEnv;
5214                      break;
5215                  }
5216              }
5217  
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          }
5227  
5228          $env->store[$name] = $value;
5229  
5230          if ($valueUnreduced) {
5231              $env->storeUnreduced[$name] = $valueUnreduced;
5232          }
5233      }
5234  
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;
5248  
5249          if ($valueUnreduced) {
5250              $env->storeUnreduced[$name] = $valueUnreduced;
5251          }
5252      }
5253  
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';
5270  
5271          if (! isset($env)) {
5272              $env = $this->getStoreEnv();
5273          }
5274  
5275          $hasNamespace = $normalizedName[0] === '^' || $normalizedName[0] === '@' || $normalizedName[0] === '%';
5276  
5277          $maxDepth = 10000;
5278  
5279          for (;;) {
5280              if ($maxDepth-- <= 0) {
5281                  break;
5282              }
5283  
5284              if (\array_key_exists($normalizedName, $env->store)) {
5285                  if ($unreduced && isset($env->storeUnreduced[$normalizedName])) {
5286                      return $env->storeUnreduced[$normalizedName];
5287                  }
5288  
5289                  return $env->store[$normalizedName];
5290              }
5291  
5292              if (! $hasNamespace && isset($env->marker)) {
5293                  if (! empty($env->store[$specialContentKey])) {
5294                      $env = $env->store[$specialContentKey]->scope;
5295                      continue;
5296                  }
5297  
5298                  if (! empty($env->declarationScopeParent)) {
5299                      $env = $env->declarationScopeParent;
5300                  } else {
5301                      $env = $this->rootEnv;
5302                  }
5303                  continue;
5304              }
5305  
5306              if (isset($env->parentStore)) {
5307                  $env = $env->parentStore;
5308              } elseif (isset($env->parent)) {
5309                  $env = $env->parent;
5310              } else {
5311                  break;
5312              }
5313          }
5314  
5315          if ($shouldThrow) {
5316              throw $this->error("Undefined variable \$$name" . ($maxDepth <= 0 ? ' (infinite recursion)' : ''));
5317          }
5318  
5319          // found nothing
5320          return null;
5321      }
5322  
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      }
5335  
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          }
5348  
5349          $parser = $this->parserFactory(__METHOD__);
5350  
5351          foreach ($args as $name => $strValue) {
5352              if ($name[0] === '$') {
5353                  $name = substr($name, 1);
5354              }
5355  
5356              if (!\is_string($strValue) || ! $parser->parseValue($strValue, $value)) {
5357                  $value = $this->coerceValue($strValue);
5358              }
5359  
5360              $this->set($name, $value);
5361          }
5362      }
5363  
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      }
5376  
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;
5387  
5388          foreach ($variables as $name => $value) {
5389              if (!$value instanceof Number && !\is_array($value)) {
5390                  $triggerWarning = true;
5391              }
5392  
5393              $this->registeredVars[$name] = $value;
5394          }
5395  
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      }
5400  
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.');
5415  
5416          $this->addVariables($variables);
5417      }
5418  
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      }
5432  
5433      /**
5434       * Returns list of variables
5435       *
5436       * @api
5437       *
5438       * @return array
5439       */
5440      public function getVariables()
5441      {
5442          return $this->registeredVars;
5443      }
5444  
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      }
5460  
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      }
5472  
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      }
5488  
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          });
5504  
5505          $this->legacyCwdImportPath = \count($actualImportPaths) !== \count($paths);
5506  
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          }
5510  
5511          $this->importPaths = $actualImportPaths;
5512      }
5513  
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      }
5530  
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;
5548  
5549              case OutputStyle::COMPRESSED:
5550                  $this->configuredFormatter = Compressed::class;
5551                  break;
5552  
5553              default:
5554                  throw new \InvalidArgumentException(sprintf('Invalid output style "%s".', $style));
5555          }
5556      }
5557  
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);
5577  
5578          $this->configuredFormatter = $formatterName;
5579      }
5580  
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      }
5597  
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      }
5616  
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      }
5632  
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      }
5648  
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          }
5665  
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          }
5669  
5670          $this->userFunctions[$this->normalizeName($name)] = [$callback, $argumentDeclaration];
5671      }
5672  
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      }
5686  
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);
5701  
5702          $this->registeredFeatures[$name] = true;
5703      }
5704  
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);
5718  
5719          if ($realPath === false) {
5720              $realPath = $path;
5721          }
5722  
5723          if (substr($path, -5) === '.sass') {
5724              $this->sourceIndex = \count($this->sourceNames);
5725              $this->sourceNames[] = $path;
5726              $this->sourceLine = 1;
5727              $this->sourceColumn = 1;
5728  
5729              throw $this->error('The Sass indented syntax is not implemented.');
5730          }
5731  
5732          if (isset($this->importCache[$realPath])) {
5733              $this->handleImportLoop($realPath);
5734  
5735              $tree = $this->importCache[$realPath];
5736          } else {
5737              $code   = file_get_contents($path);
5738              $parser = $this->parserFactory($path);
5739              $tree   = $parser->parse($code);
5740  
5741              $this->importCache[$realPath] = $tree;
5742          }
5743  
5744          $currentDirectory = $this->currentDirectory;
5745          $this->currentDirectory = dirname($path);
5746  
5747          $this->compileChildrenNoReturn($tree->children, $out);
5748          $this->currentDirectory = $currentDirectory;
5749          $this->popCallStack();
5750      }
5751  
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      }
5765  
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      }
5782  
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                  }
5802  
5803                  if (\is_callable($dir)) {
5804                      // check custom callback for import path
5805                      $file = \call_user_func($dir, $url);
5806  
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);
5825  
5826                          return $file;
5827                      }
5828                  }
5829              }
5830              return null;
5831          }
5832  
5833          if (!\is_null($currentDir)) {
5834              $relativePath = $this->resolveImportPath($url, $currentDir);
5835  
5836              if (!\is_null($relativePath)) {
5837                  return $relativePath;
5838              }
5839          }
5840  
5841          foreach ($this->importPaths as $dir) {
5842              if (\is_string($dir)) {
5843                  $path = $this->resolveImportPath($url, $dir);
5844  
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);
5851  
5852                  if (! \is_null($file)) {
5853                      return $file;
5854                  }
5855              }
5856          }
5857  
5858          if ($this->legacyCwdImportPath) {
5859              $path = $this->resolveImportPath($url, getcwd());
5860  
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);
5863  
5864                  return $path;
5865              }
5866          }
5867  
5868          throw $this->error("`$url` file not found for @import");
5869      }
5870  
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);
5880  
5881          $hasExtension = preg_match('/.s[ac]ss$/', $url);
5882  
5883          if ($hasExtension) {
5884              return $this->checkImportPathConflicts($this->tryImportPath($path));
5885          }
5886  
5887          $result = $this->checkImportPathConflicts($this->tryImportPathWithExtensions($path));
5888  
5889          if (!\is_null($result)) {
5890              return $result;
5891          }
5892  
5893          return $this->tryImportPathAsDirectory($path);
5894      }
5895  
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          }
5906  
5907          if (\count($paths) === 1) {
5908              return $paths[0];
5909          }
5910  
5911          $formattedPrettyPaths = [];
5912  
5913          foreach ($paths as $path) {
5914              $formattedPrettyPaths[] = '  ' . $this->getPrettyPath($path);
5915          }
5916  
5917          throw $this->error("It's not clear which file to import. Found:\n" . implode("\n", $formattedPrettyPaths));
5918      }
5919  
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          );
5931  
5932          if ($result) {
5933              return $result;
5934          }
5935  
5936          return $this->tryImportPath($path.'.css');
5937      }
5938  
5939      /**
5940       * @param string $path
5941       *
5942       * @return string[]
5943       */
5944      private function tryImportPath($path)
5945      {
5946          $partial = dirname($path).'/_'.basename($path);
5947  
5948          $candidates = [];
5949  
5950          if (is_file($partial)) {
5951              $candidates[] = $partial;
5952          }
5953  
5954          if (is_file($path)) {
5955              $candidates[] = $path;
5956          }
5957  
5958          return $candidates;
5959      }
5960  
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          }
5971  
5972          return $this->checkImportPathConflicts($this->tryImportPathWithExtensions($path.'/index'));
5973      }
5974  
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          }
5985  
5986          $normalizedPath = $path;
5987          $normalizedRootDirectory = $this->rootDirectory.'/';
5988  
5989          if (\DIRECTORY_SEPARATOR === '\\') {
5990              $normalizedRootDirectory = str_replace('\\', '/', $normalizedRootDirectory);
5991              $normalizedPath = str_replace('\\', '/', $path);
5992          }
5993  
5994          if (0 === strpos($normalizedPath, $normalizedRootDirectory)) {
5995              return substr($path, \strlen($normalizedRootDirectory));
5996          }
5997  
5998          return $path;
5999      }
6000  
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          }
6019  
6020          $this->encoding = $encoding;
6021      }
6022  
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);
6037  
6038          return $this;
6039      }
6040  
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);
6053  
6054          $sourceFile = isset($this->sourceNames[$this->sourceIndex]) ? $this->sourceNames[$this->sourceIndex] : '';
6055  
6056          return [$sourceFile, $this->sourceLine, $this->sourceColumn];
6057      }
6058  
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          );
6078  
6079          throw $this->error(...func_get_args());
6080      }
6081  
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          }
6097  
6098          if (! $this->ignoreCallStackMessage) {
6099              $msg = $this->addLocationToMessage($msg);
6100          }
6101  
6102          return new CompilerException($msg);
6103      }
6104  
6105      /**
6106       * @param string $msg
6107       *
6108       * @return string
6109       */
6110      private function addLocationToMessage($msg)
6111      {
6112          $line   = $this->sourceLine;
6113          $column = $this->sourceColumn;
6114  
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";
6118  
6119          $msg = "$msg: $loc";
6120  
6121          $callStackMsg = $this->callStackMessage();
6122  
6123          if ($callStackMsg) {
6124              $msg .= "\nCall Stack:\n" . $callStackMsg;
6125          }
6126  
6127          return $msg;
6128      }
6129  
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);
6141  
6142          $nbExpected = \count($ExpectedArgs);
6143  
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 = [];
6153  
6154              while (count($ExpectedArgs) && count($ExpectedArgs) > $nbActual) {
6155                  array_unshift($missing, array_pop($ExpectedArgs));
6156              }
6157  
6158              return $this->error(
6159                  'Error: %s() argument%s %s missing.',
6160                  $functionName,
6161                  count($missing) > 1 ? 's' : '',
6162                  implode(', ', $missing)
6163              );
6164          }
6165      }
6166  
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;
6179  
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];
6188  
6189                      $callStackMsg[] = $msg;
6190  
6191                      if (! \is_null($limit) && $ncall > $limit) {
6192                          break;
6193                      }
6194                  }
6195              }
6196          }
6197  
6198          return implode("\n", $callStackMsg);
6199      }
6200  
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              }
6216  
6217              $file = $this->sourceNames[$env->block->sourceIndex];
6218  
6219              if ($file === null) {
6220                  continue;
6221              }
6222  
6223              if (realpath($file) === $name) {
6224                  throw $this->error('An @import loop has been found: %s imports %s', $file, basename($file));
6225              }
6226          }
6227      }
6228  
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;
6243  
6244          $this->pushEnv();
6245  
6246          // set the args
6247          if (isset($func->args)) {
6248              $this->applyArguments($func->args, $argValues);
6249          }
6250  
6251          // throw away lines and children
6252          $tmp = new OutputBlock();
6253          $tmp->lines    = [];
6254          $tmp->children = [];
6255  
6256          $this->env->marker = 'function';
6257  
6258          if (! empty($func->parentEnv)) {
6259              $this->env->declarationScopeParent = $func->parentEnv;
6260          } else {
6261              throw $this->error("@function $name() without parentEnv");
6262          }
6263  
6264          $ret = $this->compileChildren($func->children, $tmp, $this->env->marker . ' ' . $name);
6265  
6266          $this->popEnv();
6267  
6268          return ! isset($ret) ? static::$defaultValue : $ret;
6269      }
6270  
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);
6285  
6286          if (\is_null($sorted_kwargs)) {
6287              return null;
6288          }
6289          @list($sorted, $kwargs) = $sorted_kwargs;
6290  
6291          if ($name !== 'if') {
6292              foreach ($sorted as &$val) {
6293                  if ($val !== null) {
6294                      $val = $this->reduce($val, true);
6295                  }
6296              }
6297          }
6298  
6299          $returnValue = \call_user_func($function, $sorted, $kwargs);
6300  
6301          if (! isset($returnValue)) {
6302              return null;
6303          }
6304  
6305          if (\is_array($returnValue) || $returnValue instanceof Number) {
6306              return $returnValue;
6307          }
6308  
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);
6310  
6311          return $this->coerceValue($returnValue);
6312      }
6313  
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      }
6326  
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      }
6348  
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      }
6362  
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;
6375  
6376          if (! isset($prototypes)) {
6377              $keyArgs = [];
6378              $posArgs = [];
6379  
6380              if (\is_array($args) && \count($args) && \end($args) === static::$null) {
6381                  array_pop($args);
6382              }
6383  
6384              // separate positional and keyword arguments
6385              foreach ($args as $arg) {
6386                  list($key, $value) = $arg;
6387  
6388                  if (empty($key) or empty($key[1])) {
6389                      $posArgs[] = empty($arg[2]) ? $value : $arg;
6390                  } else {
6391                      $keyArgs[$key[1]] = $value;
6392                  }
6393              }
6394  
6395              return [$posArgs, $keyArgs];
6396          }
6397  
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          }
6410  
6411          list($positionalArgs, $namedArgs, $names, $separator, $hasSplat) = $this->evaluateArguments($args, false);
6412  
6413          if (! \is_array(reset($prototypes))) {
6414              $prototypes = [$prototypes];
6415          }
6416  
6417          $parsedPrototypes = array_map([$this, 'parseFunctionPrototype'], $prototypes);
6418          assert(!empty($parsedPrototypes));
6419          $matchedPrototype = $this->selectFunctionPrototype($parsedPrototypes, \count($positionalArgs), $names);
6420  
6421          $this->verifyPrototype($matchedPrototype, \count($positionalArgs), $names, $hasSplat);
6422  
6423          $vars = $this->applyArgumentsToDeclaration($matchedPrototype, $positionalArgs, $namedArgs, $separator);
6424  
6425          $finalArgs = [];
6426          $keyArgs = [];
6427  
6428          foreach ($matchedPrototype['arguments'] as $argument) {
6429              list($normalizedName, $originalName, $default) = $argument;
6430  
6431              if (isset($vars[$normalizedName])) {
6432                  $value = $vars[$normalizedName];
6433              } else {
6434                  $value = $default;
6435              }
6436  
6437              // special null value as default: translate to real null here
6438              if ($value === [Type::T_KEYWORD, 'null']) {
6439                  $value = null;
6440              }
6441  
6442              $finalArgs[] = $value;
6443              $keyArgs[$originalName] = $value;
6444          }
6445  
6446          if ($matchedPrototype['rest_argument'] !== null) {
6447              $value = $vars[$matchedPrototype['rest_argument']];
6448  
6449              $finalArgs[] = $value;
6450              $keyArgs[$matchedPrototype['rest_argument']] = $value;
6451          }
6452  
6453          return [$finalArgs, $keyArgs];
6454      }
6455  
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;
6475  
6476          $arguments = [];
6477          $restArgument = null;
6478  
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              }
6483  
6484              $default = null;
6485              $p = explode(':', $p, 2);
6486              $name = str_replace('_', '-', $p[0]);
6487  
6488              if (isset($p[1])) {
6489                  $defaultSource = trim($p[1]);
6490  
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                      }
6498  
6499                      $parser->parseValue($defaultSource, $default);
6500                  }
6501              }
6502  
6503              if (substr($name, -3) === '...') {
6504                  $restArgument = substr($name, 0, -3);
6505              } else {
6506                  $arguments[] = [$name, $p[0], $default];
6507              }
6508          }
6509  
6510          return [
6511              'arguments' => $arguments,
6512              'rest_argument' => $restArgument,
6513          ];
6514      }
6515  
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;
6536  
6537          foreach ($prototypes as $prototype) {
6538              // Ideally, find an exact match.
6539              if ($this->checkPrototypeMatches($prototype, $positional, $names)) {
6540                  return $prototype;
6541              }
6542  
6543              $mismatchDistance = \count($prototype['arguments']) - $positional;
6544  
6545              if ($minMismatchDistance !== null) {
6546                  if (abs($mismatchDistance) > abs($minMismatchDistance)) {
6547                      continue;
6548                  }
6549  
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              }
6556  
6557              $minMismatchDistance = $mismatchDistance;
6558              $fuzzyMatch = $prototype;
6559          }
6560  
6561          return $fuzzyMatch;
6562      }
6563  
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;
6582  
6583          foreach ($prototype['arguments'] as $i => $argument) {
6584              list ($name, $originalName, $default) = $argument;
6585  
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          }
6596  
6597          if ($prototype['rest_argument'] !== null) {
6598              return true;
6599          }
6600  
6601          if ($positional > \count($prototype['arguments'])) {
6602              return false;
6603          }
6604  
6605          if ($nameUsed < \count($names)) {
6606              return false;
6607          }
6608  
6609          return true;
6610      }
6611  
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;
6629  
6630          foreach ($prototype['arguments'] as $i => $argument) {
6631              list ($name, $originalName, $default) = $argument;
6632  
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          }
6643  
6644          if ($prototype['rest_argument'] !== null) {
6645              return;
6646          }
6647  
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              }
6660  
6661              $message = $this->addLocationToMessage($message);
6662              $message .= "\nThis will be an error in future versions of Sass.";
6663              $this->logger->warn($message, true);
6664          }
6665  
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      }
6678  
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          }
6704  
6705          $splatSeparator = null;
6706          $keywordArgs = [];
6707          $names = [];
6708          $positionalArgs = [];
6709          $hasKeywordArgument = false;
6710          $hasSplat = false;
6711  
6712          foreach ($args as $arg) {
6713              if (!empty($arg[0])) {
6714                  $hasKeywordArgument = true;
6715  
6716                  assert(\is_string($arg[0][1]));
6717                  $name = str_replace('_', '-', $arg[0][1]);
6718  
6719                  if (isset($keywordArgs[$name])) {
6720                      throw new SassScriptException(sprintf('Duplicate named argument $%s.', $arg[0][1]));
6721                  }
6722  
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;
6729  
6730                  if ($val[0] === Type::T_LIST) {
6731                      foreach ($val[2] as $item) {
6732                          if (\is_null($splatSeparator)) {
6733                              $splatSeparator = $val[1];
6734                          }
6735  
6736                          $positionalArgs[] = $this->maybeReduce($reduce, $item);
6737                      }
6738  
6739                      if (isset($val[3]) && \is_array($val[3])) {
6740                          foreach ($val[3] as $name => $item) {
6741                              assert(\is_string($name));
6742  
6743                              $normalizedName = str_replace('_', '-', $name);
6744  
6745                              if (isset($keywordArgs[$normalizedName])) {
6746                                  throw new SassScriptException(sprintf('Duplicate named argument $%s.', $name));
6747                              }
6748  
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];
6758  
6759                          if (! is_numeric($name)) {
6760                              $normalizedName = str_replace('_', '-', $name);
6761  
6762                              if (isset($keywordArgs[$normalizedName])) {
6763                                  throw new SassScriptException(sprintf('Duplicate named argument $%s.', $name));
6764                              }
6765  
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                              }
6773  
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          }
6786  
6787          return [$positionalArgs, $keywordArgs, $names, $splatSeparator, $hasSplat];
6788      }
6789  
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          }
6801  
6802          return $value;
6803      }
6804  
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 = [];
6822  
6823          if (\is_null($argValues)) {
6824              $argValues = [];
6825          }
6826  
6827          if ($storeInEnv) {
6828              $storeEnv = $this->getStoreEnv();
6829  
6830              $env = new Environment();
6831              $env->store = $storeEnv->store;
6832          }
6833  
6834          $prototype = ['arguments' => [], 'rest_argument' => null];
6835          $originalRestArgumentName = null;
6836  
6837          foreach ($argDef as $arg) {
6838              list($name, $default, $isVariable) = $arg;
6839              $normalizedName = str_replace('_', '-', $name);
6840  
6841              if ($isVariable) {
6842                  $originalRestArgumentName = $name;
6843                  $prototype['rest_argument'] = $normalizedName;
6844              } else {
6845                  $prototype['arguments'][] = [$normalizedName, $name, !empty($default) ? $default : null];
6846              }
6847          }
6848  
6849          list($positionalArgs, $namedArgs, $names, $splatSeparator, $hasSplat) = $this->evaluateArguments($argValues, $reduce);
6850  
6851          $this->verifyPrototype($prototype, \count($positionalArgs), $names, $hasSplat);
6852  
6853          $vars = $this->applyArgumentsToDeclaration($prototype, $positionalArgs, $namedArgs, $splatSeparator);
6854  
6855          foreach ($prototype['arguments'] as $argument) {
6856              list($normalizedName, $name) = $argument;
6857  
6858              if (!isset($vars[$normalizedName])) {
6859                  continue;
6860              }
6861  
6862              $val = $vars[$normalizedName];
6863  
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          }
6870  
6871          if ($prototype['rest_argument'] !== null) {
6872              assert($originalRestArgumentName !== null);
6873              $name = $originalRestArgumentName;
6874              $val = $vars[$prototype['rest_argument']];
6875  
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          }
6882  
6883          if ($storeInEnv) {
6884              $storeEnv->store = $env->store;
6885          }
6886  
6887          foreach ($prototype['arguments'] as $argument) {
6888              list($normalizedName, $name, $default) = $argument;
6889  
6890              if (isset($vars[$normalizedName])) {
6891                  continue;
6892              }
6893              assert($default !== null);
6894  
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          }
6901  
6902          return $output;
6903      }
6904  
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']));
6930  
6931          for ($i = 0; $i < $minLength; $i++) {
6932              list($name) = $prototype['arguments'][$i];
6933              $val = $positionalArgs[$i];
6934  
6935              $output[$name] = $val;
6936          }
6937  
6938          $restNamed = $namedArgs;
6939  
6940          for ($i = \count($positionalArgs); $i < \count($prototype['arguments']); $i++) {
6941              $argument = $prototype['arguments'][$i];
6942              list($name) = $argument;
6943  
6944              if (isset($namedArgs[$name])) {
6945                  $val = $namedArgs[$name];
6946                  unset($restNamed[$name]);
6947              } else {
6948                  continue;
6949              }
6950  
6951              $output[$name] = $val;
6952          }
6953  
6954          if ($prototype['rest_argument'] !== null) {
6955              $name = $prototype['rest_argument'];
6956              $rest = array_values(array_slice($positionalArgs, \count($prototype['arguments'])));
6957  
6958              $val = [Type::T_LIST, \is_null($splatSeparator) ? ',' : $splatSeparator , $rest, $restNamed];
6959  
6960              $output[$name] = $val;
6961          }
6962  
6963          return $output;
6964      }
6965  
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          }
6978  
6979          if (\is_bool($value)) {
6980              return $this->toBool($value);
6981          }
6982  
6983          if (\is_null($value)) {
6984              return static::$null;
6985          }
6986  
6987          if (is_numeric($value)) {
6988              return new Number($value, '');
6989          }
6990  
6991          if ($value === '') {
6992              return static::$emptyString;
6993          }
6994  
6995          $value = [Type::T_KEYWORD, $value];
6996          $color = $this->coerceColor($value);
6997  
6998          if ($color) {
6999              return $color;
7000          }
7001  
7002          return $value;
7003      }
7004  
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          }
7017  
7018          if ($item[0] === Type::T_MAP) {
7019              return $item;
7020          }
7021  
7022          if (
7023              $item[0] === Type::T_LIST &&
7024              $item[2] === []
7025          ) {
7026              return static::$emptyMap;
7027          }
7028  
7029          return null;
7030      }
7031  
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);
7042  
7043          if ($map !== null) {
7044              return $map;
7045          }
7046  
7047          return $item;
7048      }
7049  
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          }
7064  
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              }
7070  
7071              return $item;
7072          }
7073  
7074          if ($item[0] === Type::T_MAP) {
7075              $keys = $item[1];
7076              $values = $item[2];
7077              $list = [];
7078  
7079              for ($i = 0, $s = \count($keys); $i < $s; $i++) {
7080                  $key = $keys[$i];
7081                  $value = $values[$i];
7082  
7083                  $list[] = [
7084                      Type::T_LIST,
7085                      ' ',
7086                      [$key, $value]
7087                  ];
7088              }
7089  
7090              return [Type::T_LIST, $list ? ',' : '', $list];
7091          }
7092  
7093          return [Type::T_LIST, '', [$item]];
7094      }
7095  
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          }
7108  
7109          return $value;
7110      }
7111  
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          }
7125  
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]);
7131  
7132                          if (! is_numeric($cv)) {
7133                              return null;
7134                          }
7135  
7136                          $value[$i] = $cv;
7137                      }
7138  
7139                      if (isset($value[4])) {
7140                          if (! is_numeric($value[4])) {
7141                              $cv = $this->compileRGBAValue($value[4], true);
7142  
7143                              if (! is_numeric($cv)) {
7144                                  return null;
7145                              }
7146  
7147                              $value[4] = $cv;
7148                          }
7149                      }
7150                  }
7151  
7152                  return $value;
7153  
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);
7159  
7160                          return $this->coerceColor($color);
7161                      }
7162                  }
7163  
7164                  return null;
7165  
7166              case Type::T_KEYWORD:
7167                  if (! \is_string($value[1])) {
7168                      return null;
7169                  }
7170  
7171                  $name = strtolower($value[1]);
7172  
7173                  // hexa color?
7174                  if (preg_match('/^#([0-9a-f]+)$/i', $name, $m)) {
7175                      $nofValues = \strlen($m[1]);
7176  
7177                      if (\in_array($nofValues, [3, 4, 6, 8])) {
7178                          $nbChannels = 3;
7179                          $color      = [];
7180                          $num        = hexdec($m[1]);
7181  
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                                  }
7192  
7193                                  break;
7194  
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                                  }
7203  
7204                                  break;
7205                          }
7206  
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                          }
7214  
7215                          array_unshift($color, Type::T_COLOR);
7216  
7217                          return $color;
7218                      }
7219                  }
7220  
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                  }
7226  
7227                  return null;
7228          }
7229  
7230          return null;
7231      }
7232  
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          }
7244  
7245          return $this->compileColorPartValue($value, 0, 255, true);
7246      }
7247  
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);
7261  
7262                  if ($reduced instanceof Number) {
7263                      $value = $reduced;
7264                  }
7265              }
7266  
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                  }
7275  
7276                  $value = $num;
7277              } elseif (\is_array($value)) {
7278                  $value = $this->compileValue($value);
7279              }
7280          }
7281  
7282          if (is_numeric($value)) {
7283              if ($isInt) {
7284                  $value = round($value);
7285              }
7286  
7287              $value = min($max, max($min, $value));
7288  
7289              return $value;
7290          }
7291  
7292          return $value;
7293      }
7294  
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));
7306  
7307              return $value;
7308          }
7309  
7310          return [Type::T_STRING, '', [$this->compileValue($value)]];
7311      }
7312  
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          }
7336  
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          }
7341  
7342          return $this->coerceString($value);
7343      }
7344  
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);
7357  
7358          if ($value instanceof Number) {
7359              if ($value->hasUnit('%')) {
7360                  return $value->getDimension() / 100;
7361              }
7362  
7363              return $value->getDimension();
7364          }
7365  
7366          return 0;
7367      }
7368  
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);
7384  
7385          if ($map === null) {
7386              $value = $this->compileValue($value);
7387  
7388              throw SassScriptException::forArgument("$value is not a map.", $varName);
7389          }
7390  
7391          return $map;
7392      }
7393  
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));
7411  
7412          return $value;
7413      }
7414  
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          }
7432  
7433          return $value[3];
7434      }
7435  
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          }
7453  
7454          $value = $this->compileValue($value);
7455  
7456          throw SassScriptException::forArgument("$value is not a color.", $varName);
7457      }
7458  
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          }
7477  
7478          return $value;
7479      }
7480  
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          }
7499  
7500          return intval($value);
7501      }
7502  
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      }
7520  
7521  
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              }
7535  
7536              if ($c[$i] > 255) {
7537                  $c[$i] = 255;
7538              }
7539  
7540              if (!\is_int($c[$i])) {
7541                  $c[$i] = round($c[$i]);
7542              }
7543          }
7544  
7545          return $c;
7546      }
7547  
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);
7563  
7564          $l = $min + $max;
7565          $d = $max - $min;
7566  
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              }
7575  
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          }
7584  
7585          return [Type::T_HSL, fmod($h + 360, 360), $s * 100, $l / 5.1];
7586      }
7587  
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          }
7604  
7605          if ($h * 6 < 1) {
7606              return $m1 + ($m2 - $m1) * $h * 6;
7607          }
7608  
7609          if ($h * 2 < 1) {
7610              return $m2;
7611          }
7612  
7613          if ($h * 3 < 2) {
7614              return $m1 + ($m2 - $m1) * (2 / 3 - $h) * 6;
7615          }
7616  
7617          return $m1;
7618      }
7619  
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          }
7636  
7637          $h = $hue / 360;
7638          $s = min(100, max(0, $saturation)) / 100;
7639          $l = min(100, max(0, $lightness)) / 100;
7640  
7641          $m2 = $l <= 0.5 ? $l * ($s + 1) : $l + $s - $l * $s;
7642          $m1 = $l * 2 - $m2;
7643  
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;
7647  
7648          $out = [Type::T_COLOR, $r, $g, $b];
7649  
7650          return $out;
7651      }
7652  
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;
7669  
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);
7676  
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          }
7682  
7683          return $rgb;
7684      }
7685  
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);
7701  
7702          $d = $max - $min;
7703  
7704          if ((int) $d === 0) {
7705              $h = 0;
7706          } else {
7707  
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          }
7716  
7717          return [Type::T_HWB, fmod($h, 360), $min / 255 * 100, 100 - $max / 255 *100];
7718      }
7719  
7720  
7721      // Built in functions
7722  
7723      protected static $libCall = ['function', 'args...'];
7724      protected function libCall($args)
7725      {
7726          $functionReference = $args[0];
7727  
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          }
7735  
7736          if ($functionReference === static::$null) {
7737              return static::$null;
7738          }
7739  
7740          if (! in_array($functionReference[0], [Type::T_FUNCTION_REFERENCE, Type::T_FUNCTION])) {
7741              throw $this->error('Function reference expected, got ' . $functionReference[0]);
7742          }
7743  
7744          $callArgs = [
7745              [null, $args[1], true]
7746          ];
7747  
7748          return $this->reduce([Type::T_FUNCTION_CALL, $functionReference, $callArgs]);
7749      }
7750  
7751  
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;
7760  
7761          if (count($args)) {
7762              $isCss = array_shift($args);
7763              $isCss = (($isCss === static::$true) ? true : false);
7764          }
7765  
7766          if ($isCss) {
7767              return [Type::T_FUNCTION, $name, [Type::T_LIST, ',', []]];
7768          }
7769  
7770          return $this->getFunctionReference($name, true);
7771      }
7772  
7773      protected static $libIf = ['condition', 'if-true', 'if-false:'];
7774      protected function libIf($args)
7775      {
7776          list($cond, $t, $f) = $args;
7777  
7778          if (! $this->isTruthy($this->reduce($cond, true))) {
7779              return $this->reduce($f, true);
7780          }
7781  
7782          return $this->reduce($t, true);
7783      }
7784  
7785      protected static $libIndex = ['list', 'value'];
7786      protected function libIndex($args)
7787      {
7788          list($list, $value) = $args;
7789  
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          }
7798  
7799          if ($list[0] !== Type::T_LIST) {
7800              return static::$null;
7801          }
7802  
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);
7811  
7812                  if ($itemValue instanceof Number && $value->equals($itemValue)) {
7813                      return new Number($key, '');
7814                  }
7815              }
7816              return static::$null;
7817          }
7818  
7819          $values = [];
7820  
7821          foreach ($list[2] as $item) {
7822              $values[] = $this->normalizeValue($item);
7823          }
7824  
7825          $key = array_search($this->normalizeValue($value), $values);
7826  
7827          return false === $key ? static::$null : new Number($key + 1, '');
7828      }
7829  
7830      protected static $libRgb = [
7831          ['color'],
7832          ['color', 'alpha'],
7833          ['channels'],
7834          ['red', 'green', 'blue'],
7835          ['red', 'green', 'blue', 'alpha'] ];
7836  
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;
7852  
7853              case 3:
7854                  $color = [Type::T_COLOR, $args[0], $args[1], $args[2]];
7855  
7856                  if (! $color = $this->coerceColor($color)) {
7857                      $color = [Type::T_STRING, '', [$funcName . '(', $args[0], ', ', $args[1], ', ', $args[2], ')']];
7858                  }
7859  
7860                  return $color;
7861  
7862              case 2:
7863                  if ($color = $this->coerceColor($args[0], true)) {
7864                      $alpha = $this->compileRGBAValue($args[1], true);
7865  
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;
7876  
7877              case 4:
7878              default:
7879                  $color = [Type::T_COLOR, $args[0], $args[1], $args[2], $args[3]];
7880  
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          }
7887  
7888          return $color;
7889      }
7890  
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      }
7901  
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');
7916  
7917          if ($args[1][2]) {
7918              throw new SassScriptException('Only one positional argument is allowed. All other arguments must be passed by name.');
7919          }
7920  
7921          $kwargs = $this->getArgumentListKeywords($args[1]);
7922  
7923          $scale = $operation === 'scale';
7924          $change = $operation === 'change';
7925  
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              }
7931  
7932              $number = $this->assertNumber($kwargs[$name], $name);
7933              unset($kwargs[$name]);
7934  
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              }
7941  
7942              if ($scale || $assertPercent) {
7943                  $number->assertUnit('%', $name);
7944              }
7945  
7946              if ($scale) {
7947                  $max = 100;
7948              }
7949  
7950              if ($scale || $assertPercent) {
7951                  return $number->valueInRange($change ? 0 : -$max, $max, $name);
7952              }
7953  
7954              return $number->valueInRangeWithUnit($change ? 0 : -$max, $max, $name, $checkPercent ? '%' : '');
7955          };
7956  
7957          $alpha = $getParam('alpha', 1);
7958          $red = $getParam('red', 255);
7959          $green = $getParam('green', 255);
7960          $blue = $getParam('blue', 255);
7961  
7962          if ($scale || !isset($kwargs['hue'])) {
7963              $hue = null;
7964          } else {
7965              $hueNumber = $this->assertNumber($kwargs['hue'], 'hue');
7966              unset($kwargs['hue']);
7967              $hue = $hueNumber->getDimension();
7968          }
7969          $saturation = $getParam('saturation', 100, true);
7970          $lightness = $getParam('lightness', 100, true);
7971          $whiteness = $getParam('whiteness', 100, false, true);
7972          $blackness = $getParam('blackness', 100, false, true);
7973  
7974          if (!empty($kwargs)) {
7975              $unknownNames = array_keys($kwargs);
7976              $lastName = array_pop($unknownNames);
7977              $message = sprintf(
7978                  'No argument%s named $%s%s.',
7979                  $unknownNames ? 's' : '',
7980                  $unknownNames ? implode(', $', $unknownNames) . ' or $' : '',
7981                  $lastName
7982              );
7983              throw new SassScriptException($message);
7984          }
7985  
7986          $hasRgb = $red !== null || $green !== null || $blue !== null;
7987          $hasSL = $saturation !== null || $lightness !== null;
7988          $hasWB = $whiteness !== null || $blackness !== null;
7989  
7990          if ($hasRgb && ($hasSL || $hasWB || $hue !== null)) {
7991              throw new SassScriptException(sprintf('RGB parameters may not be passed along with %s parameters.', $hasWB ? 'HWB' : 'HSL'));
7992          }
7993  
7994          if ($hasWB && $hasSL) {
7995              throw new SassScriptException('HSL parameters may not be passed along with HWB parameters.');
7996          }
7997  
7998          if ($hasRgb) {
7999              $color[1] = round($fn($color[1], $red, 255));
8000              $color[2] = round($fn($color[2], $green, 255));
8001              $color[3] = round($fn($color[3], $blue, 255));
8002          } elseif ($hasWB) {
8003              $hwb = $this->RGBtoHWB($color[1], $color[2], $color[3]);
8004              if ($hue !== null) {
8005                  $hwb[1] = $change ? $hue : $hwb[1] + $hue;
8006              }
8007              $hwb[2] = $fn($hwb[2], $whiteness, 100);
8008              $hwb[3] = $fn($hwb[3], $blackness, 100);
8009  
8010              $rgb = $this->HWBtoRGB($hwb[1], $hwb[2], $hwb[3]);
8011  
8012              if (isset($color[4])) {
8013                  $rgb[4] = $color[4];
8014              }
8015  
8016              $color = $rgb;
8017          } elseif ($hue !== null || $hasSL) {
8018              $hsl = $this->toHSL($color[1], $color[2], $color[3]);
8019  
8020              if ($hue !== null) {
8021                  $hsl[1] = $change ? $hue : $hsl[1] + $hue;
8022              }
8023              $hsl[2] = $fn($hsl[2], $saturation, 100);
8024              $hsl[3] = $fn($hsl[3], $lightness, 100);
8025  
8026              $rgb = $this->toRGB($hsl[1], $hsl[2], $hsl[3]);
8027  
8028              if (isset($color[4])) {
8029                  $rgb[4] = $color[4];
8030              }
8031  
8032              $color = $rgb;
8033          }
8034  
8035          if ($alpha !== null) {
8036              $existingAlpha = isset($color[4]) ? $color[4] : 1;
8037              $color[4] = $fn($existingAlpha, $alpha, 1);
8038          }
8039  
8040          return $color;
8041      }
8042  
8043      protected static $libAdjustColor = ['color', 'kwargs...'];
8044      protected function libAdjustColor($args)
8045      {
8046          return $this->alterColor($args, 'adjust', function ($base, $alter, $max) {
8047              if ($alter === null) {
8048                  return $base;
8049              }
8050  
8051              $new = $base + $alter;
8052  
8053              if ($new < 0) {
8054                  return 0;
8055              }
8056  
8057              if ($new > $max) {
8058                  return $max;
8059              }
8060  
8061              return $new;
8062          });
8063      }
8064  
8065      protected static $libChangeColor = ['color', 'kwargs...'];
8066      protected function libChangeColor($args)
8067      {
8068          return $this->alterColor($args,'change', function ($base, $alter, $max) {
8069              if ($alter === null) {
8070                  return $base;
8071              }
8072  
8073              return $alter;
8074          });
8075      }
8076  
8077      protected static $libScaleColor = ['color', 'kwargs...'];
8078      protected function libScaleColor($args)
8079      {
8080          return $this->alterColor($args, 'scale', function ($base, $scale, $max) {
8081              if ($scale === null) {
8082                  return $base;
8083              }
8084  
8085              $scale = $scale / 100;
8086  
8087              if ($scale < 0) {
8088                  return $base * $scale + $base;
8089              }
8090  
8091              return ($max - $base) * $scale + $base;
8092          });
8093      }
8094  
8095      protected static $libIeHexStr = ['color'];
8096      protected function libIeHexStr($args)
8097      {
8098          $color = $this->coerceColor($args[0]);
8099  
8100          if (\is_null($color)) {
8101              throw $this->error('Error: argument `$color` of `ie-hex-str($color)` must be a color');
8102          }
8103  
8104          $color[4] = isset($color[4]) ? round(255 * $color[4]) : 255;
8105  
8106          return [Type::T_STRING, '', [sprintf('#%02X%02X%02X%02X', $color[4], $color[1], $color[2], $color[3])]];
8107      }
8108  
8109      protected static $libRed = ['color'];
8110      protected function libRed($args)
8111      {
8112          $color = $this->coerceColor($args[0]);
8113  
8114          if (\is_null($color)) {
8115              throw $this->error('Error: argument `$color` of `red($color)` must be a color');
8116          }
8117  
8118          return new Number((int) $color[1], '');
8119      }
8120  
8121      protected static $libGreen = ['color'];
8122      protected function libGreen($args)
8123      {
8124          $color = $this->coerceColor($args[0]);
8125  
8126          if (\is_null($color)) {
8127              throw $this->error('Error: argument `$color` of `green($color)` must be a color');
8128          }
8129  
8130          return new Number((int) $color[2], '');
8131      }
8132  
8133      protected static $libBlue = ['color'];
8134      protected function libBlue($args)
8135      {
8136          $color = $this->coerceColor($args[0]);
8137  
8138          if (\is_null($color)) {
8139              throw $this->error('Error: argument `$color` of `blue($color)` must be a color');
8140          }
8141  
8142          return new Number((int) $color[3], '');
8143      }
8144  
8145      protected static $libAlpha = ['color'];
8146      protected function libAlpha($args)
8147      {
8148          if ($color = $this->coerceColor($args[0])) {
8149              return new Number(isset($color[4]) ? $color[4] : 1, '');
8150          }
8151  
8152          // this might be the IE function, so return value unchanged
8153          return null;
8154      }
8155  
8156      protected static $libOpacity = ['color'];
8157      protected function libOpacity($args)
8158      {
8159          $value = $args[0];
8160  
8161          if ($value instanceof Number) {
8162              return null;
8163          }
8164  
8165          return $this->libAlpha($args);
8166      }
8167  
8168      // mix two colors
8169      protected static $libMix = [
8170          ['color1', 'color2', 'weight:50%'],
8171          ['color-1', 'color-2', 'weight:50%']
8172          ];
8173      protected function libMix($args)
8174      {
8175          list($first, $second, $weight) = $args;
8176  
8177          $first = $this->assertColor($first, 'color1');
8178          $second = $this->assertColor($second, 'color2');
8179          $weightScale = $this->assertNumber($weight, 'weight')->valueInRange(0, 100, 'weight') / 100;
8180  
8181          $firstAlpha = isset($first[4]) ? $first[4] : 1;
8182          $secondAlpha = isset($second[4]) ? $second[4] : 1;
8183  
8184          $normalizedWeight = $weightScale * 2 - 1;
8185          $alphaDistance = $firstAlpha - $secondAlpha;
8186  
8187          $combinedWeight = $normalizedWeight * $alphaDistance == -1 ? $normalizedWeight : ($normalizedWeight + $alphaDistance) / (1 + $normalizedWeight * $alphaDistance);
8188          $weight1 = ($combinedWeight + 1) / 2.0;
8189          $weight2 = 1.0 - $weight1;
8190  
8191          $new = [Type::T_COLOR,
8192              $weight1 * $first[1] + $weight2 * $second[1],
8193              $weight1 * $first[2] + $weight2 * $second[2],
8194              $weight1 * $first[3] + $weight2 * $second[3],
8195          ];
8196  
8197          if ($firstAlpha != 1.0 || $secondAlpha != 1.0) {
8198              $new[] = $firstAlpha * $weightScale + $secondAlpha * (1 - $weightScale);
8199          }
8200  
8201          return $this->fixColor($new);
8202      }
8203  
8204      protected static $libHsl = [
8205          ['channels'],
8206          ['hue', 'saturation'],
8207          ['hue', 'saturation', 'lightness'],
8208          ['hue', 'saturation', 'lightness', 'alpha'] ];
8209  
8210      /**
8211       * @param array $args
8212       * @param array $kwargs
8213       * @param string $funcName
8214       *
8215       * @return array|null
8216       */
8217      protected function libHsl($args, $kwargs, $funcName = 'hsl')
8218      {
8219          $args_to_check = $args;
8220  
8221          if (\count($args) == 1) {
8222              if ($args[0][0] !== Type::T_LIST || \count($args[0][2]) < 3 || \count($args[0][2]) > 4) {
8223                  return [Type::T_STRING, '', [$funcName . '(', $args[0], ')']];
8224              }
8225  
8226              $args = $args[0][2];
8227              $args_to_check = $kwargs['channels'][2];
8228          }
8229  
8230          if (\count($args) === 2) {
8231              // if var() is used as an argument, return as a css function
8232              foreach ($args as $arg) {
8233                  if ($arg[0] === Type::T_FUNCTION && in_array($arg[1], ['var'])) {
8234                      return null;
8235                  }
8236              }
8237  
8238              throw new SassScriptException('Missing argument $lightness.');
8239          }
8240  
8241          foreach ($kwargs as $arg) {
8242              if (in_array($arg[0], [Type::T_FUNCTION_CALL, Type::T_FUNCTION]) && in_array($arg[1], ['min', 'max'])) {
8243                  return null;
8244              }
8245          }
8246  
8247          foreach ($args_to_check as $k => $arg) {
8248              if (in_array($arg[0], [Type::T_FUNCTION_CALL, Type::T_FUNCTION]) && in_array($arg[1], ['min', 'max'])) {
8249                  if (count($kwargs) > 1 || ($k >= 2 && count($args) === 4)) {
8250                      return null;
8251                  }
8252  
8253                  $args[$k] = $this->stringifyFncallArgs($arg);
8254              }
8255  
8256              if (
8257                  $k >= 2 && count($args) === 4 &&
8258                  in_array($arg[0], [Type::T_FUNCTION_CALL, Type::T_FUNCTION]) &&
8259                  in_array($arg[1], ['calc','env'])
8260              ) {
8261                  return null;
8262              }
8263          }
8264  
8265          $hue = $this->reduce($args[0]);
8266          $saturation = $this->reduce($args[1]);
8267          $lightness = $this->reduce($args[2]);
8268          $alpha = null;
8269  
8270          if (\count($args) === 4) {
8271              $alpha = $this->compileColorPartValue($args[3], 0, 100, false);
8272  
8273              if (!$hue instanceof Number || !$saturation instanceof Number || ! $lightness instanceof Number || ! is_numeric($alpha)) {
8274                  return [Type::T_STRING, '',
8275                      [$funcName . '(', $args[0], ', ', $args[1], ', ', $args[2], ', ', $args[3], ')']];
8276              }
8277          } else {
8278              if (!$hue instanceof Number || !$saturation instanceof Number || ! $lightness instanceof Number) {
8279                  return [Type::T_STRING, '', [$funcName . '(', $args[0], ', ', $args[1], ', ', $args[2], ')']];
8280              }
8281          }
8282  
8283          $hueValue = fmod($hue->getDimension(), 360);
8284  
8285          while ($hueValue < 0) {
8286              $hueValue += 360;
8287          }
8288  
8289          $color = $this->toRGB($hueValue, max(0, min($saturation->getDimension(), 100)), max(0, min($lightness->getDimension(), 100)));
8290  
8291          if (! \is_null($alpha)) {
8292              $color[4] = $alpha;
8293          }
8294  
8295          return $color;
8296      }
8297  
8298      protected static $libHsla = [
8299              ['channels'],
8300              ['hue', 'saturation'],
8301              ['hue', 'saturation', 'lightness'],
8302              ['hue', 'saturation', 'lightness', 'alpha']];
8303      protected function libHsla($args, $kwargs)
8304      {
8305          return $this->libHsl($args, $kwargs, 'hsla');
8306      }
8307  
8308      protected static $libHue = ['color'];
8309      protected function libHue($args)
8310      {
8311          $color = $this->assertColor($args[0], 'color');
8312          $hsl = $this->toHSL($color[1], $color[2], $color[3]);
8313  
8314          return new Number($hsl[1], 'deg');
8315      }
8316  
8317      protected static $libSaturation = ['color'];
8318      protected function libSaturation($args)
8319      {
8320          $color = $this->assertColor($args[0], 'color');
8321          $hsl = $this->toHSL($color[1], $color[2], $color[3]);
8322  
8323          return new Number($hsl[2], '%');
8324      }
8325  
8326      protected static $libLightness = ['color'];
8327      protected function libLightness($args)
8328      {
8329          $color = $this->assertColor($args[0], 'color');
8330          $hsl = $this->toHSL($color[1], $color[2], $color[3]);
8331  
8332          return new Number($hsl[3], '%');
8333      }
8334  
8335      /*
8336       * Todo : a integrer dans le futur module color
8337      protected static $libHwb = [
8338          ['channels'],
8339          ['hue', 'whiteness', 'blackness'],
8340          ['hue', 'whiteness', 'blackness', 'alpha'] ];
8341      protected function libHwb($args, $kwargs, $funcName = 'hwb')
8342      {
8343          $args_to_check = $args;
8344  
8345          if (\count($args) == 1) {
8346              if ($args[0][0] !== Type::T_LIST) {
8347                  throw $this->error("Missing elements \$whiteness and \$blackness");
8348              }
8349  
8350              if (\trim($args[0][1])) {
8351                  throw $this->error("\$channels must be a space-separated list.");
8352              }
8353  
8354              if (! empty($args[0]['enclosing'])) {
8355                  throw $this->error("\$channels must be an unbracketed list.");
8356              }
8357  
8358              $args = $args[0][2];
8359              if (\count($args) > 3) {
8360                  throw $this->error("hwb() : Only 3 elements are allowed but ". \count($args) . "were passed");
8361              }
8362  
8363              $args_to_check = $this->extractSlashAlphaInColorFunction($kwargs['channels'][2]);
8364              if (\count($args_to_check) !== \count($kwargs['channels'][2])) {
8365                  $args = $args_to_check;
8366              }
8367          }
8368  
8369          if (\count($args_to_check) < 2) {
8370              throw $this->error("Missing elements \$whiteness and \$blackness");
8371          }
8372          if (\count($args_to_check) < 3) {
8373              throw $this->error("Missing element \$blackness");
8374          }
8375          if (\count($args_to_check) > 4) {
8376              throw $this->error("hwb() : Only 4 elements are allowed but ". \count($args) . "were passed");
8377          }
8378  
8379          foreach ($kwargs as $k => $arg) {
8380              if (in_array($arg[0], [Type::T_FUNCTION_CALL]) && in_array($arg[1], ['min', 'max'])) {
8381                  return null;
8382              }
8383          }
8384  
8385          foreach ($args_to_check as $k => $arg) {
8386              if (in_array($arg[0], [Type::T_FUNCTION_CALL]) && in_array($arg[1], ['min', 'max'])) {
8387                  if (count($kwargs) > 1 || ($k >= 2 && count($args) === 4)) {
8388                      return null;
8389                  }
8390  
8391                  $args[$k] = $this->stringifyFncallArgs($arg);
8392              }
8393  
8394              if (
8395                  $k >= 2 && count($args) === 4 &&
8396                  in_array($arg[0], [Type::T_FUNCTION_CALL, Type::T_FUNCTION]) &&
8397                  in_array($arg[1], ['calc','env'])
8398              ) {
8399                  return null;
8400              }
8401          }
8402  
8403          $hue = $this->reduce($args[0]);
8404          $whiteness = $this->reduce($args[1]);
8405          $blackness = $this->reduce($args[2]);
8406          $alpha = null;
8407  
8408          if (\count($args) === 4) {
8409              $alpha = $this->compileColorPartValue($args[3], 0, 1, false);
8410  
8411              if (! \is_numeric($alpha)) {
8412                  $val = $this->compileValue($args[3]);
8413                  throw $this->error("\$alpha: $val is not a number");
8414              }
8415          }
8416  
8417          $this->assertNumber($hue, 'hue');
8418          $this->assertUnit($whiteness, ['%'], 'whiteness');
8419          $this->assertUnit($blackness, ['%'], 'blackness');
8420  
8421          $this->assertRange($whiteness, 0, 100, "0% and 100%", "whiteness");
8422          $this->assertRange($blackness, 0, 100, "0% and 100%", "blackness");
8423  
8424          $w = $whiteness->getDimension();
8425          $b = $blackness->getDimension();
8426  
8427          $hueValue = $hue->getDimension() % 360;
8428  
8429          while ($hueValue < 0) {
8430              $hueValue += 360;
8431          }
8432  
8433          $color = $this->HWBtoRGB($hueValue, $w, $b);
8434  
8435          if (! \is_null($alpha)) {
8436              $color[4] = $alpha;
8437          }
8438  
8439          return $color;
8440      }
8441  
8442      protected static $libWhiteness = ['color'];
8443      protected function libWhiteness($args, $kwargs, $funcName = 'whiteness') {
8444  
8445          $color = $this->assertColor($args[0]);
8446          $hwb = $this->RGBtoHWB($color[1], $color[2], $color[3]);
8447  
8448          return new Number($hwb[2], '%');
8449      }
8450  
8451      protected static $libBlackness = ['color'];
8452      protected function libBlackness($args, $kwargs, $funcName = 'blackness') {
8453  
8454          $color = $this->assertColor($args[0]);
8455          $hwb = $this->RGBtoHWB($color[1], $color[2], $color[3]);
8456  
8457          return new Number($hwb[3], '%');
8458      }
8459      */
8460  
8461      /**
8462       * @param array     $color
8463       * @param int       $idx
8464       * @param int|float $amount
8465       *
8466       * @return array
8467       */
8468      protected function adjustHsl($color, $idx, $amount)
8469      {
8470          $hsl = $this->toHSL($color[1], $color[2], $color[3]);
8471          $hsl[$idx] += $amount;
8472  
8473          if ($idx !== 1) {
8474              // Clamp the saturation and lightness
8475              $hsl[$idx] = min(max(0, $hsl[$idx]), 100);
8476          }
8477  
8478          $out = $this->toRGB($hsl[1], $hsl[2], $hsl[3]);
8479  
8480          if (isset($color[4])) {
8481              $out[4] = $color[4];
8482          }
8483  
8484          return $out;
8485      }
8486  
8487      protected static $libAdjustHue = ['color', 'degrees'];
8488      protected function libAdjustHue($args)
8489      {
8490          $color = $this->assertColor($args[0], 'color');
8491          $degrees = $this->assertNumber($args[1], 'degrees')->getDimension();
8492  
8493          return $this->adjustHsl($color, 1, $degrees);
8494      }
8495  
8496      protected static $libLighten = ['color', 'amount'];
8497      protected function libLighten($args)
8498      {
8499          $color = $this->assertColor($args[0], 'color');
8500          $amount = Util::checkRange('amount', new Range(0, 100), $args[1], '%');
8501  
8502          return $this->adjustHsl($color, 3, $amount);
8503      }
8504  
8505      protected static $libDarken = ['color', 'amount'];
8506      protected function libDarken($args)
8507      {
8508          $color = $this->assertColor($args[0], 'color');
8509          $amount = Util::checkRange('amount', new Range(0, 100), $args[1], '%');
8510  
8511          return $this->adjustHsl($color, 3, -$amount);
8512      }
8513  
8514      protected static $libSaturate = [['color', 'amount'], ['amount']];
8515      protected function libSaturate($args)
8516      {
8517          $value = $args[0];
8518  
8519          if (count($args) === 1) {
8520              $this->assertNumber($args[0], 'amount');
8521  
8522              return null;
8523          }
8524  
8525          $color = $this->assertColor($args[0], 'color');
8526          $amount = $this->assertNumber($args[1], 'amount');
8527  
8528          return $this->adjustHsl($color, 2, $amount->valueInRange(0, 100, 'amount'));
8529      }
8530  
8531      protected static $libDesaturate = ['color', 'amount'];
8532      protected function libDesaturate($args)
8533      {
8534          $color = $this->assertColor($args[0], 'color');
8535          $amount = $this->assertNumber($args[1], 'amount');
8536  
8537          return $this->adjustHsl($color, 2, -$amount->valueInRange(0, 100, 'amount'));
8538      }
8539  
8540      protected static $libGrayscale = ['color'];
8541      protected function libGrayscale($args)
8542      {
8543          $value = $args[0];
8544  
8545          if ($value instanceof Number) {
8546              return null;
8547          }
8548  
8549          return $this->adjustHsl($this->assertColor($value, 'color'), 2, -100);
8550      }
8551  
8552      protected static $libComplement = ['color'];
8553      protected function libComplement($args)
8554      {
8555          return $this->adjustHsl($this->assertColor($args[0], 'color'), 1, 180);
8556      }
8557  
8558      protected static $libInvert = ['color', 'weight:100%'];
8559      protected function libInvert($args)
8560      {
8561          $value = $args[0];
8562  
8563          $weight = $this->assertNumber($args[1], 'weight');
8564  
8565          if ($value instanceof Number) {
8566              if ($weight->getDimension() != 100 || !$weight->hasUnit('%')) {
8567                  throw new SassScriptException('Only one argument may be passed to the plain-CSS invert() function.');
8568              }
8569  
8570              return null;
8571          }
8572  
8573          $color = $this->assertColor($value, 'color');
8574          $inverted = $color;
8575          $inverted[1] = 255 - $inverted[1];
8576          $inverted[2] = 255 - $inverted[2];
8577          $inverted[3] = 255 - $inverted[3];
8578  
8579          return $this->libMix([$inverted, $color, $weight]);
8580      }
8581  
8582      // increases opacity by amount
8583      protected static $libOpacify = ['color', 'amount'];
8584      protected function libOpacify($args)
8585      {
8586          $color = $this->assertColor($args[0], 'color');
8587          $amount = $this->assertNumber($args[1], 'amount');
8588  
8589          $color[4] = (isset($color[4]) ? $color[4] : 1) + $amount->valueInRangeWithUnit(0, 1, 'amount', '');
8590          $color[4] = min(1, max(0, $color[4]));
8591  
8592          return $color;
8593      }
8594  
8595      protected static $libFadeIn = ['color', 'amount'];
8596      protected function libFadeIn($args)
8597      {
8598          return $this->libOpacify($args);
8599      }
8600  
8601      // decreases opacity by amount
8602      protected static $libTransparentize = ['color', 'amount'];
8603      protected function libTransparentize($args)
8604      {
8605          $color = $this->assertColor($args[0], 'color');
8606          $amount = $this->assertNumber($args[1], 'amount');
8607  
8608          $color[4] = (isset($color[4]) ? $color[4] : 1) - $amount->valueInRangeWithUnit(0, 1, 'amount', '');
8609          $color[4] = min(1, max(0, $color[4]));
8610  
8611          return $color;
8612      }
8613  
8614      protected static $libFadeOut = ['color', 'amount'];
8615      protected function libFadeOut($args)
8616      {
8617          return $this->libTransparentize($args);
8618      }
8619  
8620      protected static $libUnquote = ['string'];
8621      protected function libUnquote($args)
8622      {
8623          try {
8624              $str = $this->assertString($args[0], 'string');
8625          } catch (SassScriptException $e) {
8626              $value = $this->compileValue($args[0]);
8627              $fname = $this->getPrettyPath($this->sourceNames[$this->sourceIndex]);
8628              $line  = $this->sourceLine;
8629  
8630              $message = "Passing $value, a non-string value, to unquote()
8631  will be an error in future versions of Sass.\n         on line $line of $fname";
8632  
8633              $this->logger->warn($message, true);
8634  
8635              return $args[0];
8636          }
8637  
8638          $str[1] = '';
8639  
8640          return $str;
8641      }
8642  
8643      protected static $libQuote = ['string'];
8644      protected function libQuote($args)
8645      {
8646          $value = $this->assertString($args[0], 'string');
8647  
8648          $value[1] = '"';
8649  
8650          return $value;
8651      }
8652  
8653      protected static $libPercentage = ['number'];
8654      protected function libPercentage($args)
8655      {
8656          $num = $this->assertNumber($args[0], 'number');
8657          $num->assertNoUnits('number');
8658  
8659          return new Number($num->getDimension() * 100, '%');
8660      }
8661  
8662      protected static $libRound = ['number'];
8663      protected function libRound($args)
8664      {
8665          $num = $this->assertNumber($args[0], 'number');
8666  
8667          return new Number(round($num->getDimension()), $num->getNumeratorUnits(), $num->getDenominatorUnits());
8668      }
8669  
8670      protected static $libFloor = ['number'];
8671      protected function libFloor($args)
8672      {
8673          $num = $this->assertNumber($args[0], 'number');
8674  
8675          return new Number(floor($num->getDimension()), $num->getNumeratorUnits(), $num->getDenominatorUnits());
8676      }
8677  
8678      protected static $libCeil = ['number'];
8679      protected function libCeil($args)
8680      {
8681          $num = $this->assertNumber($args[0], 'number');
8682  
8683          return new Number(ceil($num->getDimension()), $num->getNumeratorUnits(), $num->getDenominatorUnits());
8684      }
8685  
8686      protected static $libAbs = ['number'];
8687      protected function libAbs($args)
8688      {
8689          $num = $this->assertNumber($args[0], 'number');
8690  
8691          return new Number(abs($num->getDimension()), $num->getNumeratorUnits(), $num->getDenominatorUnits());
8692      }
8693  
8694      protected static $libMin = ['numbers...'];
8695      protected function libMin($args)
8696      {
8697          /**
8698           * @var Number|null
8699           */
8700          $min = null;
8701  
8702          foreach ($args[0][2] as $arg) {
8703              $number = $this->assertNumber($arg);
8704  
8705              if (\is_null($min) || $min->greaterThan($number)) {
8706                  $min = $number;
8707              }
8708          }
8709  
8710          if (!\is_null($min)) {
8711              return $min;
8712          }
8713  
8714          throw $this->error('At least one argument must be passed.');
8715      }
8716  
8717      protected static $libMax = ['numbers...'];
8718      protected function libMax($args)
8719      {
8720          /**
8721           * @var Number|null
8722           */
8723          $max = null;
8724  
8725          foreach ($args[0][2] as $arg) {
8726              $number = $this->assertNumber($arg);
8727  
8728              if (\is_null($max) || $max->lessThan($number)) {
8729                  $max = $number;
8730              }
8731          }
8732  
8733          if (!\is_null($max)) {
8734              return $max;
8735          }
8736  
8737          throw $this->error('At least one argument must be passed.');
8738      }
8739  
8740      protected static $libLength = ['list'];
8741      protected function libLength($args)
8742      {
8743          $list = $this->coerceList($args[0], ',', true);
8744  
8745          return new Number(\count($list[2]), '');
8746      }
8747  
8748      protected static $libListSeparator = ['list'];
8749      protected function libListSeparator($args)
8750      {
8751          if (! \in_array($args[0][0], [Type::T_LIST, Type::T_MAP])) {
8752              return [Type::T_KEYWORD, 'space'];
8753          }
8754  
8755          $list = $this->coerceList($args[0]);
8756  
8757          if ($list[1] === '' && \count($list[2]) <= 1 && empty($list['enclosing'])) {
8758              return [Type::T_KEYWORD, 'space'];
8759          }
8760  
8761          if ($list[1] === ',') {
8762              return [Type::T_KEYWORD, 'comma'];
8763          }
8764  
8765          if ($list[1] === '/') {
8766              return [Type::T_KEYWORD, 'slash'];
8767          }
8768  
8769          return [Type::T_KEYWORD, 'space'];
8770      }
8771  
8772      protected static $libNth = ['list', 'n'];
8773      protected function libNth($args)
8774      {
8775          $list = $this->coerceList($args[0], ',', false);
8776          $n = $this->assertInteger($args[1]);
8777  
8778          if ($n > 0) {
8779              $n--;
8780          } elseif ($n < 0) {
8781              $n += \count($list[2]);
8782          }
8783  
8784          return isset($list[2][$n]) ? $list[2][$n] : static::$defaultValue;
8785      }
8786  
8787      protected static $libSetNth = ['list', 'n', 'value'];
8788      protected function libSetNth($args)
8789      {
8790          $list = $this->coerceList($args[0]);
8791          $n = $this->assertInteger($args[1]);
8792  
8793          if ($n > 0) {
8794              $n--;
8795          } elseif ($n < 0) {
8796              $n += \count($list[2]);
8797          }
8798  
8799          if (! isset($list[2][$n])) {
8800              throw $this->error('Invalid argument for "n"');
8801          }
8802  
8803          $list[2][$n] = $args[2];
8804  
8805          return $list;
8806      }
8807  
8808      protected static $libMapGet = ['map', 'key', 'keys...'];
8809      protected function libMapGet($args)
8810      {
8811          $map = $this->assertMap($args[0], 'map');
8812          if (!isset($args[2])) {
8813              // BC layer for usages of the function from PHP code rather than from the Sass function
8814              $args[2] = self::$emptyArgumentList;
8815          }
8816          $keys = array_merge([$args[1]], $args[2][2]);
8817          $value = static::$null;
8818  
8819          foreach ($keys as $key) {
8820              if (!\is_array($map) || $map[0] !== Type::T_MAP) {
8821                  return static::$null;
8822              }
8823  
8824              $map = $this->mapGet($map, $key);
8825  
8826              if ($map === null) {
8827                  return static::$null;
8828              }
8829  
8830              $value = $map;
8831          }
8832  
8833          return $value;
8834      }
8835  
8836      /**
8837       * Gets the value corresponding to that key in the map
8838       *
8839       * @param array        $map
8840       * @param Number|array $key
8841       *
8842       * @return Number|array|null
8843       */
8844      private function mapGet(array $map, $key)
8845      {
8846          $index = $this->mapGetEntryIndex($map, $key);
8847  
8848          if ($index !== null) {
8849              return $map[2][$index];
8850          }
8851  
8852          return null;
8853      }
8854  
8855      /**
8856       * Gets the index corresponding to that key in the map entries
8857       *
8858       * @param array        $map
8859       * @param Number|array $key
8860       *
8861       * @return int|null
8862       */
8863      private function mapGetEntryIndex(array $map, $key)
8864      {
8865          $key = $this->compileStringContent($this->coerceString($key));
8866  
8867          for ($i = \count($map[1]) - 1; $i >= 0; $i--) {
8868              if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) {
8869                  return $i;
8870              }
8871          }
8872  
8873          return null;
8874      }
8875  
8876      protected static $libMapKeys = ['map'];
8877      protected function libMapKeys($args)
8878      {
8879          $map = $this->assertMap($args[0], 'map');
8880          $keys = $map[1];
8881  
8882          return [Type::T_LIST, ',', $keys];
8883      }
8884  
8885      protected static $libMapValues = ['map'];
8886      protected function libMapValues($args)
8887      {
8888          $map = $this->assertMap($args[0], 'map');
8889          $values = $map[2];
8890  
8891          return [Type::T_LIST, ',', $values];
8892      }
8893  
8894      protected static $libMapRemove = [
8895          ['map'],
8896          ['map', 'key', 'keys...'],
8897      ];
8898      protected function libMapRemove($args)
8899      {
8900          $map = $this->assertMap($args[0], 'map');
8901  
8902          if (\count($args) === 1) {
8903              return $map;
8904          }
8905  
8906          $keys = [];
8907          $keys[] = $this->compileStringContent($this->coerceString($args[1]));
8908  
8909          foreach ($args[2][2] as $key) {
8910              $keys[] = $this->compileStringContent($this->coerceString($key));
8911          }
8912  
8913          for ($i = \count($map[1]) - 1; $i >= 0; $i--) {
8914              if (in_array($this->compileStringContent($this->coerceString($map[1][$i])), $keys)) {
8915                  array_splice($map[1], $i, 1);
8916                  array_splice($map[2], $i, 1);
8917              }
8918          }
8919  
8920          return $map;
8921      }
8922  
8923      protected static $libMapHasKey = ['map', 'key', 'keys...'];
8924      protected function libMapHasKey($args)
8925      {
8926          $map = $this->assertMap($args[0], 'map');
8927          if (!isset($args[2])) {
8928              // BC layer for usages of the function from PHP code rather than from the Sass function
8929              $args[2] = self::$emptyArgumentList;
8930          }
8931          $keys = array_merge([$args[1]], $args[2][2]);
8932          $lastKey = array_pop($keys);
8933  
8934          foreach ($keys as $key) {
8935              $value = $this->mapGet($map, $key);
8936  
8937              if ($value === null || $value instanceof Number || $value[0] !== Type::T_MAP) {
8938                  return self::$false;
8939              }
8940  
8941              $map = $value;
8942          }
8943  
8944          return $this->toBool($this->mapHasKey($map, $lastKey));
8945      }
8946  
8947      /**
8948       * @param array|Number $keyValue
8949       *
8950       * @return bool
8951       */
8952      private function mapHasKey(array $map, $keyValue)
8953      {
8954          $key = $this->compileStringContent($this->coerceString($keyValue));
8955  
8956          for ($i = \count($map[1]) - 1; $i >= 0; $i--) {
8957              if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) {
8958                  return true;
8959              }
8960          }
8961  
8962          return false;
8963      }
8964  
8965      protected static $libMapMerge = [
8966          ['map1', 'map2'],
8967          ['map-1', 'map-2'],
8968          ['map1', 'args...']
8969      ];
8970      protected function libMapMerge($args)
8971      {
8972          $map1 = $this->assertMap($args[0], 'map1');
8973          $map2 = $args[1];
8974          $keys = [];
8975          if ($map2[0] === Type::T_LIST && isset($map2[3]) && \is_array($map2[3])) {
8976              // This is an argument list for the variadic signature
8977              if (\count($map2[2]) === 0) {
8978                  throw new SassScriptException('Expected $args to contain a key.');
8979              }
8980              if (\count($map2[2]) === 1) {
8981                  throw new SassScriptException('Expected $args to contain a value.');
8982              }
8983              $keys = $map2[2];
8984              $map2 = array_pop($keys);
8985          }
8986          $map2 = $this->assertMap($map2, 'map2');
8987  
8988          return $this->modifyMap($map1, $keys, function ($oldValue) use ($map2) {
8989              $nestedMap = $this->tryMap($oldValue);
8990  
8991              if ($nestedMap === null) {
8992                  return $map2;
8993              }
8994  
8995              return $this->mergeMaps($nestedMap, $map2);
8996          });
8997      }
8998  
8999      /**
9000       * @param array    $map
9001       * @param array    $keys
9002       * @param callable $modify
9003       * @param bool     $addNesting
9004       *
9005       * @return Number|array
9006       *
9007       * @phpstan-param array<Number|array> $keys
9008       * @phpstan-param callable(Number|array): (Number|array) $modify
9009       */
9010      private function modifyMap(array $map, array $keys, callable $modify, $addNesting = true)
9011      {
9012          if ($keys === []) {
9013              return $modify($map);
9014          }
9015  
9016          return $this->modifyNestedMap($map, $keys, $modify, $addNesting);
9017      }
9018  
9019      /**
9020       * @param array    $map
9021       * @param array    $keys
9022       * @param callable $modify
9023       * @param bool     $addNesting
9024       *
9025       * @return array
9026       *
9027       * @phpstan-param non-empty-array<Number|array> $keys
9028       * @phpstan-param callable(Number|array): (Number|array) $modify
9029       */
9030      private function modifyNestedMap(array $map, array $keys, callable $modify, $addNesting)
9031      {
9032          $key = array_shift($keys);
9033  
9034          $nestedValueIndex = $this->mapGetEntryIndex($map, $key);
9035  
9036          if ($keys === []) {
9037              if ($nestedValueIndex !== null) {
9038                  $map[2][$nestedValueIndex] = $modify($map[2][$nestedValueIndex]);
9039              } else {
9040                  $map[1][] = $key;
9041                  $map[2][] = $modify(self::$null);
9042              }
9043  
9044              return $map;
9045          }
9046  
9047          $nestedMap = $nestedValueIndex !== null ? $this->tryMap($map[2][$nestedValueIndex]) : null;
9048  
9049          if ($nestedMap === null && !$addNesting) {
9050              return $map;
9051          }
9052  
9053          if ($nestedMap === null) {
9054              $nestedMap = self::$emptyMap;
9055          }
9056  
9057          $newNestedMap = $this->modifyNestedMap($nestedMap, $keys, $modify, $addNesting);
9058  
9059          if ($nestedValueIndex !== null) {
9060              $map[2][$nestedValueIndex] = $newNestedMap;
9061          } else {
9062              $map[1][] = $key;
9063              $map[2][] = $newNestedMap;
9064          }
9065  
9066          return $map;
9067      }
9068  
9069      /**
9070       * Merges 2 Sass maps together
9071       *
9072       * @param array $map1
9073       * @param array $map2
9074       *
9075       * @return array
9076       */
9077      private function mergeMaps(array $map1, array $map2)
9078      {
9079          foreach ($map2[1] as $i2 => $key2) {
9080              $map1EntryIndex = $this->mapGetEntryIndex($map1, $key2);
9081  
9082              if ($map1EntryIndex !== null) {
9083                  $map1[2][$map1EntryIndex] = $map2[2][$i2];
9084                  continue;
9085              }
9086  
9087              $map1[1][] = $key2;
9088              $map1[2][] = $map2[2][$i2];
9089          }
9090  
9091          return $map1;
9092      }
9093  
9094      protected static $libKeywords = ['args'];
9095      protected function libKeywords($args)
9096      {
9097          $value = $args[0];
9098  
9099          if ($value[0] !== Type::T_LIST || !isset($value[3]) || !\is_array($value[3])) {
9100              $compiledValue = $this->compileValue($value);
9101  
9102              throw SassScriptException::forArgument($compiledValue . ' is not an argument list.', 'args');
9103          }
9104  
9105          $keys = [];
9106          $values = [];
9107  
9108          foreach ($this->getArgumentListKeywords($value) as $name => $arg) {
9109              $keys[] = [Type::T_KEYWORD, $name];
9110              $values[] = $arg;
9111          }
9112  
9113          return [Type::T_MAP, $keys, $values];
9114      }
9115  
9116      protected static $libIsBracketed = ['list'];
9117      protected function libIsBracketed($args)
9118      {
9119          $list = $args[0];
9120          $this->coerceList($list, ' ');
9121  
9122          if (! empty($list['enclosing']) && $list['enclosing'] === 'bracket') {
9123              return self::$true;
9124          }
9125  
9126          return self::$false;
9127      }
9128  
9129      /**
9130       * @param array $list1
9131       * @param array|Number|null $sep
9132       *
9133       * @return string
9134       * @throws CompilerException
9135       *
9136       * @deprecated
9137       */
9138      protected function listSeparatorForJoin($list1, $sep)
9139      {
9140          @trigger_error(sprintf('The "%s" method is deprecated.', __METHOD__), E_USER_DEPRECATED);
9141  
9142          if (! isset($sep)) {
9143              return $list1[1];
9144          }
9145  
9146          switch ($this->compileValue($sep)) {
9147              case 'comma':
9148                  return ',';
9149  
9150              case 'space':
9151                  return ' ';
9152  
9153              default:
9154                  return $list1[1];
9155          }
9156      }
9157  
9158      protected static $libJoin = ['list1', 'list2', 'separator:auto', 'bracketed:auto'];
9159      protected function libJoin($args)
9160      {
9161          list($list1, $list2, $sep, $bracketed) = $args;
9162  
9163          $list1 = $this->coerceList($list1, ' ', true);
9164          $list2 = $this->coerceList($list2, ' ', true);
9165  
9166          switch ($this->compileStringContent($this->assertString($sep, 'separator'))) {
9167              case 'comma':
9168                  $separator = ',';
9169                  break;
9170  
9171              case 'space':
9172                  $separator = ' ';
9173                  break;
9174  
9175              case 'slash':
9176                  $separator = '/';
9177                  break;
9178  
9179              case 'auto':
9180                  if ($list1[1] !== '' || count($list1[2]) > 1 || !empty($list1['enclosing']) && $list1['enclosing'] !== 'parent') {
9181                      $separator = $list1[1] ?: ' ';
9182                  } elseif ($list2[1] !== '' || count($list2[2]) > 1 || !empty($list2['enclosing']) && $list2['enclosing'] !== 'parent') {
9183                      $separator = $list2[1] ?: ' ';
9184                  } else {
9185                      $separator = ' ';
9186                  }
9187                  break;
9188  
9189              default:
9190                  throw SassScriptException::forArgument('Must be "space", "comma", "slash", or "auto".', 'separator');
9191          }
9192  
9193          if ($bracketed === static::$true) {
9194              $bracketed = true;
9195          } elseif ($bracketed === static::$false) {
9196              $bracketed = false;
9197          } elseif ($bracketed === [Type::T_KEYWORD, 'auto']) {
9198              $bracketed = 'auto';
9199          } elseif ($bracketed === static::$null) {
9200              $bracketed = false;
9201          } else {
9202              $bracketed = $this->compileValue($bracketed);
9203              $bracketed = ! ! $bracketed;
9204  
9205              if ($bracketed === true) {
9206                  $bracketed = true;
9207              }
9208          }
9209  
9210          if ($bracketed === 'auto') {
9211              $bracketed = false;
9212  
9213              if (! empty($list1['enclosing']) && $list1['enclosing'] === 'bracket') {
9214                  $bracketed = true;
9215              }
9216          }
9217  
9218          $res = [Type::T_LIST, $separator, array_merge($list1[2], $list2[2])];
9219  
9220          if ($bracketed) {
9221              $res['enclosing'] = 'bracket';
9222          }
9223  
9224          return $res;
9225      }
9226  
9227      protected static $libAppend = ['list', 'val', 'separator:auto'];
9228      protected function libAppend($args)
9229      {
9230          list($list1, $value, $sep) = $args;
9231  
9232          $list1 = $this->coerceList($list1, ' ', true);
9233  
9234          switch ($this->compileStringContent($this->assertString($sep, 'separator'))) {
9235              case 'comma':
9236                  $separator = ',';
9237                  break;
9238  
9239              case 'space':
9240                  $separator = ' ';
9241                  break;
9242  
9243              case 'slash':
9244                  $separator = '/';
9245                  break;
9246  
9247              case 'auto':
9248                  $separator = $list1[1] === '' && \count($list1[2]) <= 1 && (empty($list1['enclosing']) || $list1['enclosing'] === 'parent') ? ' ' : $list1[1];
9249                  break;
9250  
9251              default:
9252                  throw SassScriptException::forArgument('Must be "space", "comma", "slash", or "auto".', 'separator');
9253          }
9254  
9255          $res = [Type::T_LIST, $separator, array_merge($list1[2], [$value])];
9256  
9257          if (isset($list1['enclosing'])) {
9258              $res['enclosing'] = $list1['enclosing'];
9259          }
9260  
9261          return $res;
9262      }
9263  
9264      protected static $libZip = ['lists...'];
9265      protected function libZip($args)
9266      {
9267          $argLists = [];
9268          foreach ($args[0][2] as $arg) {
9269              $argLists[] = $this->coerceList($arg);
9270          }
9271  
9272          $lists = [];
9273          $firstList = array_shift($argLists);
9274  
9275          $result = [Type::T_LIST, ',', $lists];
9276          if (! \is_null($firstList)) {
9277              foreach ($firstList[2] as $key => $item) {
9278                  $list = [Type::T_LIST, ' ', [$item]];
9279  
9280                  foreach ($argLists as $arg) {
9281                      if (isset($arg[2][$key])) {
9282                          $list[2][] = $arg[2][$key];
9283                      } else {
9284                          break 2;
9285                      }
9286                  }
9287  
9288                  $lists[] = $list;
9289              }
9290  
9291              $result[2] = $lists;
9292          } else {
9293              $result['enclosing'] = 'parent';
9294          }
9295  
9296          return $result;
9297      }
9298  
9299      protected static $libTypeOf = ['value'];
9300      protected function libTypeOf($args)
9301      {
9302          $value = $args[0];
9303  
9304          return [Type::T_KEYWORD, $this->getTypeOf($value)];
9305      }
9306  
9307      /**
9308       * @param array|Number $value
9309       *
9310       * @return string
9311       */
9312      private function getTypeOf($value)
9313      {
9314          switch ($value[0]) {
9315              case Type::T_KEYWORD:
9316                  if ($value === static::$true || $value === static::$false) {
9317                      return 'bool';
9318                  }
9319  
9320                  if ($this->coerceColor($value)) {
9321                      return 'color';
9322                  }
9323  
9324                  // fall-thru
9325              case Type::T_FUNCTION:
9326                  return 'string';
9327  
9328              case Type::T_FUNCTION_REFERENCE:
9329                  return 'function';
9330  
9331              case Type::T_LIST:
9332                  if (isset($value[3]) && \is_array($value[3])) {
9333                      return 'arglist';
9334                  }
9335  
9336                  // fall-thru
9337              default:
9338                  return $value[0];
9339          }
9340      }
9341  
9342      protected static $libUnit = ['number'];
9343      protected function libUnit($args)
9344      {
9345          $num = $this->assertNumber($args[0], 'number');
9346  
9347          return [Type::T_STRING, '"', [$num->unitStr()]];
9348      }
9349  
9350      protected static $libUnitless = ['number'];
9351      protected function libUnitless($args)
9352      {
9353          $value = $this->assertNumber($args[0], 'number');
9354  
9355          return $this->toBool($value->unitless());
9356      }
9357  
9358      protected static $libComparable = [
9359          ['number1', 'number2'],
9360          ['number-1', 'number-2']
9361      ];
9362      protected function libComparable($args)
9363      {
9364          list($number1, $number2) = $args;
9365  
9366          if (
9367              ! $number1 instanceof Number ||
9368              ! $number2 instanceof Number
9369          ) {
9370              throw $this->error('Invalid argument(s) for "comparable"');
9371          }
9372  
9373          return $this->toBool($number1->isComparableTo($number2));
9374      }
9375  
9376      protected static $libStrIndex = ['string', 'substring'];
9377      protected function libStrIndex($args)
9378      {
9379          $string = $this->assertString($args[0], 'string');
9380          $stringContent = $this->compileStringContent($string);
9381  
9382          $substring = $this->assertString($args[1], 'substring');
9383          $substringContent = $this->compileStringContent($substring);
9384  
9385          if (! \strlen($substringContent)) {
9386              $result = 0;
9387          } else {
9388              $result = Util::mbStrpos($stringContent, $substringContent);
9389          }
9390  
9391          return $result === false ? static::$null : new Number($result + 1, '');
9392      }
9393  
9394      protected static $libStrInsert = ['string', 'insert', 'index'];
9395      protected function libStrInsert($args)
9396      {
9397          $string = $this->assertString($args[0], 'string');
9398          $stringContent = $this->compileStringContent($string);
9399  
9400          $insert = $this->assertString($args[1], 'insert');
9401          $insertContent = $this->compileStringContent($insert);
9402  
9403          $index = $this->assertInteger($args[2], 'index');
9404          if ($index > 0) {
9405              $index = $index - 1;
9406          }
9407          if ($index < 0) {
9408              $index = max(Util::mbStrlen($stringContent) + 1 + $index, 0);
9409          }
9410  
9411          $string[2] = [
9412              Util::mbSubstr($stringContent, 0, $index),
9413              $insertContent,
9414              Util::mbSubstr($stringContent, $index)
9415          ];
9416  
9417          return $string;
9418      }
9419  
9420      protected static $libStrLength = ['string'];
9421      protected function libStrLength($args)
9422      {
9423          $string = $this->assertString($args[0], 'string');
9424          $stringContent = $this->compileStringContent($string);
9425  
9426          return new Number(Util::mbStrlen($stringContent), '');
9427      }
9428  
9429      protected static $libStrSlice = ['string', 'start-at', 'end-at:-1'];
9430      protected function libStrSlice($args)
9431      {
9432          $string = $this->assertString($args[0], 'string');
9433          $stringContent = $this->compileStringContent($string);
9434  
9435          $start = $this->assertNumber($args[1], 'start-at');
9436          $start->assertNoUnits('start-at');
9437          $startInt = $this->assertInteger($start, 'start-at');
9438          $end = $this->assertNumber($args[2], 'end-at');
9439          $end->assertNoUnits('end-at');
9440          $endInt = $this->assertInteger($end, 'end-at');
9441  
9442          if ($endInt === 0) {
9443              return [Type::T_STRING, $string[1], []];
9444          }
9445  
9446          if ($startInt > 0) {
9447              $startInt--;
9448          }
9449  
9450          if ($endInt < 0) {
9451              $endInt = Util::mbStrlen($stringContent) + $endInt;
9452          } else {
9453              $endInt--;
9454          }
9455  
9456          if ($endInt < $startInt) {
9457              return [Type::T_STRING, $string[1], []];
9458          }
9459  
9460          $length = $endInt - $startInt + 1; // The end of the slice is inclusive
9461  
9462          $string[2] = [Util::mbSubstr($stringContent, $startInt, $length)];
9463  
9464          return $string;
9465      }
9466  
9467      protected static $libToLowerCase = ['string'];
9468      protected function libToLowerCase($args)
9469      {
9470          $string = $this->assertString($args[0], 'string');
9471          $stringContent = $this->compileStringContent($string);
9472  
9473          $string[2] = [$this->stringTransformAsciiOnly($stringContent, 'strtolower')];
9474  
9475          return $string;
9476      }
9477  
9478      protected static $libToUpperCase = ['string'];
9479      protected function libToUpperCase($args)
9480      {
9481          $string = $this->assertString($args[0], 'string');
9482          $stringContent = $this->compileStringContent($string);
9483  
9484          $string[2] = [$this->stringTransformAsciiOnly($stringContent, 'strtoupper')];
9485  
9486          return $string;
9487      }
9488  
9489      /**
9490       * Apply a filter on a string content, only on ascii chars
9491       * let extended chars untouched
9492       *
9493       * @param string $stringContent
9494       * @param callable $filter
9495       * @return string
9496       */
9497      protected function stringTransformAsciiOnly($stringContent, $filter)
9498      {
9499          $mblength = Util::mbStrlen($stringContent);
9500          if ($mblength === strlen($stringContent)) {
9501              return $filter($stringContent);
9502          }
9503          $filteredString = "";
9504          for ($i = 0; $i < $mblength; $i++) {
9505              $char = Util::mbSubstr($stringContent, $i, 1);
9506              if (strlen($char) > 1) {
9507                  $filteredString .= $char;
9508              } else {
9509                  $filteredString .= $filter($char);
9510              }
9511          }
9512  
9513          return $filteredString;
9514      }
9515  
9516      protected static $libFeatureExists = ['feature'];
9517      protected function libFeatureExists($args)
9518      {
9519          $string = $this->assertString($args[0], 'feature');
9520          $name = $this->compileStringContent($string);
9521  
9522          return $this->toBool(
9523              \array_key_exists($name, $this->registeredFeatures) ? $this->registeredFeatures[$name] : false
9524          );
9525      }
9526  
9527      protected static $libFunctionExists = ['name'];
9528      protected function libFunctionExists($args)
9529      {
9530          $string = $this->assertString($args[0], 'name');
9531          $name = $this->compileStringContent($string);
9532  
9533          // user defined functions
9534          if ($this->has(static::$namespaces['function'] . $name)) {
9535              return self::$true;
9536          }
9537  
9538          $name = $this->normalizeName($name);
9539  
9540          if (isset($this->userFunctions[$name])) {
9541              return self::$true;
9542          }
9543  
9544          // built-in functions
9545          $f = $this->getBuiltinFunction($name);
9546  
9547          return $this->toBool(\is_callable($f));
9548      }
9549  
9550      protected static $libGlobalVariableExists = ['name'];
9551      protected function libGlobalVariableExists($args)
9552      {
9553          $string = $this->assertString($args[0], 'name');
9554          $name = $this->compileStringContent($string);
9555  
9556          return $this->toBool($this->has($name, $this->rootEnv));
9557      }
9558  
9559      protected static $libMixinExists = ['name'];
9560      protected function libMixinExists($args)
9561      {
9562          $string = $this->assertString($args[0], 'name');
9563          $name = $this->compileStringContent($string);
9564  
9565          return $this->toBool($this->has(static::$namespaces['mixin'] . $name));
9566      }
9567  
9568      protected static $libVariableExists = ['name'];
9569      protected function libVariableExists($args)
9570      {
9571          $string = $this->assertString($args[0], 'name');
9572          $name = $this->compileStringContent($string);
9573  
9574          return $this->toBool($this->has($name));
9575      }
9576  
9577      protected static $libCounter = ['args...'];
9578      /**
9579       * Workaround IE7's content counter bug.
9580       *
9581       * @param array $args
9582       *
9583       * @return array
9584       */
9585      protected function libCounter($args)
9586      {
9587          $list = array_map([$this, 'compileValue'], $args[0][2]);
9588  
9589          return [Type::T_STRING, '', ['counter(' . implode(',', $list) . ')']];
9590      }
9591  
9592      protected static $libRandom = ['limit:null'];
9593      protected function libRandom($args)
9594      {
9595          if (isset($args[0]) && $args[0] !== static::$null) {
9596              $limit = $this->assertNumber($args[0], 'limit');
9597  
9598              if ($limit->hasUnits()) {
9599                  $unitString = $limit->unitStr();
9600                  $message = <<<TXT
9601  random() will no longer ignore \$limit units ($limit) in a future release.
9602  
9603  Recommendation: random(\$limit / 1$unitString) * 1$unitString
9604  
9605  To preserve current behavior: random(\$limit / 1$unitString)
9606  
9607  More info: https://sass-lang.com/d/random-with-units
9608  
9609  TXT;
9610  
9611                  Warn::deprecation($this->addLocationToMessage($message));
9612              }
9613  
9614              $n = $this->assertInteger($limit, 'limit');
9615  
9616              if ($n < 1) {
9617                  throw new SassScriptException("\$limit: Must be greater than 0, was $n.");
9618              }
9619  
9620              return new Number(mt_rand(1, $n), '');
9621          }
9622  
9623          $max = mt_getrandmax();
9624          return new Number(mt_rand(0, $max - 1) / $max, '');
9625      }
9626  
9627      protected static $libUniqueId = [];
9628      protected function libUniqueId()
9629      {
9630          static $id;
9631  
9632          if (! isset($id)) {
9633              $id = PHP_INT_SIZE === 4
9634                  ? mt_rand(0, pow(36, 5)) . str_pad(mt_rand(0, pow(36, 5)) % 10000000, 7, '0', STR_PAD_LEFT)
9635                  : mt_rand(0, pow(36, 8));
9636          }
9637  
9638          $id += mt_rand(0, 10) + 1;
9639  
9640          return [Type::T_STRING, '', ['u' . str_pad(base_convert($id, 10, 36), 8, '0', STR_PAD_LEFT)]];
9641      }
9642  
9643      /**
9644       * @param array|Number $value
9645       * @param bool         $force_enclosing_display
9646       *
9647       * @return array
9648       */
9649      protected function inspectFormatValue($value, $force_enclosing_display = false)
9650      {
9651          if ($value === static::$null) {
9652              $value = [Type::T_KEYWORD, 'null'];
9653          }
9654  
9655          $stringValue = [$value];
9656  
9657          if ($value instanceof Number) {
9658              return [Type::T_STRING, '', $stringValue];
9659          }
9660  
9661          if ($value[0] === Type::T_LIST) {
9662              if (end($value[2]) === static::$null) {
9663                  array_pop($value[2]);
9664                  $value[2][] = [Type::T_STRING, '', ['']];
9665                  $force_enclosing_display = true;
9666              }
9667  
9668              if (
9669                  ! empty($value['enclosing']) &&
9670                  ($force_enclosing_display ||
9671                      ($value['enclosing'] === 'bracket') ||
9672                      ! \count($value[2]))
9673              ) {
9674                  $value['enclosing'] = 'forced_' . $value['enclosing'];
9675                  $force_enclosing_display = true;
9676              } elseif (! \count($value[2])) {
9677                  $value['enclosing'] = 'forced_parent';
9678              }
9679  
9680              foreach ($value[2] as $k => $listelement) {
9681                  $value[2][$k] = $this->inspectFormatValue($listelement, $force_enclosing_display);
9682              }
9683  
9684              $stringValue = [$value];
9685          }
9686  
9687          return [Type::T_STRING, '', $stringValue];
9688      }
9689  
9690      protected static $libInspect = ['value'];
9691      protected function libInspect($args)
9692      {
9693          $value = $args[0];
9694  
9695          return $this->inspectFormatValue($value);
9696      }
9697  
9698      /**
9699       * Preprocess selector args
9700       *
9701       * @param array       $arg
9702       * @param string|null $varname
9703       * @param bool        $allowParent
9704       *
9705       * @return array
9706       */
9707      protected function getSelectorArg($arg, $varname = null, $allowParent = false)
9708      {
9709          static $parser = null;
9710  
9711          if (\is_null($parser)) {
9712              $parser = $this->parserFactory(__METHOD__);
9713          }
9714  
9715          if (! $this->checkSelectorArgType($arg)) {
9716              $var_value = $this->compileValue($arg);
9717              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);
9718          }
9719  
9720  
9721          if ($arg[0] === Type::T_STRING) {
9722              $arg[1] = '';
9723          }
9724          $arg = $this->compileValue($arg);
9725  
9726          $parsedSelector = [];
9727  
9728          if ($parser->parseSelector($arg, $parsedSelector, true)) {
9729              $selector = $this->evalSelectors($parsedSelector);
9730              $gluedSelector = $this->glueFunctionSelectors($selector);
9731  
9732              if (! $allowParent) {
9733                  foreach ($gluedSelector as $selector) {
9734                      foreach ($selector as $s) {
9735                          if (in_array(static::$selfSelector, $s)) {
9736                              throw SassScriptException::forArgument("Parent selectors aren't allowed here.", $varname);
9737                          }
9738                      }
9739                  }
9740              }
9741  
9742              return $gluedSelector;
9743          }
9744  
9745          throw SassScriptException::forArgument("expected more input, invalid selector.", $varname);
9746      }
9747  
9748      /**
9749       * Check variable type for getSelectorArg() function
9750       * @param array $arg
9751       * @param int $maxDepth
9752       * @return bool
9753       */
9754      protected function checkSelectorArgType($arg, $maxDepth = 2)
9755      {
9756          if ($arg[0] === Type::T_LIST && $maxDepth > 0) {
9757              foreach ($arg[2] as $elt) {
9758                  if (! $this->checkSelectorArgType($elt, $maxDepth - 1)) {
9759                      return false;
9760                  }
9761              }
9762              return true;
9763          }
9764          if (!in_array($arg[0], [Type::T_STRING, Type::T_KEYWORD])) {
9765              return false;
9766          }
9767          return true;
9768      }
9769  
9770      /**
9771       * Postprocess selector to output in right format
9772       *
9773       * @param array $selectors
9774       *
9775       * @return array
9776       */
9777      protected function formatOutputSelector($selectors)
9778      {
9779          $selectors = $this->collapseSelectorsAsList($selectors);
9780  
9781          return $selectors;
9782      }
9783  
9784      protected static $libIsSuperselector = ['super', 'sub'];
9785      protected function libIsSuperselector($args)
9786      {
9787          list($super, $sub) = $args;
9788  
9789          $super = $this->getSelectorArg($super, 'super');
9790          $sub = $this->getSelectorArg($sub, 'sub');
9791  
9792          return $this->toBool($this->isSuperSelector($super, $sub));
9793      }
9794  
9795      /**
9796       * Test a $super selector again $sub
9797       *
9798       * @param array $super
9799       * @param array $sub
9800       *
9801       * @return bool
9802       */
9803      protected function isSuperSelector($super, $sub)
9804      {
9805          // one and only one selector for each arg
9806          if (! $super) {
9807              throw $this->error('Invalid super selector for isSuperSelector()');
9808          }
9809  
9810          if (! $sub) {
9811              throw $this->error('Invalid sub selector for isSuperSelector()');
9812          }
9813  
9814          if (count($sub) > 1) {
9815              foreach ($sub as $s) {
9816                  if (! $this->isSuperSelector($super, [$s])) {
9817                      return false;
9818                  }
9819              }
9820              return true;
9821          }
9822  
9823          if (count($super) > 1) {
9824              foreach ($super as $s) {
9825                  if ($this->isSuperSelector([$s], $sub)) {
9826                      return true;
9827                  }
9828              }
9829              return false;
9830          }
9831  
9832          $super = reset($super);
9833          $sub = reset($sub);
9834  
9835          $i = 0;
9836          $nextMustMatch = false;
9837  
9838          foreach ($super as $node) {
9839              $compound = '';
9840  
9841              array_walk_recursive(
9842                  $node,
9843                  function ($value, $key) use (&$compound) {
9844                      $compound .= $value;
9845                  }
9846              );
9847  
9848              if ($this->isImmediateRelationshipCombinator($compound)) {
9849                  if ($node !== $sub[$i]) {
9850                      return false;
9851                  }
9852  
9853                  $nextMustMatch = true;
9854                  $i++;
9855              } else {
9856                  while ($i < \count($sub) && ! $this->isSuperPart($node, $sub[$i])) {
9857                      if ($nextMustMatch) {
9858                          return false;
9859                      }
9860  
9861                      $i++;
9862                  }
9863  
9864                  if ($i >= \count($sub)) {
9865                      return false;
9866                  }
9867  
9868                  $nextMustMatch = false;
9869                  $i++;
9870              }
9871          }
9872  
9873          return true;
9874      }
9875  
9876      /**
9877       * Test a part of super selector again a part of sub selector
9878       *
9879       * @param array $superParts
9880       * @param array $subParts
9881       *
9882       * @return bool
9883       */
9884      protected function isSuperPart($superParts, $subParts)
9885      {
9886          $i = 0;
9887  
9888          foreach ($superParts as $superPart) {
9889              while ($i < \count($subParts) && $subParts[$i] !== $superPart) {
9890                  $i++;
9891              }
9892  
9893              if ($i >= \count($subParts)) {
9894                  return false;
9895              }
9896  
9897              $i++;
9898          }
9899  
9900          return true;
9901      }
9902  
9903      protected static $libSelectorAppend = ['selector...'];
9904      protected function libSelectorAppend($args)
9905      {
9906          // get the selector... list
9907          $args = reset($args);
9908          $args = $args[2];
9909  
9910          if (\count($args) < 1) {
9911              throw $this->error('selector-append() needs at least 1 argument');
9912          }
9913  
9914          $selectors = [];
9915          foreach ($args as $arg) {
9916              $selectors[] = $this->getSelectorArg($arg, 'selector');
9917          }
9918  
9919          return $this->formatOutputSelector($this->selectorAppend($selectors));
9920      }
9921  
9922      /**
9923       * Append parts of the last selector in the list to the previous, recursively
9924       *
9925       * @param array $selectors
9926       *
9927       * @return array
9928       *
9929       * @throws \ScssPhp\ScssPhp\Exception\CompilerException
9930       */
9931      protected function selectorAppend($selectors)
9932      {
9933          $lastSelectors = array_pop($selectors);
9934  
9935          if (! $lastSelectors) {
9936              throw $this->error('Invalid selector list in selector-append()');
9937          }
9938  
9939          while (\count($selectors)) {
9940              $previousSelectors = array_pop($selectors);
9941  
9942              if (! $previousSelectors) {
9943                  throw $this->error('Invalid selector list in selector-append()');
9944              }
9945  
9946              // do the trick, happening $lastSelector to $previousSelector
9947              $appended = [];
9948  
9949              foreach ($previousSelectors as $previousSelector) {
9950                  foreach ($lastSelectors as $lastSelector) {
9951                      $previous = $previousSelector;
9952                      foreach ($previousSelector as $j => $previousSelectorParts) {
9953                          foreach ($lastSelector as $lastSelectorParts) {
9954                              foreach ($lastSelectorParts as $lastSelectorPart) {
9955                                  $previous[$j][] = $lastSelectorPart;
9956                              }
9957                          }
9958                      }
9959  
9960                      $appended[] = $previous;
9961                  }
9962              }
9963  
9964              $lastSelectors = $appended;
9965          }
9966  
9967          return $lastSelectors;
9968      }
9969  
9970      protected static $libSelectorExtend = [
9971          ['selector', 'extendee', 'extender'],
9972          ['selectors', 'extendee', 'extender']
9973      ];
9974      protected function libSelectorExtend($args)
9975      {
9976          list($selectors, $extendee, $extender) = $args;
9977  
9978          $selectors = $this->getSelectorArg($selectors, 'selector');
9979          $extendee  = $this->getSelectorArg($extendee, 'extendee');
9980          $extender  = $this->getSelectorArg($extender, 'extender');
9981  
9982          if (! $selectors || ! $extendee || ! $extender) {
9983              throw $this->error('selector-extend() invalid arguments');
9984          }
9985  
9986          $extended = $this->extendOrReplaceSelectors($selectors, $extendee, $extender);
9987  
9988          return $this->formatOutputSelector($extended);
9989      }
9990  
9991      protected static $libSelectorReplace = [
9992          ['selector', 'original', 'replacement'],
9993          ['selectors', 'original', 'replacement']
9994      ];
9995      protected function libSelectorReplace($args)
9996      {
9997          list($selectors, $original, $replacement) = $args;
9998  
9999          $selectors   = $this->getSelectorArg($selectors, 'selector');
10000          $original    = $this->getSelectorArg($original, 'original');
10001          $replacement = $this->getSelectorArg($replacement, 'replacement');
10002  
10003          if (! $selectors || ! $original || ! $replacement) {
10004              throw $this->error('selector-replace() invalid arguments');
10005          }
10006  
10007          $replaced = $this->extendOrReplaceSelectors($selectors, $original, $replacement, true);
10008  
10009          return $this->formatOutputSelector($replaced);
10010      }
10011  
10012      /**
10013       * Extend/replace in selectors
10014       * used by selector-extend and selector-replace that use the same logic
10015       *
10016       * @param array $selectors
10017       * @param array $extendee
10018       * @param array $extender
10019       * @param bool  $replace
10020       *
10021       * @return array
10022       */
10023      protected function extendOrReplaceSelectors($selectors, $extendee, $extender, $replace = false)
10024      {
10025          $saveExtends = $this->extends;
10026          $saveExtendsMap = $this->extendsMap;
10027  
10028          $this->extends = [];
10029          $this->extendsMap = [];
10030  
10031          foreach ($extendee as $es) {
10032              if (\count($es) !== 1) {
10033                  throw $this->error('Can\'t extend complex selector.');
10034              }
10035  
10036              // only use the first one
10037              $this->pushExtends(reset($es), $extender, null);
10038          }
10039  
10040          $extended = [];
10041  
10042          foreach ($selectors as $selector) {
10043              if (! $replace) {
10044                  $extended[] = $selector;
10045              }
10046  
10047              $n = \count($extended);
10048  
10049              $this->matchExtends($selector, $extended);
10050  
10051              // if didnt match, keep the original selector if we are in a replace operation
10052              if ($replace && \count($extended) === $n) {
10053                  $extended[] = $selector;
10054              }
10055          }
10056  
10057          $this->extends = $saveExtends;
10058          $this->extendsMap = $saveExtendsMap;
10059  
10060          return $extended;
10061      }
10062  
10063      protected static $libSelectorNest = ['selector...'];
10064      protected function libSelectorNest($args)
10065      {
10066          // get the selector... list
10067          $args = reset($args);
10068          $args = $args[2];
10069  
10070          if (\count($args) < 1) {
10071              throw $this->error('selector-nest() needs at least 1 argument');
10072          }
10073  
10074          $selectorsMap = [];
10075          foreach ($args as $arg) {
10076              $selectorsMap[] = $this->getSelectorArg($arg, 'selector', true);
10077          }
10078  
10079          assert(!empty($selectorsMap));
10080  
10081          $envs = [];
10082  
10083          foreach ($selectorsMap as $selectors) {
10084              $env = new Environment();
10085              $env->selectors = $selectors;
10086  
10087              $envs[] = $env;
10088          }
10089  
10090          $envs            = array_reverse($envs);
10091          $env             = $this->extractEnv($envs);
10092          $outputSelectors = $this->multiplySelectors($env);
10093  
10094          return $this->formatOutputSelector($outputSelectors);
10095      }
10096  
10097      protected static $libSelectorParse = [
10098          ['selector'],
10099          ['selectors']
10100      ];
10101      protected function libSelectorParse($args)
10102      {
10103          $selectors = reset($args);
10104          $selectors = $this->getSelectorArg($selectors, 'selector');
10105  
10106          return $this->formatOutputSelector($selectors);
10107      }
10108  
10109      protected static $libSelectorUnify = ['selectors1', 'selectors2'];
10110      protected function libSelectorUnify($args)
10111      {
10112          list($selectors1, $selectors2) = $args;
10113  
10114          $selectors1 = $this->getSelectorArg($selectors1, 'selectors1');
10115          $selectors2 = $this->getSelectorArg($selectors2, 'selectors2');
10116  
10117          if (! $selectors1 || ! $selectors2) {
10118              throw $this->error('selector-unify() invalid arguments');
10119          }
10120  
10121          // only consider the first compound of each
10122          $compound1 = reset($selectors1);
10123          $compound2 = reset($selectors2);
10124  
10125          // unify them and that's it
10126          $unified = $this->unifyCompoundSelectors($compound1, $compound2);
10127  
10128          return $this->formatOutputSelector($unified);
10129      }
10130  
10131      /**
10132       * The selector-unify magic as its best
10133       * (at least works as expected on test cases)
10134       *
10135       * @param array $compound1
10136       * @param array $compound2
10137       *
10138       * @return array
10139       */
10140      protected function unifyCompoundSelectors($compound1, $compound2)
10141      {
10142          if (! \count($compound1)) {
10143              return $compound2;
10144          }
10145  
10146          if (! \count($compound2)) {
10147              return $compound1;
10148          }
10149  
10150          // check that last part are compatible
10151          $lastPart1 = array_pop($compound1);
10152          $lastPart2 = array_pop($compound2);
10153          $last      = $this->mergeParts($lastPart1, $lastPart2);
10154  
10155          if (! $last) {
10156              return [[]];
10157          }
10158  
10159          $unifiedCompound = [$last];
10160          $unifiedSelectors = [$unifiedCompound];
10161  
10162          // do the rest
10163          while (\count($compound1) || \count($compound2)) {
10164              $part1 = end($compound1);
10165              $part2 = end($compound2);
10166  
10167              if ($part1 && ($match2 = $this->matchPartInCompound($part1, $compound2))) {
10168                  list($compound2, $part2, $after2) = $match2;
10169  
10170                  if ($after2) {
10171                      $unifiedSelectors = $this->prependSelectors($unifiedSelectors, $after2);
10172                  }
10173  
10174                  $c = $this->mergeParts($part1, $part2);
10175                  $unifiedSelectors = $this->prependSelectors($unifiedSelectors, [$c]);
10176  
10177                  $part1 = $part2 = null;
10178  
10179                  array_pop($compound1);
10180              }
10181  
10182              if ($part2 && ($match1 = $this->matchPartInCompound($part2, $compound1))) {
10183                  list($compound1, $part1, $after1) = $match1;
10184  
10185                  if ($after1) {
10186                      $unifiedSelectors = $this->prependSelectors($unifiedSelectors, $after1);
10187                  }
10188  
10189                  $c = $this->mergeParts($part2, $part1);
10190                  $unifiedSelectors = $this->prependSelectors($unifiedSelectors, [$c]);
10191  
10192                  $part1 = $part2 = null;
10193  
10194                  array_pop($compound2);
10195              }
10196  
10197              $new = [];
10198  
10199              if ($part1 && $part2) {
10200                  array_pop($compound1);
10201                  array_pop($compound2);
10202  
10203                  $s   = $this->prependSelectors($unifiedSelectors, [$part2]);
10204                  $new = array_merge($new, $this->prependSelectors($s, [$part1]));
10205                  $s   = $this->prependSelectors($unifiedSelectors, [$part1]);
10206                  $new = array_merge($new, $this->prependSelectors($s, [$part2]));
10207              } elseif ($part1) {
10208                  array_pop($compound1);
10209  
10210                  $new = array_merge($new, $this->prependSelectors($unifiedSelectors, [$part1]));
10211              } elseif ($part2) {
10212                  array_pop($compound2);
10213  
10214                  $new = array_merge($new, $this->prependSelectors($unifiedSelectors, [$part2]));
10215              }
10216  
10217              if ($new) {
10218                  $unifiedSelectors = $new;
10219              }
10220          }
10221  
10222          return $unifiedSelectors;
10223      }
10224  
10225      /**
10226       * Prepend each selector from $selectors with $parts
10227       *
10228       * @param array $selectors
10229       * @param array $parts
10230       *
10231       * @return array
10232       */
10233      protected function prependSelectors($selectors, $parts)
10234      {
10235          $new = [];
10236  
10237          foreach ($selectors as $compoundSelector) {
10238              array_unshift($compoundSelector, $parts);
10239  
10240              $new[] = $compoundSelector;
10241          }
10242  
10243          return $new;
10244      }
10245  
10246      /**
10247       * Try to find a matching part in a compound:
10248       * - with same html tag name
10249       * - with some class or id or something in common
10250       *
10251       * @param array $part
10252       * @param array $compound
10253       *
10254       * @return array|false
10255       */
10256      protected function matchPartInCompound($part, $compound)
10257      {
10258          $partTag = $this->findTagName($part);
10259          $before  = $compound;
10260          $after   = [];
10261  
10262          // try to find a match by tag name first
10263          while (\count($before)) {
10264              $p = array_pop($before);
10265  
10266              if ($partTag && $partTag !== '*' && $partTag == $this->findTagName($p)) {
10267                  return [$before, $p, $after];
10268              }
10269  
10270              $after[] = $p;
10271          }
10272  
10273          // try again matching a non empty intersection and a compatible tagname
10274          $before = $compound;
10275          $after = [];
10276  
10277          while (\count($before)) {
10278              $p = array_pop($before);
10279  
10280              if ($this->checkCompatibleTags($partTag, $this->findTagName($p))) {
10281                  if (\count(array_intersect($part, $p))) {
10282                      return [$before, $p, $after];
10283                  }
10284              }
10285  
10286              $after[] = $p;
10287          }
10288  
10289          return false;
10290      }
10291  
10292      /**
10293       * Merge two part list taking care that
10294       * - the html tag is coming first - if any
10295       * - the :something are coming last
10296       *
10297       * @param array $parts1
10298       * @param array $parts2
10299       *
10300       * @return array
10301       */
10302      protected function mergeParts($parts1, $parts2)
10303      {
10304          $tag1 = $this->findTagName($parts1);
10305          $tag2 = $this->findTagName($parts2);
10306          $tag  = $this->checkCompatibleTags($tag1, $tag2);
10307  
10308          // not compatible tags
10309          if ($tag === false) {
10310              return [];
10311          }
10312  
10313          if ($tag) {
10314              if ($tag1) {
10315                  $parts1 = array_diff($parts1, [$tag1]);
10316              }
10317  
10318              if ($tag2) {
10319                  $parts2 = array_diff($parts2, [$tag2]);
10320              }
10321          }
10322  
10323          $mergedParts = array_merge($parts1, $parts2);
10324          $mergedOrderedParts = [];
10325  
10326          foreach ($mergedParts as $part) {
10327              if (strpos($part, ':') === 0) {
10328                  $mergedOrderedParts[] = $part;
10329              }
10330          }
10331  
10332          $mergedParts = array_diff($mergedParts, $mergedOrderedParts);
10333          $mergedParts = array_merge($mergedParts, $mergedOrderedParts);
10334  
10335          if ($tag) {
10336              array_unshift($mergedParts, $tag);
10337          }
10338  
10339          return $mergedParts;
10340      }
10341  
10342      /**
10343       * Check the compatibility between two tag names:
10344       * if both are defined they should be identical or one has to be '*'
10345       *
10346       * @param string $tag1
10347       * @param string $tag2
10348       *
10349       * @return array|false
10350       */
10351      protected function checkCompatibleTags($tag1, $tag2)
10352      {
10353          $tags = [$tag1, $tag2];
10354          $tags = array_unique($tags);
10355          $tags = array_filter($tags);
10356  
10357          if (\count($tags) > 1) {
10358              $tags = array_diff($tags, ['*']);
10359          }
10360  
10361          // not compatible nodes
10362          if (\count($tags) > 1) {
10363              return false;
10364          }
10365  
10366          return $tags;
10367      }
10368  
10369      /**
10370       * Find the html tag name in a selector parts list
10371       *
10372       * @param string[] $parts
10373       *
10374       * @return string
10375       */
10376      protected function findTagName($parts)
10377      {
10378          foreach ($parts as $part) {
10379              if (! preg_match('/^[\[.:#%_-]/', $part)) {
10380                  return $part;
10381              }
10382          }
10383  
10384          return '';
10385      }
10386  
10387      protected static $libSimpleSelectors = ['selector'];
10388      protected function libSimpleSelectors($args)
10389      {
10390          $selector = reset($args);
10391          $selector = $this->getSelectorArg($selector, 'selector');
10392  
10393          // remove selectors list layer, keeping the first one
10394          $selector = reset($selector);
10395  
10396          // remove parts list layer, keeping the first part
10397          $part = reset($selector);
10398  
10399          $listParts = [];
10400  
10401          foreach ($part as $p) {
10402              $listParts[] = [Type::T_STRING, '', [$p]];
10403          }
10404  
10405          return [Type::T_LIST, ',', $listParts];
10406      }
10407  
10408      protected static $libScssphpGlob = ['pattern'];
10409      protected function libScssphpGlob($args)
10410      {
10411          @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);
10412  
10413          $this->logger->warn('The "scssphp-glob" function is deprecated an will be removed in ScssPhp 2.0.', true);
10414  
10415          $string = $this->assertString($args[0], 'pattern');
10416          $pattern = $this->compileStringContent($string);
10417          $matches = glob($pattern);
10418          $listParts = [];
10419  
10420          foreach ($matches as $match) {
10421              if (! is_file($match)) {
10422                  continue;
10423              }
10424  
10425              $listParts[] = [Type::T_STRING, '"', [$match]];
10426          }
10427  
10428          return [Type::T_LIST, ',', $listParts];
10429      }
10430  }