vendor/scssphp/scssphp/src/Parser.php line 2098

Open in your IDE?
  1. <?php
  3. /**
  4.  * SCSSPHP
  5.  *
  6.  * @copyright 2012-2020 Leaf Corcoran
  7.  *
  8.  * @license http://opensource.org/licenses/MIT MIT
  9.  *
  10.  * @link http://scssphp.github.io/scssphp
  11.  */
  13. namespace ScssPhp\ScssPhp;
  15. use ScssPhp\ScssPhp\Exception\ParserException;
  16. use ScssPhp\ScssPhp\Logger\LoggerInterface;
  17. use ScssPhp\ScssPhp\Logger\QuietLogger;
  19. /**
  20.  * Parser
  21.  *
  22.  * @author Leaf Corcoran <leafot@gmail.com>
  23.  *
  24.  * @internal
  25.  */
  26. class Parser
  27. {
  28.     const SOURCE_INDEX  = -1;
  29.     const SOURCE_LINE   = -2;
  30.     const SOURCE_COLUMN = -3;
  32.     /**
  33.      * @var array<string, int>
  34.      */
  35.     protected static $precedence = [
  36.         '='   => 0,
  37.         'or'  => 1,
  38.         'and' => 2,
  39.         '=='  => 3,
  40.         '!='  => 3,
  41.         '<='  => 4,
  42.         '>='  => 4,
  43.         '<'   => 4,
  44.         '>'   => 4,
  45.         '+'   => 5,
  46.         '-'   => 5,
  47.         '*'   => 6,
  48.         '/'   => 6,
  49.         '%'   => 6,
  50.     ];
  52.     /**
  53.      * @var string
  54.      */
  55.     protected static $commentPattern;
  56.     /**
  57.      * @var string
  58.      */
  59.     protected static $operatorPattern;
  60.     /**
  61.      * @var string
  62.      */
  63.     protected static $whitePattern;
  65.     /**
  66.      * @var Cache|null
  67.      */
  68.     protected $cache;
  70.     private $sourceName;
  71.     private $sourceIndex;
  72.     /**
  73.      * @var array<int, int>
  74.      */
  75.     private $sourcePositions;
  76.     /**
  77.      * @var array|null
  78.      */
  79.     private $charset;
  80.     /**
  81.      * The current offset in the buffer
  82.      *
  83.      * @var int
  84.      */
  85.     private $count;
  86.     /**
  87.      * @var Block|null
  88.      */
  89.     private $env;
  90.     /**
  91.      * @var bool
  92.      */
  93.     private $inParens;
  94.     /**
  95.      * @var bool
  96.      */
  97.     private $eatWhiteDefault;
  98.     /**
  99.      * @var bool
  100.      */
  101.     private $discardComments;
  102.     private $allowVars;
  103.     /**
  104.      * @var string
  105.      */
  106.     private $buffer;
  107.     private $utf8;
  108.     /**
  109.      * @var string|null
  110.      */
  111.     private $encoding;
  112.     private $patternModifiers;
  113.     private $commentsSeen;
  115.     private $cssOnly;
  117.     /**
  118.      * @var LoggerInterface
  119.      */
  120.     private $logger;
  122.     /**
  123.      * Constructor
  124.      *
  125.      * @api
  126.      *
  127.      * @param string|null          $sourceName
  128.      * @param integer              $sourceIndex
  129.      * @param string|null          $encoding
  130.      * @param Cache|null           $cache
  131.      * @param bool                 $cssOnly
  132.      * @param LoggerInterface|null $logger
  133.      */
  134.     public function __construct($sourceName, $sourceIndex = 0, $encoding = 'utf-8', Cache $cache = null, $cssOnly = false, LoggerInterface $logger = null)
  135.     {
  136.         $this->sourceName       = $sourceName ?: '(stdin)';
  137.         $this->sourceIndex      = $sourceIndex;
  138.         $this->charset          = null;
  139.         $this->utf8             = ! $encoding || strtolower($encoding) === 'utf-8';
  140.         $this->patternModifiers = $this->utf8 ? 'Aisu' : 'Ais';
  141.         $this->commentsSeen     = [];
  142.         $this->commentsSeen     = [];
  143.         $this->allowVars        = true;
  144.         $this->cssOnly          = $cssOnly;
  145.         $this->logger = $logger ?: new QuietLogger();
  147.         if (empty(static::$operatorPattern)) {
  148.             static::$operatorPattern = '([*\/%+-]|[!=]\=|\>\=?|\<\=?|and|or)';
  150.             $commentSingle      = '\/\/';
  151.             $commentMultiLeft   = '\/\*';
  152.             $commentMultiRight  = '\*\/';
  154.             static::$commentPattern = $commentMultiLeft . '.*?' . $commentMultiRight;
  155.             static::$whitePattern = $this->utf8
  156.                 ? '/' . $commentSingle . '[^\n]*\s*|(' . static::$commentPattern . ')\s*|\s+/AisuS'
  157.                 : '/' . $commentSingle . '[^\n]*\s*|(' . static::$commentPattern . ')\s*|\s+/AisS';
  158.         }
  160.         $this->cache = $cache;
  161.     }
  163.     /**
  164.      * Get source file name
  165.      *
  166.      * @api
  167.      *
  168.      * @return string
  169.      */
  170.     public function getSourceName()
  171.     {
  172.         return $this->sourceName;
  173.     }
  175.     /**
  176.      * Throw parser error
  177.      *
  178.      * @api
  179.      *
  180.      * @param string $msg
  181.      *
  182.      * @phpstan-return never-return
  183.      *
  184.      * @throws ParserException
  185.      *
  186.      * @deprecated use "parseError" and throw the exception in the caller instead.
  187.      */
  188.     public function throwParseError($msg = 'parse error')
  189.     {
  190.         @trigger_error(
  191.             'The method "throwParseError" is deprecated. Use "parseError" and throw the exception in the caller instead',
  192.             E_USER_DEPRECATED
  193.         );
  195.         throw $this->parseError($msg);
  196.     }
  198.     /**
  199.      * Creates a parser error
  200.      *
  201.      * @api
  202.      *
  203.      * @param string $msg
  204.      *
  205.      * @return ParserException
  206.      */
  207.     public function parseError($msg = 'parse error')
  208.     {
  209.         list($line, $column) = $this->getSourcePosition($this->count);
  211.         $loc = empty($this->sourceName)
  212.              ? "line: $line, column: $column"
  213.              : "$this->sourceName on line $line, at column $column";
  215.         if ($this->peek('(.*?)(\n|$)', $m, $this->count)) {
  216.             $this->restoreEncoding();
  218.             $e = new ParserException("$msg: failed at `$m[1]` $loc");
  219.             $e->setSourcePosition([$this->sourceName, $line, $column]);
  221.             return $e;
  222.         }
  224.         $this->restoreEncoding();
  226.         $e = new ParserException("$msg: $loc");
  227.         $e->setSourcePosition([$this->sourceName, $line, $column]);
  229.         return $e;
  230.     }
  232.     /**
  233.      * Parser buffer
  234.      *
  235.      * @api
  236.      *
  237.      * @param string $buffer
  238.      *
  239.      * @return Block
  240.      */
  241.     public function parse($buffer)
  242.     {
  243.         if ($this->cache) {
  244.             $cacheKey = $this->sourceName . ':' . md5($buffer);
  245.             $parseOptions = [
  246.                 'charset' => $this->charset,
  247.                 'utf8' => $this->utf8,
  248.             ];
  249.             $v = $this->cache->getCache('parse', $cacheKey, $parseOptions);
  251.             if (! \is_null($v)) {
  252.                 return $v;
  253.             }
  254.         }
  256.         // strip BOM (byte order marker)
  257.         if (substr($buffer, 0, 3) === "\xef\xbb\xbf") {
  258.             $buffer = substr($buffer, 3);
  259.         }
  261.         $this->buffer          = rtrim($buffer, "\x00..\x1f");
  262.         $this->count           = 0;
  263.         $this->env             = null;
  264.         $this->inParens        = false;
  265.         $this->eatWhiteDefault = true;
  267.         $this->saveEncoding();
  268.         $this->extractLineNumbers($buffer);
  270.         $this->pushBlock(null); // root block
  271.         $this->whitespace();
  272.         $this->pushBlock(null);
  273.         $this->popBlock();
  275.         while ($this->parseChunk()) {
  276.             ;
  277.         }
  279.         if ($this->count !== \strlen($this->buffer)) {
  280.             throw $this->parseError();
  281.         }
  283.         if (! empty($this->env->parent)) {
  284.             throw $this->parseError('unclosed block');
  285.         }
  287.         if ($this->charset) {
  288.             array_unshift($this->env->children, $this->charset);
  289.         }
  291.         $this->restoreEncoding();
  293.         if ($this->cache) {
  294.             $this->cache->setCache('parse', $cacheKey, $this->env, $parseOptions);
  295.         }
  297.         return $this->env;
  298.     }
  300.     /**
  301.      * Parse a value or value list
  302.      *
  303.      * @api
  304.      *
  305.      * @param string       $buffer
  306.      * @param string|array $out
  307.      *
  308.      * @return boolean
  309.      */
  310.     public function parseValue($buffer, &$out)
  311.     {
  312.         $this->count           = 0;
  313.         $this->env             = null;
  314.         $this->inParens        = false;
  315.         $this->eatWhiteDefault = true;
  316.         $this->buffer          = (string) $buffer;
  318.         $this->saveEncoding();
  319.         $this->extractLineNumbers($this->buffer);
  321.         $list = $this->valueList($out);
  323.         $this->restoreEncoding();
  325.         return $list;
  326.     }
  328.     /**
  329.      * Parse a selector or selector list
  330.      *
  331.      * @api
  332.      *
  333.      * @param string       $buffer
  334.      * @param string|array $out
  335.      * @param bool         $shouldValidate
  336.      *
  337.      * @return boolean
  338.      */
  339.     public function parseSelector($buffer, &$out, $shouldValidate = true)
  340.     {
  341.         $this->count           = 0;
  342.         $this->env             = null;
  343.         $this->inParens        = false;
  344.         $this->eatWhiteDefault = true;
  345.         $this->buffer          = (string) $buffer;
  347.         $this->saveEncoding();
  348.         $this->extractLineNumbers($this->buffer);
  350.         // discard space/comments at the start
  351.         $this->discardComments = true;
  352.         $this->whitespace();
  353.         $this->discardComments = false;
  355.         $selector = $this->selectors($out);
  357.         $this->restoreEncoding();
  359.         if ($shouldValidate && $this->count !== strlen($buffer)) {
  360.             throw $this->parseError("`" . substr($buffer, $this->count) . "` is not a valid Selector in `$buffer`");
  361.         }
  363.         return $selector;
  364.     }
  366.     /**
  367.      * Parse a media Query
  368.      *
  369.      * @api
  370.      *
  371.      * @param string       $buffer
  372.      * @param string|array $out
  373.      *
  374.      * @return boolean
  375.      */
  376.     public function parseMediaQueryList($buffer, &$out)
  377.     {
  378.         $this->count           = 0;
  379.         $this->env             = null;
  380.         $this->inParens        = false;
  381.         $this->eatWhiteDefault = true;
  382.         $this->buffer          = (string) $buffer;
  384.         $this->saveEncoding();
  385.         $this->extractLineNumbers($this->buffer);
  387.         $isMediaQuery = $this->mediaQueryList($out);
  389.         $this->restoreEncoding();
  391.         return $isMediaQuery;
  392.     }
  394.     /**
  395.      * Parse a single chunk off the head of the buffer and append it to the
  396.      * current parse environment.
  397.      *
  398.      * Returns false when the buffer is empty, or when there is an error.
  399.      *
  400.      * This function is called repeatedly until the entire document is
  401.      * parsed.
  402.      *
  403.      * This parser is most similar to a recursive descent parser. Single
  404.      * functions represent discrete grammatical rules for the language, and
  405.      * they are able to capture the text that represents those rules.
  406.      *
  407.      * Consider the function Compiler::keyword(). (All parse functions are
  408.      * structured the same.)
  409.      *
  410.      * The function takes a single reference argument. When calling the
  411.      * function it will attempt to match a keyword on the head of the buffer.
  412.      * If it is successful, it will place the keyword in the referenced
  413.      * argument, advance the position in the buffer, and return true. If it
  414.      * fails then it won't advance the buffer and it will return false.
  415.      *
  416.      * All of these parse functions are powered by Compiler::match(), which behaves
  417.      * the same way, but takes a literal regular expression. Sometimes it is
  418.      * more convenient to use match instead of creating a new function.
  419.      *
  420.      * Because of the format of the functions, to parse an entire string of
  421.      * grammatical rules, you can chain them together using &&.
  422.      *
  423.      * But, if some of the rules in the chain succeed before one fails, then
  424.      * the buffer position will be left at an invalid state. In order to
  425.      * avoid this, Compiler::seek() is used to remember and set buffer positions.
  426.      *
  427.      * Before parsing a chain, use $s = $this->count to remember the current
  428.      * position into $s. Then if a chain fails, use $this->seek($s) to
  429.      * go back where we started.
  430.      *
  431.      * @return boolean
  432.      */
  433.     protected function parseChunk()
  434.     {
  435.         $s = $this->count;
  437.         // the directives
  438.         if (isset($this->buffer[$this->count]) && $this->buffer[$this->count] === '@') {
  439.             if (
  440.                 $this->literal('@at-root', 8) &&
  441.                 ($this->selectors($selector) || true) &&
  442.                 ($this->map($with) || true) &&
  443.                 (($this->matchChar('(') &&
  444.                     $this->interpolation($with) &&
  445.                     $this->matchChar(')')) || true) &&
  446.                 $this->matchChar('{', false)
  447.             ) {
  448.                 ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  450.                 $atRoot = $this->pushSpecialBlock(Type::T_AT_ROOT, $s);
  451.                 $atRoot->selector = $selector;
  452.                 $atRoot->with     = $with;
  454.                 return true;
  455.             }
  457.             $this->seek($s);
  459.             if (
  460.                 $this->literal('@media', 6) &&
  461.                 $this->mediaQueryList($mediaQueryList) &&
  462.                 $this->matchChar('{', false)
  463.             ) {
  464.                 $media = $this->pushSpecialBlock(Type::T_MEDIA, $s);
  465.                 $media->queryList = $mediaQueryList[2];
  467.                 return true;
  468.             }
  470.             $this->seek($s);
  472.             if (
  473.                 $this->literal('@mixin', 6) &&
  474.                 $this->keyword($mixinName) &&
  475.                 ($this->argumentDef($args) || true) &&
  476.                 $this->matchChar('{', false)
  477.             ) {
  478.                 ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  480.                 $mixin = $this->pushSpecialBlock(Type::T_MIXIN, $s);
  481.                 $mixin->name = $mixinName;
  482.                 $mixin->args = $args;
  484.                 return true;
  485.             }
  487.             $this->seek($s);
  489.             if (
  490.                 ($this->literal('@include', 8) &&
  491.                     $this->keyword($mixinName) &&
  492.                     ($this->matchChar('(') &&
  493.                     ($this->argValues($argValues) || true) &&
  494.                     $this->matchChar(')') || true) &&
  495.                     ($this->end()) ||
  496.                 ($this->literal('using', 5) &&
  497.                     $this->argumentDef($argUsing) &&
  498.                     ($this->end() || $this->matchChar('{') && $hasBlock = true)) ||
  499.                 $this->matchChar('{') && $hasBlock = true)
  500.             ) {
  501.                 ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  503.                 $child = [
  504.                     Type::T_INCLUDE,
  505.                     $mixinName,
  506.                     isset($argValues) ? $argValues : null,
  507.                     null,
  508.                     isset($argUsing) ? $argUsing : null
  509.                 ];
  511.                 if (! empty($hasBlock)) {
  512.                     $include = $this->pushSpecialBlock(Type::T_INCLUDE, $s);
  513.                     $include->child = $child;
  514.                 } else {
  515.                     $this->append($child, $s);
  516.                 }
  518.                 return true;
  519.             }
  521.             $this->seek($s);
  523.             if (
  524.                 $this->literal('@scssphp-import-once', 20) &&
  525.                 $this->valueList($importPath) &&
  526.                 $this->end()
  527.             ) {
  528.                 ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  530.                 list($line, $column) = $this->getSourcePosition($s);
  531.                 $file = $this->sourceName;
  532.                 $this->logger->warn("The \"@scssphp-import-once\" directive is deprecated and will be removed in ScssPhp 2.0, in \"$file\", line $line, column $column.", true);
  534.                 $this->append([Type::T_SCSSPHP_IMPORT_ONCE, $importPath], $s);
  536.                 return true;
  537.             }
  539.             $this->seek($s);
  541.             if (
  542.                 $this->literal('@import', 7) &&
  543.                 $this->valueList($importPath) &&
  544.                 $importPath[0] !== Type::T_FUNCTION_CALL &&
  545.                 $this->end()
  546.             ) {
  547.                 if ($this->cssOnly) {
  548.                     $this->assertPlainCssValid([Type::T_IMPORT, $importPath], $s);
  549.                     $this->append([Type::T_COMMENT, rtrim(substr($this->buffer, $s, $this->count - $s))]);
  550.                     return true;
  551.                 }
  553.                 $this->append([Type::T_IMPORT, $importPath], $s);
  555.                 return true;
  556.             }
  558.             $this->seek($s);
  560.             if (
  561.                 $this->literal('@import', 7) &&
  562.                 $this->url($importPath) &&
  563.                 $this->end()
  564.             ) {
  565.                 if ($this->cssOnly) {
  566.                     $this->assertPlainCssValid([Type::T_IMPORT, $importPath], $s);
  567.                     $this->append([Type::T_COMMENT, rtrim(substr($this->buffer, $s, $this->count - $s))]);
  568.                     return true;
  569.                 }
  571.                 $this->append([Type::T_IMPORT, $importPath], $s);
  573.                 return true;
  574.             }
  576.             $this->seek($s);
  578.             if (
  579.                 $this->literal('@extend', 7) &&
  580.                 $this->selectors($selectors) &&
  581.                 $this->end()
  582.             ) {
  583.                 ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  585.                 // check for '!flag'
  586.                 $optional = $this->stripOptionalFlag($selectors);
  587.                 $this->append([Type::T_EXTEND, $selectors, $optional], $s);
  589.                 return true;
  590.             }
  592.             $this->seek($s);
  594.             if (
  595.                 $this->literal('@function', 9) &&
  596.                 $this->keyword($fnName) &&
  597.                 $this->argumentDef($args) &&
  598.                 $this->matchChar('{', false)
  599.             ) {
  600.                 ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  602.                 $func = $this->pushSpecialBlock(Type::T_FUNCTION, $s);
  603.                 $func->name = $fnName;
  604.                 $func->args = $args;
  606.                 return true;
  607.             }
  609.             $this->seek($s);
  611.             if (
  612.                 $this->literal('@return', 7) &&
  613.                 ($this->valueList($retVal) || true) &&
  614.                 $this->end()
  615.             ) {
  616.                 ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  618.                 $this->append([Type::T_RETURN, isset($retVal) ? $retVal : [Type::T_NULL]], $s);
  620.                 return true;
  621.             }
  623.             $this->seek($s);
  625.             if (
  626.                 $this->literal('@each', 5) &&
  627.                 $this->genericList($varNames, 'variable', ',', false) &&
  628.                 $this->literal('in', 2) &&
  629.                 $this->valueList($list) &&
  630.                 $this->matchChar('{', false)
  631.             ) {
  632.                 ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  634.                 $each = $this->pushSpecialBlock(Type::T_EACH, $s);
  636.                 foreach ($varNames[2] as $varName) {
  637.                     $each->vars[] = $varName[1];
  638.                 }
  640.                 $each->list = $list;
  642.                 return true;
  643.             }
  645.             $this->seek($s);
  647.             if (
  648.                 $this->literal('@while', 6) &&
  649.                 $this->expression($cond) &&
  650.                 $this->matchChar('{', false)
  651.             ) {
  652.                 ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  654.                 while (
  655.                     $cond[0] === Type::T_LIST &&
  656.                     ! empty($cond['enclosing']) &&
  657.                     $cond['enclosing'] === 'parent' &&
  658.                     \count($cond[2]) == 1
  659.                 ) {
  660.                     $cond = reset($cond[2]);
  661.                 }
  663.                 $while = $this->pushSpecialBlock(Type::T_WHILE, $s);
  664.                 $while->cond = $cond;
  666.                 return true;
  667.             }
  669.             $this->seek($s);
  671.             if (
  672.                 $this->literal('@for', 4) &&
  673.                 $this->variable($varName) &&
  674.                 $this->literal('from', 4) &&
  675.                 $this->expression($start) &&
  676.                 ($this->literal('through', 7) ||
  677.                     ($forUntil = true && $this->literal('to', 2))) &&
  678.                 $this->expression($end) &&
  679.                 $this->matchChar('{', false)
  680.             ) {
  681.                 ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  683.                 $for = $this->pushSpecialBlock(Type::T_FOR, $s);
  684.                 $for->var   = $varName[1];
  685.                 $for->start = $start;
  686.                 $for->end   = $end;
  687.                 $for->until = isset($forUntil);
  689.                 return true;
  690.             }
  692.             $this->seek($s);
  694.             if (
  695.                 $this->literal('@if', 3) &&
  696.                 $this->functionCallArgumentsList($cond, false, '{', false)
  697.             ) {
  698.                 ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  700.                 $if = $this->pushSpecialBlock(Type::T_IF, $s);
  702.                 while (
  703.                     $cond[0] === Type::T_LIST &&
  704.                     ! empty($cond['enclosing']) &&
  705.                     $cond['enclosing'] === 'parent' &&
  706.                     \count($cond[2]) == 1
  707.                 ) {
  708.                     $cond = reset($cond[2]);
  709.                 }
  711.                 $if->cond  = $cond;
  712.                 $if->cases = [];
  714.                 return true;
  715.             }
  717.             $this->seek($s);
  719.             if (
  720.                 $this->literal('@debug', 6) &&
  721.                 $this->functionCallArgumentsList($value, false)
  722.             ) {
  723.                 ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  725.                 $this->append([Type::T_DEBUG, $value], $s);
  727.                 return true;
  728.             }
  730.             $this->seek($s);
  732.             if (
  733.                 $this->literal('@warn', 5) &&
  734.                 $this->functionCallArgumentsList($value, false)
  735.             ) {
  736.                 ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  738.                 $this->append([Type::T_WARN, $value], $s);
  740.                 return true;
  741.             }
  743.             $this->seek($s);
  745.             if (
  746.                 $this->literal('@error', 6) &&
  747.                 $this->functionCallArgumentsList($value, false)
  748.             ) {
  749.                 ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  751.                 $this->append([Type::T_ERROR, $value], $s);
  753.                 return true;
  754.             }
  756.             $this->seek($s);
  758.             if (
  759.                 $this->literal('@content', 8) &&
  760.                 ($this->end() ||
  761.                     $this->matchChar('(') &&
  762.                     $this->argValues($argContent) &&
  763.                     $this->matchChar(')') &&
  764.                     $this->end())
  765.             ) {
  766.                 ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  768.                 $this->append([Type::T_MIXIN_CONTENT, isset($argContent) ? $argContent : null], $s);
  770.                 return true;
  771.             }
  773.             $this->seek($s);
  775.             $last = $this->last();
  777.             if (isset($last) && $last[0] === Type::T_IF) {
  778.                 list(, $if) = $last;
  780.                 if ($this->literal('@else', 5)) {
  781.                     if ($this->matchChar('{', false)) {
  782.                         $else = $this->pushSpecialBlock(Type::T_ELSE, $s);
  783.                     } elseif (
  784.                         $this->literal('if', 2) &&
  785.                         $this->functionCallArgumentsList($cond, false, '{', false)
  786.                     ) {
  787.                         $else = $this->pushSpecialBlock(Type::T_ELSEIF, $s);
  788.                         $else->cond = $cond;
  789.                     }
  791.                     if (isset($else)) {
  792.                         $else->dontAppend = true;
  793.                         $if->cases[] = $else;
  795.                         return true;
  796.                     }
  797.                 }
  799.                 $this->seek($s);
  800.             }
  802.             // only retain the first @charset directive encountered
  803.             if (
  804.                 $this->literal('@charset', 8) &&
  805.                 $this->valueList($charset) &&
  806.                 $this->end()
  807.             ) {
  808.                 if (! isset($this->charset)) {
  809.                     $statement = [Type::T_CHARSET, $charset];
  811.                     list($line, $column) = $this->getSourcePosition($s);
  813.                     $statement[static::SOURCE_LINE]   = $line;
  814.                     $statement[static::SOURCE_COLUMN] = $column;
  815.                     $statement[static::SOURCE_INDEX]  = $this->sourceIndex;
  817.                     $this->charset = $statement;
  818.                 }
  820.                 return true;
  821.             }
  823.             $this->seek($s);
  825.             if (
  826.                 $this->literal('@supports', 9) &&
  827.                 ($t1 = $this->supportsQuery($supportQuery)) &&
  828.                 ($t2 = $this->matchChar('{', false))
  829.             ) {
  830.                 $directive = $this->pushSpecialBlock(Type::T_DIRECTIVE, $s);
  831.                 $directive->name  = 'supports';
  832.                 $directive->value = $supportQuery;
  834.                 return true;
  835.             }
  837.             $this->seek($s);
  839.             // doesn't match built in directive, do generic one
  840.             if (
  841.                 $this->matchChar('@', false) &&
  842.                 $this->mixedKeyword($dirName) &&
  843.                 $this->directiveValue($dirValue, '{')
  844.             ) {
  845.                 if (count($dirName) === 1 && is_string(reset($dirName))) {
  846.                     $dirName = reset($dirName);
  847.                 } else {
  848.                     $dirName = [Type::T_STRING, '', $dirName];
  849.                 }
  850.                 if ($dirName === 'media') {
  851.                     $directive = $this->pushSpecialBlock(Type::T_MEDIA, $s);
  852.                 } else {
  853.                     $directive = $this->pushSpecialBlock(Type::T_DIRECTIVE, $s);
  854.                     $directive->name = $dirName;
  855.                 }
  857.                 if (isset($dirValue)) {
  858.                     ! $this->cssOnly || ($dirValue = $this->assertPlainCssValid($dirValue));
  859.                     $directive->value = $dirValue;
  860.                 }
  862.                 return true;
  863.             }
  865.             $this->seek($s);
  867.             // maybe it's a generic blockless directive
  868.             if (
  869.                 $this->matchChar('@', false) &&
  870.                 $this->mixedKeyword($dirName) &&
  871.                 ! $this->isKnownGenericDirective($dirName) &&
  872.                 ($this->end(false) || ($this->directiveValue($dirValue, '') && $this->end(false)))
  873.             ) {
  874.                 if (\count($dirName) === 1 && \is_string(\reset($dirName))) {
  875.                     $dirName = \reset($dirName);
  876.                 } else {
  877.                     $dirName = [Type::T_STRING, '', $dirName];
  878.                 }
  879.                 if (
  880.                     ! empty($this->env->parent) &&
  881.                     $this->env->type &&
  882.                     ! \in_array($this->env->type, [Type::T_DIRECTIVE, Type::T_MEDIA])
  883.                 ) {
  884.                     $plain = \trim(\substr($this->buffer, $s, $this->count - $s));
  885.                     throw $this->parseError(
  886.                         "Unknown directive `{$plain}` not allowed in `" . $this->env->type . "` block"
  887.                     );
  888.                 }
  889.                 // blockless directives with a blank line after keeps their blank lines after
  890.                 // sass-spec compliance purpose
  891.                 $s = $this->count;
  892.                 $hasBlankLine = false;
  893.                 if ($this->match('\s*?\n\s*\n', $out, false)) {
  894.                     $hasBlankLine = true;
  895.                     $this->seek($s);
  896.                 }
  897.                 $isNotRoot = ! empty($this->env->parent);
  898.                 $this->append([Type::T_DIRECTIVE, [$dirName, $dirValue, $hasBlankLine, $isNotRoot]], $s);
  899.                 $this->whitespace();
  901.                 return true;
  902.             }
  904.             $this->seek($s);
  906.             return false;
  907.         }
  909.         $inCssSelector = null;
  910.         if ($this->cssOnly) {
  911.             $inCssSelector = (! empty($this->env->parent) &&
  912.                 ! in_array($this->env->type, [Type::T_DIRECTIVE, Type::T_MEDIA]));
  913.         }
  914.         // custom properties : right part is static
  915.         if (($this->customProperty($name) ) && $this->matchChar(':', false)) {
  916.             $start = $this->count;
  918.             // but can be complex and finish with ; or }
  919.             foreach ([';','}'] as $ending) {
  920.                 if (
  921.                     $this->openString($ending, $stringValue, '(', ')', false) &&
  922.                     $this->end()
  923.                 ) {
  924.                     $end = $this->count;
  925.                     $value = $stringValue;
  927.                     // check if we have only a partial value due to nested [] or { } to take in account
  928.                     $nestingPairs = [['[', ']'], ['{', '}']];
  930.                     foreach ($nestingPairs as $nestingPair) {
  931.                         $p = strpos($this->buffer, $nestingPair[0], $start);
  933.                         if ($p && $p < $end) {
  934.                             $this->seek($start);
  936.                             if (
  937.                                 $this->openString($ending, $stringValue, $nestingPair[0], $nestingPair[1], false) &&
  938.                                 $this->end() &&
  939.                                 $this->count > $end
  940.                             ) {
  941.                                 $end = $this->count;
  942.                                 $value = $stringValue;
  943.                             }
  944.                         }
  945.                     }
  947.                     $this->seek($end);
  948.                     $this->append([Type::T_CUSTOM_PROPERTY, $name, $value], $s);
  950.                     return true;
  951.                 }
  952.             }
  954.             // TODO: output an error here if nothing found according to sass spec
  955.         }
  957.         $this->seek($s);
  959.         // property shortcut
  960.         // captures most properties before having to parse a selector
  961.         if (
  962.             $this->keyword($name, false) &&
  963.             $this->literal(': ', 2) &&
  964.             $this->valueList($value) &&
  965.             $this->end()
  966.         ) {
  967.             $name = [Type::T_STRING, '', [$name]];
  968.             $this->append([Type::T_ASSIGN, $name, $value], $s);
  970.             return true;
  971.         }
  973.         $this->seek($s);
  975.         // variable assigns
  976.         if (
  977.             $this->variable($name) &&
  978.             $this->matchChar(':') &&
  979.             $this->valueList($value) &&
  980.             $this->end()
  981.         ) {
  982.             ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  984.             // check for '!flag'
  985.             $assignmentFlags = $this->stripAssignmentFlags($value);
  986.             $this->append([Type::T_ASSIGN, $name, $value, $assignmentFlags], $s);
  988.             return true;
  989.         }
  991.         $this->seek($s);
  993.         // opening css block
  994.         if (
  995.             $this->selectors($selectors) &&
  996.             $this->matchChar('{', false)
  997.         ) {
  998.             ! $this->cssOnly || ! $inCssSelector || $this->assertPlainCssValid(false);
  1000.             $this->pushBlock($selectors, $s);
  1002.             if ($this->eatWhiteDefault) {
  1003.                 $this->whitespace();
  1004.                 $this->append(null); // collect comments at the beginning if needed
  1005.             }
  1007.             return true;
  1008.         }
  1010.         $this->seek($s);
  1012.         // property assign, or nested assign
  1013.         if (
  1014.             $this->propertyName($name) &&
  1015.             $this->matchChar(':')
  1016.         ) {
  1017.             $foundSomething = false;
  1019.             if ($this->valueList($value)) {
  1020.                 if (empty($this->env->parent)) {
  1021.                     throw $this->parseError('expected "{"');
  1022.                 }
  1024.                 $this->append([Type::T_ASSIGN, $name, $value], $s);
  1025.                 $foundSomething = true;
  1026.             }
  1028.             if ($this->matchChar('{', false)) {
  1029.                 ! $this->cssOnly || $this->assertPlainCssValid(false);
  1031.                 $propBlock = $this->pushSpecialBlock(Type::T_NESTED_PROPERTY, $s);
  1032.                 $propBlock->prefix = $name;
  1033.                 $propBlock->hasValue = $foundSomething;
  1035.                 $foundSomething = true;
  1036.             } elseif ($foundSomething) {
  1037.                 $foundSomething = $this->end();
  1038.             }
  1040.             if ($foundSomething) {
  1041.                 return true;
  1042.             }
  1043.         }
  1045.         $this->seek($s);
  1047.         // closing a block
  1048.         if ($this->matchChar('}', false)) {
  1049.             $block = $this->popBlock();
  1051.             if (! isset($block->type) || $block->type !== Type::T_IF) {
  1052.                 if ($this->env->parent) {
  1053.                     $this->append(null); // collect comments before next statement if needed
  1054.                 }
  1055.             }
  1057.             if (isset($block->type) && $block->type === Type::T_INCLUDE) {
  1058.                 $include = $block->child;
  1059.                 unset($block->child);
  1060.                 $include[3] = $block;
  1061.                 $this->append($include, $s);
  1062.             } elseif (empty($block->dontAppend)) {
  1063.                 $type = isset($block->type) ? $block->type : Type::T_BLOCK;
  1064.                 $this->append([$type, $block], $s);
  1065.             }
  1067.             // collect comments just after the block closing if needed
  1068.             if ($this->eatWhiteDefault) {
  1069.                 $this->whitespace();
  1071.                 if ($this->env->comments) {
  1072.                     $this->append(null);
  1073.                 }
  1074.             }
  1076.             return true;
  1077.         }
  1079.         // extra stuff
  1080.         if ($this->matchChar(';')) {
  1081.             return true;
  1082.         }
  1084.         return false;
  1085.     }
  1087.     /**
  1088.      * Push block onto parse tree
  1089.      *
  1090.      * @param array|null $selectors
  1091.      * @param integer $pos
  1092.      *
  1093.      * @return Block
  1094.      */
  1095.     protected function pushBlock($selectors, $pos = 0)
  1096.     {
  1097.         list($line, $column) = $this->getSourcePosition($pos);
  1099.         $b = new Block();
  1100.         $b->sourceName   = $this->sourceName;
  1101.         $b->sourceLine   = $line;
  1102.         $b->sourceColumn = $column;
  1103.         $b->sourceIndex  = $this->sourceIndex;
  1104.         $b->selectors    = $selectors;
  1105.         $b->comments     = [];
  1106.         $b->parent       = $this->env;
  1108.         if (! $this->env) {
  1109.             $b->children = [];
  1110.         } elseif (empty($this->env->children)) {
  1111.             $this->env->children = $this->env->comments;
  1112.             $b->children = [];
  1113.             $this->env->comments = [];
  1114.         } else {
  1115.             $b->children = $this->env->comments;
  1116.             $this->env->comments = [];
  1117.         }
  1119.         $this->env = $b;
  1121.         // collect comments at the beginning of a block if needed
  1122.         if ($this->eatWhiteDefault) {
  1123.             $this->whitespace();
  1125.             if ($this->env->comments) {
  1126.                 $this->append(null);
  1127.             }
  1128.         }
  1130.         return $b;
  1131.     }
  1133.     /**
  1134.      * Push special (named) block onto parse tree
  1135.      *
  1136.      * @param string  $type
  1137.      * @param integer $pos
  1138.      *
  1139.      * @return Block
  1140.      */
  1141.     protected function pushSpecialBlock($type, $pos)
  1142.     {
  1143.         $block = $this->pushBlock(null, $pos);
  1144.         $block->type = $type;
  1146.         return $block;
  1147.     }
  1149.     /**
  1150.      * Pop scope and return last block
  1151.      *
  1152.      * @return Block
  1153.      *
  1154.      * @throws \Exception
  1155.      */
  1156.     protected function popBlock()
  1157.     {
  1159.         // collect comments ending just before of a block closing
  1160.         if ($this->env->comments) {
  1161.             $this->append(null);
  1162.         }
  1164.         // pop the block
  1165.         $block = $this->env;
  1167.         if (empty($block->parent)) {
  1168.             throw $this->parseError('unexpected }');
  1169.         }
  1171.         if ($block->type == Type::T_AT_ROOT) {
  1172.             // keeps the parent in case of self selector &
  1173.             $block->selfParent = $block->parent;
  1174.         }
  1176.         $this->env = $block->parent;
  1178.         unset($block->parent);
  1180.         return $block;
  1181.     }
  1183.     /**
  1184.      * Peek input stream
  1185.      *
  1186.      * @param string  $regex
  1187.      * @param array   $out
  1188.      * @param integer $from
  1189.      *
  1190.      * @return integer
  1191.      */
  1192.     protected function peek($regex, &$out, $from = null)
  1193.     {
  1194.         if (! isset($from)) {
  1195.             $from = $this->count;
  1196.         }
  1198.         $r = '/' . $regex . '/' . $this->patternModifiers;
  1199.         $result = preg_match($r, $this->buffer, $out, 0, $from);
  1201.         return $result;
  1202.     }
  1204.     /**
  1205.      * Seek to position in input stream (or return current position in input stream)
  1206.      *
  1207.      * @param integer $where
  1208.      */
  1209.     protected function seek($where)
  1210.     {
  1211.         $this->count = $where;
  1212.     }
  1214.     /**
  1215.      * Assert a parsed part is plain CSS Valid
  1216.      *
  1217.      * @param array|false $parsed
  1218.      * @param int $startPos
  1219.      * @throws ParserException
  1220.      */
  1221.     protected function assertPlainCssValid($parsed, $startPos = null)
  1222.     {
  1223.         $type = '';
  1224.         if ($parsed) {
  1225.             $type = $parsed[0];
  1226.             $parsed = $this->isPlainCssValidElement($parsed);
  1227.         }
  1228.         if (! $parsed) {
  1229.             if (! \is_null($startPos)) {
  1230.                 $plain = rtrim(substr($this->buffer, $startPos, $this->count - $startPos));
  1231.                 $message = "Error : `{$plain}` isn't allowed in plain CSS";
  1232.             } else {
  1233.                 $message = 'Error: SCSS syntax not allowed in CSS file';
  1234.             }
  1235.             if ($type) {
  1236.                 $message .= " ($type)";
  1237.             }
  1238.             throw $this->parseError($message);
  1239.         }
  1241.         return $parsed;
  1242.     }
  1244.     /**
  1245.      * Check a parsed element is plain CSS Valid
  1246.      * @param array $parsed
  1247.      * @return bool|array
  1248.      */
  1249.     protected function isPlainCssValidElement($parsed, $allowExpression = false)
  1250.     {
  1251.         // keep string as is
  1252.         if (is_string($parsed)) {
  1253.             return $parsed;
  1254.         }
  1256.         if (
  1257.             \in_array($parsed[0], [Type::T_FUNCTION, Type::T_FUNCTION_CALL]) &&
  1258.             !\in_array($parsed[1], [
  1259.                 'alpha',
  1260.                 'attr',
  1261.                 'calc',
  1262.                 'cubic-bezier',
  1263.                 'env',
  1264.                 'grayscale',
  1265.                 'hsl',
  1266.                 'hsla',
  1267.                 'hwb',
  1268.                 'invert',
  1269.                 'linear-gradient',
  1270.                 'min',
  1271.                 'max',
  1272.                 'radial-gradient',
  1273.                 'repeating-linear-gradient',
  1274.                 'repeating-radial-gradient',
  1275.                 'rgb',
  1276.                 'rgba',
  1277.                 'rotate',
  1278.                 'saturate',
  1279.                 'var',
  1280.             ]) &&
  1281.             Compiler::isNativeFunction($parsed[1])
  1282.         ) {
  1283.             return false;
  1284.         }
  1286.         switch ($parsed[0]) {
  1287.             case Type::T_BLOCK:
  1288.             case Type::T_KEYWORD:
  1289.             case Type::T_NULL:
  1290.             case Type::T_NUMBER:
  1291.             case Type::T_MEDIA:
  1292.                 return $parsed;
  1294.             case Type::T_COMMENT:
  1295.                 if (isset($parsed[2])) {
  1296.                     return false;
  1297.                 }
  1298.                 return $parsed;
  1300.             case Type::T_DIRECTIVE:
  1301.                 if (\is_array($parsed[1])) {
  1302.                     $parsed[1][1] = $this->isPlainCssValidElement($parsed[1][1]);
  1303.                     if (! $parsed[1][1]) {
  1304.                         return false;
  1305.                     }
  1306.                 }
  1308.                 return $parsed;
  1310.             case Type::T_IMPORT:
  1311.                 if ($parsed[1][0] === Type::T_LIST) {
  1312.                     return false;
  1313.                 }
  1314.                 $parsed[1] = $this->isPlainCssValidElement($parsed[1]);
  1315.                 if ($parsed[1] === false) {
  1316.                     return false;
  1317.                 }
  1318.                 return $parsed;
  1320.             case Type::T_STRING:
  1321.                 foreach ($parsed[2] as $k => $substr) {
  1322.                     if (\is_array($substr)) {
  1323.                         $parsed[2][$k] = $this->isPlainCssValidElement($substr);
  1324.                         if (! $parsed[2][$k]) {
  1325.                             return false;
  1326.                         }
  1327.                     }
  1328.                 }
  1329.                 return $parsed;
  1331.             case Type::T_LIST:
  1332.                 if (!empty($parsed['enclosing'])) {
  1333.                     return false;
  1334.                 }
  1335.                 foreach ($parsed[2] as $k => $listElement) {
  1336.                     $parsed[2][$k] = $this->isPlainCssValidElement($listElement);
  1337.                     if (! $parsed[2][$k]) {
  1338.                         return false;
  1339.                     }
  1340.                 }
  1341.                 return $parsed;
  1343.             case Type::T_ASSIGN:
  1344.                 foreach ([1, 2, 3] as $k) {
  1345.                     if (! empty($parsed[$k])) {
  1346.                         $parsed[$k] = $this->isPlainCssValidElement($parsed[$k]);
  1347.                         if (! $parsed[$k]) {
  1348.                             return false;
  1349.                         }
  1350.                     }
  1351.                 }
  1352.                 return $parsed;
  1354.             case Type::T_EXPRESSION:
  1355.                 list( ,$op, $lhs, $rhs, $inParens, $whiteBefore, $whiteAfter) = $parsed;
  1356.                 if (! $allowExpression &&  ! \in_array($op, ['and', 'or', '/'])) {
  1357.                     return false;
  1358.                 }
  1359.                 $lhs = $this->isPlainCssValidElement($lhs, true);
  1360.                 if (! $lhs) {
  1361.                     return false;
  1362.                 }
  1363.                 $rhs = $this->isPlainCssValidElement($rhs, true);
  1364.                 if (! $rhs) {
  1365.                     return false;
  1366.                 }
  1368.                 return [
  1369.                     Type::T_STRING,
  1370.                     '', [
  1371.                         $this->inParens ? '(' : '',
  1372.                         $lhs,
  1373.                         ($whiteBefore ? ' ' : '') . $op . ($whiteAfter ? ' ' : ''),
  1374.                         $rhs,
  1375.                         $this->inParens ? ')' : ''
  1376.                     ]
  1377.                 ];
  1379.             case Type::T_CUSTOM_PROPERTY:
  1380.             case Type::T_UNARY:
  1381.                 $parsed[2] = $this->isPlainCssValidElement($parsed[2]);
  1382.                 if (! $parsed[2]) {
  1383.                     return false;
  1384.                 }
  1385.                 return $parsed;
  1387.             case Type::T_FUNCTION:
  1388.                 $argsList = $parsed[2];
  1389.                 foreach ($argsList[2] as $argElement) {
  1390.                     if (! $this->isPlainCssValidElement($argElement)) {
  1391.                         return false;
  1392.                     }
  1393.                 }
  1394.                 return $parsed;
  1396.             case Type::T_FUNCTION_CALL:
  1397.                 $parsed[0] = Type::T_FUNCTION;
  1398.                 $argsList = [Type::T_LIST, ',', []];
  1399.                 foreach ($parsed[2] as $arg) {
  1400.                     if ($arg[0] || ! empty($arg[2])) {
  1401.                         // no named arguments possible in a css function call
  1402.                         // nor ... argument
  1403.                         return false;
  1404.                     }
  1405.                     $arg = $this->isPlainCssValidElement($arg[1], $parsed[1] === 'calc');
  1406.                     if (! $arg) {
  1407.                         return false;
  1408.                     }
  1409.                     $argsList[2][] = $arg;
  1410.                 }
  1411.                 $parsed[2] = $argsList;
  1412.                 return $parsed;
  1413.         }
  1415.         return false;
  1416.     }
  1418.     /**
  1419.      * Match string looking for either ending delim, escape, or string interpolation
  1420.      *
  1421.      * {@internal This is a workaround for preg_match's 250K string match limit. }}
  1422.      *
  1423.      * @param array  $m     Matches (passed by reference)
  1424.      * @param string $delim Delimiter
  1425.      *
  1426.      * @return boolean True if match; false otherwise
  1427.      */
  1428.     protected function matchString(&$m, $delim)
  1429.     {
  1430.         $token = null;
  1432.         $end = \strlen($this->buffer);
  1434.         // look for either ending delim, escape, or string interpolation
  1435.         foreach (['#{', '\\', "\r", $delim] as $lookahead) {
  1436.             $pos = strpos($this->buffer, $lookahead, $this->count);
  1438.             if ($pos !== false && $pos < $end) {
  1439.                 $end = $pos;
  1440.                 $token = $lookahead;
  1441.             }
  1442.         }
  1444.         if (! isset($token)) {
  1445.             return false;
  1446.         }
  1448.         $match = substr($this->buffer, $this->count, $end - $this->count);
  1449.         $m = [
  1450.             $match . $token,
  1451.             $match,
  1452.             $token
  1453.         ];
  1454.         $this->count = $end + \strlen($token);
  1456.         return true;
  1457.     }
  1459.     /**
  1460.      * Try to match something on head of buffer
  1461.      *
  1462.      * @param string  $regex
  1463.      * @param array   $out
  1464.      * @param boolean $eatWhitespace
  1465.      *
  1466.      * @return boolean
  1467.      */
  1468.     protected function match($regex, &$out, $eatWhitespace = null)
  1469.     {
  1470.         $r = '/' . $regex . '/' . $this->patternModifiers;
  1472.         if (! preg_match($r, $this->buffer, $out, 0, $this->count)) {
  1473.             return false;
  1474.         }
  1476.         $this->count += \strlen($out[0]);
  1478.         if (! isset($eatWhitespace)) {
  1479.             $eatWhitespace = $this->eatWhiteDefault;
  1480.         }
  1482.         if ($eatWhitespace) {
  1483.             $this->whitespace();
  1484.         }
  1486.         return true;
  1487.     }
  1489.     /**
  1490.      * Match a single string
  1491.      *
  1492.      * @param string  $char
  1493.      * @param boolean $eatWhitespace
  1494.      *
  1495.      * @return boolean
  1496.      */
  1497.     protected function matchChar($char, $eatWhitespace = null)
  1498.     {
  1499.         if (! isset($this->buffer[$this->count]) || $this->buffer[$this->count] !== $char) {
  1500.             return false;
  1501.         }
  1503.         $this->count++;
  1505.         if (! isset($eatWhitespace)) {
  1506.             $eatWhitespace = $this->eatWhiteDefault;
  1507.         }
  1509.         if ($eatWhitespace) {
  1510.             $this->whitespace();
  1511.         }
  1513.         return true;
  1514.     }
  1516.     /**
  1517.      * Match literal string
  1518.      *
  1519.      * @param string  $what
  1520.      * @param integer $len
  1521.      * @param boolean $eatWhitespace
  1522.      *
  1523.      * @return boolean
  1524.      */
  1525.     protected function literal($what, $len, $eatWhitespace = null)
  1526.     {
  1527.         if (strcasecmp(substr($this->buffer, $this->count, $len), $what) !== 0) {
  1528.             return false;
  1529.         }
  1531.         $this->count += $len;
  1533.         if (! isset($eatWhitespace)) {
  1534.             $eatWhitespace = $this->eatWhiteDefault;
  1535.         }
  1537.         if ($eatWhitespace) {
  1538.             $this->whitespace();
  1539.         }
  1541.         return true;
  1542.     }
  1544.     /**
  1545.      * Match some whitespace
  1546.      *
  1547.      * @return boolean
  1548.      */
  1549.     protected function whitespace()
  1550.     {
  1551.         $gotWhite = false;
  1553.         while (preg_match(static::$whitePattern, $this->buffer, $m, 0, $this->count)) {
  1554.             if (isset($m[1]) && empty($this->commentsSeen[$this->count])) {
  1555.                 // comment that are kept in the output CSS
  1556.                 $comment = [];
  1557.                 $startCommentCount = $this->count;
  1558.                 $endCommentCount = $this->count + \strlen($m[1]);
  1560.                 // find interpolations in comment
  1561.                 $p = strpos($this->buffer, '#{', $this->count);
  1563.                 while ($p !== false && $p < $endCommentCount) {
  1564.                     $c           = substr($this->buffer, $this->count, $p - $this->count);
  1565.                     $comment[]   = $c;
  1566.                     $this->count = $p;
  1567.                     $out         = null;
  1569.                     if ($this->interpolation($out)) {
  1570.                         // keep right spaces in the following string part
  1571.                         if ($out[3]) {
  1572.                             while ($this->buffer[$this->count - 1] !== '}') {
  1573.                                 $this->count--;
  1574.                             }
  1576.                             $out[3] = '';
  1577.                         }
  1579.                         $comment[] = [Type::T_COMMENT, substr($this->buffer, $p, $this->count - $p), $out];
  1580.                     } else {
  1581.                         list($line, $column) = $this->getSourcePosition($this->count);
  1582.                         $file = $this->sourceName;
  1583.                         if (!$this->discardComments) {
  1584.                             $this->logger->warn("Unterminated interpolations in multiline comments are deprecated and will be removed in ScssPhp 2.0, in \"$file\", line $line, column $column.", true);
  1585.                         }
  1586.                         $comment[] = substr($this->buffer, $this->count, 2);
  1588.                         $this->count += 2;
  1589.                     }
  1591.                     $p = strpos($this->buffer, '#{', $this->count);
  1592.                 }
  1594.                 // remaining part
  1595.                 $c = substr($this->buffer, $this->count, $endCommentCount - $this->count);
  1597.                 if (! $comment) {
  1598.                     // single part static comment
  1599.                     $this->appendComment([Type::T_COMMENT, $c]);
  1600.                 } else {
  1601.                     $comment[] = $c;
  1602.                     $staticComment = substr($this->buffer, $startCommentCount, $endCommentCount - $startCommentCount);
  1603.                     $commentStatement = [Type::T_COMMENT, $staticComment, [Type::T_STRING, '', $comment]];
  1605.                     list($line, $column) = $this->getSourcePosition($startCommentCount);
  1606.                     $commentStatement[self::SOURCE_LINE] = $line;
  1607.                     $commentStatement[self::SOURCE_COLUMN] = $column;
  1608.                     $commentStatement[self::SOURCE_INDEX] = $this->sourceIndex;
  1610.                     $this->appendComment($commentStatement);
  1611.                 }
  1613.                 $this->commentsSeen[$startCommentCount] = true;
  1614.                 $this->count = $endCommentCount;
  1615.             } else {
  1616.                 // comment that are ignored and not kept in the output css
  1617.                 $this->count += \strlen($m[0]);
  1618.                 // silent comments are not allowed in plain CSS files
  1619.                 ! $this->cssOnly
  1620.                   || ! \strlen(trim($m[0]))
  1621.                   || $this->assertPlainCssValid(false, $this->count - \strlen($m[0]));
  1622.             }
  1624.             $gotWhite = true;
  1625.         }
  1627.         return $gotWhite;
  1628.     }
  1630.     /**
  1631.      * Append comment to current block
  1632.      *
  1633.      * @param array $comment
  1634.      */
  1635.     protected function appendComment($comment)
  1636.     {
  1637.         if (! $this->discardComments) {
  1638.             $this->env->comments[] = $comment;
  1639.         }
  1640.     }
  1642.     /**
  1643.      * Append statement to current block
  1644.      *
  1645.      * @param array|null $statement
  1646.      * @param integer $pos
  1647.      */
  1648.     protected function append($statement, $pos = null)
  1649.     {
  1650.         if (! \is_null($statement)) {
  1651.             ! $this->cssOnly || ($statement = $this->assertPlainCssValid($statement, $pos));
  1653.             if (! \is_null($pos)) {
  1654.                 list($line, $column) = $this->getSourcePosition($pos);
  1656.                 $statement[static::SOURCE_LINE]   = $line;
  1657.                 $statement[static::SOURCE_COLUMN] = $column;
  1658.                 $statement[static::SOURCE_INDEX]  = $this->sourceIndex;
  1659.             }
  1661.             $this->env->children[] = $statement;
  1662.         }
  1664.         $comments = $this->env->comments;
  1666.         if ($comments) {
  1667.             $this->env->children = array_merge($this->env->children, $comments);
  1668.             $this->env->comments = [];
  1669.         }
  1670.     }
  1672.     /**
  1673.      * Returns last child was appended
  1674.      *
  1675.      * @return array|null
  1676.      */
  1677.     protected function last()
  1678.     {
  1679.         $i = \count($this->env->children) - 1;
  1681.         if (isset($this->env->children[$i])) {
  1682.             return $this->env->children[$i];
  1683.         }
  1684.     }
  1686.     /**
  1687.      * Parse media query list
  1688.      *
  1689.      * @param array $out
  1690.      *
  1691.      * @return boolean
  1692.      */
  1693.     protected function mediaQueryList(&$out)
  1694.     {
  1695.         return $this->genericList($out, 'mediaQuery', ',', false);
  1696.     }
  1698.     /**
  1699.      * Parse media query
  1700.      *
  1701.      * @param array $out
  1702.      *
  1703.      * @return boolean
  1704.      */
  1705.     protected function mediaQuery(&$out)
  1706.     {
  1707.         $expressions = null;
  1708.         $parts = [];
  1710.         if (
  1711.             ($this->literal('only', 4) && ($only = true) ||
  1712.             $this->literal('not', 3) && ($not = true) || true) &&
  1713.             $this->mixedKeyword($mediaType)
  1714.         ) {
  1715.             $prop = [Type::T_MEDIA_TYPE];
  1717.             if (isset($only)) {
  1718.                 $prop[] = [Type::T_KEYWORD, 'only'];
  1719.             }
  1721.             if (isset($not)) {
  1722.                 $prop[] = [Type::T_KEYWORD, 'not'];
  1723.             }
  1725.             $media = [Type::T_LIST, '', []];
  1727.             foreach ((array) $mediaType as $type) {
  1728.                 if (\is_array($type)) {
  1729.                     $media[2][] = $type;
  1730.                 } else {
  1731.                     $media[2][] = [Type::T_KEYWORD, $type];
  1732.                 }
  1733.             }
  1735.             $prop[]  = $media;
  1736.             $parts[] = $prop;
  1737.         }
  1739.         if (empty($parts) || $this->literal('and', 3)) {
  1740.             $this->genericList($expressions, 'mediaExpression', 'and', false);
  1742.             if (\is_array($expressions)) {
  1743.                 $parts = array_merge($parts, $expressions[2]);
  1744.             }
  1745.         }
  1747.         $out = $parts;
  1749.         return true;
  1750.     }
  1752.     /**
  1753.      * Parse supports query
  1754.      *
  1755.      * @param array $out
  1756.      *
  1757.      * @return boolean
  1758.      */
  1759.     protected function supportsQuery(&$out)
  1760.     {
  1761.         $expressions = null;
  1762.         $parts = [];
  1764.         $s = $this->count;
  1766.         $not = false;
  1768.         if (
  1769.             ($this->literal('not', 3) && ($not = true) || true) &&
  1770.             $this->matchChar('(') &&
  1771.             ($this->expression($property)) &&
  1772.             $this->literal(': ', 2) &&
  1773.             $this->valueList($value) &&
  1774.             $this->matchChar(')')
  1775.         ) {
  1776.             $support = [Type::T_STRING, '', [[Type::T_KEYWORD, ($not ? 'not ' : '') . '(']]];
  1777.             $support[2][] = $property;
  1778.             $support[2][] = [Type::T_KEYWORD, ': '];
  1779.             $support[2][] = $value;
  1780.             $support[2][] = [Type::T_KEYWORD, ')'];
  1782.             $parts[] = $support;
  1783.             $s = $this->count;
  1784.         } else {
  1785.             $this->seek($s);
  1786.         }
  1788.         if (
  1789.             $this->matchChar('(') &&
  1790.             $this->supportsQuery($subQuery) &&
  1791.             $this->matchChar(')')
  1792.         ) {
  1793.             $parts[] = [Type::T_STRING, '', [[Type::T_KEYWORD, '('], $subQuery, [Type::T_KEYWORD, ')']]];
  1794.             $s = $this->count;
  1795.         } else {
  1796.             $this->seek($s);
  1797.         }
  1799.         if (
  1800.             $this->literal('not', 3) &&
  1801.             $this->supportsQuery($subQuery)
  1802.         ) {
  1803.             $parts[] = [Type::T_STRING, '', [[Type::T_KEYWORD, 'not '], $subQuery]];
  1804.             $s = $this->count;
  1805.         } else {
  1806.             $this->seek($s);
  1807.         }
  1809.         if (
  1810.             $this->literal('selector(', 9) &&
  1811.             $this->selector($selector) &&
  1812.             $this->matchChar(')')
  1813.         ) {
  1814.             $support = [Type::T_STRING, '', [[Type::T_KEYWORD, 'selector(']]];
  1816.             $selectorList = [Type::T_LIST, '', []];
  1818.             foreach ($selector as $sc) {
  1819.                 $compound = [Type::T_STRING, '', []];
  1821.                 foreach ($sc as $scp) {
  1822.                     if (\is_array($scp)) {
  1823.                         $compound[2][] = $scp;
  1824.                     } else {
  1825.                         $compound[2][] = [Type::T_KEYWORD, $scp];
  1826.                     }
  1827.                 }
  1829.                 $selectorList[2][] = $compound;
  1830.             }
  1832.             $support[2][] = $selectorList;
  1833.             $support[2][] = [Type::T_KEYWORD, ')'];
  1834.             $parts[] = $support;
  1835.             $s = $this->count;
  1836.         } else {
  1837.             $this->seek($s);
  1838.         }
  1840.         if ($this->variable($var) or $this->interpolation($var)) {
  1841.             $parts[] = $var;
  1842.             $s = $this->count;
  1843.         } else {
  1844.             $this->seek($s);
  1845.         }
  1847.         if (
  1848.             $this->literal('and', 3) &&
  1849.             $this->genericList($expressions, 'supportsQuery', ' and', false)
  1850.         ) {
  1851.             array_unshift($expressions[2], [Type::T_STRING, '', $parts]);
  1853.             $parts = [$expressions];
  1854.             $s = $this->count;
  1855.         } else {
  1856.             $this->seek($s);
  1857.         }
  1859.         if (
  1860.             $this->literal('or', 2) &&
  1861.             $this->genericList($expressions, 'supportsQuery', ' or', false)
  1862.         ) {
  1863.             array_unshift($expressions[2], [Type::T_STRING, '', $parts]);
  1865.             $parts = [$expressions];
  1866.             $s = $this->count;
  1867.         } else {
  1868.             $this->seek($s);
  1869.         }
  1871.         if (\count($parts)) {
  1872.             if ($this->eatWhiteDefault) {
  1873.                 $this->whitespace();
  1874.             }
  1876.             $out = [Type::T_STRING, '', $parts];
  1878.             return true;
  1879.         }
  1881.         return false;
  1882.     }
  1885.     /**
  1886.      * Parse media expression
  1887.      *
  1888.      * @param array $out
  1889.      *
  1890.      * @return boolean
  1891.      */
  1892.     protected function mediaExpression(&$out)
  1893.     {
  1894.         $s = $this->count;
  1895.         $value = null;
  1897.         if (
  1898.             $this->matchChar('(') &&
  1899.             $this->expression($feature) &&
  1900.             ($this->matchChar(':') &&
  1901.                 $this->expression($value) || true) &&
  1902.             $this->matchChar(')')
  1903.         ) {
  1904.             $out = [Type::T_MEDIA_EXPRESSION, $feature];
  1906.             if ($value) {
  1907.                 $out[] = $value;
  1908.             }
  1910.             return true;
  1911.         }
  1913.         $this->seek($s);
  1915.         return false;
  1916.     }
  1918.     /**
  1919.      * Parse argument values
  1920.      *
  1921.      * @param array $out
  1922.      *
  1923.      * @return boolean
  1924.      */
  1925.     protected function argValues(&$out)
  1926.     {
  1927.         $discardComments = $this->discardComments;
  1928.         $this->discardComments = true;
  1930.         if ($this->genericList($list, 'argValue', ',', false)) {
  1931.             $out = $list[2];
  1933.             $this->discardComments = $discardComments;
  1935.             return true;
  1936.         }
  1938.         $this->discardComments = $discardComments;
  1940.         return false;
  1941.     }
  1943.     /**
  1944.      * Parse argument value
  1945.      *
  1946.      * @param array $out
  1947.      *
  1948.      * @return boolean
  1949.      */
  1950.     protected function argValue(&$out)
  1951.     {
  1952.         $s = $this->count;
  1954.         $keyword = null;
  1956.         if (! $this->variable($keyword) || ! $this->matchChar(':')) {
  1957.             $this->seek($s);
  1959.             $keyword = null;
  1960.         }
  1962.         if ($this->genericList($value, 'expression', '', true)) {
  1963.             $out = [$keyword, $value, false];
  1964.             $s = $this->count;
  1966.             if ($this->literal('...', 3)) {
  1967.                 $out[2] = true;
  1968.             } else {
  1969.                 $this->seek($s);
  1970.             }
  1972.             return true;
  1973.         }
  1975.         return false;
  1976.     }
  1978.     /**
  1979.      * Check if a generic directive is known to be able to allow almost any syntax or not
  1980.      * @param mixed $directiveName
  1981.      * @return bool
  1982.      */
  1983.     protected function isKnownGenericDirective($directiveName)
  1984.     {
  1985.         if (\is_array($directiveName) && \is_string(reset($directiveName))) {
  1986.             $directiveName = reset($directiveName);
  1987.         }
  1988.         if (! \is_string($directiveName)) {
  1989.             return false;
  1990.         }
  1991.         if (
  1992.             \in_array($directiveName, [
  1993.             'at-root',
  1994.             'media',
  1995.             'mixin',
  1996.             'include',
  1997.             'scssphp-import-once',
  1998.             'import',
  1999.             'extend',
  2000.             'function',
  2001.             'break',
  2002.             'continue',
  2003.             'return',
  2004.             'each',
  2005.             'while',
  2006.             'for',
  2007.             'if',
  2008.             'debug',
  2009.             'warn',
  2010.             'error',
  2011.             'content',
  2012.             'else',
  2013.             'charset',
  2014.             'supports',
  2015.             // Todo
  2016.             'use',
  2017.             'forward',
  2018.             ])
  2019.         ) {
  2020.             return true;
  2021.         }
  2022.         return false;
  2023.     }
  2025.     /**
  2026.      * Parse directive value list that considers $vars as keyword
  2027.      *
  2028.      * @param array          $out
  2029.      * @param boolean|string $endChar
  2030.      *
  2031.      * @return boolean
  2032.      */
  2033.     protected function directiveValue(&$out, $endChar = false)
  2034.     {
  2035.         $s = $this->count;
  2037.         if ($this->variable($out)) {
  2038.             if ($endChar && $this->matchChar($endChar, false)) {
  2039.                 return true;
  2040.             }
  2042.             if (! $endChar && $this->end()) {
  2043.                 return true;
  2044.             }
  2045.         }
  2047.         $this->seek($s);
  2049.         if (\is_string($endChar) && $this->openString($endChar ? $endChar : ';', $out, null, null, true, ";}{")) {
  2050.             if ($endChar && $this->matchChar($endChar, false)) {
  2051.                 return true;
  2052.             }
  2053.             $ss = $this->count;
  2054.             if (!$endChar && $this->end()) {
  2055.                 $this->seek($ss);
  2056.                 return true;
  2057.             }
  2058.         }
  2060.         $this->seek($s);
  2062.         $allowVars = $this->allowVars;
  2063.         $this->allowVars = false;
  2065.         $res = $this->genericList($out, 'spaceList', ',');
  2066.         $this->allowVars = $allowVars;
  2068.         if ($res) {
  2069.             if ($endChar && $this->matchChar($endChar, false)) {
  2070.                 return true;
  2071.             }
  2073.             if (! $endChar && $this->end()) {
  2074.                 return true;
  2075.             }
  2076.         }
  2078.         $this->seek($s);
  2080.         if ($endChar && $this->matchChar($endChar, false)) {
  2081.             return true;
  2082.         }
  2084.         return false;
  2085.     }
  2087.     /**
  2088.      * Parse comma separated value list
  2089.      *
  2090.      * @param array $out
  2091.      *
  2092.      * @return boolean
  2093.      */
  2094.     protected function valueList(&$out)
  2095.     {
  2096.         $discardComments = $this->discardComments;
  2097.         $this->discardComments = true;
  2098.         $res = $this->genericList($out, 'spaceList', ',');
  2099.         $this->discardComments = $discardComments;
  2101.         return $res;
  2102.     }
  2104.     /**
  2105.      * Parse a function call, where externals () are part of the call
  2106.      * and not of the value list
  2107.      *
  2108.      * @param $out
  2109.      * @param bool $mandatoryEnclos
  2110.      * @param null|string $charAfter
  2111.      * @param null|bool $eatWhiteSp
  2112.      * @return bool
  2113.      */
  2114.     protected function functionCallArgumentsList(&$out, $mandatoryEnclos = true, $charAfter = null, $eatWhiteSp = null)
  2115.     {
  2116.         $s = $this->count;
  2118.         if (
  2119.             $this->matchChar('(') &&
  2120.             $this->valueList($out) &&
  2121.             $this->matchChar(')') &&
  2122.             ($charAfter ? $this->matchChar($charAfter, $eatWhiteSp) : $this->end())
  2123.         ) {
  2124.             return true;
  2125.         }
  2127.         if (! $mandatoryEnclos) {
  2128.             $this->seek($s);
  2130.             if (
  2131.                 $this->valueList($out) &&
  2132.                 ($charAfter ? $this->matchChar($charAfter, $eatWhiteSp) : $this->end())
  2133.             ) {
  2134.                 return true;
  2135.             }
  2136.         }
  2138.         $this->seek($s);
  2140.         return false;
  2141.     }
  2143.     /**
  2144.      * Parse space separated value list
  2145.      *
  2146.      * @param array $out
  2147.      *
  2148.      * @return boolean
  2149.      */
  2150.     protected function spaceList(&$out)
  2151.     {
  2152.         return $this->genericList($out, 'expression');
  2153.     }
  2155.     /**
  2156.      * Parse generic list
  2157.      *
  2158.      * @param array   $out
  2159.      * @param string  $parseItem The name of the method used to parse items
  2160.      * @param string  $delim
  2161.      * @param boolean $flatten
  2162.      *
  2163.      * @return boolean
  2164.      */
  2165.     protected function genericList(&$out, $parseItem, $delim = '', $flatten = true)
  2166.     {
  2167.         $s     = $this->count;
  2168.         $items = [];
  2169.         $value = null;
  2171.         while ($this->$parseItem($value)) {
  2172.             $trailing_delim = false;
  2173.             $items[] = $value;
  2175.             if ($delim) {
  2176.                 if (! $this->literal($delim, \strlen($delim))) {
  2177.                     break;
  2178.                 }
  2180.                 $trailing_delim = true;
  2181.             } else {
  2182.                 // if no delim watch that a keyword didn't eat the single/double quote
  2183.                 // from the following starting string
  2184.                 if ($value[0] === Type::T_KEYWORD) {
  2185.                     $word = $value[1];
  2187.                     $last_char = substr($word, -1);
  2189.                     if (
  2190.                         strlen($word) > 1 &&
  2191.                         in_array($last_char, [ "'", '"']) &&
  2192.                         substr($word, -2, 1) !== '\\'
  2193.                     ) {
  2194.                         // if there is a non escaped opening quote in the keyword, this seems unlikely a mistake
  2195.                         $word = str_replace('\\' . $last_char, '\\\\', $word);
  2196.                         if (strpos($word, $last_char) < strlen($word) - 1) {
  2197.                             continue;
  2198.                         }
  2200.                         $currentCount = $this->count;
  2202.                         // let's try to rewind to previous char and try a parse
  2203.                         $this->count--;
  2204.                         // in case the keyword also eat spaces
  2205.                         while (substr($this->buffer, $this->count, 1) !== $last_char) {
  2206.                             $this->count--;
  2207.                         }
  2209.                         $nextValue = null;
  2210.                         if ($this->$parseItem($nextValue)) {
  2211.                             if ($nextValue[0] === Type::T_KEYWORD && $nextValue[1] === $last_char) {
  2212.                                 // bad try, forget it
  2213.                                 $this->seek($currentCount);
  2214.                                 continue;
  2215.                             }
  2216.                             if ($nextValue[0] !== Type::T_STRING) {
  2217.                                 // bad try, forget it
  2218.                                 $this->seek($currentCount);
  2219.                                 continue;
  2220.                             }
  2222.                             // OK it was a good idea
  2223.                             $value[1] = substr($value[1], 0, -1);
  2224.                             array_pop($items);
  2225.                             $items[] = $value;
  2226.                             $items[] = $nextValue;
  2227.                         } else {
  2228.                             // bad try, forget it
  2229.                             $this->seek($currentCount);
  2230.                             continue;
  2231.                         }
  2232.                     }
  2233.                 }
  2234.             }
  2235.         }
  2237.         if (! $items) {
  2238.             $this->seek($s);
  2240.             return false;
  2241.         }
  2243.         if ($trailing_delim) {
  2244.             $items[] = [Type::T_NULL];
  2245.         }
  2247.         if ($flatten && \count($items) === 1) {
  2248.             $out = $items[0];
  2249.         } else {
  2250.             $out = [Type::T_LIST, $delim, $items];
  2251.         }
  2253.         return true;
  2254.     }
  2256.     /**
  2257.      * Parse expression
  2258.      *
  2259.      * @param array   $out
  2260.      * @param boolean $listOnly
  2261.      * @param boolean $lookForExp
  2262.      *
  2263.      * @return boolean
  2264.      */
  2265.     protected function expression(&$out, $listOnly = false, $lookForExp = true)
  2266.     {
  2267.         $s = $this->count;
  2268.         $discard = $this->discardComments;
  2269.         $this->discardComments = true;
  2270.         $allowedTypes = ($listOnly ? [Type::T_LIST] : [Type::T_LIST, Type::T_MAP]);
  2272.         if ($this->matchChar('(')) {
  2273.             if ($this->enclosedExpression($lhs, $s, ')', $allowedTypes)) {
  2274.                 if ($lookForExp) {
  2275.                     $out = $this->expHelper($lhs, 0);
  2276.                 } else {
  2277.                     $out = $lhs;
  2278.                 }
  2280.                 $this->discardComments = $discard;
  2282.                 return true;
  2283.             }
  2285.             $this->seek($s);
  2286.         }
  2288.         if (\in_array(Type::T_LIST, $allowedTypes) && $this->matchChar('[')) {
  2289.             if ($this->enclosedExpression($lhs, $s, ']', [Type::T_LIST])) {
  2290.                 if ($lookForExp) {
  2291.                     $out = $this->expHelper($lhs, 0);
  2292.                 } else {
  2293.                     $out = $lhs;
  2294.                 }
  2296.                 $this->discardComments = $discard;
  2298.                 return true;
  2299.             }
  2301.             $this->seek($s);
  2302.         }
  2304.         if (! $listOnly && $this->value($lhs)) {
  2305.             if ($lookForExp) {
  2306.                 $out = $this->expHelper($lhs, 0);
  2307.             } else {
  2308.                 $out = $lhs;
  2309.             }
  2311.             $this->discardComments = $discard;
  2313.             return true;
  2314.         }
  2316.         $this->discardComments = $discard;
  2318.         return false;
  2319.     }
  2321.     /**
  2322.      * Parse expression specifically checking for lists in parenthesis or brackets
  2323.      *
  2324.      * @param array   $out
  2325.      * @param integer $s
  2326.      * @param string  $closingParen
  2327.      * @param array   $allowedTypes
  2328.      *
  2329.      * @return boolean
  2330.      */
  2331.     protected function enclosedExpression(&$out, $s, $closingParen = ')', $allowedTypes = [Type::T_LIST, Type::T_MAP])
  2332.     {
  2333.         if ($this->matchChar($closingParen) && \in_array(Type::T_LIST, $allowedTypes)) {
  2334.             $out = [Type::T_LIST, '', []];
  2336.             switch ($closingParen) {
  2337.                 case ')':
  2338.                     $out['enclosing'] = 'parent'; // parenthesis list
  2339.                     break;
  2341.                 case ']':
  2342.                     $out['enclosing'] = 'bracket'; // bracketed list
  2343.                     break;
  2344.             }
  2346.             return true;
  2347.         }
  2349.         if (
  2350.             $this->valueList($out) &&
  2351.             $this->matchChar($closingParen) && ! ($closingParen === ')' &&
  2352.             \in_array($out[0], [Type::T_EXPRESSION, Type::T_UNARY])) &&
  2353.             \in_array(Type::T_LIST, $allowedTypes)
  2354.         ) {
  2355.             if ($out[0] !== Type::T_LIST || ! empty($out['enclosing'])) {
  2356.                 $out = [Type::T_LIST, '', [$out]];
  2357.             }
  2359.             switch ($closingParen) {
  2360.                 case ')':
  2361.                     $out['enclosing'] = 'parent'; // parenthesis list
  2362.                     break;
  2364.                 case ']':
  2365.                     $out['enclosing'] = 'bracket'; // bracketed list
  2366.                     break;
  2367.             }
  2369.             return true;
  2370.         }
  2372.         $this->seek($s);
  2374.         if (\in_array(Type::T_MAP, $allowedTypes) && $this->map($out)) {
  2375.             return true;
  2376.         }
  2378.         return false;
  2379.     }
  2381.     /**
  2382.      * Parse left-hand side of subexpression
  2383.      *
  2384.      * @param array   $lhs
  2385.      * @param integer $minP
  2386.      *
  2387.      * @return array
  2388.      */
  2389.     protected function expHelper($lhs, $minP)
  2390.     {
  2391.         $operators = static::$operatorPattern;
  2393.         $ss = $this->count;
  2394.         $whiteBefore = isset($this->buffer[$this->count - 1]) &&
  2395.             ctype_space($this->buffer[$this->count - 1]);
  2397.         while ($this->match($operators, $m, false) && static::$precedence[$m[1]] >= $minP) {
  2398.             $whiteAfter = isset($this->buffer[$this->count]) &&
  2399.                 ctype_space($this->buffer[$this->count]);
  2400.             $varAfter = isset($this->buffer[$this->count]) &&
  2401.                 $this->buffer[$this->count] === '$';
  2403.             $this->whitespace();
  2405.             $op = $m[1];
  2407.             // don't turn negative numbers into expressions
  2408.             if ($op === '-' && $whiteBefore && ! $whiteAfter && ! $varAfter) {
  2409.                 break;
  2410.             }
  2412.             if (! $this->value($rhs) && ! $this->expression($rhs, true, false)) {
  2413.                 break;
  2414.             }
  2416.             if ($op === '-' && ! $whiteAfter && $rhs[0] === Type::T_KEYWORD) {
  2417.                 break;
  2418.             }
  2420.             // consume higher-precedence operators on the right-hand side
  2421.             $rhs = $this->expHelper($rhs, static::$precedence[$op] + 1);
  2423.             $lhs = [Type::T_EXPRESSION, $op, $lhs, $rhs, $this->inParens, $whiteBefore, $whiteAfter];
  2425.             $ss = $this->count;
  2426.             $whiteBefore = isset($this->buffer[$this->count - 1]) &&
  2427.                 ctype_space($this->buffer[$this->count - 1]);
  2428.         }
  2430.         $this->seek($ss);
  2432.         return $lhs;
  2433.     }
  2435.     /**
  2436.      * Parse value
  2437.      *
  2438.      * @param array $out
  2439.      *
  2440.      * @return boolean
  2441.      */
  2442.     protected function value(&$out)
  2443.     {
  2444.         if (! isset($this->buffer[$this->count])) {
  2445.             return false;
  2446.         }
  2448.         $s = $this->count;
  2449.         $char = $this->buffer[$this->count];
  2451.         if (
  2452.             $this->literal('url(', 4) &&
  2453.             $this->match('data:([a-z]+)\/([a-z0-9.+-]+);base64,', $m, false)
  2454.         ) {
  2455.             $len = strspn(
  2456.                 $this->buffer,
  2457.                 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwyxz0123456789+/=',
  2458.                 $this->count
  2459.             );
  2461.             $this->count += $len;
  2463.             if ($this->matchChar(')')) {
  2464.                 $content = substr($this->buffer, $s, $this->count - $s);
  2465.                 $out = [Type::T_KEYWORD, $content];
  2467.                 return true;
  2468.             }
  2469.         }
  2471.         $this->seek($s);
  2473.         if (
  2474.             $this->literal('url(', 4, false) &&
  2475.             $this->match('\s*(\/\/[^\s\)]+)\s*', $m)
  2476.         ) {
  2477.             $content = 'url(' . $m[1];
  2479.             if ($this->matchChar(')')) {
  2480.                 $content .= ')';
  2481.                 $out = [Type::T_KEYWORD, $content];
  2483.                 return true;
  2484.             }
  2485.         }
  2487.         $this->seek($s);
  2489.         // not
  2490.         if ($char === 'n' && $this->literal('not', 3, false)) {
  2491.             if (
  2492.                 $this->whitespace() &&
  2493.                 $this->value($inner)
  2494.             ) {
  2495.                 $out = [Type::T_UNARY, 'not', $inner, $this->inParens];
  2497.                 return true;
  2498.             }
  2500.             $this->seek($s);
  2502.             if ($this->parenValue($inner)) {
  2503.                 $out = [Type::T_UNARY, 'not', $inner, $this->inParens];
  2505.                 return true;
  2506.             }
  2508.             $this->seek($s);
  2509.         }
  2511.         // addition
  2512.         if ($char === '+') {
  2513.             $this->count++;
  2515.             $follow_white = $this->whitespace();
  2517.             if ($this->value($inner)) {
  2518.                 $out = [Type::T_UNARY, '+', $inner, $this->inParens];
  2520.                 return true;
  2521.             }
  2523.             if ($follow_white) {
  2524.                 $out = [Type::T_KEYWORD, $char];
  2525.                 return  true;
  2526.             }
  2528.             $this->seek($s);
  2530.             return false;
  2531.         }
  2533.         // negation
  2534.         if ($char === '-') {
  2535.             if ($this->customProperty($out)) {
  2536.                 return true;
  2537.             }
  2539.             $this->count++;
  2541.             $follow_white = $this->whitespace();
  2543.             if ($this->variable($inner) || $this->unit($inner) || $this->parenValue($inner)) {
  2544.                 $out = [Type::T_UNARY, '-', $inner, $this->inParens];
  2546.                 return true;
  2547.             }
  2549.             if (
  2550.                 $this->keyword($inner) &&
  2551.                 ! $this->func($inner, $out)
  2552.             ) {
  2553.                 $out = [Type::T_UNARY, '-', $inner, $this->inParens];
  2555.                 return true;
  2556.             }
  2558.             if ($follow_white) {
  2559.                 $out = [Type::T_KEYWORD, $char];
  2561.                 return  true;
  2562.             }
  2564.             $this->seek($s);
  2565.         }
  2567.         // paren
  2568.         if ($char === '(' && $this->parenValue($out)) {
  2569.             return true;
  2570.         }
  2572.         if ($char === '#') {
  2573.             if ($this->interpolation($out) || $this->color($out)) {
  2574.                 return true;
  2575.             }
  2577.             $this->count++;
  2579.             if ($this->keyword($keyword)) {
  2580.                 $out = [Type::T_KEYWORD, '#' . $keyword];
  2582.                 return true;
  2583.             }
  2585.             $this->count--;
  2586.         }
  2588.         if ($this->matchChar('&', true)) {
  2589.             $out = [Type::T_SELF];
  2591.             return true;
  2592.         }
  2594.         if ($char === '$' && $this->variable($out)) {
  2595.             return true;
  2596.         }
  2598.         if ($char === 'p' && $this->progid($out)) {
  2599.             return true;
  2600.         }
  2602.         if (($char === '"' || $char === "'") && $this->string($out)) {
  2603.             return true;
  2604.         }
  2606.         if ($this->unit($out)) {
  2607.             return true;
  2608.         }
  2610.         // unicode range with wildcards
  2611.         if (
  2612.             $this->literal('U+', 2) &&
  2613.             $this->match('\?+|([0-9A-F]+(\?+|(-[0-9A-F]+))?)', $m, false)
  2614.         ) {
  2615.             $unicode = explode('-', $m[0]);
  2616.             if (strlen(reset($unicode)) <= 6 && strlen(end($unicode)) <= 6) {
  2617.                 $out = [Type::T_KEYWORD, 'U+' . $m[0]];
  2619.                 return true;
  2620.             }
  2621.             $this->count -= strlen($m[0]) + 2;
  2622.         }
  2624.         if ($this->keyword($keyword, false)) {
  2625.             if ($this->func($keyword, $out)) {
  2626.                 return true;
  2627.             }
  2629.             $this->whitespace();
  2631.             if ($keyword === 'null') {
  2632.                 $out = [Type::T_NULL];
  2633.             } else {
  2634.                 $out = [Type::T_KEYWORD, $keyword];
  2635.             }
  2637.             return true;
  2638.         }
  2640.         return false;
  2641.     }
  2643.     /**
  2644.      * Parse parenthesized value
  2645.      *
  2646.      * @param array $out
  2647.      *
  2648.      * @return boolean
  2649.      */
  2650.     protected function parenValue(&$out)
  2651.     {
  2652.         $s = $this->count;
  2654.         $inParens = $this->inParens;
  2656.         if ($this->matchChar('(')) {
  2657.             if ($this->matchChar(')')) {
  2658.                 $out = [Type::T_LIST, '', []];
  2660.                 return true;
  2661.             }
  2663.             $this->inParens = true;
  2665.             if (
  2666.                 $this->expression($exp) &&
  2667.                 $this->matchChar(')')
  2668.             ) {
  2669.                 $out = $exp;
  2670.                 $this->inParens = $inParens;
  2672.                 return true;
  2673.             }
  2674.         }
  2676.         $this->inParens = $inParens;
  2677.         $this->seek($s);
  2679.         return false;
  2680.     }
  2682.     /**
  2683.      * Parse "progid:"
  2684.      *
  2685.      * @param array $out
  2686.      *
  2687.      * @return boolean
  2688.      */
  2689.     protected function progid(&$out)
  2690.     {
  2691.         $s = $this->count;
  2693.         if (
  2694.             $this->literal('progid:', 7, false) &&
  2695.             $this->openString('(', $fn) &&
  2696.             $this->matchChar('(')
  2697.         ) {
  2698.             $this->openString(')', $args, '(');
  2700.             if ($this->matchChar(')')) {
  2701.                 $out = [Type::T_STRING, '', [
  2702.                     'progid:', $fn, '(', $args, ')'
  2703.                 ]];
  2705.                 return true;
  2706.             }
  2707.         }
  2709.         $this->seek($s);
  2711.         return false;
  2712.     }
  2714.     /**
  2715.      * Parse function call
  2716.      *
  2717.      * @param string $name
  2718.      * @param array  $func
  2719.      *
  2720.      * @return boolean
  2721.      */
  2722.     protected function func($name, &$func)
  2723.     {
  2724.         $s = $this->count;
  2726.         if ($this->matchChar('(')) {
  2727.             if ($name === 'alpha' && $this->argumentList($args)) {
  2728.                 $func = [Type::T_FUNCTION, $name, [Type::T_STRING, '', $args]];
  2730.                 return true;
  2731.             }
  2733.             if ($name !== 'expression' && ! preg_match('/^(-[a-z]+-)?calc$/', $name)) {
  2734.                 $ss = $this->count;
  2736.                 if (
  2737.                     $this->argValues($args) &&
  2738.                     $this->matchChar(')')
  2739.                 ) {
  2740.                     $func = [Type::T_FUNCTION_CALL, $name, $args];
  2742.                     return true;
  2743.                 }
  2745.                 $this->seek($ss);
  2746.             }
  2748.             if (
  2749.                 ($this->openString(')', $str, '(') || true) &&
  2750.                 $this->matchChar(')')
  2751.             ) {
  2752.                 $args = [];
  2754.                 if (! empty($str)) {
  2755.                     $args[] = [null, [Type::T_STRING, '', [$str]]];
  2756.                 }
  2758.                 $func = [Type::T_FUNCTION_CALL, $name, $args];
  2760.                 return true;
  2761.             }
  2762.         }
  2764.         $this->seek($s);
  2766.         return false;
  2767.     }
  2769.     /**
  2770.      * Parse function call argument list
  2771.      *
  2772.      * @param array $out
  2773.      *
  2774.      * @return boolean
  2775.      */
  2776.     protected function argumentList(&$out)
  2777.     {
  2778.         $s = $this->count;
  2779.         $this->matchChar('(');
  2781.         $args = [];
  2783.         while ($this->keyword($var)) {
  2784.             if (
  2785.                 $this->matchChar('=') &&
  2786.                 $this->expression($exp)
  2787.             ) {
  2788.                 $args[] = [Type::T_STRING, '', [$var . '=']];
  2789.                 $arg = $exp;
  2790.             } else {
  2791.                 break;
  2792.             }
  2794.             $args[] = $arg;
  2796.             if (! $this->matchChar(',')) {
  2797.                 break;
  2798.             }
  2800.             $args[] = [Type::T_STRING, '', [', ']];
  2801.         }
  2803.         if (! $this->matchChar(')') || ! $args) {
  2804.             $this->seek($s);
  2806.             return false;
  2807.         }
  2809.         $out = $args;
  2811.         return true;
  2812.     }
  2814.     /**
  2815.      * Parse mixin/function definition  argument list
  2816.      *
  2817.      * @param array $out
  2818.      *
  2819.      * @return boolean
  2820.      */
  2821.     protected function argumentDef(&$out)
  2822.     {
  2823.         $s = $this->count;
  2824.         $this->matchChar('(');
  2826.         $args = [];
  2828.         while ($this->variable($var)) {
  2829.             $arg = [$var[1], null, false];
  2831.             $ss = $this->count;
  2833.             if (
  2834.                 $this->matchChar(':') &&
  2835.                 $this->genericList($defaultVal, 'expression', '', true)
  2836.             ) {
  2837.                 $arg[1] = $defaultVal;
  2838.             } else {
  2839.                 $this->seek($ss);
  2840.             }
  2842.             $ss = $this->count;
  2844.             if ($this->literal('...', 3)) {
  2845.                 $sss = $this->count;
  2847.                 if (! $this->matchChar(')')) {
  2848.                     throw $this->parseError('... has to be after the final argument');
  2849.                 }
  2851.                 $arg[2] = true;
  2853.                 $this->seek($sss);
  2854.             } else {
  2855.                 $this->seek($ss);
  2856.             }
  2858.             $args[] = $arg;
  2860.             if (! $this->matchChar(',')) {
  2861.                 break;
  2862.             }
  2863.         }
  2865.         if (! $this->matchChar(')')) {
  2866.             $this->seek($s);
  2868.             return false;
  2869.         }
  2871.         $out = $args;
  2873.         return true;
  2874.     }
  2876.     /**
  2877.      * Parse map
  2878.      *
  2879.      * @param array $out
  2880.      *
  2881.      * @return boolean
  2882.      */
  2883.     protected function map(&$out)
  2884.     {
  2885.         $s = $this->count;
  2887.         if (! $this->matchChar('(')) {
  2888.             return false;
  2889.         }
  2891.         $keys = [];
  2892.         $values = [];
  2894.         while (
  2895.             $this->genericList($key, 'expression', '', true) &&
  2896.             $this->matchChar(':') &&
  2897.             $this->genericList($value, 'expression', '', true)
  2898.         ) {
  2899.             $keys[] = $key;
  2900.             $values[] = $value;
  2902.             if (! $this->matchChar(',')) {
  2903.                 break;
  2904.             }
  2905.         }
  2907.         if (! $keys || ! $this->matchChar(')')) {
  2908.             $this->seek($s);
  2910.             return false;
  2911.         }
  2913.         $out = [Type::T_MAP, $keys, $values];
  2915.         return true;
  2916.     }
  2918.     /**
  2919.      * Parse color
  2920.      *
  2921.      * @param array $out
  2922.      *
  2923.      * @return boolean
  2924.      */
  2925.     protected function color(&$out)
  2926.     {
  2927.         $s = $this->count;
  2929.         if ($this->match('(#([0-9a-f]+)\b)', $m)) {
  2930.             if (\in_array(\strlen($m[2]), [3,4,6,8])) {
  2931.                 $out = [Type::T_KEYWORD, $m[0]];
  2933.                 return true;
  2934.             }
  2936.             $this->seek($s);
  2938.             return false;
  2939.         }
  2941.         return false;
  2942.     }
  2944.     /**
  2945.      * Parse number with unit
  2946.      *
  2947.      * @param array $unit
  2948.      *
  2949.      * @return boolean
  2950.      */
  2951.     protected function unit(&$unit)
  2952.     {
  2953.         $s = $this->count;
  2955.         if ($this->match('([0-9]*(\.)?[0-9]+)([%a-zA-Z]+)?', $m, false)) {
  2956.             if (\strlen($this->buffer) === $this->count || ! ctype_digit($this->buffer[$this->count])) {
  2957.                 $this->whitespace();
  2959.                 $unit = new Node\Number($m[1], empty($m[3]) ? '' : $m[3]);
  2961.                 return true;
  2962.             }
  2964.             $this->seek($s);
  2965.         }
  2967.         return false;
  2968.     }
  2970.     /**
  2971.      * Parse string
  2972.      *
  2973.      * @param array $out
  2974.      *
  2975.      * @return boolean
  2976.      */
  2977.     protected function string(&$out, $keepDelimWithInterpolation = false)
  2978.     {
  2979.         $s = $this->count;
  2981.         if ($this->matchChar('"', false)) {
  2982.             $delim = '"';
  2983.         } elseif ($this->matchChar("'", false)) {
  2984.             $delim = "'";
  2985.         } else {
  2986.             return false;
  2987.         }
  2989.         $content = [];
  2990.         $oldWhite = $this->eatWhiteDefault;
  2991.         $this->eatWhiteDefault = false;
  2992.         $hasInterpolation = false;
  2994.         while ($this->matchString($m, $delim)) {
  2995.             if ($m[1] !== '') {
  2996.                 $content[] = $m[1];
  2997.             }
  2999.             if ($m[2] === '#{') {
  3000.                 $this->count -= \strlen($m[2]);
  3002.                 if ($this->interpolation($inter, false)) {
  3003.                     $content[] = $inter;
  3004.                     $hasInterpolation = true;
  3005.                 } else {
  3006.                     $this->count += \strlen($m[2]);
  3007.                     $content[] = '#{'; // ignore it
  3008.                 }
  3009.             } elseif ($m[2] === "\r") {
  3010.                 $content[] = chr(10);
  3011.                 // TODO : warning
  3012.                 # DEPRECATION WARNING on line x, column y of zzz:
  3013.                 # Unescaped multiline strings are deprecated and will be removed in a future version of Sass.
  3014.                 # To include a newline in a string, use "\a" or "\a " as in CSS.
  3015.                 if ($this->matchChar("\n", false)) {
  3016.                     $content[] = ' ';
  3017.                 }
  3018.             } elseif ($m[2] === '\\') {
  3019.                 if (
  3020.                     $this->literal("\r\n", 2, false) ||
  3021.                     $this->matchChar("\r", false) ||
  3022.                     $this->matchChar("\n", false) ||
  3023.                     $this->matchChar("\f", false)
  3024.                 ) {
  3025.                     // this is a continuation escaping, to be ignored
  3026.                 } elseif ($this->matchEscapeCharacter($c)) {
  3027.                     $content[] = $c;
  3028.                 } else {
  3029.                     throw $this->parseError('Unterminated escape sequence');
  3030.                 }
  3031.             } else {
  3032.                 $this->count -= \strlen($delim);
  3033.                 break; // delim
  3034.             }
  3035.         }
  3037.         $this->eatWhiteDefault = $oldWhite;
  3039.         if ($this->literal($delim, \strlen($delim))) {
  3040.             if ($hasInterpolation && ! $keepDelimWithInterpolation) {
  3041.                 $delim = '"';
  3042.             }
  3044.             $out = [Type::T_STRING, $delim, $content];
  3046.             return true;
  3047.         }
  3049.         $this->seek($s);
  3051.         return false;
  3052.     }
  3054.     /**
  3055.      * @param string $out
  3056.      * @param bool $inKeywords
  3057.      * @return bool
  3058.      */
  3059.     protected function matchEscapeCharacter(&$out, $inKeywords = false)
  3060.     {
  3061.         $s = $this->count;
  3062.         if ($this->match('[a-f0-9]', $m, false)) {
  3063.             $hex = $m[0];
  3065.             for ($i = 5; $i--;) {
  3066.                 if ($this->match('[a-f0-9]', $m, false)) {
  3067.                     $hex .= $m[0];
  3068.                 } else {
  3069.                     break;
  3070.                 }
  3071.             }
  3073.             // CSS allows Unicode escape sequences to be followed by a delimiter space
  3074.             // (necessary in some cases for shorter sequences to disambiguate their end)
  3075.             $this->matchChar(' ', false);
  3077.             $value = hexdec($hex);
  3079.             if (!$inKeywords && ($value == 0 || ($value >= 0xD800 && $value <= 0xDFFF) || $value >= 0x10FFFF)) {
  3080.                 $out = "\xEF\xBF\xBD"; // "\u{FFFD}" but with a syntax supported on PHP 5
  3081.             } elseif ($value < 0x20) {
  3082.                 $out = Util::mbChr($value);
  3083.             } else {
  3084.                 $out = Util::mbChr($value);
  3085.             }
  3087.             return true;
  3088.         }
  3090.         if ($this->match('.', $m, false)) {
  3091.             if ($inKeywords && in_array($m[0], ["'",'"','@','&',' ','\\',':','/','%'])) {
  3092.                 $this->seek($s);
  3093.                 return false;
  3094.             }
  3095.             $out = $m[0];
  3097.             return true;
  3098.         }
  3100.         return false;
  3101.     }
  3103.     /**
  3104.      * Parse keyword or interpolation
  3105.      *
  3106.      * @param array   $out
  3107.      * @param boolean $restricted
  3108.      *
  3109.      * @return boolean
  3110.      */
  3111.     protected function mixedKeyword(&$out, $restricted = false)
  3112.     {
  3113.         $parts = [];
  3115.         $oldWhite = $this->eatWhiteDefault;
  3116.         $this->eatWhiteDefault = false;
  3118.         for (;;) {
  3119.             if ($restricted ? $this->restrictedKeyword($key) : $this->keyword($key)) {
  3120.                 $parts[] = $key;
  3121.                 continue;
  3122.             }
  3124.             if ($this->interpolation($inter)) {
  3125.                 $parts[] = $inter;
  3126.                 continue;
  3127.             }
  3129.             break;
  3130.         }
  3132.         $this->eatWhiteDefault = $oldWhite;
  3134.         if (! $parts) {
  3135.             return false;
  3136.         }
  3138.         if ($this->eatWhiteDefault) {
  3139.             $this->whitespace();
  3140.         }
  3142.         $out = $parts;
  3144.         return true;
  3145.     }
  3147.     /**
  3148.      * Parse an unbounded string stopped by $end
  3149.      *
  3150.      * @param string  $end
  3151.      * @param array   $out
  3152.      * @param string  $nestOpen
  3153.      * @param string  $nestClose
  3154.      * @param boolean $rtrim
  3155.      * @param string $disallow
  3156.      *
  3157.      * @return boolean
  3158.      */
  3159.     protected function openString($end, &$out, $nestOpen = null, $nestClose = null, $rtrim = true, $disallow = null)
  3160.     {
  3161.         $oldWhite = $this->eatWhiteDefault;
  3162.         $this->eatWhiteDefault = false;
  3164.         if ($nestOpen && ! $nestClose) {
  3165.             $nestClose = $end;
  3166.         }
  3168.         $patt = ($disallow ? '[^' . $this->pregQuote($disallow) . ']' : '.');
  3169.         $patt = '(' . $patt . '*?)([\'"]|#\{|'
  3170.             . $this->pregQuote($end) . '|'
  3171.             . (($nestClose && $nestClose !== $end) ? $this->pregQuote($nestClose) . '|' : '')
  3172.             . static::$commentPattern . ')';
  3174.         $nestingLevel = 0;
  3176.         $content = [];
  3178.         while ($this->match($patt, $m, false)) {
  3179.             if (isset($m[1]) && $m[1] !== '') {
  3180.                 $content[] = $m[1];
  3182.                 if ($nestOpen) {
  3183.                     $nestingLevel += substr_count($m[1], $nestOpen);
  3184.                 }
  3185.             }
  3187.             $tok = $m[2];
  3189.             $this->count -= \strlen($tok);
  3191.             if ($tok === $end && ! $nestingLevel) {
  3192.                 break;
  3193.             }
  3195.             if ($tok === $nestClose) {
  3196.                 $nestingLevel--;
  3197.             }
  3199.             if (($tok === "'" || $tok === '"') && $this->string($str, true)) {
  3200.                 $content[] = $str;
  3201.                 continue;
  3202.             }
  3204.             if ($tok === '#{' && $this->interpolation($inter)) {
  3205.                 $content[] = $inter;
  3206.                 continue;
  3207.             }
  3209.             $content[] = $tok;
  3210.             $this->count += \strlen($tok);
  3211.         }
  3213.         $this->eatWhiteDefault = $oldWhite;
  3215.         if (! $content || $tok !== $end) {
  3216.             return false;
  3217.         }
  3219.         // trim the end
  3220.         if ($rtrim && \is_string(end($content))) {
  3221.             $content[\count($content) - 1] = rtrim(end($content));
  3222.         }
  3224.         $out = [Type::T_STRING, '', $content];
  3226.         return true;
  3227.     }
  3229.     /**
  3230.      * Parser interpolation
  3231.      *
  3232.      * @param string|array $out
  3233.      * @param boolean      $lookWhite save information about whitespace before and after
  3234.      *
  3235.      * @return boolean
  3236.      */
  3237.     protected function interpolation(&$out, $lookWhite = true)
  3238.     {
  3239.         $oldWhite = $this->eatWhiteDefault;
  3240.         $allowVars = $this->allowVars;
  3241.         $this->allowVars = true;
  3242.         $this->eatWhiteDefault = true;
  3244.         $s = $this->count;
  3246.         if (
  3247.             $this->literal('#{', 2) &&
  3248.             $this->valueList($value) &&
  3249.             $this->matchChar('}', false)
  3250.         ) {
  3251.             if ($value === [Type::T_SELF]) {
  3252.                 $out = $value;
  3253.             } else {
  3254.                 if ($lookWhite) {
  3255.                     $left = ($s > 0 && preg_match('/\s/', $this->buffer[$s - 1])) ? ' ' : '';
  3256.                     $right = (
  3257.                         ! empty($this->buffer[$this->count]) &&
  3258.                         preg_match('/\s/', $this->buffer[$this->count])
  3259.                     ) ? ' ' : '';
  3260.                 } else {
  3261.                     $left = $right = false;
  3262.                 }
  3264.                 $out = [Type::T_INTERPOLATE, $value, $left, $right];
  3265.             }
  3267.             $this->eatWhiteDefault = $oldWhite;
  3268.             $this->allowVars = $allowVars;
  3270.             if ($this->eatWhiteDefault) {
  3271.                 $this->whitespace();
  3272.             }
  3274.             return true;
  3275.         }
  3277.         $this->seek($s);
  3279.         $this->eatWhiteDefault = $oldWhite;
  3280.         $this->allowVars = $allowVars;
  3282.         return false;
  3283.     }
  3285.     /**
  3286.      * Parse property name (as an array of parts or a string)
  3287.      *
  3288.      * @param array $out
  3289.      *
  3290.      * @return boolean
  3291.      */
  3292.     protected function propertyName(&$out)
  3293.     {
  3294.         $parts = [];
  3296.         $oldWhite = $this->eatWhiteDefault;
  3297.         $this->eatWhiteDefault = false;
  3299.         for (;;) {
  3300.             if ($this->interpolation($inter)) {
  3301.                 $parts[] = $inter;
  3302.                 continue;
  3303.             }
  3305.             if ($this->keyword($text)) {
  3306.                 $parts[] = $text;
  3307.                 continue;
  3308.             }
  3310.             if (! $parts && $this->match('[:.#]', $m, false)) {
  3311.                 // css hacks
  3312.                 $parts[] = $m[0];
  3313.                 continue;
  3314.             }
  3316.             break;
  3317.         }
  3319.         $this->eatWhiteDefault = $oldWhite;
  3321.         if (! $parts) {
  3322.             return false;
  3323.         }
  3325.         // match comment hack
  3326.         if (preg_match(static::$whitePattern, $this->buffer, $m, 0, $this->count)) {
  3327.             if (! empty($m[0])) {
  3328.                 $parts[] = $m[0];
  3329.                 $this->count += \strlen($m[0]);
  3330.             }
  3331.         }
  3333.         $this->whitespace(); // get any extra whitespace
  3335.         $out = [Type::T_STRING, '', $parts];
  3337.         return true;
  3338.     }
  3340.     /**
  3341.      * Parse custom property name (as an array of parts or a string)
  3342.      *
  3343.      * @param array $out
  3344.      *
  3345.      * @return boolean
  3346.      */
  3347.     protected function customProperty(&$out)
  3348.     {
  3349.         $s = $this->count;
  3351.         if (! $this->literal('--', 2, false)) {
  3352.             return false;
  3353.         }
  3355.         $parts = ['--'];
  3357.         $oldWhite = $this->eatWhiteDefault;
  3358.         $this->eatWhiteDefault = false;
  3360.         for (;;) {
  3361.             if ($this->interpolation($inter)) {
  3362.                 $parts[] = $inter;
  3363.                 continue;
  3364.             }
  3366.             if ($this->matchChar('&', false)) {
  3367.                 $parts[] = [Type::T_SELF];
  3368.                 continue;
  3369.             }
  3371.             if ($this->variable($var)) {
  3372.                 $parts[] = $var;
  3373.                 continue;
  3374.             }
  3376.             if ($this->keyword($text)) {
  3377.                 $parts[] = $text;
  3378.                 continue;
  3379.             }
  3381.             break;
  3382.         }
  3384.         $this->eatWhiteDefault = $oldWhite;
  3386.         if (\count($parts) == 1) {
  3387.             $this->seek($s);
  3389.             return false;
  3390.         }
  3392.         $this->whitespace(); // get any extra whitespace
  3394.         $out = [Type::T_STRING, '', $parts];
  3396.         return true;
  3397.     }
  3399.     /**
  3400.      * Parse comma separated selector list
  3401.      *
  3402.      * @param array $out
  3403.      * @param string|boolean $subSelector
  3404.      *
  3405.      * @return boolean
  3406.      */
  3407.     protected function selectors(&$out, $subSelector = false)
  3408.     {
  3409.         $s = $this->count;
  3410.         $selectors = [];
  3412.         while ($this->selector($sel, $subSelector)) {
  3413.             $selectors[] = $sel;
  3415.             if (! $this->matchChar(',', true)) {
  3416.                 break;
  3417.             }
  3419.             while ($this->matchChar(',', true)) {
  3420.                 ; // ignore extra
  3421.             }
  3422.         }
  3424.         if (! $selectors) {
  3425.             $this->seek($s);
  3427.             return false;
  3428.         }
  3430.         $out = $selectors;
  3432.         return true;
  3433.     }
  3435.     /**
  3436.      * Parse whitespace separated selector list
  3437.      *
  3438.      * @param array          $out
  3439.      * @param string|boolean $subSelector
  3440.      *
  3441.      * @return boolean
  3442.      */
  3443.     protected function selector(&$out, $subSelector = false)
  3444.     {
  3445.         $selector = [];
  3447.         $discardComments = $this->discardComments;
  3448.         $this->discardComments = true;
  3450.         for (;;) {
  3451.             $s = $this->count;
  3453.             if ($this->match('[>+~]+', $m, true)) {
  3454.                 if (
  3455.                     $subSelector && \is_string($subSelector) && strpos($subSelector, 'nth-') === 0 &&
  3456.                     $m[0] === '+' && $this->match("(\d+|n\b)", $counter)
  3457.                 ) {
  3458.                     $this->seek($s);
  3459.                 } else {
  3460.                     $selector[] = [$m[0]];
  3461.                     continue;
  3462.                 }
  3463.             }
  3465.             if ($this->selectorSingle($part, $subSelector)) {
  3466.                 $selector[] = $part;
  3467.                 $this->whitespace();
  3468.                 continue;
  3469.             }
  3471.             break;
  3472.         }
  3474.         $this->discardComments = $discardComments;
  3476.         if (! $selector) {
  3477.             return false;
  3478.         }
  3480.         $out = $selector;
  3482.         return true;
  3483.     }
  3485.     /**
  3486.      * parsing escaped chars in selectors:
  3487.      * - escaped single chars are kept escaped in the selector but in a normalized form
  3488.      *   (if not in 0-9a-f range as this would be ambigous)
  3489.      * - other escaped sequences (multibyte chars or 0-9a-f) are kept in their initial escaped form,
  3490.      *   normalized to lowercase
  3491.      *
  3492.      * TODO: this is a fallback solution. Ideally escaped chars in selectors should be encoded as the genuine chars,
  3493.      * and escaping added when printing in the Compiler, where/if it's mandatory
  3494.      * - but this require a better formal selector representation instead of the array we have now
  3495.      *
  3496.      * @param string $out
  3497.      * @param bool $keepEscapedNumber
  3498.      * @return bool
  3499.      */
  3500.     protected function matchEscapeCharacterInSelector(&$out, $keepEscapedNumber = false)
  3501.     {
  3502.         $s_escape = $this->count;
  3503.         if ($this->match('\\\\', $m)) {
  3504.             $out = '\\' . $m[0];
  3505.             return true;
  3506.         }
  3508.         if ($this->matchEscapeCharacter($escapedout, true)) {
  3509.             if (strlen($escapedout) === 1) {
  3510.                 if (!preg_match(",\w,", $escapedout)) {
  3511.                     $out = '\\' . $escapedout;
  3512.                     return true;
  3513.                 } elseif (! $keepEscapedNumber || ! \is_numeric($escapedout)) {
  3514.                     $out = $escapedout;
  3515.                     return true;
  3516.                 }
  3517.             }
  3518.             $escape_sequence = rtrim(substr($this->buffer, $s_escape, $this->count - $s_escape));
  3519.             if (strlen($escape_sequence) < 6) {
  3520.                 $escape_sequence .= ' ';
  3521.             }
  3522.             $out = '\\' . strtolower($escape_sequence);
  3523.             return true;
  3524.         }
  3525.         if ($this->match('\\S', $m)) {
  3526.             $out = '\\' . $m[0];
  3527.             return true;
  3528.         }
  3531.         return false;
  3532.     }
  3534.     /**
  3535.      * Parse the parts that make up a selector
  3536.      *
  3537.      * {@internal
  3538.      *     div[yes=no]#something.hello.world:nth-child(-2n+1)%placeholder
  3539.      * }}
  3540.      *
  3541.      * @param array          $out
  3542.      * @param string|boolean $subSelector
  3543.      *
  3544.      * @return boolean
  3545.      */
  3546.     protected function selectorSingle(&$out, $subSelector = false)
  3547.     {
  3548.         $oldWhite = $this->eatWhiteDefault;
  3549.         $this->eatWhiteDefault = false;
  3551.         $parts = [];
  3553.         if ($this->matchChar('*', false)) {
  3554.             $parts[] = '*';
  3555.         }
  3557.         for (;;) {
  3558.             if (! isset($this->buffer[$this->count])) {
  3559.                 break;
  3560.             }
  3562.             $s = $this->count;
  3563.             $char = $this->buffer[$this->count];
  3565.             // see if we can stop early
  3566.             if ($char === '{' || $char === ',' || $char === ';' || $char === '}' || $char === '@') {
  3567.                 break;
  3568.             }
  3570.             // parsing a sub selector in () stop with the closing )
  3571.             if ($subSelector && $char === ')') {
  3572.                 break;
  3573.             }
  3575.             //self
  3576.             switch ($char) {
  3577.                 case '&':
  3578.                     $parts[] = Compiler::$selfSelector;
  3579.                     $this->count++;
  3580.                     ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  3581.                     continue 2;
  3583.                 case '.':
  3584.                     $parts[] = '.';
  3585.                     $this->count++;
  3586.                     continue 2;
  3588.                 case '|':
  3589.                     $parts[] = '|';
  3590.                     $this->count++;
  3591.                     continue 2;
  3592.             }
  3594.             // handling of escaping in selectors : get the escaped char
  3595.             if ($char === '\\') {
  3596.                 $this->count++;
  3597.                 if ($this->matchEscapeCharacterInSelector($escaped, true)) {
  3598.                     $parts[] = $escaped;
  3599.                     continue;
  3600.                 }
  3601.                 $this->count--;
  3602.             }
  3604.             if ($char === '%') {
  3605.                 $this->count++;
  3607.                 if ($this->placeholder($placeholder)) {
  3608.                     $parts[] = '%';
  3609.                     $parts[] = $placeholder;
  3610.                     ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  3611.                     continue;
  3612.                 }
  3614.                 break;
  3615.             }
  3617.             if ($char === '#') {
  3618.                 if ($this->interpolation($inter)) {
  3619.                     $parts[] = $inter;
  3620.                     ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
  3621.                     continue;
  3622.                 }
  3624.                 $parts[] = '#';
  3625.                 $this->count++;
  3626.                 continue;
  3627.             }
  3629.             // a pseudo selector
  3630.             if ($char === ':') {
  3631.                 if ($this->buffer[$this->count + 1] === ':') {
  3632.                     $this->count += 2;
  3633.                     $part = '::';
  3634.                 } else {
  3635.                     $this->count++;
  3636.                     $part = ':';
  3637.                 }
  3639.                 if ($this->mixedKeyword($nameParts, true)) {
  3640.                     $parts[] = $part;
  3642.                     foreach ($nameParts as $sub) {
  3643.                         $parts[] = $sub;
  3644.                     }
  3646.                     $ss = $this->count;
  3648.                     if (
  3649.                         $nameParts === ['not'] ||
  3650.                         $nameParts === ['is'] ||
  3651.                         $nameParts === ['has'] ||
  3652.                         $nameParts === ['where'] ||
  3653.                         $nameParts === ['slotted'] ||
  3654.                         $nameParts === ['nth-child'] ||
  3655.                         $nameParts === ['nth-last-child'] ||
  3656.                         $nameParts === ['nth-of-type'] ||
  3657.                         $nameParts === ['nth-last-of-type']
  3658.                     ) {
  3659.                         if (
  3660.                             $this->matchChar('(', true) &&
  3661.                             ($this->selectors($subs, reset($nameParts)) || true) &&
  3662.                             $this->matchChar(')')
  3663.                         ) {
  3664.                             $parts[] = '(';
  3666.                             while ($sub = array_shift($subs)) {
  3667.                                 while ($ps = array_shift($sub)) {
  3668.                                     foreach ($ps as &$p) {
  3669.                                         $parts[] = $p;
  3670.                                     }
  3672.                                     if (\count($sub) && reset($sub)) {
  3673.                                         $parts[] = ' ';
  3674.                                     }
  3675.                                 }
  3677.                                 if (\count($subs) && reset($subs)) {
  3678.                                     $parts[] = ', ';
  3679.                                 }
  3680.                             }
  3682.                             $parts[] = ')';
  3683.                         } else {
  3684.                             $this->seek($ss);
  3685.                         }
  3686.                     } elseif (
  3687.                         $this->matchChar('(', true) &&
  3688.                         ($this->openString(')', $str, '(') || true) &&
  3689.                         $this->matchChar(')')
  3690.                     ) {
  3691.                         $parts[] = '(';
  3693.                         if (! empty($str)) {
  3694.                             $parts[] = $str;
  3695.                         }
  3697.                         $parts[] = ')';
  3698.                     } else {
  3699.                         $this->seek($ss);
  3700.                     }
  3702.                     continue;
  3703.                 }
  3704.             }
  3706.             $this->seek($s);
  3708.             // 2n+1
  3709.             if ($subSelector && \is_string($subSelector) && strpos($subSelector, 'nth-') === 0) {
  3710.                 if ($this->match("(\s*(\+\s*|\-\s*)?(\d+|n|\d+n))+", $counter)) {
  3711.                     $parts[] = $counter[0];
  3712.                     //$parts[] = str_replace(' ', '', $counter[0]);
  3713.                     continue;
  3714.                 }
  3715.             }
  3717.             $this->seek($s);
  3719.             // attribute selector
  3720.             if (
  3721.                 $char === '[' &&
  3722.                 $this->matchChar('[') &&
  3723.                 ($this->openString(']', $str, '[') || true) &&
  3724.                 $this->matchChar(']')
  3725.             ) {
  3726.                 $parts[] = '[';
  3728.                 if (! empty($str)) {
  3729.                     $parts[] = $str;
  3730.                 }
  3732.                 $parts[] = ']';
  3733.                 continue;
  3734.             }
  3736.             $this->seek($s);
  3738.             // for keyframes
  3739.             if ($this->unit($unit)) {
  3740.                 $parts[] = $unit;
  3741.                 continue;
  3742.             }
  3744.             if ($this->restrictedKeyword($name, false, true)) {
  3745.                 $parts[] = $name;
  3746.                 continue;
  3747.             }
  3749.             break;
  3750.         }
  3752.         $this->eatWhiteDefault = $oldWhite;
  3754.         if (! $parts) {
  3755.             return false;
  3756.         }
  3758.         $out = $parts;
  3760.         return true;
  3761.     }
  3763.     /**
  3764.      * Parse a variable
  3765.      *
  3766.      * @param array $out
  3767.      *
  3768.      * @return boolean
  3769.      */
  3770.     protected function variable(&$out)
  3771.     {
  3772.         $s = $this->count;
  3774.         if (
  3775.             $this->matchChar('$', false) &&
  3776.             $this->keyword($name)
  3777.         ) {
  3778.             if ($this->allowVars) {
  3779.                 $out = [Type::T_VARIABLE, $name];
  3780.             } else {
  3781.                 $out = [Type::T_KEYWORD, '$' . $name];
  3782.             }
  3784.             return true;
  3785.         }
  3787.         $this->seek($s);
  3789.         return false;
  3790.     }
  3792.     /**
  3793.      * Parse a keyword
  3794.      *
  3795.      * @param string  $word
  3796.      * @param boolean $eatWhitespace
  3797.      * @param boolean $inSelector
  3798.      *
  3799.      * @return boolean
  3800.      */
  3801.     protected function keyword(&$word, $eatWhitespace = null, $inSelector = false)
  3802.     {
  3803.         $s = $this->count;
  3804.         $match = $this->match(
  3805.             $this->utf8
  3806.                 ? '(([\pL\w\x{00A0}-\x{10FFFF}_\-\*!"\']|\\\\[a-f0-9]{6} ?|\\\\[a-f0-9]{1,5}(?![a-f0-9]) ?|[\\\\].)([\pL\w\x{00A0}-\x{10FFFF}\-_"\']|\\\\[a-f0-9]{6} ?|\\\\[a-f0-9]{1,5}(?![a-f0-9]) ?|[\\\\].)*)'
  3807.                 : '(([\w_\-\*!"\']|\\\\[a-f0-9]{6} ?|\\\\[a-f0-9]{1,5}(?![a-f0-9]) ?|[\\\\].)([\w\-_"\']|\\\\[a-f0-9]{6} ?|\\\\[a-f0-9]{1,5}(?![a-f0-9]) ?|[\\\\].)*)',
  3808.             $m,
  3809.             false
  3810.         );
  3812.         if ($match) {
  3813.             $word = $m[1];
  3815.             // handling of escaping in keyword : get the escaped char
  3816.             if (strpos($word, '\\') !== false) {
  3817.                 $send = $this->count;
  3818.                 $escapedWord = [];
  3819.                 $this->seek($s);
  3820.                 $previousEscape = false;
  3821.                 while ($this->count < $send) {
  3822.                     $char = $this->buffer[$this->count];
  3823.                     $this->count++;
  3824.                     if (
  3825.                         $this->count < $send
  3826.                         && $char === '\\'
  3827.                         && !$previousEscape
  3828.                         && (
  3829.                             $inSelector ?
  3830.                                 $this->matchEscapeCharacterInSelector($out)
  3831.                                 :
  3832.                                 $this->matchEscapeCharacter($out, true)
  3833.                         )
  3834.                     ) {
  3835.                         $escapedWord[] = $out;
  3836.                     } else {
  3837.                         if ($previousEscape) {
  3838.                             $previousEscape = false;
  3839.                         } elseif ($char === '\\') {
  3840.                             $previousEscape = true;
  3841.                         }
  3842.                         $escapedWord[] = $char;
  3843.                     }
  3844.                 }
  3846.                 $word = implode('', $escapedWord);
  3847.             }
  3849.             if (is_null($eatWhitespace) ? $this->eatWhiteDefault : $eatWhitespace) {
  3850.                 $this->whitespace();
  3851.             }
  3853.             return true;
  3854.         }
  3856.         return false;
  3857.     }
  3859.     /**
  3860.      * Parse a keyword that should not start with a number
  3861.      *
  3862.      * @param string  $word
  3863.      * @param boolean $eatWhitespace
  3864.      * @param boolean $inSelector
  3865.      *
  3866.      * @return boolean
  3867.      */
  3868.     protected function restrictedKeyword(&$word, $eatWhitespace = null, $inSelector = false)
  3869.     {
  3870.         $s = $this->count;
  3872.         if ($this->keyword($word, $eatWhitespace, $inSelector) && (\ord($word[0]) > 57 || \ord($word[0]) < 48)) {
  3873.             return true;
  3874.         }
  3876.         $this->seek($s);
  3878.         return false;
  3879.     }
  3881.     /**
  3882.      * Parse a placeholder
  3883.      *
  3884.      * @param string|array $placeholder
  3885.      *
  3886.      * @return boolean
  3887.      */
  3888.     protected function placeholder(&$placeholder)
  3889.     {
  3890.         $match = $this->match(
  3891.             $this->utf8
  3892.                 ? '([\pL\w\-_]+)'
  3893.                 : '([\w\-_]+)',
  3894.             $m
  3895.         );
  3897.         if ($match) {
  3898.             $placeholder = $m[1];
  3900.             return true;
  3901.         }
  3903.         if ($this->interpolation($placeholder)) {
  3904.             return true;
  3905.         }
  3907.         return false;
  3908.     }
  3910.     /**
  3911.      * Parse a url
  3912.      *
  3913.      * @param array $out
  3914.      *
  3915.      * @return boolean
  3916.      */
  3917.     protected function url(&$out)
  3918.     {
  3919.         if ($this->literal('url(', 4)) {
  3920.             $s = $this->count;
  3922.             if (
  3923.                 ($this->string($out) || $this->spaceList($out)) &&
  3924.                 $this->matchChar(')')
  3925.             ) {
  3926.                 $out = [Type::T_STRING, '', ['url(', $out, ')']];
  3928.                 return true;
  3929.             }
  3931.             $this->seek($s);
  3933.             if (
  3934.                 $this->openString(')', $out) &&
  3935.                 $this->matchChar(')')
  3936.             ) {
  3937.                 $out = [Type::T_STRING, '', ['url(', $out, ')']];
  3939.                 return true;
  3940.             }
  3941.         }
  3943.         return false;
  3944.     }
  3946.     /**
  3947.      * Consume an end of statement delimiter
  3948.      * @param bool $eatWhitespace
  3949.      *
  3950.      * @return boolean
  3951.      */
  3952.     protected function end($eatWhitespace = null)
  3953.     {
  3954.         if ($this->matchChar(';', $eatWhitespace)) {
  3955.             return true;
  3956.         }
  3958.         if ($this->count === \strlen($this->buffer) || $this->buffer[$this->count] === '}') {
  3959.             // if there is end of file or a closing block next then we don't need a ;
  3960.             return true;
  3961.         }
  3963.         return false;
  3964.     }
  3966.     /**
  3967.      * Strip assignment flag from the list
  3968.      *
  3969.      * @param array $value
  3970.      *
  3971.      * @return array
  3972.      */
  3973.     protected function stripAssignmentFlags(&$value)
  3974.     {
  3975.         $flags = [];
  3977.         for ($token = &$value; $token[0] === Type::T_LIST && ($s = \count($token[2])); $token = &$lastNode) {
  3978.             $lastNode = &$token[2][$s - 1];
  3980.             while ($lastNode[0] === Type::T_KEYWORD && \in_array($lastNode[1], ['!default', '!global'])) {
  3981.                 array_pop($token[2]);
  3983.                 $node     = end($token[2]);
  3984.                 $token    = $this->flattenList($token);
  3985.                 $flags[]  = $lastNode[1];
  3986.                 $lastNode = $node;
  3987.             }
  3988.         }
  3990.         return $flags;
  3991.     }
  3993.     /**
  3994.      * Strip optional flag from selector list
  3995.      *
  3996.      * @param array $selectors
  3997.      *
  3998.      * @return string
  3999.      */
  4000.     protected function stripOptionalFlag(&$selectors)
  4001.     {
  4002.         $optional = false;
  4003.         $selector = end($selectors);
  4004.         $part     = end($selector);
  4006.         if ($part === ['!optional']) {
  4007.             array_pop($selectors[\count($selectors) - 1]);
  4009.             $optional = true;
  4010.         }
  4012.         return $optional;
  4013.     }
  4015.     /**
  4016.      * Turn list of length 1 into value type
  4017.      *
  4018.      * @param array $value
  4019.      *
  4020.      * @return array
  4021.      */
  4022.     protected function flattenList($value)
  4023.     {
  4024.         if ($value[0] === Type::T_LIST && \count($value[2]) === 1) {
  4025.             return $this->flattenList($value[2][0]);
  4026.         }
  4028.         return $value;
  4029.     }
  4031.     /**
  4032.      * Quote regular expression
  4033.      *
  4034.      * @param string $what
  4035.      *
  4036.      * @return string
  4037.      */
  4038.     private function pregQuote($what)
  4039.     {
  4040.         return preg_quote($what, '/');
  4041.     }
  4043.     /**
  4044.      * Extract line numbers from buffer
  4045.      *
  4046.      * @param string $buffer
  4047.      */
  4048.     private function extractLineNumbers($buffer)
  4049.     {
  4050.         $this->sourcePositions = [0 => 0];
  4051.         $prev = 0;
  4053.         while (($pos = strpos($buffer, "\n", $prev)) !== false) {
  4054.             $this->sourcePositions[] = $pos;
  4055.             $prev = $pos + 1;
  4056.         }
  4058.         $this->sourcePositions[] = \strlen($buffer);
  4060.         if (substr($buffer, -1) !== "\n") {
  4061.             $this->sourcePositions[] = \strlen($buffer) + 1;
  4062.         }
  4063.     }
  4065.     /**
  4066.      * Get source line number and column (given character position in the buffer)
  4067.      *
  4068.      * @param integer $pos
  4069.      *
  4070.      * @return array
  4071.      */
  4072.     private function getSourcePosition($pos)
  4073.     {
  4074.         $low = 0;
  4075.         $high = \count($this->sourcePositions);
  4077.         while ($low < $high) {
  4078.             $mid = (int) (($high + $low) / 2);
  4080.             if ($pos < $this->sourcePositions[$mid]) {
  4081.                 $high = $mid - 1;
  4082.                 continue;
  4083.             }
  4085.             if ($pos >= $this->sourcePositions[$mid + 1]) {
  4086.                 $low = $mid + 1;
  4087.                 continue;
  4088.             }
  4090.             return [$mid + 1, $pos - $this->sourcePositions[$mid]];
  4091.         }
  4093.         return [$low + 1, $pos - $this->sourcePositions[$low]];
  4094.     }
  4096.     /**
  4097.      * Save internal encoding of mbstring
  4098.      *
  4099.      * When mbstring.func_overload is used to replace the standard PHP string functions,
  4100.      * this method configures the internal encoding to a single-byte one so that the
  4101.      * behavior matches the normal behavior of PHP string functions while using the parser.
  4102.      * The existing internal encoding is saved and will be restored when calling {@see restoreEncoding}.
  4103.      *
  4104.      * If mbstring.func_overload is not used (or does not override string functions), this method is a no-op.
  4105.      *
  4106.      * @return void
  4107.      */
  4108.     private function saveEncoding()
  4109.     {
  4110.         if (\PHP_VERSION_ID < 80000 && \extension_loaded('mbstring') && (2 & (int) ini_get('mbstring.func_overload')) > 0) {
  4111.             $this->encoding = mb_internal_encoding();
  4113.             mb_internal_encoding('iso-8859-1');
  4114.         }
  4115.     }
  4117.     /**
  4118.      * Restore internal encoding
  4119.      *
  4120.      * @return void
  4121.      */
  4122.     private function restoreEncoding()
  4123.     {
  4124.         if (\extension_loaded('mbstring') && $this->encoding) {
  4125.             mb_internal_encoding($this->encoding);
  4126.         }
  4127.     }
  4128. }