Changeset 124748 in spip-zone


Ignore:
Timestamp:
May 18, 2020, 3:00:58 PM (7 days ago)
Author:
Cerdic
Message:

Mise a jour de la lib ScssPHP avec notamment de belles optimisations de rapidite

Location:
_plugins_/scssphp/tags/v2.4.1
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/scssphp/tags/v2.4.1

    • Property subgit:lock:73b46dcaabc20eae094f976523940227adcf162d deleted
    • Property subgit:lock:a4e8938c75d941fd9e04e16fae6fbda7feb5152d set to 2020-05-18T17:03:26.550
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/Cache.php

    r124745 r124748  
    103103            $cacheTime = filemtime($fileCache);
    104104
    105             if ((is_null($lastModified) || $cacheTime > $lastModified) &&
     105            if ((\is_null($lastModified) || $cacheTime > $lastModified) &&
    106106                $cacheTime + self::$gcLifetime > time()
    107107            ) {
     
    109109                $c = unserialize($c);
    110110
    111                 if (is_array($c) && isset($c['value'])) {
     111                if (\is_array($c) && isset($c['value'])) {
    112112                    return $c['value'];
    113113                }
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/Colors.php

    r124745 r124748  
    187187    public static function colorNameToRGBa($colorName)
    188188    {
    189         if (is_string($colorName) && isset(static::$cssColors[$colorName])) {
     189        if (\is_string($colorName) && isset(static::$cssColors[$colorName])) {
    190190            $rgba = explode(',', static::$cssColors[$colorName]);
    191191
     
    226226        }
    227227
    228         if (is_null($reverseColorTable)) {
     228        if (\is_null($reverseColorTable)) {
    229229            $reverseColorTable = [];
    230230
     
    232232                $rgb_str = explode(',', $rgb_str);
    233233
    234                 if (count($rgb_str) == 3) {
    235                     $reverseColorTable[intval($rgb_str[0])][intval($rgb_str[1])][intval($rgb_str[2])] = $name;
     234                if (\count($rgb_str) == 3) {
     235                    $reverseColorTable[\intval($rgb_str[0])][\intval($rgb_str[1])][\intval($rgb_str[2])] = $name;
    236236                }
    237237            }
    238238        }
    239239
    240         if (isset($reverseColorTable[intval($r)][intval($g)][intval($b)])) {
    241             return $reverseColorTable[intval($r)][intval($g)][intval($b)];
     240        if (isset($reverseColorTable[\intval($r)][\intval($g)][\intval($b)])) {
     241            return $reverseColorTable[\intval($r)][\intval($g)][\intval($b)];
    242242        }
    243243
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/Compiler.php

    r124747 r124748  
    162162    protected $shouldEvaluate;
    163163    protected $ignoreErrors;
     164    protected $ignoreCallStackMessage = false;
    164165
    165166    protected $callStack = [];
     
    229230            $cache          = $this->cache->getCache("compile", $cacheKey, $compileOptions);
    230231
    231             if (is_array($cache) && isset($cache['dependencies']) && isset($cache['out'])) {
     232            if (\is_array($cache) && isset($cache['dependencies']) && isset($cache['out'])) {
    232233                // check if any dependency file changed before accepting the cache
    233234                foreach ($cache['dependencies'] as $file => $mtime) {
     
    256257        $this->charsetSeen    = null;
    257258        $this->shouldEvaluate = null;
     259        $this->ignoreCallStackMessage = false;
    258260
    259261        $this->parser = $this->parserFactory($path);
     
    272274
    273275        if ($this->sourceMap) {
    274             if (is_object($this->sourceMap) && $this->sourceMap instanceof SourceMapGenerator) {
     276            if (\is_object($this->sourceMap) && $this->sourceMap instanceof SourceMapGenerator) {
    275277                $sourceMapGenerator = $this->sourceMap;
    276278                $this->sourceMap = self::SOURCE_MAP_FILE;
     
    329331            $cssOnly = true;
    330332        }
    331         $parser = new Parser($path, count($this->sourceNames), $this->encoding, $this->cache, $cssOnly);
     333        $parser = new Parser($path, \count($this->sourceNames), $this->encoding, $this->cache, $cssOnly);
    332334
    333335        $this->sourceNames[] = $path;
     
    348350    {
    349351        foreach ($origin as $sel) {
    350             if (in_array($target, $sel)) {
     352            if (\in_array($target, $sel)) {
    351353                return true;
    352354            }
     
    369371        }
    370372
    371         $i = count($this->extends);
     373        $i = \count($this->extends);
    372374        $this->extends[] = [$target, $origin, $block];
    373375
     
    465467                $selectors[] = $s;
    466468
    467                 if (! is_array($s)) {
     469                if (! \is_array($s)) {
    468470                    continue;
    469471                }
     
    498500            }
    499501
    500             if ($placeholderSelector && 0 === count($block->selectors) && null !== $parentKey) {
     502            if ($placeholderSelector && 0 === \count($block->selectors) && null !== $parentKey) {
    501503                unset($block->parent->children[$parentKey]);
    502504
     
    522524
    523525        foreach ($parts as $part) {
    524             if (is_array($part)) {
     526            if (\is_array($part)) {
    525527                $part = $this->glueFunctionSelectors($part);
    526528                $new[] = $part;
     
    528530                // a selector part finishing with a ) is the last part of a :not( or :nth-child(
    529531                // and need to be joined to this
    530                 if (count($new) && is_string($new[count($new) - 1]) &&
    531                     strlen($part) && substr($part, -1) === ')' && strpos($part, '(') === false
     532                if (\count($new) && \is_string($new[\count($new) - 1]) &&
     533                    \strlen($part) && substr($part, -1) === ')' && strpos($part, '(') === false
    532534                ) {
    533                     while (count($new)>1 && substr($new[count($new) - 1], -1) !== '(') {
     535                    while (\count($new)>1 && substr($new[\count($new) - 1], -1) !== '(') {
    534536                        $part = array_pop($new) . $part;
    535537                    }
    536                     $new[count($new) - 1] .= $part;
     538                    $new[\count($new) - 1] .= $part;
    537539                } else {
    538540                    $new[] = $part;
     
    557559        $selector = $this->glueFunctionSelectors($selector);
    558560
    559         if (count($selector) == 1 && in_array(reset($selector), $partsPile)) {
     561        if (\count($selector) == 1 && \in_array(reset($selector), $partsPile)) {
    560562            return;
    561563        }
     
    569571            // check that we are not building an infinite loop of extensions
    570572            // if the new part is just including a previous part don't try to extend anymore
    571             if (count($part) > 1) {
     573            if (\count($part) > 1) {
    572574                foreach ($partsPile as $previousPart) {
    573                     if (! count(array_diff($previousPart, $part))) {
     575                    if (! \count(array_diff($previousPart, $part))) {
    574576                        continue 2;
    575577                    }
     
    579581            $partsPile[] = $part;
    580582            if ($this->matchExtendsSingle($part, $origin, $initial)) {
    581                 $after       = array_slice($selector, $i + 1);
    582                 $before      = array_slice($selector, 0, $i);
     583                $after       = \array_slice($selector, $i + 1);
     584                $before      = \array_slice($selector, 0, $i);
    583585                list($before, $nonBreakableBefore) = $this->extractRelationshipFromFragment($before);
    584586
     
    587589
    588590                    // remove shared parts
    589                     if (count($new) > 1) {
     591                    if (\count($new) > 1) {
    590592                        while ($k < $i && isset($new[$k]) && $selector[$k] === $new[$k]) {
    591593                            $k++;
    592594                        }
    593595                    }
    594                     if (count($nonBreakableBefore) and $k == count($new)) {
     596                    if (\count($nonBreakableBefore) and $k == \count($new)) {
    595597                        $k--;
    596598                    }
    597599
    598600                    $replacement = [];
    599                     $tempReplacement = $k > 0 ? array_slice($new, $k) : $new;
    600 
    601                     for ($l = count($tempReplacement) - 1; $l >= 0; $l--) {
     601                    $tempReplacement = $k > 0 ? \array_slice($new, $k) : $new;
     602
     603                    for ($l = \count($tempReplacement) - 1; $l >= 0; $l--) {
    602604                        $slice = [];
    603605
    604606                        foreach ($tempReplacement[$l] as $chunk) {
    605                             if (! in_array($chunk, $slice)) {
     607                            if (! \in_array($chunk, $slice)) {
    606608                                $slice[] = $chunk;
    607609                            }
     
    615617                    }
    616618
    617                     $afterBefore = $l != 0 ? array_slice($tempReplacement, 0, $l) : [];
     619                    $afterBefore = $l != 0 ? \array_slice($tempReplacement, 0, $l) : [];
    618620
    619621                    // Merge shared direct relationships.
     
    634636
    635637                    // recursively check for more matches
    636                     $startRecurseFrom = count($before) + min(count($nonBreakableBefore), count($mergedBefore));
    637                     if (count($origin) > 1) {
     638                    $startRecurseFrom = \count($before) + min(\count($nonBreakableBefore), \count($mergedBefore));
     639                    if (\count($origin) > 1) {
    638640                        $this->matchExtends($result, $out, $startRecurseFrom, false);
    639641                    } else {
     
    642644
    643645                    // selector sequence merging
    644                     if (! empty($before) && count($new) > 1) {
    645                         $preSharedParts = $k > 0 ? array_slice($before, 0, $k) : [];
    646                         $postSharedParts = $k > 0 ? array_slice($before, $k) : $before;
     646                    if (! empty($before) && \count($new) > 1) {
     647                        $preSharedParts = $k > 0 ? \array_slice($before, 0, $k) : [];
     648                        $postSharedParts = $k > 0 ? \array_slice($before, $k) : $before;
    647649
    648650                        list($betweenSharedParts, $nonBreakabl2) = $this->extractRelationshipFromFragment($afterBefore);
     
    664666            array_pop($partsPile);
    665667        }
    666         while (count($outRecurs)) {
     668        while (\count($outRecurs)) {
    667669            $result = array_shift($outRecurs);
    668670            $this->pushOrMergeExtentedSelector($out, $result);
     
    696698    protected function pushOrMergeExtentedSelector(&$out, $extended)
    697699    {
    698         if (count($out) && count($extended) === 1 && count(reset($extended)) === 1) {
     700        if (\count($out) && \count($extended) === 1 && \count(reset($extended)) === 1) {
    699701            $single = reset($extended);
    700702            $part = reset($single);
    701703            if ($this->isPseudoSelector($part, $matchesExtended)
    702               && in_array($matchesExtended[1], [ 'slotted' ])) {
     704              && \in_array($matchesExtended[1], [ 'slotted' ])) {
    703705                $prev = end($out);
    704706                $prev = $this->glueFunctionSelectors($prev);
    705                 if (count($prev) === 1 && count(reset($prev)) === 1) {
     707                if (\count($prev) === 1 && \count(reset($prev)) === 1) {
    706708                    $single = reset($prev);
    707709                    $part = reset($single);
     
    735737
    736738        // simple usual cases, no need to do the whole trick
    737         if (in_array($rawSingle, [['>'],['+'],['~']])) {
     739        if (\in_array($rawSingle, [['>'],['+'],['~']])) {
    738740            return false;
    739741        }
     
    741743        foreach ($rawSingle as $part) {
    742744            // matches Number
    743             if (! is_string($part)) {
     745            if (! \is_string($part)) {
    744746                return false;
    745747            }
    746748
    747             if (! preg_match('/^[\[.:#%]/', $part) && count($single)) {
    748                 $single[count($single) - 1] .= $part;
     749            if (! preg_match('/^[\[.:#%]/', $part) && \count($single)) {
     750                $single[\count($single) - 1] .= $part;
    749751            } else {
    750752                $single[] = $part;
     
    754756        $extendingDecoratedTag = false;
    755757
    756         if (count($single) > 1) {
     758        if (\count($single) > 1) {
    757759            $matches = null;
    758760            $extendingDecoratedTag = preg_match('/^[a-z0-9]+$/i', $single[0], $matches) ? $matches[0] : false;
     
    770772            if ($initial
    771773                && $this->isPseudoSelector($part, $matches)
    772                 && ! in_array($matches[1], [ 'not' ])) {
     774                && ! \in_array($matches[1], [ 'not' ])) {
    773775                $buffer    = $matches[2];
    774776                $parser    = $this->parserFactory(__METHOD__);
     
    800802
    801803            // check count
    802             if ($count !== count($target)) {
     804            if ($count !== \count($target)) {
    803805                continue;
    804806            }
     
    826828                $combined = $this->combineSelectorSingle($replacement, $rem);
    827829
    828                 if (count(array_diff($combined, $origin[$j][count($origin[$j]) - 1]))) {
    829                     $origin[$j][count($origin[$j]) - 1] = $combined;
     830                if (\count(array_diff($combined, $origin[$j][\count($origin[$j]) - 1]))) {
     831                    $origin[$j][\count($origin[$j]) - 1] = $combined;
    830832                }
    831833            }
     
    856858        $children = [];
    857859
    858         $j = $i = count($fragment);
     860        $j = $i = \count($fragment);
    859861
    860862        for (;;) {
    861             $children = $j != $i ? array_slice($fragment, $j, $i - $j) : [];
    862             $parents  = array_slice($fragment, 0, $j);
     863            $children = $j != $i ? \array_slice($fragment, $j, $i - $j) : [];
     864            $parents  = \array_slice($fragment, 0, $j);
    863865            $slice    = end($parents);
    864866
     
    888890        $pseudo = [];
    889891
    890         while (count($other) && strpos(end($other), ':')===0) {
     892        while (\count($other) && strpos(end($other), ':')===0) {
    891893            array_unshift($pseudo, array_pop($other));
    892894        }
     
    904906                    $wasTag = true;
    905907                } elseif ($wasTag) {
    906                     $tag[count($tag) - 1] .= $part;
     908                    $tag[\count($tag) - 1] .= $part;
    907909                } else {
    908910                    $out[] = $part;
     
    911913        }
    912914
    913         if (count($tag)) {
     915        if (\count($tag)) {
    914916            array_unshift($out, $tag[0]);
    915917        }
    916         while (count($pseudo)) {
     918        while (\count($pseudo)) {
    917919            $out[] = array_shift($pseudo);
    918920        }
     
    10331035    protected function compileDirective($directive, OutputBlock $out)
    10341036    {
    1035         if (is_array($directive)) {
     1037        if (\is_array($directive)) {
    10361038            $s = '@' . $directive[0];
    10371039            if (! empty($directive[1])) {
     
    11471149            }
    11481150
    1149             if (count($childStash)) {
     1151            if (\count($childStash)) {
    11501152                $scope = array_shift($childStash);
    11511153            } elseif ($scope->children) {
     
    11561158        }
    11571159
    1158         if (! count($filteredScopes)) {
     1160        if (! \count($filteredScopes)) {
    11591161            return $this->rootBlock;
    11601162        }
     
    11671169        $p = &$newScope;
    11681170
    1169         while (count($filteredScopes)) {
     1171        while (\count($filteredScopes)) {
    11701172            $s = array_shift($filteredScopes);
    11711173            $s->parent = $p;
     
    11891191    protected function completeScope($scope, $previousScope)
    11901192    {
    1191         if (! $scope->type && (! $scope->selectors || ! count($scope->selectors)) && count($scope->lines)) {
     1193        if (! $scope->type && (! $scope->selectors || ! \count($scope->selectors)) && \count($scope->lines)) {
    11921194            $scope->selectors = $this->findScopeSelectors($previousScope, $scope->depth);
    11931195        }
     
    13221324        } elseif (isset($block->selectors)) {
    13231325            // a selector starting with number is a keyframe rule
    1324             if (count($block->selectors)) {
     1326            if (\count($block->selectors)) {
    13251327                $s = reset($block->selectors);
    13261328
    1327                 while (is_array($s)) {
     1329                while (\is_array($s)) {
    13281330                    $s = reset($s);
    13291331                }
    13301332
    1331                 if (is_object($s) && $s instanceof Node\Number) {
     1333                if (\is_object($s) && $s instanceof Node\Number) {
    13321334                    return $this->testWithWithout('keyframes', $with, $without);
    13331335                }
     
    13541356
    13551357        // if without, reject only if in the list (or 'all' is in the list)
    1356         if (count($without)) {
     1358        if (\count($without)) {
    13571359            return (isset($without[$what]) || isset($without['all'])) ? false : true;
    13581360        }
     
    14991501        $out = $this->makeOutputBlock(null);
    15001502
    1501         if (isset($this->lineNumberStyle) && count($env->selectors) && count($block->children)) {
     1503        if (isset($this->lineNumberStyle) && \count($env->selectors) && \count($block->children)) {
    15021504            $annotation = $this->makeOutputBlock(Type::T_COMMENT);
    15031505            $annotation->depth = 0;
     
    15251527        $this->scope->children[] = $out;
    15261528
    1527         if (count($block->children)) {
     1529        if (\count($block->children)) {
    15281530            $out->selectors = $this->multiplySelectors($env, $block->selfParent);
    15291531
     
    15651567            }
    15661568
     1569            $ignoreCallStackMessage = $this->ignoreCallStackMessage;
     1570            $this->ignoreCallStackMessage = true;
    15671571            try {
    15681572                $c = $this->compileValue($value[2]);
     
    15701574                // ignore error in comment compilation which are only interpolation
    15711575            }
     1576            $this->ignoreCallStackMessage = $ignoreCallStackMessage;
    15721577
    15731578            if ($pushEnv) {
     
    16411646    {
    16421647        foreach ($part as &$p) {
    1643             if (is_array($p) && ($p[0] === Type::T_INTERPOLATE || $p[0] === Type::T_STRING)) {
     1648            if (\is_array($p) && ($p[0] === Type::T_INTERPOLATE || $p[0] === Type::T_STRING)) {
    16441649                $p = $this->compileValue($p);
    16451650
     
    16481653                    $this->shouldEvaluate = true;
    16491654                }
    1650             } elseif (is_string($p) && strlen($p) >= 2 &&
     1655            } elseif (\is_string($p) && \strlen($p) >= 2 &&
    16511656                ($first = $p[0]) && ($first === '"' || $first === "'") &&
    16521657                substr($p, -1) === $first
     
    16881693
    16891694                if ($selectorFormat && $this->isImmediateRelationshipCombinator($compound)) {
    1690                     if (count($output)) {
    1691                         $output[count($output) - 1] .= ' ' . $compound;
     1695                    if (\count($output)) {
     1696                        $output[\count($output) - 1] .= ' ' . $compound;
    16921697                    } else {
    16931698                        $output[] = $compound;
     
    16961701                    $glueNext = true;
    16971702                } elseif ($glueNext) {
    1698                     $output[count($output) - 1] .= ' ' . $compound;
     1703                    $output[\count($output) - 1] .= ' ' . $compound;
    16991704                    $glueNext = false;
    17001705                } else {
     
    17351740    {
    17361741        foreach ($selectors as &$part) {
    1737             if (is_array($part)) {
     1742            if (\is_array($part)) {
    17381743                if ($part === [Type::T_SELF]) {
    17391744                    $part = '&';
     
    17601765        foreach ($single as $part) {
    17611766            if (empty($joined) ||
    1762                 ! is_string($part) ||
     1767                ! \is_string($part) ||
    17631768                preg_match('/[\[.:#%]/', $part)
    17641769            ) {
     
    17671772            }
    17681773
    1769             if (is_array(end($joined))) {
     1774            if (\is_array(end($joined))) {
    17701775                $joined[] = $part;
    17711776            } else {
    1772                 $joined[count($joined) - 1] .= $part;
     1777                $joined[\count($joined) - 1] .= $part;
    17731778            }
    17741779        }
     
    17861791    protected function compileSelector($selector)
    17871792    {
    1788         if (! is_array($selector)) {
     1793        if (! \is_array($selector)) {
    17891794            return $selector; // media and the like
    17901795        }
     
    18091814    {
    18101815        foreach ($piece as &$p) {
    1811             if (! is_array($p)) {
     1816            if (! \is_array($p)) {
    18121817                continue;
    18131818            }
     
    18361841    protected function hasSelectorPlaceholder($selector)
    18371842    {
    1838         if (! is_array($selector)) {
     1843        if (! \is_array($selector)) {
    18391844            return false;
    18401845        }
     
    18421847        foreach ($selector as $parts) {
    18431848            foreach ($parts as $part) {
    1844                 if (strlen($part) && '%' === $part[0]) {
     1849                if (\strlen($part) && '%' === $part[0]) {
    18451850                    return true;
    18461851                }
     
    18611866
    18621867        // infinite calling loop
    1863         if (count($this->callStack) > 25000) {
     1868        if (\count($this->callStack) > 25000) {
    18641869            // not displayed but you can var_dump it to deep debug
    18651870            $msg = $this->callStackMessage(true, 100);
     
    18921897
    18931898            if (isset($ret)) {
     1899                $this->popCallStack();
    18941900                return $ret;
    18951901            }
     
    19161922
    19171923        foreach ($stms as $stm) {
    1918             if ($selfParent && isset($stm[1]) && is_object($stm[1]) && $stm[1] instanceof Block) {
     1924            if ($selfParent && isset($stm[1]) && \is_object($stm[1]) && $stm[1] instanceof Block) {
    19191925                $stm[1]->selfParent = $selfParent;
    19201926                $ret = $this->compileChild($stm, $out);
    19211927                $stm[1]->selfParent = null;
    1922             } elseif ($selfParent && in_array($stm[0], [TYPE::T_INCLUDE, TYPE::T_EXTEND])) {
     1928            } elseif ($selfParent && \in_array($stm[0], [TYPE::T_INCLUDE, TYPE::T_EXTEND])) {
    19231929                $stm['selfParent'] = $selfParent;
    19241930                $ret = $this->compileChild($stm, $out);
     
    19301936            if (isset($ret)) {
    19311937                $this->throwError('@return may only be used within a function');
     1938                $this->popCallStack();
    19321939
    19331940                return;
     
    19561963
    19571964            foreach ($query as $kq => $q) {
    1958                 for ($i = 1; $i < count($q); $i++) {
     1965                for ($i = 1; $i < \count($q); $i++) {
    19591966                    $value = $this->compileValue($q[$i]);
    19601967
     
    19751982
    19761983            if ($shouldReparse) {
    1977                 if (is_null($parser)) {
     1984                if (\is_null($parser)) {
    19781985                    $parser = $this->parserFactory(__METHOD__);
    19791986                }
     
    19891996                        $queries = $this->evaluateMediaQuery($queries[2]);
    19901997
    1991                         while (count($queries)) {
     1998                        while (\count($queries)) {
    19921999                            $outQueryList[] = array_shift($queries);
    19932000                        }
     
    20342041                switch ($q[0]) {
    20352042                    case Type::T_MEDIA_TYPE:
    2036                         $newType = array_map([$this, 'compileValue'], array_slice($q, 1));
     2043                        $newType = array_map([$this, 'compileValue'], \array_slice($q, 1));
    20372044
    20382045                        // combining not and anything else than media type is too risky and should be avoided
    20392046                        if (! $mediaTypeOnly) {
    2040                             if (in_array(Type::T_NOT, $newType) || ($type && in_array(Type::T_NOT, $type) )) {
     2047                            if (\in_array(Type::T_NOT, $newType) || ($type && \in_array(Type::T_NOT, $type) )) {
    20412048                                if ($type) {
    20422049                                    array_unshift($parts, implode(' ', array_filter($type)));
     
    20442051
    20452052                                if (! empty($parts)) {
    2046                                     if (strlen($current)) {
     2053                                    if (\strlen($current)) {
    20472054                                        $current .= $this->formatter->tagSeparator;
    20482055                                    }
     
    21072114
    21082115            if (! empty($parts)) {
    2109                 if (strlen($current)) {
     2116                if (\strlen($current)) {
    21102117                    $current .= $this->formatter->tagSeparator;
    21112118                }
     
    21892196        }
    21902197
    2191         if (count($type1) > 1) {
     2198        if (\count($type1) > 1) {
    21922199            $m1 = strtolower($type1[0]);
    21932200            $t1 = strtolower($type1[1]);
     
    21972204        }
    21982205
    2199         if (count($type2) > 1) {
     2206        if (\count($type2) > 1) {
    22002207            $m2 = strtolower($type2[0]);
    22012208            $t2 = strtolower($type2[1]);
     
    22482255
    22492256            if ($path = $this->findImport($path)) {
    2250                 if (! $once || ! in_array($path, $this->importedFiles)) {
     2257                if (! $once || ! \in_array($path, $this->importedFiles)) {
    22512258                    $this->importFile($path, $out);
    22522259                    $this->importedFiles[] = $path;
     
    22632270        if ($rawPath[0] === Type::T_LIST) {
    22642271            // handle a list of strings
    2265             if (count($rawPath[2]) === 0) {
     2272            if (\count($rawPath[2]) === 0) {
    22662273                return false;
    22672274            }
     
    23062313        $i = 0;
    23072314
    2308         while ($i < count($root->children)) {
    2309             if (! isset($root->children[$i]->type) || ! in_array($root->children[$i]->type, $allowed)) {
     2315        while ($i < \count($root->children)) {
     2316            if (! isset($root->children[$i]->type) || ! \in_array($root->children[$i]->type, $allowed)) {
    23102317                break;
    23112318            }
     
    23172324        $saveChildren = [];
    23182325
    2319         while ($i < count($root->children)) {
     2326        while ($i < \count($root->children)) {
    23202327            $saveChildren[] = array_pop($root->children);
    23212328        }
     
    23312338
    23322339        // repush children
    2333         while (count($saveChildren)) {
     2340        while (\count($saveChildren)) {
    23342341            $root->children[] = array_pop($saveChildren);
    23352342        }
     
    23522359
    23532360            if (end($parent->children) !== $out) {
    2354                 $outWrite = &$parent->children[count($parent->children) - 1];
     2361                $outWrite = &$parent->children[\count($parent->children) - 1];
    23552362            }
    23562363        }
    23572364
    23582365        // check if it's a flat output or not
    2359         if (count($out->children)) {
    2360             $lastChild = &$out->children[count($out->children) - 1];
    2361 
    2362             if ($lastChild->depth === $out->depth && is_null($lastChild->selectors) && ! count($lastChild->children)) {
     2366        if (\count($out->children)) {
     2367            $lastChild = &$out->children[\count($out->children) - 1];
     2368
     2369            if ($lastChild->depth === $out->depth && \is_null($lastChild->selectors) && ! \count($lastChild->children)) {
    23632370                $outWrite = $lastChild;
    23642371            } else {
     
    23892396            $this->sourceLine   = isset($child[Parser::SOURCE_LINE]) ? $child[Parser::SOURCE_LINE] : -1;
    23902397            $this->sourceColumn = isset($child[Parser::SOURCE_COLUMN]) ? $child[Parser::SOURCE_COLUMN] : -1;
    2391         } elseif (is_array($child) && isset($child[1]->sourceLine)) {
     2398        } elseif (\is_array($child) && isset($child[1]->sourceLine)) {
    23922399            $this->sourceIndex  = $child[1]->sourceIndex;
    23932400            $this->sourceLine   = $child[1]->sourceLine;
     
    24682475                if ($name[0] === Type::T_VARIABLE) {
    24692476                    $flags     = isset($child[3]) ? $child[3] : [];
    2470                     $isDefault = in_array('!default', $flags);
    2471                     $isGlobal  = in_array('!global', $flags);
     2477                    $isDefault = \in_array('!default', $flags);
     2478                    $isGlobal  = \in_array('!global', $flags);
    24722479
    24732480                    if ($isGlobal) {
     
    24772484
    24782485                    $shouldSet = $isDefault &&
    2479                         (is_null($result = $this->get($name[1], false)) ||
     2486                        (\is_null($result = $this->get($name[1], false)) ||
    24802487                        $result === static::$null);
    24812488
     
    24892496
    24902497                // handle shorthand syntaxes : size / line-height...
    2491                 if (in_array($compiledName, ['font', 'grid-row', 'grid-column', 'border-radius'])) {
     2498                if (\in_array($compiledName, ['font', 'grid-row', 'grid-column', 'border-radius'])) {
    24922499                    if ($value[0] === Type::T_VARIABLE) {
    24932500                        // if the font value comes from variable, the content is already reduced
     
    25212528                            $divider = $shorthandValue[3];
    25222529
    2523                             if (is_array($divider)) {
     2530                            if (\is_array($divider)) {
    25242531                                $divider = $this->reduce($divider, true);
    25252532                            }
    25262533
    2527                             if (intval($divider->dimension) and !count($divider->units)) {
     2534                            if (\intval($divider->dimension) and !\count($divider->units)) {
    25282535                                $revert = false;
    25292536                            }
     
    25402547                                    // if the list of values is too long, this has to be a shorthand,
    25412548                                    // otherwise it could be a real division
    2542                                     if (is_null($maxListElements) or count($shorthandValue[2]) <= $maxListElements) {
     2549                                    if (\is_null($maxListElements) or \count($shorthandValue[2]) <= $maxListElements) {
    25432550                                        if ($shorthandDividerNeedsUnit) {
    25442551                                            $divider = $item[3];
    25452552
    2546                                             if (is_array($divider)) {
     2553                                            if (\is_array($divider)) {
    25472554                                                $divider = $this->reduce($divider, true);
    25482555                                            }
    25492556
    2550                                             if (intval($divider->dimension) and !count($divider->units)) {
     2557                                            if (\intval($divider->dimension) and !\count($divider->units)) {
    25512558                                                $revert = false;
    25522559                                            }
     
    25772584
    25782585                // ignore empty value
    2579                 if (strlen($compiledValue)) {
     2586                if (\strlen($compiledValue)) {
    25802587                    $line = $this->formatter->property(
    25812588                        $compiledName,
     
    26462653
    26472654                foreach ($list[2] as $item) {
    2648                     if (count($each->vars) === 1) {
     2655                    if (\count($each->vars) === 1) {
    26492656                        $this->set($each->vars[0], $item, true);
    26502657                    } else {
     
    27922799
    27932800                        foreach ($mixin->children as $k => $child) {
    2794                             if (isset($child[1]) && is_object($child[1]) && $child[1] instanceof Block) {
     2801                            if (isset($child[1]) && \is_object($child[1]) && $child[1] instanceof Block) {
    27952802                                $mixin->children[$k][1]->parent = $parent;
    27962803                            }
     
    29912998    protected function reduce($value, $inExp = false)
    29922999    {
    2993         if (is_null($value)) {
     3000        if (\is_null($value)) {
    29943001            return null;
    29953002        }
     
    30313038                $fn = "op${ucOpName}${ucLType}${ucRType}";
    30323039
    3033                 if (is_callable([$this, $fn]) ||
     3040                if (\is_callable([$this, $fn]) ||
    30343041                    (($fn = "op${ucLType}${ucRType}") &&
    3035                         is_callable([$this, $fn]) &&
     3042                        \is_callable([$this, $fn]) &&
    30363043                        $passOp = true) ||
    30373044                    (($fn = "op${ucOpName}") &&
    3038                         is_callable([$this, $fn]) &&
     3045                        \is_callable([$this, $fn]) &&
    30393046                        $genOp = true)
    30403047                ) {
     
    31513158            case Type::T_STRING:
    31523159                foreach ($value[2] as &$item) {
    3153                     if (is_array($item) || $item instanceof \ArrayAccess) {
     3160                    if (\is_array($item) || $item instanceof \ArrayAccess) {
    31543161                        $item = $this->reduce($item);
    31553162                    }
     
    36933700                $b = $this->compileRGBAValue($b);
    36943701
    3695                 if (count($value) === 5) {
     3702                if (\count($value) === 5) {
    36963703                    $alpha = $this->compileRGBAValue($value[4], true);
    36973704
     
    36993706                        $colorName = Colors::RGBaToColorName($r, $g, $b, $alpha);
    37003707
    3701                         if (! is_null($colorName)) {
     3708                        if (! \is_null($colorName)) {
    37023709                            return $colorName;
    37033710                        }
     
    37193726                $colorName = Colors::RGBaToColorName($r, $g, $b);
    37203727
    3721                 if (! is_null($colorName)) {
     3728                if (! \is_null($colorName)) {
    37223729                    return $colorName;
    37233730                }
     
    37833790
    37843791                    $compiled = $this->compileValue($item);
    3785                     if ($prefix_value && strlen($compiled)) {
     3792                    if ($prefix_value && \strlen($compiled)) {
    37863793                        $compiled = $prefix_value . $compiled;
    37873794                    }
     
    37893796                }
    37903797
    3791                 return $pre . substr(implode("$delim", $filtered), strlen($prefix_value)) . $post;
     3798                return $pre . substr(implode("$delim", $filtered), \strlen($prefix_value)) . $post;
    37923799
    37933800            case Type::T_MAP:
     
    37963803                $filtered = [];
    37973804
    3798                 for ($i = 0, $s = count($keys); $i < $s; $i++) {
     3805                for ($i = 0, $s = \count($keys); $i < $s; $i++) {
    37993806                    $filtered[$this->compileValue($keys[$i])] = $this->compileValue($values[$i]);
    38003807                }
     
    38173824                }
    38183825
    3819                 $left = count($left[2]) > 0 ?
     3826                $left = \count($left[2]) > 0 ?
    38203827                    $this->compileValue($left) . $delim . $whiteLeft: '';
    38213828
     
    38263833                }
    38273834
    3828                 $right = count($right[2]) > 0 ?
     3835                $right = \count($right[2]) > 0 ?
    38293836                    $whiteRight . $delim . $this->compileValue($right) : '';
    38303837
     
    39153922
    39163923        foreach ($string[2] as $part) {
    3917             if (is_array($part) || $part instanceof \ArrayAccess) {
     3924            if (\is_array($part) || $part instanceof \ArrayAccess) {
    39183925                $parts[] = $this->compileValue($part);
    39193926            } else {
     
    39383945        foreach ($items as $i => $item) {
    39393946            if ($item[0] === Type::T_INTERPOLATE) {
    3940                 $before = [Type::T_LIST, $list[1], array_slice($items, 0, $i)];
    3941                 $after  = [Type::T_LIST, $list[1], array_slice($items, $i + 1)];
     3947                $before = [Type::T_LIST, $list[1], \array_slice($items, 0, $i)];
     3948                $after  = [Type::T_LIST, $list[1], \array_slice($items, $i + 1)];
    39423949
    39433950                return [Type::T_INTERPOLATED, $item, $before, $after];
     
    39643971        $selfParentSelectors = null;
    39653972
    3966         if (! is_null($selfParent) && $selfParent->selectors) {
     3973        if (! \is_null($selfParent) && $selfParent->selectors) {
    39673974            $selfParentSelectors = $this->evalSelectors($selfParent->selectors);
    39683975        }
     
    40314038                    $setSelf = true;
    40324039
    4033                     if (is_null($selfParentSelectors)) {
     4040                    if (\is_null($selfParentSelectors)) {
    40344041                        $selfParentSelectors = $parent;
    40354042                    }
     
    40424049
    40434050                        foreach ($parentPart as $pp) {
    4044                             if (is_array($pp)) {
     4051                            if (\is_array($pp)) {
    40454052                                $flatten = [];
    40464053
     
    40994106        list($this->env, $this->storeEnv) = $store;
    41004107
    4101         if (is_null($childQueries)) {
     4108        if (\is_null($childQueries)) {
    41024109            $childQueries = $parentQueries;
    41034110        } else {
     
    41914198    {
    41924199        foreach ($store as $key => $value) {
    4193             if (empty($excludedVars) || !in_array($key, $excludedVars)) {
     4200            if (empty($excludedVars) || !\in_array($key, $excludedVars)) {
    41944201                $this->set($key, $value, true);
    41954202            }
     
    42534260            }
    42544261
    4255             if (array_key_exists($name, $env->store)) {
     4262            if (\array_key_exists($name, $env->store)) {
    42564263                break;
    42574264            }
     
    43364343            }
    43374344
    4338             if (array_key_exists($normalizedName, $env->store)) {
     4345            if (\array_key_exists($normalizedName, $env->store)) {
    43394346                if ($unreduced && isset($env->storeUnreduced[$normalizedName])) {
    43404347                    return $env->storeUnreduced[$normalizedName];
     
    43854392    protected function has($name, Environment $env = null)
    43864393    {
    4387         return ! is_null($this->get($name, false, $env));
     4394        return ! \is_null($this->get($name, false, $env));
    43884395    }
    43894396
     
    44854492    public function addImportPath($path)
    44864493    {
    4487         if (! in_array($path, $this->importPaths)) {
     4494        if (! \in_array($path, $this->importPaths)) {
    44884495            $this->importPaths[] = $path;
    44894496        }
     
    46084615    protected function importFile($path, OutputBlock $out)
    46094616    {
     4617        $this->pushCallStack('import '.$path);
    46104618        // see if tree is cached
    46114619        $realPath = realpath($path);
     
    46284636        $this->compileChildrenNoReturn($tree->children, $out);
    46294637        array_shift($this->importPaths);
     4638        $this->popCallStack();
    46304639    }
    46314640
     
    46474656        // for "normal" scss imports (ignore vanilla css and external requests)
    46484657        if (! preg_match('~\.css$|^https?://|^//~', $url)) {
     4658            $isPartial = (strpos(basename($url), '_') === 0);
    46494659            // try both normal and the _partial filename
    4650             $urls = [$url, preg_replace('~[^/]+$~', '_\0', $url)];
     4660            $urls = [$url . ($hasExtension ? '' : '.scss')];
     4661            if (! $isPartial) {
     4662                $urls[] = preg_replace('~[^/]+$~', '_\0', $url) . ($hasExtension ? '' : '.scss');
     4663            }
    46514664            if (!$hasExtension) {
    4652                 $urls[0] .= ".scss";
    4653                 $urls[1] .= ".scss";
     4665                $urls[] = "$url/index.scss";
     4666                $urls[] = "$url/_index.scss";
    46544667                // allow to find a plain css file, *if* no scss or partial scss is found
    46554668                $urls[] .= $url . ".css";
     
    46584671
    46594672        foreach ($this->importPaths as $dir) {
    4660             if (is_string($dir)) {
     4673            if (\is_string($dir)) {
    46614674                // check urls for normal import paths
    46624675                foreach ($urls as $full) {
     
    46724685                    }
    46734686                }
    4674             } elseif (is_callable($dir)) {
     4687            } elseif (\is_callable($dir)) {
    46754688                // check custom callback for import path
    4676                 $file = call_user_func($dir, $url);
    4677 
    4678                 if (! is_null($file)) {
     4689                $file = \call_user_func($dir, $url);
     4690
     4691                if (! \is_null($file)) {
    46794692                    return $file;
    46804693                }
     
    47344747        }
    47354748
    4736         $line   = $this->sourceLine;
    4737         $column = $this->sourceColumn;
    4738 
    4739         $loc = isset($this->sourceNames[$this->sourceIndex])
    4740              ? $this->sourceNames[$this->sourceIndex] . " on line $line, at column $column"
    4741              : "line: $line, column: $column";
    4742 
    4743         if (func_num_args() > 1) {
    4744             $msg = call_user_func_array('sprintf', func_get_args());
    4745         }
    4746 
    4747         $msg = "$msg: $loc";
    4748 
    4749         $callStackMsg = $this->callStackMessage();
    4750 
    4751         if ($callStackMsg) {
    4752             $msg .= "\nCall Stack:\n" . $callStackMsg;
     4749        if (\func_num_args() > 1) {
     4750            $msg = \call_user_func_array('sprintf', \func_get_args());
     4751        }
     4752
     4753        if (!$this->ignoreCallStackMessage) {
     4754            $line   = $this->sourceLine;
     4755            $column = $this->sourceColumn;
     4756
     4757            $loc = isset($this->sourceNames[$this->sourceIndex])
     4758                ? $this->sourceNames[$this->sourceIndex] . " on line $line, at column $column"
     4759                : "line: $line, column: $column";
     4760
     4761            $msg = "$msg: $loc";
     4762
     4763            $callStackMsg = $this->callStackMessage();
     4764
     4765            if ($callStackMsg) {
     4766                $msg .= "\nCall Stack:\n" . $callStackMsg;
     4767            }
    47534768        }
    47544769
     
    47804795                    $callStackMsg[] = $msg;
    47814796
    4782                     if (! is_null($limit) && $ncall > $limit) {
     4797                    if (! \is_null($limit) && $ncall > $limit) {
    47834798                        break;
    47844799                    }
     
    48764891            // see if we can find a user function
    48774892            list($f, $prototype) = $this->userFunctions[$name];
    4878         } elseif (($f = $this->getBuiltinFunction($name)) && is_callable($f)) {
     4893        } elseif (($f = $this->getBuiltinFunction($name)) && \is_callable($f)) {
    48794894            $libName   = $f[1];
    48804895            $prototype = isset(static::$$libName) ? static::$$libName : null;
     
    48974912        }
    48984913
    4899         $returnValue = call_user_func($f, $sorted, $kwargs);
     4914        $returnValue = \call_user_func($f, $sorted, $kwargs);
    49004915
    49014916        if (! isset($returnValue)) {
     
    49624977
    49634978        // specific cases ?
    4964         if (in_array($functionName, ['libRgb', 'libRgba', 'libHsl', 'libHsla'])) {
     4979        if (\in_array($functionName, ['libRgb', 'libRgba', 'libHsl', 'libHsla'])) {
    49654980            // notation 100 127 255 / 0 is in fact a simple list of 4 values
    49664981            foreach ($args as $k => $arg) {
    4967                 if ($arg[1][0] === Type::T_LIST && count($arg[1][2]) === 3) {
     4982                if ($arg[1][0] === Type::T_LIST && \count($arg[1][2]) === 3) {
    49684983                    $last = end($arg[1][2]);
    49694984
     
    49804995        $finalArgs = [];
    49814996
    4982         if (! is_array(reset($prototypes))) {
     4997        if (! \is_array(reset($prototypes))) {
    49834998            $prototypes = [$prototypes];
    49844999        }
     
    49985013                $name    = array_shift($p);
    49995014
    5000                 if (count($p)) {
     5015                if (\count($p)) {
    50015016                    $p = trim(reset($p));
    50025017
     
    50055020                        $default = [Type::T_KEYWORD, 'null'];
    50065021                    } else {
    5007                         if (is_null($parser)) {
     5022                        if (\is_null($parser)) {
    50085023                            $parser = $this->parserFactory(__METHOD__);
    50095024                        }
     
    50225037                $argDef[] = [$name, $default, $isVariable];
    50235038            }
     5039
     5040            $ignoreCallStackMessage = $this->ignoreCallStackMessage;
     5041            $this->ignoreCallStackMessage = true;
    50245042
    50255043            try {
     
    50605078                $exceptionMessage = $e->getMessage();
    50615079            }
     5080            $this->ignoreCallStackMessage = $ignoreCallStackMessage;
    50625081        }
    50635082
     
    50855104    {
    50865105        $output = [];
    5087         if (is_array($argValues) && count($argValues) && end($argValues) === static::$null) {
     5106        if (\is_array($argValues) && \count($argValues) && end($argValues) === static::$null) {
    50885107            array_pop($argValues);
    50895108        }
     
    51335152                        break;
    51345153                    }
    5135                 } elseif ($args[$name][0] < count($remaining)) {
     5154                } elseif ($args[$name][0] < \count($remaining)) {
    51365155                    $this->throwError("The argument $%s was passed both by position and by name.", $arg[0][1]);
    51375156                    break;
     
    51605179                            }
    51615180                        } else {
    5162                             if (is_null($splatSeparator)) {
     5181                            if (\is_null($splatSeparator)) {
    51635182                                $splatSeparator = $val[1];
    51645183                            }
     
    51885207                            }
    51895208                        } else {
    5190                             if (is_null($splatSeparator)) {
     5209                            if (\is_null($splatSeparator)) {
    51915210                                $splatSeparator = $val[1];
    51925211                            }
     
    52105229
    52115230            if ($isVariable) {
    5212                 $val = [Type::T_LIST, is_null($splatSeparator) ? ',' : $splatSeparator , [], $isVariable];
    5213 
    5214                 for ($count = count($remaining); $i < $count; $i++) {
     5231                $val = [Type::T_LIST, \is_null($splatSeparator) ? ',' : $splatSeparator , [], $isVariable];
     5232
     5233                for ($count = \count($remaining); $i < $count; $i++) {
    52155234                    $val[2][] = $remaining[$i];
    52165235                }
     
    52675286    protected function coerceValue($value)
    52685287    {
    5269         if (is_array($value) || $value instanceof \ArrayAccess) {
     5288        if (\is_array($value) || $value instanceof \ArrayAccess) {
    52705289            return $value;
    52715290        }
    52725291
    5273         if (is_bool($value)) {
     5292        if (\is_bool($value)) {
    52745293            return $this->toBool($value);
    52755294        }
    52765295
    5277         if (is_null($value)) {
     5296        if (\is_null($value)) {
    52785297            return static::$null;
    52795298        }
     
    53435362            $list = [];
    53445363
    5345             for ($i = 0, $s = count($keys); $i < $s; $i++) {
     5364            for ($i = 0, $s = \count($keys); $i < $s; $i++) {
    53465365                $key = $keys[$i];
    53475366                $value = $values[$i];
     
    54275446            case Type::T_LIST:
    54285447                if ($inRGBFunction) {
    5429                     if (count($value[2]) == 3 || count($value[2]) == 4) {
     5448                    if (\count($value[2]) == 3 || \count($value[2]) == 4) {
    54305449                        $color = $value[2];
    54315450                        array_unshift($color, Type::T_COLOR);
     
    54385457
    54395458            case Type::T_KEYWORD:
    5440                 if (! is_string($value[1])) {
     5459                if (! \is_string($value[1])) {
    54415460                    return null;
    54425461                }
     
    54455464                // hexa color?
    54465465                if (preg_match('/^#([0-9a-f]+)$/i', $name, $m)) {
    5447                     $nofValues = strlen($m[1]);
    5448 
    5449                     if (in_array($nofValues, [3, 4, 6, 8])) {
     5466                    $nofValues = \strlen($m[1]);
     5467
     5468                    if (\in_array($nofValues, [3, 4, 6, 8])) {
    54505469                        $nbChannels = 3;
    54515470                        $color      = [];
     
    55315550    {
    55325551        if (! is_numeric($value)) {
    5533             if (is_array($value)) {
     5552            if (\is_array($value)) {
    55345553                $reduced = $this->reduce($value);
    55355554
    5536                 if (is_object($reduced) && $value->type === Type::T_NUMBER) {
     5555                if (\is_object($reduced) && $value->type === Type::T_NUMBER) {
    55375556                    $value = $reduced;
    55385557                }
    55395558            }
    55405559
    5541             if (is_object($value) && $value->type === Type::T_NUMBER) {
     5560            if (\is_object($value) && $value->type === Type::T_NUMBER) {
    55425561                $num = $value->dimension;
    55435562
    5544                 if (count($value->units)) {
     5563                if (\count($value->units)) {
    55455564                    $unit = array_keys($value->units);
    55465565                    $unit = reset($unit);
     
    55565575
    55575576                $value = $num;
    5558             } elseif (is_array($value)) {
     5577            } elseif (\is_array($value)) {
    55595578                $value = $this->compileValue($value);
    55605579            }
     
    59045923    protected function libRgb($args, $kwargs, $funcName = 'rgb')
    59055924    {
    5906         switch (count($args)) {
     5925        switch (\count($args)) {
    59075926            case 1:
    59085927                if (! $color = $this->coerceColor($args[0], true)) {
     
    59735992                }
    59745993
    5975                 $color[$irgba] = call_user_func($fn, $color[$irgba], $val, $iarg);
     5994                $color[$irgba] = \call_user_func($fn, $color[$irgba], $val, $iarg);
    59765995            }
    59775996        }
     
    59836002                if (! empty($args[$iarg])) {
    59846003                    $val = $this->assertNumber($args[$iarg]);
    5985                     $hsl[$ihsl] = call_user_func($fn, $hsl[$ihsl], $val, $iarg);
     6004                    $hsl[$ihsl] = \call_user_func($fn, $hsl[$ihsl], $val, $iarg);
    59866005                }
    59876006            }
     
    61596178    protected function libHsl($args, $kwargs, $funcName = 'hsl')
    61606179    {
    6161         if (count($args) == 1) {
    6162             if ($args[0][0] !== Type::T_LIST || count($args[0][2]) < 3 || count($args[0][2]) > 4) {
     6180        if (\count($args) == 1) {
     6181            if ($args[0][0] !== Type::T_LIST || \count($args[0][2]) < 3 || \count($args[0][2]) > 4) {
    61636182                return [Type::T_STRING, '', [$funcName . '(', $args[0], ')']];
    61646183            }
     
    61736192        $alpha = null;
    61746193
    6175         if (count($args) === 4) {
     6194        if (\count($args) === 4) {
    61766195            $alpha = $this->compileColorPartValue($args[3], 0, 100, false);
    61776196
     
    61886207        $color = $this->toRGB($hue, $saturation, $lightness);
    61896208
    6190         if (! is_null($alpha)) {
     6209        if (! \is_null($alpha)) {
    61916210            $color[4] = $alpha;
    61926211        }
     
    64486467        foreach ($numbers as $key => $pair) {
    64496468            list($original, $normalized) = $pair;
    6450             if (is_null($normalized) or is_null($minNormalized)) {
    6451                 if (is_null($minOriginal) || $original[1] <= $minOriginal[1]) {
     6469            if (\is_null($normalized) or \is_null($minNormalized)) {
     6470                if (\is_null($minOriginal) || $original[1] <= $minOriginal[1]) {
    64526471                    $minOriginal = $original;
    64536472                    $minNormalized = $normalized;
     
    64706489        foreach ($numbers as $key => $pair) {
    64716490            list($original, $normalized) = $pair;
    6472             if (is_null($normalized) or is_null($maxNormalized)) {
    6473                 if (is_null($maxOriginal) || $original[1] >= $maxOriginal[1]) {
     6491            if (\is_null($normalized) or \is_null($maxNormalized)) {
     6492                if (\is_null($maxOriginal) || $original[1] >= $maxOriginal[1]) {
    64746493                    $maxOriginal = $original;
    64756494                    $maxNormalized = $normalized;
     
    65246543        $list = $this->coerceList($args[0], ',', true);
    65256544
    6526         return count($list[2]);
     6545        return \count($list[2]);
    65276546    }
    65286547
     
    65306549    protected function libListSeparator($args)
    65316550    {
    6532         if (count($args) > 1) {
     6551        if (\count($args) > 1) {
    65336552            return 'comma';
    65346553        }
     
    65366555        $list = $this->coerceList($args[0]);
    65376556
    6538         if (count($list[2]) <= 1) {
     6557        if (\count($list[2]) <= 1) {
    65396558            return 'space';
    65406559        }
     
    65566575            $n--;
    65576576        } elseif ($n < 0) {
    6558             $n += count($list[2]);
     6577            $n += \count($list[2]);
    65596578        }
    65606579
     
    65716590            $n--;
    65726591        } elseif ($n < 0) {
    6573             $n += count($list[2]);
     6592            $n += \count($list[2]);
    65746593        }
    65756594
     
    65916610        $key = $args[1];
    65926611
    6593         if (! is_null($key)) {
     6612        if (! \is_null($key)) {
    65946613            $key = $this->compileStringContent($this->coerceString($key));
    65956614
    6596             for ($i = count($map[1]) - 1; $i >= 0; $i--) {
     6615            for ($i = \count($map[1]) - 1; $i >= 0; $i--) {
    65976616                if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) {
    65986617                    return $map[2][$i];
     
    66286647        $key = $this->compileStringContent($this->coerceString($args[1]));
    66296648
    6630         for ($i = count($map[1]) - 1; $i >= 0; $i--) {
     6649        for ($i = \count($map[1]) - 1; $i >= 0; $i--) {
    66316650            if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) {
    66326651                array_splice($map[1], $i, 1);
     
    66446663        $key = $this->compileStringContent($this->coerceString($args[1]));
    66456664
    6646         for ($i = count($map[1]) - 1; $i >= 0; $i--) {
     6665        for ($i = \count($map[1]) - 1; $i >= 0; $i--) {
    66476666            if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) {
    66486667                return true;
     
    69106929        $stringContent = $this->compileStringContent($string);
    69116930
    6912         return new Node\Number(strlen($stringContent), '');
     6931        return new Node\Number(\strlen($stringContent), '');
    69136932    }
    69146933
     
    69456964        $stringContent = $this->compileStringContent($string);
    69466965
    6947         $string[2] = [function_exists('mb_strtolower') ? mb_strtolower($stringContent) : strtolower($stringContent)];
     6966        $string[2] = [\function_exists('mb_strtolower') ? mb_strtolower($stringContent) : strtolower($stringContent)];
    69486967
    69496968        return $string;
     
    69566975        $stringContent = $this->compileStringContent($string);
    69576976
    6958         $string[2] = [function_exists('mb_strtoupper') ? mb_strtoupper($stringContent) : strtoupper($stringContent)];
     6977        $string[2] = [\function_exists('mb_strtoupper') ? mb_strtoupper($stringContent) : strtoupper($stringContent)];
    69596978
    69606979        return $string;
     
    69686987
    69696988        return $this->toBool(
    6970             array_key_exists($name, $this->registeredFeatures) ? $this->registeredFeatures[$name] : false
     6989            \array_key_exists($name, $this->registeredFeatures) ? $this->registeredFeatures[$name] : false
    69716990        );
    69726991    }
     
    69927011        $f = $this->getBuiltinFunction($name);
    69937012
    6994         return $this->toBool(is_callable($f));
     7013        return $this->toBool(\is_callable($f));
    69957014    }
    69967015
     
    70477066                return null;
    70487067            }
    7049             if ($n - intval($n) > 0) {
     7068            if ($n - \intval($n) > 0) {
    70507069                $this->throwError("Expected \$limit to be an integer but got $n for `random`");
    70517070
     
    70537072            }
    70547073
    7055             return new Node\Number(mt_rand(1, intval($n)), '');
     7074            return new Node\Number(mt_rand(1, \intval($n)), '');
    70567075        }
    70577076
     
    70877106                if ($force_enclosing_display
    70887107                    || ($value['enclosing'] === 'bracket' )
    7089                     || !count($value[2])) {
     7108                    || !\count($value[2])) {
    70907109                    $value['enclosing'] = 'forced_'.$value['enclosing'];
    70917110                    $force_enclosing_display = true;
     
    71197138        static $parser = null;
    71207139
    7121         if (is_null($parser)) {
     7140        if (\is_null($parser)) {
    71227141            $parser = $this->parserFactory(__METHOD__);
    71237142        }
     
    71747193    {
    71757194        // one and only one selector for each arg
    7176         if (! $super || count($super) !== 1) {
     7195        if (! $super || \count($super) !== 1) {
    71777196            $this->throwError("Invalid super selector for isSuperSelector()");
    71787197        }
    71797198
    7180         if (! $sub || count($sub) !== 1) {
     7199        if (! $sub || \count($sub) !== 1) {
    71817200            $this->throwError("Invalid sub selector for isSuperSelector()");
    71827201        }
     
    72067225                $i++;
    72077226            } else {
    7208                 while ($i < count($sub) && ! $this->isSuperPart($node, $sub[$i])) {
     7227                while ($i < \count($sub) && ! $this->isSuperPart($node, $sub[$i])) {
    72097228                    if ($nextMustMatch) {
    72107229                        return false;
     
    72147233                }
    72157234
    7216                 if ($i >= count($sub)) {
     7235                if ($i >= \count($sub)) {
    72177236                    return false;
    72187237                }
     
    72397258
    72407259        foreach ($superParts as $superPart) {
    7241             while ($i < count($subParts) && $subParts[$i] !== $superPart) {
     7260            while ($i < \count($subParts) && $subParts[$i] !== $superPart) {
    72427261                $i++;
    72437262            }
    72447263
    7245             if ($i >= count($subParts)) {
     7264            if ($i >= \count($subParts)) {
    72467265                return false;
    72477266            }
     
    72607279        $args = $args[2];
    72617280
    7262         if (count($args) < 1) {
     7281        if (\count($args) < 1) {
    72637282            $this->throwError("selector-append() needs at least 1 argument");
    72647283        }
     
    72867305        }
    72877306
    7288         while (count($selectors)) {
     7307        while (\count($selectors)) {
    72897308            $previousSelectors = array_pop($selectors);
    72907309
     
    73877406            }
    73887407
    7389             $n = count($extended);
     7408            $n = \count($extended);
    73907409
    73917410            $this->matchExtends($selector, $extended);
    73927411
    73937412            // if didnt match, keep the original selector if we are in a replace operation
    7394             if ($replace and count($extended) === $n) {
     7413            if ($replace and \count($extended) === $n) {
    73957414                $extended[] = $selector;
    73967415            }
     
    74107429        $args = $args[2];
    74117430
    7412         if (count($args) < 1) {
     7431        if (\count($args) < 1) {
    74137432            $this->throwError("selector-nest() needs at least 1 argument");
    74147433        }
     
    74737492    protected function unifyCompoundSelectors($compound1, $compound2)
    74747493    {
    7475         if (! count($compound1)) {
     7494        if (! \count($compound1)) {
    74767495            return $compound2;
    74777496        }
    74787497
    7479         if (! count($compound2)) {
     7498        if (! \count($compound2)) {
    74807499            return $compound1;
    74817500        }
     
    74947513
    74957514        // do the rest
    7496         while (count($compound1) || count($compound2)) {
     7515        while (\count($compound1) || \count($compound2)) {
    74977516            $part1 = end($compound1);
    74987517            $part2 = end($compound2);
     
    75947613
    75957614        // try to find a match by tag name first
    7596         while (count($before)) {
     7615        while (\count($before)) {
    75977616            $p = array_pop($before);
    75987617
     
    76087627        $after = [];
    76097628
    7610         while (count($before)) {
     7629        while (\count($before)) {
    76117630            $p = array_pop($before);
    76127631
    76137632            if ($this->checkCompatibleTags($partTag, $this->findTagName($p))) {
    7614                 if (count(array_intersect($part, $p))) {
     7633                if (\count(array_intersect($part, $p))) {
    76157634                    return [$before, $p, $after];
    76167635                }
     
    76887707        $tags = array_filter($tags);
    76897708
    7690         if (count($tags) > 1) {
     7709        if (\count($tags) > 1) {
    76917710            $tags = array_diff($tags, ['*']);
    76927711        }
    76937712
    76947713        // not compatible nodes
    7695         if (count($tags) > 1) {
     7714        if (\count($tags) > 1) {
    76967715            return false;
    76977716        }
     
    77387757        return [Type::T_LIST, ',', $listParts];
    77397758    }
     7759
     7760    protected static $libScssphpGlob = ['pattern'];
     7761    protected function libScssphpGlob($args)
     7762    {
     7763        $string = $this->coerceString($args[0]);
     7764        $pattern = $this->compileStringContent($string);
     7765        $matches = glob($pattern);
     7766        $listParts = [];
     7767
     7768        foreach ($matches as $match) {
     7769            if (! is_file($match)) {
     7770                continue;
     7771            }
     7772
     7773            $listParts[] = [Type::T_STRING, '"', [$match]];
     7774        }
     7775
     7776        return [Type::T_LIST, ',', $listParts];
     7777    }
    77407778}
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/Formatter.php

    r124745 r124748  
    320320
    321321            $lines = explode("\n", $str);
    322             $lineCount = count($lines);
     322            $lineCount = \count($lines);
    323323            $this->currentLine += $lineCount-1;
    324324
    325325            $lastLine = array_pop($lines);
    326326
    327             $this->currentColumn = ($lineCount === 1 ? $this->currentColumn : 0) + strlen($lastLine);
     327            $this->currentColumn = ($lineCount === 1 ? $this->currentColumn : 0) + \strlen($lastLine);
    328328        }
    329329
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/Formatter/Nested.php

    r124745 r124748  
    9191        }
    9292
    93         $isMediaOrDirective = in_array($block->type, [Type::T_DIRECTIVE, Type::T_MEDIA]);
     93        $isMediaOrDirective = \in_array($block->type, [Type::T_DIRECTIVE, Type::T_MEDIA]);
    9494        $isSupport = ($block->type === Type::T_DIRECTIVE
    9595            && $block->selectors && strpos(implode('', $block->selectors), '@supports') !== false);
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/Node/Number.php

    r124745 r124748  
    9090        $this->type      = Type::T_NUMBER;
    9191        $this->dimension = $dimension;
    92         $this->units     = is_array($initialUnit)
     92        $this->units     = \is_array($initialUnit)
    9393            ? $initialUnit
    9494            : ($initialUnit ? [$initialUnit => 1]
     
    111111        $dimension = $this->dimension;
    112112
    113         if (count($units)) {
     113        if (\count($units)) {
    114114            $baseUnit = array_keys($units);
    115115            $baseUnit = reset($baseUnit);
     
    149149    {
    150150        if ($offset === -3) {
    151             return ! is_null($this->sourceColumn);
     151            return ! \is_null($this->sourceColumn);
    152152        }
    153153
    154154        if ($offset === -2) {
    155             return ! is_null($this->sourceLine);
     155            return ! \is_null($this->sourceLine);
    156156        }
    157157
     
    253253        foreach ($this->units as $unit => $exp) {
    254254            $b = $this->findBaseUnit($unit);
    255             if (is_null($baseUnit)) {
     255            if (\is_null($baseUnit)) {
    256256                $baseUnit = $b;
    257257            }
    258             if (is_null($b) or $b !== $baseUnit) {
     258            if (\is_null($b) or $b !== $baseUnit) {
    259259                return false;
    260260            }
     
    275275        foreach ($this->units as $unit => $unitSize) {
    276276            if ($unitSize > 0) {
    277                 $numerators = array_pad($numerators, count($numerators) + $unitSize, $unit);
     277                $numerators = array_pad($numerators, \count($numerators) + $unitSize, $unit);
    278278                continue;
    279279            }
    280280
    281281            if ($unitSize < 0) {
    282                 $denominators = array_pad($denominators, count($denominators) - $unitSize, $unit);
     282                $denominators = array_pad($denominators, \count($denominators) - $unitSize, $unit);
    283283                continue;
    284284            }
    285285        }
    286286
    287         return implode('*', $numerators) . (count($denominators) ? '/' . implode('*', $denominators) : '');
     287        return implode('*', $numerators) . (\count($denominators) ? '/' . implode('*', $denominators) : '');
    288288    }
    289289
     
    303303        });
    304304
    305         if (count($units) > 1 && array_sum($units) === 0) {
     305        if (\count($units) > 1 && array_sum($units) === 0) {
    306306            $dimension = $this->dimension;
    307307            $units     = [];
     
    317317        $unitSize = array_sum($units);
    318318
    319         if ($compiler && ($unitSize > 1 || $unitSize < 0 || count($units) > 1)) {
     319        if ($compiler && ($unitSize > 1 || $unitSize < 0 || \count($units) > 1)) {
    320320            $this->units = $units;
    321321            $unit = $this->unitStr();
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/Parser.php

    r124747 r124748  
    174174            $v = $this->cache->getCache("parse", $cacheKey, $parseOptions);
    175175
    176             if (! is_null($v)) {
     176            if (! \is_null($v)) {
    177177                return $v;
    178178            }
     
    202202        }
    203203
    204         if ($this->count !== strlen($this->buffer)) {
     204        if ($this->count !== \strlen($this->buffer)) {
    205205            $this->throwParseError();
    206206        }
     
    602602                    && !empty($cond['enclosing'])
    603603                    && $cond['enclosing'] === 'parent'
    604                     && count($cond[2]) == 1) {
     604                    && \count($cond[2]) == 1) {
    605605                    $cond = reset($cond[2]);
    606606                }
     
    10771077        $token = null;
    10781078
    1079         $end = strlen($this->buffer);
     1079        $end = \strlen($this->buffer);
    10801080
    10811081        // look for either ending delim, escape, or string interpolation
     
    10991099            $token
    11001100        ];
    1101         $this->count = $end + strlen($token);
     1101        $this->count = $end + \strlen($token);
    11021102
    11031103        return true;
     
    11211121        }
    11221122
    1123         $this->count += strlen($out[0]);
     1123        $this->count += \strlen($out[0]);
    11241124
    11251125        if (! isset($eatWhitespace)) {
     
    12031203                $comment = [];
    12041204                $startCommentCount = $this->count;
    1205                 $endCommentCount = $this->count + strlen($m[1]);
     1205                $endCommentCount = $this->count + \strlen($m[1]);
    12061206
    12071207                // find interpolations in comment
     
    12501250            } else {
    12511251                // comment that are ignored and not kept in the output css
    1252                 $this->count += strlen($m[0]);
     1252                $this->count += \strlen($m[0]);
    12531253            }
    12541254
     
    12681268        if (! $this->discardComments) {
    12691269            if ($comment[0] === Type::T_COMMENT) {
    1270                 if (is_string($comment[1])) {
     1270                if (\is_string($comment[1])) {
    12711271                    $comment[1] = substr(preg_replace(['/^\s+/m', '/^(.)/m'], ['', ' \1'], $comment[1]), 1);
    12721272                }
    1273                 if (isset($comment[2]) and is_array($comment[2]) and $comment[2][0] === Type::T_STRING) {
     1273                if (isset($comment[2]) and \is_array($comment[2]) and $comment[2][0] === Type::T_STRING) {
    12741274                    foreach ($comment[2][2] as $k => $v) {
    1275                         if (is_string($v)) {
     1275                        if (\is_string($v)) {
    12761276                            $p = strpos($v, "\n");
    12771277                            if ($p !== false) {
     
    12961296    protected function append($statement, $pos = null)
    12971297    {
    1298         if (! is_null($statement)) {
    1299             if (! is_null($pos)) {
     1298        if (! \is_null($statement)) {
     1299            if (! \is_null($pos)) {
    13001300                list($line, $column) = $this->getSourcePosition($pos);
    13011301
     
    13231323    protected function last()
    13241324    {
    1325         $i = count($this->env->children) - 1;
     1325        $i = \count($this->env->children) - 1;
    13261326
    13271327        if (isset($this->env->children[$i])) {
     
    13701370
    13711371            foreach ((array) $mediaType as $type) {
    1372                 if (is_array($type)) {
     1372                if (\is_array($type)) {
    13731373                    $media[2][] = $type;
    13741374                } else {
     
    13841384            $this->genericList($expressions, 'mediaExpression', 'and', false);
    13851385
    1386             if (is_array($expressions)) {
     1386            if (\is_array($expressions)) {
    13871387                $parts = array_merge($parts, $expressions[2]);
    13881388            }
     
    14601460
    14611461                foreach ($sc as $scp) {
    1462                     if (is_array($scp)) {
     1462                    if (\is_array($scp)) {
    14631463                        $compound[2][] = $scp;
    14641464                    } else {
     
    15041504        }
    15051505
    1506         if (count($parts)) {
     1506        if (\count($parts)) {
    15071507            if ($this->eatWhiteDefault) {
    15081508                $this->whitespace();
     
    17041704
    17051705            if ($delim) {
    1706                 if (! $this->literal($delim, strlen($delim))) {
     1706                if (! $this->literal($delim, \strlen($delim))) {
    17071707                    break;
    17081708                }
     
    17201720            $items[] = [Type::T_NULL];
    17211721        }
    1722         if ($flatten && count($items) === 1) {
     1722        if ($flatten && \count($items) === 1) {
    17231723            $out = $items[0];
    17241724        } else {
     
    17611761        }
    17621762
    1763         if (in_array(Type::T_LIST, $allowedTypes) && $this->matchChar('[')) {
     1763        if (\in_array(Type::T_LIST, $allowedTypes) && $this->matchChar('[')) {
    17641764            if ($this->enclosedExpression($lhs, $s, "]", [Type::T_LIST])) {
    17651765                if ($lookForExp) {
     
    18041804    protected function enclosedExpression(&$out, $s, $closingParen = ")", $allowedTypes = [Type::T_LIST, Type::T_MAP])
    18051805    {
    1806         if ($this->matchChar($closingParen) && in_array(Type::T_LIST, $allowedTypes)) {
     1806        if ($this->matchChar($closingParen) && \in_array(Type::T_LIST, $allowedTypes)) {
    18071807            $out = [Type::T_LIST, '', []];
    18081808            switch ($closingParen) {
     
    18181818
    18191819        if ($this->valueList($out) && $this->matchChar($closingParen)
    1820             && in_array($out[0], [Type::T_LIST, Type::T_KEYWORD])
    1821             && in_array(Type::T_LIST, $allowedTypes)) {
     1820            && \in_array($out[0], [Type::T_LIST, Type::T_KEYWORD])
     1821            && \in_array(Type::T_LIST, $allowedTypes)) {
    18221822            if ($out[0] !== Type::T_LIST || ! empty($out['enclosing'])) {
    18231823                $out = [Type::T_LIST, '', [$out]];
     
    18361836        $this->seek($s);
    18371837
    1838         if (in_array(Type::T_MAP, $allowedTypes) && $this->map($out)) {
     1838        if (\in_array(Type::T_MAP, $allowedTypes) && $this->map($out)) {
    18391839            return true;
    18401840        }
     
    19651965            $this->count++;
    19661966
     1967            $follow_white = $this->whitespace();
     1968
    19671969            if ($this->value($inner)) {
    19681970                $out = [Type::T_UNARY, '+', $inner, $this->inParens];
     
    19711973            }
    19721974
    1973             $this->count--;
     1975            if ($follow_white) {
     1976                $out = [Type::T_KEYWORD, $char];
     1977                return  true;
     1978            }
     1979
     1980            $this->seek($s);
    19741981
    19751982            return false;
     
    19781985        // negation
    19791986        if ($char === '-') {
     1987            if ($this->customProperty($out)) {
     1988                return true;
     1989            }
     1990
    19801991            $this->count++;
     1992
     1993            $follow_white = $this->whitespace();
    19811994
    19821995            if ($this->variable($inner) || $this->unit($inner) || $this->parenValue($inner)) {
     
    19861999            }
    19872000
    1988             $this->count--;
    1989 
    1990             if ($this->customProperty($out)) {
    1991                 return true;
    1992             }
     2001            if ($this->keyword($inner) && ! $this->func($inner, $out)) {
     2002                $out = [Type::T_UNARY, '-', $inner, $this->inParens];
     2003
     2004                return true;
     2005            }
     2006
     2007            if ($follow_white) {
     2008                $out = [Type::T_KEYWORD, $char];
     2009                return  true;
     2010            }
     2011
     2012            $this->seek($s);
    19932013        }
    19942014
     
    20022022                return true;
    20032023            }
     2024            $this->count++;
     2025            if ($this->keyword($keyword)) {
     2026                $out = [Type::T_KEYWORD, "#" . $keyword];
     2027                return true;
     2028            }
     2029            $this->count--;
    20042030        }
    20052031
     
    23222348
    23232349        if ($this->match('(#([0-9a-f]+))', $m)) {
    2324             if (in_array(strlen($m[2]), [3,4,6,8])) {
     2350            if (\in_array(\strlen($m[2]), [3,4,6,8])) {
    23252351                $out = [Type::T_KEYWORD, $m[0]];
    23262352                return true;
     
    23462372
    23472373        if ($this->match('([0-9]*(\.)?[0-9]+)([%a-zA-Z]+)?', $m, false)) {
    2348             if (strlen($this->buffer) === $this->count || ! ctype_digit($this->buffer[$this->count])) {
     2374            if (\strlen($this->buffer) === $this->count || ! ctype_digit($this->buffer[$this->count])) {
    23492375                $this->whitespace();
    23502376
     
    23902416
    23912417            if ($m[2] === '#{') {
    2392                 $this->count -= strlen($m[2]);
     2418                $this->count -= \strlen($m[2]);
    23932419
    23942420                if ($this->interpolation($inter, false)) {
     
    23962422                    $hasInterpolation = true;
    23972423                } else {
    2398                     $this->count += strlen($m[2]);
     2424                    $this->count += \strlen($m[2]);
    23992425                    $content[] = '#{'; // ignore it
    24002426                }
     
    24162442                }
    24172443            } else {
    2418                 $this->count -= strlen($delim);
     2444                $this->count -= \strlen($delim);
    24192445                break; // delim
    24202446            }
     
    24232449        $this->eatWhiteDefault = $oldWhite;
    24242450
    2425         if ($this->literal($delim, strlen($delim))) {
     2451        if ($this->literal($delim, \strlen($delim))) {
    24262452            if ($hasInterpolation) {
    24272453                $delim = '"';
     
    25322558            $tok = $m[2];
    25332559
    2534             $this->count-= strlen($tok);
     2560            $this->count-= \strlen($tok);
    25352561
    25362562            if ($tok === $end && ! $nestingLevel) {
     
    25532579
    25542580            $content[] = $tok;
    2555             $this->count+= strlen($tok);
     2581            $this->count+= \strlen($tok);
    25562582        }
    25572583
     
    25632589
    25642590        // trim the end
    2565         if ($trimEnd && is_string(end($content))) {
    2566             $content[count($content) - 1] = rtrim(end($content));
     2591        if ($trimEnd && \is_string(end($content))) {
     2592            $content[\count($content) - 1] = rtrim(end($content));
    25672593        }
    25682594
     
    26712697            if (! empty($m[0])) {
    26722698                $parts[] = $m[0];
    2673                 $this->count += strlen($m[0]);
     2699                $this->count += \strlen($m[0]);
    26742700            }
    26752701        }
     
    27082734            }
    27092735
     2736            if ($this->variable($var)) {
     2737                $parts[] = $var;
     2738                continue;
     2739            }
     2740
    27102741            if ($this->keyword($text)) {
    27112742                $parts[] = $text;
     
    27182749        $this->eatWhiteDefault = $oldWhite;
    27192750
    2720         if (count($parts) == 1) {
     2751        if (\count($parts) == 1) {
    27212752            $this->seek($s);
    27222753
     
    27832814
    27842815            if ($this->match('[>+~]+', $m, true)) {
    2785                 if ($subSelector && is_string($subSelector) && strpos($subSelector, 'nth-') === 0 &&
     2816                if ($subSelector && \is_string($subSelector) && strpos($subSelector, 'nth-') === 0 &&
    27862817                    $m[0] === '+' && $this->match("(\d+|n\b)", $counter)
    27872818                ) {
     
    29402971                                    }
    29412972
    2942                                     if (count($sub) && reset($sub)) {
     2973                                    if (\count($sub) && reset($sub)) {
    29432974                                        $parts[] = ' ';
    29442975                                    }
    29452976                                }
    29462977
    2947                                 if (count($subs) && reset($subs)) {
     2978                                if (\count($subs) && reset($subs)) {
    29482979                                    $parts[] = ', ';
    29492980                                }
     
    29783009
    29793010            // 2n+1
    2980             if ($subSelector && is_string($subSelector) && strpos($subSelector, 'nth-') === 0) {
     3011            if ($subSelector && \is_string($subSelector) && strpos($subSelector, 'nth-') === 0) {
    29813012                if ($this->match("(\s*(\+\s*|\-\s*)?(\d+|n|\d+n))+", $counter)) {
    29823013                    $parts[] = $counter[0];
     
    30943125        $s = $this->count;
    30953126
    3096         if ($this->keyword($word, $eatWhitespace) && (ord($word[0]) > 57 || ord($word[0]) < 48)) {
     3127        if ($this->keyword($word, $eatWhitespace) && (\ord($word[0]) > 57 || \ord($word[0]) < 48)) {
    30973128            return true;
    30983129        }
     
    31593190        }
    31603191
    3161         if ($this->count === strlen($this->buffer) || $this->buffer[$this->count] === '}') {
     3192        if ($this->count === \strlen($this->buffer) || $this->buffer[$this->count] === '}') {
    31623193            // if there is end of file or a closing block next then we don't need a ;
    31633194            return true;
     
    31783209        $flags = [];
    31793210
    3180         for ($token = &$value; $token[0] === Type::T_LIST && ($s = count($token[2])); $token = &$lastNode) {
     3211        for ($token = &$value; $token[0] === Type::T_LIST && ($s = \count($token[2])); $token = &$lastNode) {
    31813212            $lastNode = &$token[2][$s - 1];
    31823213
    3183             while ($lastNode[0] === Type::T_KEYWORD && in_array($lastNode[1], ['!default', '!global'])) {
     3214            while ($lastNode[0] === Type::T_KEYWORD && \in_array($lastNode[1], ['!default', '!global'])) {
    31843215                array_pop($token[2]);
    31853216
     
    32083239
    32093240        if ($part === ['!optional']) {
    3210             array_pop($selectors[count($selectors) - 1]);
     3241            array_pop($selectors[\count($selectors) - 1]);
    32113242
    32123243            $optional = true;
     
    32253256    protected function flattenList($value)
    32263257    {
    3227         if ($value[0] === Type::T_LIST && count($value[2]) === 1) {
     3258        if ($value[0] === Type::T_LIST && \count($value[2]) === 1) {
    32283259            return $this->flattenList($value[2][0]);
    32293260        }
     
    32433274    protected function to($what, &$out, $until = false, $allowNewline = false)
    32443275    {
    3245         if (is_string($allowNewline)) {
     3276        if (\is_string($allowNewline)) {
    32463277            $validChars = $allowNewline;
    32473278        } else {
     
    32563287
    32573288        if ($until) {
    3258             $this->count -= strlen($what); // give back $what
     3289            $this->count -= \strlen($what); // give back $what
    32593290        }
    32603291
     
    33033334        }
    33043335
    3305         $this->sourcePositions[] = strlen($buffer);
     3336        $this->sourcePositions[] = \strlen($buffer);
    33063337
    33073338        if (substr($buffer, -1) !== "\n") {
    3308             $this->sourcePositions[] = strlen($buffer) + 1;
     3339            $this->sourcePositions[] = \strlen($buffer) + 1;
    33093340        }
    33103341    }
     
    33203351    {
    33213352        $low = 0;
    3322         $high = count($this->sourcePositions);
     3353        $high = \count($this->sourcePositions);
    33233354
    33243355        while ($low < $high) {
     
    33463377    private function saveEncoding()
    33473378    {
    3348         if (extension_loaded('mbstring')) {
     3379        if (\extension_loaded('mbstring')) {
    33493380            $this->encoding = mb_internal_encoding();
    33503381
     
    33583389    private function restoreEncoding()
    33593390    {
    3360         if (extension_loaded('mbstring') && $this->encoding) {
     3391        if (\extension_loaded('mbstring') && $this->encoding) {
    33613392            mb_internal_encoding($this->encoding);
    33623393        }
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/SourceMap/SourceMapGenerator.php

    r124745 r124748  
    133133    {
    134134        $file = $this->options['sourceMapWriteTo'];
    135         $dir  = dirname($file);
     135        $dir  = \dirname($file);
    136136
    137137        // directory does not exist
     
    202202
    203203        // less.js compat fixes
    204         if (count($sourceMap['sources']) && empty($sourceMap['sourceRoot'])) {
     204        if (\count($sourceMap['sources']) && empty($sourceMap['sourceRoot'])) {
    205205            unset($sourceMap['sourceRoot']);
    206206        }
     
    236236    public function generateMappings()
    237237    {
    238         if (! count($this->mappings)) {
     238        if (! \count($this->mappings)) {
    239239            return '';
    240240        }
     
    314314
    315315        // "Trim" the 'sourceMapBasepath' from the output filename.
    316         if (strlen($basePath) && strpos($filename, $basePath) === 0) {
    317             $filename = substr($filename, strlen($basePath));
     316        if (\strlen($basePath) && strpos($filename, $basePath) === 0) {
     317            $filename = substr($filename, \strlen($basePath));
    318318        }
    319319
  • _plugins_/scssphp/tags/v2.4.1/lib/scssphp/src/Version.php

    r124745 r124748  
    1919class Version
    2020{
    21     const VERSION = 'v1.0.8';
     21    const VERSION = 'v1.0.9';
    2222}
  • _plugins_/scssphp/tags/v2.4.1/paquet.xml

    r124747 r124748  
    22        prefix="scssphp"
    33        categorie="outil"
    4         version="2.2.3"
     4        version="2.3.0"
    55        etat="stable"
    66        compatibilite="[3.1.0;3.3.*]"
     
    2222        <pipeline nom="formulaire_admin" />
    2323
    24         <procure nom="scssphp" version="1.0.8" />
     24        <procure nom="scssphp" version="1.0.9" />
    2525
    2626        <necessite nom="php" compatibilite="[5.6.0;[" />
Note: See TracChangeset for help on using the changeset viewer.