diff --git a/lib/adminlib.php b/lib/adminlib.php
index fdb999b33db..45b99183084 100644
--- a/lib/adminlib.php
+++ b/lib/adminlib.php
@@ -10861,9 +10861,9 @@ class admin_setting_scsscode extends admin_setting_configtextarea {
         $scss = new core_scss();
         try {
             $scss->compile($data);
-        } catch (Leafo\ScssPhp\Exception\ParserException $e) {
+        } catch (ScssPhp\ScssPhp\Exception\ParserException $e) {
             return get_string('scssinvalid', 'admin', $e->getMessage());
-        } catch (Leafo\ScssPhp\Exception\CompilerException $e) {
+        } catch (ScssPhp\ScssPhp\Exception\CompilerException $e) {
             // Silently ignore this - it could be a scss variable defined from somewhere
             // else which we are not examining here.
             return true;
diff --git a/lib/classes/component.php b/lib/classes/component.php
index 187fde8d555..22edb6ba780 100644
--- a/lib/classes/component.php
+++ b/lib/classes/component.php
@@ -80,7 +80,7 @@ class core_component {
         'GeoIp2' => 'lib/maxmind/GeoIp2',
         'Sabberworm\\CSS' => 'lib/php-css-parser',
         'MoodleHQ\\RTLCSS' => 'lib/rtlcss',
-        'Leafo\\ScssPhp' => 'lib/scssphp',
+        'ScssPhp\\ScssPhp' => 'lib/scssphp',
         'Box\\Spout' => 'lib/spout/src/Spout',
         'MatthiasMullie\\Minify' => 'lib/minify/matthiasmullie-minify/src/',
         'MatthiasMullie\\PathConverter' => 'lib/minify/matthiasmullie-pathconverter/src/',
diff --git a/lib/classes/scss.php b/lib/classes/scss.php
index 22810801e15..a196105b702 100644
--- a/lib/classes/scss.php
+++ b/lib/classes/scss.php
@@ -31,7 +31,7 @@ defined('MOODLE_INTERNAL') || die();
  * @copyright  2016 Frédéric Massart
  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
-class core_scss extends \Leafo\ScssPhp\Compiler {
+class core_scss extends \ScssPhp\ScssPhp\Compiler {
 
     /** @var string The path to the SCSS file. */
     protected $scssfile;
@@ -150,14 +150,14 @@ class core_scss extends \Leafo\ScssPhp\Compiler {
      * Compile child; returns a value to halt execution
      *
      * @param array $child
-     * @param \Leafo\ScssPhp\Formatter\OutputBlock $out
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
      *
      * @return array|null
      */
-    protected function compileChild($child, \Leafo\ScssPhp\Formatter\OutputBlock $out) {
+    protected function compileChild($child, \ScssPhp\ScssPhp\Formatter\OutputBlock $out) {
         switch($child[0]) {
-            case \Leafo\ScssPhp\Type::T_SCSSPHP_IMPORT_ONCE:
-            case \Leafo\ScssPhp\Type::T_IMPORT:
+            case \ScssPhp\ScssPhp\Type::T_SCSSPHP_IMPORT_ONCE:
+            case \ScssPhp\ScssPhp\Type::T_IMPORT:
                 list(, $rawpath) = $child;
                 $rawpath = $this->reduce($rawpath);
                 $path = $this->compileStringContent($rawpath);
diff --git a/lib/scssphp/Base/Range.php b/lib/scssphp/Base/Range.php
index 8bcc6ecf35f..094e9030398 100644
--- a/lib/scssphp/Base/Range.php
+++ b/lib/scssphp/Base/Range.php
@@ -2,14 +2,14 @@
 /**
  * SCSSPHP
  *
- * @copyright 2015-2018 Leaf Corcoran
+ * @copyright 2015-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp\Base;
+namespace ScssPhp\ScssPhp\Base;
 
 /**
  * Range
diff --git a/lib/scssphp/Block.php b/lib/scssphp/Block.php
index a6ef8e034f3..bb1afdd4bc7 100644
--- a/lib/scssphp/Block.php
+++ b/lib/scssphp/Block.php
@@ -2,14 +2,14 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp;
+namespace ScssPhp\ScssPhp;
 
 /**
  * Block
@@ -24,7 +24,7 @@ class Block
     public $type;
 
     /**
-     * @var \Leafo\ScssPhp\Block
+     * @var \ScssPhp\ScssPhp\Block
      */
     public $parent;
 
@@ -62,4 +62,9 @@ class Block
      * @var array
      */
     public $children;
+
+    /**
+     * @var \ScssPhp\ScssPhp\Block
+     */
+    public $selfParent;
 }
diff --git a/lib/scssphp/Cache.php b/lib/scssphp/Cache.php
new file mode 100644
index 00000000000..1cf496f5149
--- /dev/null
+++ b/lib/scssphp/Cache.php
@@ -0,0 +1,239 @@
+<?php
+/**
+ * SCSSPHP
+ *
+ * @copyright 2012-2019 Leaf Corcoran
+ *
+ * @license http://opensource.org/licenses/MIT MIT
+ *
+ * @link http://scssphp.github.io/scssphp
+ */
+
+namespace ScssPhp\ScssPhp;
+
+use Exception;
+
+/**
+ * The scss cache manager.
+ *
+ * In short:
+ *
+ * allow to put in cache/get from cache a generic result from a known operation on a generic dataset,
+ * taking in account options that affects the result
+ *
+ * The cache manager is agnostic about data format and only the operation is expected to be described by string
+ *
+ */
+
+/**
+ * SCSS cache
+ *
+ * @author Cedric Morin
+ */
+class Cache
+{
+    const CACHE_VERSION = 1;
+
+    // directory used for storing data
+    public static $cacheDir = false;
+
+    // prefix for the storing data
+    public static $prefix = 'scssphp_';
+
+    // force a refresh : 'once' for refreshing the first hit on a cache only, true to never use the cache in this hit
+    public static $forceRefresh = false;
+
+    // specifies the number of seconds after which data cached will be seen as 'garbage' and potentially cleaned up
+    public static $gcLifetime = 604800;
+
+    // array of already refreshed cache if $forceRefresh==='once'
+    protected static $refreshed = [];
+
+    /**
+     * Constructor
+     *
+     * @param array $options
+     */
+    public function __construct($options)
+    {
+        // check $cacheDir
+        if (isset($options['cache_dir'])) {
+            self::$cacheDir = $options['cache_dir'];
+        }
+
+        if (empty(self::$cacheDir)) {
+            throw new Exception('cache_dir not set');
+        }
+
+        if (isset($options['prefix'])) {
+            self::$prefix = $options['prefix'];
+        }
+
+        if (empty(self::$prefix)) {
+            throw new Exception('prefix not set');
+        }
+
+        if (isset($options['forceRefresh'])) {
+            self::$forceRefresh = $options['force_refresh'];
+        }
+
+        self::checkCacheDir();
+    }
+
+    /**
+     * Get the cached result of $operation on $what,
+     * which is known as dependant from the content of $options
+     *
+     * @param string  $operation    parse, compile...
+     * @param mixed   $what         content key (e.g., filename to be treated)
+     * @param array   $options      any option that affect the operation result on the content
+     * @param integer $lastModified last modified timestamp
+     *
+     * @return mixed
+     *
+     * @throws \Exception
+     */
+    public function getCache($operation, $what, $options = [], $lastModified = null)
+    {
+        $fileCache = self::$cacheDir . self::cacheName($operation, $what, $options);
+
+        if ((! self::$forceRefresh || (self::$forceRefresh === 'once' &&
+            isset(self::$refreshed[$fileCache]))) && file_exists($fileCache)
+        ) {
+            $cacheTime = filemtime($fileCache);
+
+            if ((is_null($lastModified) || $cacheTime > $lastModified) &&
+                $cacheTime + self::$gcLifetime > time()
+            ) {
+                $c = file_get_contents($fileCache);
+                $c = unserialize($c);
+
+                if (is_array($c) && isset($c['value'])) {
+                    return $c['value'];
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Put in cache the result of $operation on $what,
+     * which is known as dependant from the content of $options
+     *
+     * @param string $operation
+     * @param mixed  $what
+     * @param mixed  $value
+     * @param array  $options
+     */
+    public function setCache($operation, $what, $value, $options = [])
+    {
+        $fileCache = self::$cacheDir . self::cacheName($operation, $what, $options);
+
+        $c = ['value' => $value];
+        $c = serialize($c);
+        file_put_contents($fileCache, $c);
+
+        if (self::$forceRefresh === 'once') {
+            self::$refreshed[$fileCache] = true;
+        }
+    }
+
+    /**
+     * Get the cache name for the caching of $operation on $what,
+     * which is known as dependant from the content of $options
+     *
+     * @param string $operation
+     * @param mixed  $what
+     * @param array  $options
+     *
+     * @return string
+     */
+    private static function cacheName($operation, $what, $options = [])
+    {
+        $t = [
+          'version' => self::CACHE_VERSION,
+          'operation' => $operation,
+          'what' => $what,
+          'options' => $options
+        ];
+
+        $t = self::$prefix
+          . sha1(json_encode($t))
+          . ".$operation"
+          . ".scsscache";
+
+        return $t;
+    }
+
+    /**
+     * Check that the cache dir exists and is writeable
+     *
+     * @throws \Exception
+     */
+    public static function checkCacheDir()
+    {
+        self::$cacheDir = str_replace('\\', '/', self::$cacheDir);
+        self::$cacheDir = rtrim(self::$cacheDir, '/') . '/';
+
+        if (! file_exists(self::$cacheDir)) {
+            if (! mkdir(self::$cacheDir)) {
+                throw new Exception('Cache directory couldn\'t be created: ' . self::$cacheDir);
+            }
+        } elseif (! is_dir(self::$cacheDir)) {
+            throw new Exception('Cache directory doesn\'t exist: ' . self::$cacheDir);
+        } elseif (! is_writable(self::$cacheDir)) {
+            throw new Exception('Cache directory isn\'t writable: ' . self::$cacheDir);
+        }
+    }
+
+    /**
+     * Delete unused cached files
+     */
+    public static function cleanCache()
+    {
+        static $clean = false;
+
+        if ($clean || empty(self::$cacheDir)) {
+            return;
+        }
+
+        $clean = true;
+
+        // only remove files with extensions created by SCSSPHP Cache
+        // css files removed based on the list files
+        $removeTypes = ['scsscache' => 1];
+
+        $files = scandir(self::$cacheDir);
+
+        if (! $files) {
+            return;
+        }
+
+        $checkTime = time() - self::$gcLifetime;
+
+        foreach ($files as $file) {
+            // don't delete if the file wasn't created with SCSSPHP Cache
+            if (strpos($file, self::$prefix) !== 0) {
+                continue;
+            }
+
+            $parts = explode('.', $file);
+            $type = array_pop($parts);
+
+            if (! isset($removeTypes[$type])) {
+                continue;
+            }
+
+            $fullPath = self::$cacheDir . $file;
+            $mtime = filemtime($fullPath);
+
+            // don't delete if it's a relatively new file
+            if ($mtime > $checkTime) {
+                continue;
+            }
+
+            unlink($fullPath);
+        }
+    }
+}
diff --git a/lib/scssphp/Colors.php b/lib/scssphp/Colors.php
index 2314ea58d19..ad459246a20 100644
--- a/lib/scssphp/Colors.php
+++ b/lib/scssphp/Colors.php
@@ -2,14 +2,14 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp;
+namespace ScssPhp\ScssPhp;
 
 /**
  * CSS Colors
diff --git a/lib/scssphp/Compiler.php b/lib/scssphp/Compiler.php
index 292e960e48a..8f26740dbe2 100644
--- a/lib/scssphp/Compiler.php
+++ b/lib/scssphp/Compiler.php
@@ -2,26 +2,27 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp;
+namespace ScssPhp\ScssPhp;
 
-use Leafo\ScssPhp\Base\Range;
-use Leafo\ScssPhp\Block;
-use Leafo\ScssPhp\Colors;
-use Leafo\ScssPhp\Compiler\Environment;
-use Leafo\ScssPhp\Exception\CompilerException;
-use Leafo\ScssPhp\Formatter\OutputBlock;
-use Leafo\ScssPhp\Node;
-use Leafo\ScssPhp\SourceMap\SourceMapGenerator;
-use Leafo\ScssPhp\Type;
-use Leafo\ScssPhp\Parser;
-use Leafo\ScssPhp\Util;
+use ScssPhp\ScssPhp\Base\Range;
+use ScssPhp\ScssPhp\Block;
+use ScssPhp\ScssPhp\Cache;
+use ScssPhp\ScssPhp\Colors;
+use ScssPhp\ScssPhp\Compiler\Environment;
+use ScssPhp\ScssPhp\Exception\CompilerException;
+use ScssPhp\ScssPhp\Formatter\OutputBlock;
+use ScssPhp\ScssPhp\Node;
+use ScssPhp\ScssPhp\SourceMap\SourceMapGenerator;
+use ScssPhp\ScssPhp\Type;
+use ScssPhp\ScssPhp\Parser;
+use ScssPhp\ScssPhp\Util;
 
 /**
  * The scss compiler and parser.
@@ -98,17 +99,17 @@ class Compiler
         'function' => '^',
     ];
 
-    static public $true = [Type::T_KEYWORD, 'true'];
-    static public $false = [Type::T_KEYWORD, 'false'];
-    static public $null = [Type::T_NULL];
-    static public $nullString = [Type::T_STRING, '', []];
+    static public $true         = [Type::T_KEYWORD, 'true'];
+    static public $false        = [Type::T_KEYWORD, 'false'];
+    static public $null         = [Type::T_NULL];
+    static public $nullString   = [Type::T_STRING, '', []];
     static public $defaultValue = [Type::T_KEYWORD, ''];
     static public $selfSelector = [Type::T_SELF];
-    static public $emptyList = [Type::T_LIST, '', []];
-    static public $emptyMap = [Type::T_MAP, [], []];
-    static public $emptyString = [Type::T_STRING, '"', []];
-    static public $with = [Type::T_KEYWORD, 'with'];
-    static public $without = [Type::T_KEYWORD, 'without'];
+    static public $emptyList    = [Type::T_LIST, '', []];
+    static public $emptyMap     = [Type::T_MAP, [], []];
+    static public $emptyString  = [Type::T_STRING, '"', []];
+    static public $with         = [Type::T_KEYWORD, 'with'];
+    static public $without      = [Type::T_KEYWORD, 'without'];
 
     protected $importPaths = [''];
     protected $importCache = [];
@@ -129,15 +130,15 @@ class Compiler
     protected $sourceMapOptions = [];
 
     /**
-     * @var string|\Leafo\ScssPhp\Formatter
+     * @var string|\ScssPhp\ScssPhp\Formatter
      */
-    protected $formatter = 'Leafo\ScssPhp\Formatter\Nested';
+    protected $formatter = 'ScssPhp\ScssPhp\Formatter\Nested';
 
     protected $rootEnv;
     protected $rootBlock;
 
     /**
-     * @var \Leafo\ScssPhp\Compiler\Environment
+     * @var \ScssPhp\ScssPhp\Compiler\Environment
      */
     protected $env;
     protected $scope;
@@ -145,26 +146,48 @@ class Compiler
     protected $charsetSeen;
     protected $sourceNames;
 
-    private $indentLevel;
-    private $commentsSeen;
-    private $extends;
-    private $extendsMap;
-    private $parsedFiles;
-    private $parser;
-    private $sourceIndex;
-    private $sourceLine;
-    private $sourceColumn;
-    private $stderr;
-    private $shouldEvaluate;
-    private $ignoreErrors;
+    protected $cache;
+
+    protected $indentLevel;
+    protected $extends;
+    protected $extendsMap;
+    protected $parsedFiles;
+    protected $parser;
+    protected $sourceIndex;
+    protected $sourceLine;
+    protected $sourceColumn;
+    protected $stderr;
+    protected $shouldEvaluate;
+    protected $ignoreErrors;
+
+    protected $callStack = [];
 
     /**
      * Constructor
      */
-    public function __construct()
+    public function __construct($cacheOptions = null)
     {
         $this->parsedFiles = [];
         $this->sourceNames = [];
+
+        if ($cacheOptions) {
+            $this->cache = new Cache($cacheOptions);
+        }
+    }
+
+    public function getCompileOptions()
+    {
+        $options = [
+            'importPaths'        => $this->importPaths,
+            'registeredVars'     => $this->registeredVars,
+            'registeredFeatures' => $this->registeredFeatures,
+            'encoding'           => $this->encoding,
+            'sourceMap'          => serialize($this->sourceMap),
+            'sourceMapOptions'   => $this->sourceMapOptions,
+            'formatter'          => $this->formatter,
+        ];
+
+        return $options;
     }
 
     /**
@@ -179,8 +202,28 @@ class Compiler
      */
     public function compile($code, $path = null)
     {
+        if ($this->cache) {
+            $cacheKey       = ($path ? $path : "(stdin)") . ":" . md5($code);
+            $compileOptions = $this->getCompileOptions();
+            $cache          = $this->cache->getCache("compile", $cacheKey, $compileOptions);
+
+            if (is_array($cache) && isset($cache['dependencies']) && isset($cache['out'])) {
+                // check if any dependency file changed before accepting the cache
+                foreach ($cache['dependencies'] as $file => $mtime) {
+                    if (! file_exists($file) || filemtime($file) !== $mtime) {
+                        unset($cache);
+                        break;
+                    }
+                }
+
+                if (isset($cache)) {
+                    return $cache['out'];
+                }
+            }
+        }
+
+
         $this->indentLevel    = -1;
-        $this->commentsSeen   = [];
         $this->extends        = [];
         $this->extendsMap     = [];
         $this->sourceIndex    = null;
@@ -194,7 +237,7 @@ class Compiler
         $this->stderr         = fopen('php://stderr', 'w');
 
         $this->parser = $this->parserFactory($path);
-        $tree = $this->parser->parse($code);
+        $tree         = $this->parser->parse($code);
         $this->parser = null;
 
         $this->formatter = new $this->formatter();
@@ -235,6 +278,15 @@ class Compiler
             $out .= sprintf('/*# sourceMappingURL=%s */', $sourceMapUrl);
         }
 
+        if ($this->cache && isset($cacheKey) && isset($compileOptions)) {
+            $v = [
+                'dependencies' => $this->getParsedFiles(),
+                'out' => &$out,
+            ];
+
+            $this->cache->setCache("compile", $cacheKey, $v, $compileOptions);
+        }
+
         return $out;
     }
 
@@ -243,11 +295,11 @@ class Compiler
      *
      * @param string $path
      *
-     * @return \Leafo\ScssPhp\Parser
+     * @return \ScssPhp\ScssPhp\Parser
      */
     protected function parserFactory($path)
     {
-        $parser = new Parser($path, count($this->sourceNames), $this->encoding);
+        $parser = new Parser($path, count($this->sourceNames), $this->encoding, $this->cache);
 
         $this->sourceNames[] = $path;
         $this->addParsedFile($path);
@@ -305,7 +357,7 @@ class Compiler
      * @param string $type
      * @param array  $selectors
      *
-     * @return \Leafo\ScssPhp\Formatter\OutputBlock
+     * @return \ScssPhp\ScssPhp\Formatter\OutputBlock
      */
     protected function makeOutputBlock($type, $selectors = null)
     {
@@ -316,9 +368,16 @@ class Compiler
         $out->parent       = $this->scope;
         $out->selectors    = $selectors;
         $out->depth        = $this->env->depth;
-        $out->sourceName   = $this->env->block->sourceName;
-        $out->sourceLine   = $this->env->block->sourceLine;
-        $out->sourceColumn = $this->env->block->sourceColumn;
+
+        if ($this->env->block instanceof Block) {
+            $out->sourceName   = $this->env->block->sourceName;
+            $out->sourceLine   = $this->env->block->sourceLine;
+            $out->sourceColumn = $this->env->block->sourceColumn;
+        } else {
+            $out->sourceName   = null;
+            $out->sourceLine   = null;
+            $out->sourceColumn = null;
+        }
 
         return $out;
     }
@@ -326,7 +385,7 @@ class Compiler
     /**
      * Compile root
      *
-     * @param \Leafo\ScssPhp\Block $rootBlock
+     * @param \ScssPhp\ScssPhp\Block $rootBlock
      */
     protected function compileRoot(Block $rootBlock)
     {
@@ -365,8 +424,8 @@ class Compiler
     /**
      * Flatten selectors
      *
-     * @param \Leafo\ScssPhp\Formatter\OutputBlock $block
-     * @param string                               $parentKey
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
+     * @param string                                 $parentKey
      */
     protected function flattenSelectors(OutputBlock $block, $parentKey = null)
     {
@@ -421,6 +480,37 @@ class Compiler
         }
     }
 
+    /**
+     * Glue parts of :not( or :nth-child( ... that are in general splitted in selectors parts
+     *
+     * @param array $parts
+     *
+     * @return array
+     */
+    protected function glueFunctionSelectors($parts)
+    {
+        $new = [];
+
+        foreach ($parts as $part) {
+            if (is_array($part)) {
+                $part = $this->glueFunctionSelectors($part);
+                $new[] = $part;
+            } else {
+                // a selector part finishing with a ) is the last part of a :not( or :nth-child(
+                // and need to be joined to this
+                if (count($new) && is_string($new[count($new) - 1]) &&
+                    strlen($part) && substr($part, -1) === ')' && strpos($part, '(') === false
+                ) {
+                    $new[count($new) - 1] .= $part;
+                } else {
+                    $new[] = $part;
+                }
+            }
+        }
+
+        return $new;
+    }
+
     /**
      * Match extends
      *
@@ -431,14 +521,33 @@ class Compiler
      */
     protected function matchExtends($selector, &$out, $from = 0, $initial = true)
     {
+        static $partsPile = [];
+
+        $selector = $this->glueFunctionSelectors($selector);
+
+        if (count($selector) == 1 && in_array(reset($selector), $partsPile)) {
+            return;
+        }
+
         foreach ($selector as $i => $part) {
             if ($i < $from) {
                 continue;
             }
 
+            // check that we are not building an infinite loop of extensions
+            // if the new part is just including a previous part don't try to extend anymore
+            if (count($part) > 1) {
+                foreach ($partsPile as $previousPart) {
+                    if (! count(array_diff($previousPart, $part))) {
+                        continue 2;
+                    }
+                }
+            }
+
             if ($this->matchExtendsSingle($part, $origin)) {
-                $after = array_slice($selector, $i + 1);
-                $before = array_slice($selector, 0, $i);
+                $partsPile[] = $part;
+                $after       = array_slice($selector, $i + 1);
+                $before      = array_slice($selector, 0, $i);
 
                 list($before, $nonBreakableBefore) = $this->extractRelationshipFromFragment($before);
 
@@ -446,7 +555,7 @@ class Compiler
                     $k = 0;
 
                     // remove shared parts
-                    if ($initial) {
+                    if (count($new) > 1) {
                         while ($k < $i && isset($new[$k]) && $selector[$k] === $new[$k]) {
                             $k++;
                         }
@@ -456,7 +565,14 @@ class Compiler
                     $tempReplacement = $k > 0 ? array_slice($new, $k) : $new;
 
                     for ($l = count($tempReplacement) - 1; $l >= 0; $l--) {
-                        $slice = $tempReplacement[$l];
+                        $slice = [];
+
+                        foreach ($tempReplacement[$l] as $chunk) {
+                            if (! in_array($chunk, $slice)) {
+                                $slice[] = $chunk;
+                            }
+                        }
+
                         array_unshift($replacement, $slice);
 
                         if (! $this->isImmediateRelationshipCombinator(end($slice))) {
@@ -483,18 +599,19 @@ class Compiler
                     $out[] = $result;
 
                     // recursively check for more matches
-                    $this->matchExtends($result, $out, count($before) + count($mergedBefore), false);
+                    $startRecurseFrom = count($before) + min(count($nonBreakableBefore), count($mergedBefore));
+                    $this->matchExtends($result, $out, $startRecurseFrom, false);
 
                     // selector sequence merging
                     if (! empty($before) && count($new) > 1) {
-                        $sharedParts = $k > 0 ? array_slice($before, 0, $k) : [];
+                        $preSharedParts = $k > 0 ? array_slice($before, 0, $k) : [];
                         $postSharedParts = $k > 0 ? array_slice($before, $k) : $before;
 
-                        list($injectBetweenSharedParts, $nonBreakable2) = $this->extractRelationshipFromFragment($afterBefore);
+                        list($betweenSharedParts, $nonBreakable2) = $this->extractRelationshipFromFragment($afterBefore);
 
                         $result2 = array_merge(
-                            $sharedParts,
-                            $injectBetweenSharedParts,
+                            $preSharedParts,
+                            $betweenSharedParts,
                             $postSharedParts,
                             $nonBreakable2,
                             $nonBreakableBefore,
@@ -505,6 +622,8 @@ class Compiler
                         $out[] = $result2;
                     }
                 }
+
+                array_pop($partsPile);
             }
         }
     }
@@ -522,6 +641,11 @@ class Compiler
         $counts = [];
         $single = [];
 
+        // simple usual cases, no need to do the whole trick
+        if (in_array($rawSingle, [['>'],['+'],['~']])) {
+            return false;
+        }
+
         foreach ($rawSingle as $part) {
             // matches Number
             if (! is_string($part)) {
@@ -556,6 +680,8 @@ class Compiler
         foreach ($counts as $idx => $count) {
             list($target, $origin, /* $block */) = $this->extends[$idx];
 
+            $origin = $this->glueFunctionSelectors($origin);
+
             // check count
             if ($count !== count($target)) {
                 continue;
@@ -596,7 +722,6 @@ class Compiler
         return $found;
     }
 
-
     /**
      * Extract a relationship from the fragment.
      *
@@ -606,6 +731,7 @@ class Compiler
      * the rest.
      *
      * @param array $fragment The selector fragment maybe ending with a direction relationship combinator.
+     *
      * @return array The selector without the relationship fragment if any, the relationship fragment.
      */
     protected function extractRelationshipFromFragment(array $fragment)
@@ -669,19 +795,24 @@ class Compiler
     /**
      * Compile media
      *
-     * @param \Leafo\ScssPhp\Block $media
+     * @param \ScssPhp\ScssPhp\Block $media
      */
     protected function compileMedia(Block $media)
     {
         $this->pushEnv($media);
 
-        $mediaQuery = $this->compileMediaQuery($this->multiplyMedia($this->env));
-
-        if (! empty($mediaQuery)) {
-            $this->scope = $this->makeOutputBlock(Type::T_MEDIA, [$mediaQuery]);
+        $mediaQueries = $this->compileMediaQuery($this->multiplyMedia($this->env));
 
+        if (! empty($mediaQueries) && $mediaQueries) {
+            $previousScope = $this->scope;
             $parentScope = $this->mediaParent($this->scope);
-            $parentScope->children[] = $this->scope;
+
+            foreach ($mediaQueries as $mediaQuery) {
+                $this->scope = $this->makeOutputBlock(Type::T_MEDIA, [$mediaQuery]);
+
+                $parentScope->children[] = $this->scope;
+                $parentScope = $this->scope;
+            }
 
             // top level properties in a media cause it to be wrapped
             $needsWrap = false;
@@ -701,21 +832,44 @@ class Compiler
 
             if ($needsWrap) {
                 $wrapped = new Block;
-                $wrapped->sourceName   = $media->sourceName;
-                $wrapped->sourceIndex  = $media->sourceIndex;
-                $wrapped->sourceLine   = $media->sourceLine;
+                $wrapped->sourceName = $media->sourceName;
+                $wrapped->sourceIndex = $media->sourceIndex;
+                $wrapped->sourceLine = $media->sourceLine;
                 $wrapped->sourceColumn = $media->sourceColumn;
-                $wrapped->selectors    = [];
-                $wrapped->comments     = [];
-                $wrapped->parent       = $media;
-                $wrapped->children     = $media->children;
+                $wrapped->selectors = [];
+                $wrapped->comments = [];
+                $wrapped->parent = $media;
+                $wrapped->children = $media->children;
 
                 $media->children = [[Type::T_BLOCK, $wrapped]];
+                if (isset($this->lineNumberStyle)) {
+                    $annotation = $this->makeOutputBlock(Type::T_COMMENT);
+                    $annotation->depth = 0;
+
+                    $file = $this->sourceNames[$media->sourceIndex];
+                    $line = $media->sourceLine;
+
+                    switch ($this->lineNumberStyle) {
+                        case static::LINE_COMMENTS:
+                            $annotation->lines[] = '/* line ' . $line
+                                                 . ($file ? ', ' . $file : '')
+                                                 . ' */';
+                            break;
+
+                        case static::DEBUG_INFO:
+                            $annotation->lines[] = '@media -sass-debug-info{'
+                                                 . ($file ? 'filename{font-family:"' . $file . '"}' : '')
+                                                 . 'line{font-family:' . $line . '}}';
+                            break;
+                    }
+
+                    $this->scope->children[] = $annotation;
+                }
             }
 
             $this->compileChildrenNoReturn($media->children, $this->scope);
 
-            $this->scope = $this->scope->parent;
+            $this->scope = $previousScope;
         }
 
         $this->popEnv();
@@ -724,9 +878,9 @@ class Compiler
     /**
      * Media parent
      *
-     * @param \Leafo\ScssPhp\Formatter\OutputBlock $scope
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $scope
      *
-     * @return \Leafo\ScssPhp\Formatter\OutputBlock
+     * @return \ScssPhp\ScssPhp\Formatter\OutputBlock
      */
     protected function mediaParent(OutputBlock $scope)
     {
@@ -744,7 +898,7 @@ class Compiler
     /**
      * Compile directive
      *
-     * @param \Leafo\ScssPhp\Block $block
+     * @param \ScssPhp\ScssPhp\Block $block
      */
     protected function compileDirective(Block $block)
     {
@@ -764,13 +918,13 @@ class Compiler
     /**
      * Compile at-root
      *
-     * @param \Leafo\ScssPhp\Block $block
+     * @param \ScssPhp\ScssPhp\Block $block
      */
     protected function compileAtRoot(Block $block)
     {
         $env     = $this->pushEnv($block);
         $envs    = $this->compactEnv($env);
-        $without = isset($block->with) ? $this->compileWith($block->with) : static::WITH_RULE;
+        list($with, $without) = $this->compileWith(isset($block->with) ? $block->with : null);
 
         // wrap inline selector
         if ($block->selector) {
@@ -783,18 +937,29 @@ class Compiler
             $wrapped->comments     = [];
             $wrapped->parent       = $block;
             $wrapped->children     = $block->children;
+            $wrapped->selfParent   = $block->selfParent;
 
             $block->children = [[Type::T_BLOCK, $wrapped]];
+            $block->selector = null;
         }
 
-        $this->env = $this->filterWithout($envs, $without);
-        $newBlock  = $this->spliceTree($envs, $block, $without);
+        $selfParent = $block->selfParent;
+
+        if (! $block->selfParent->selectors && isset($block->parent) && $block->parent &&
+            isset($block->parent->selectors) && $block->parent->selectors
+        ) {
+            $selfParent = $block->parent;
+        }
+
+        $this->env = $this->filterWithWithout($envs, $with, $without);
 
         $saveScope   = $this->scope;
-        $this->scope = $this->rootBlock;
+        $this->scope = $this->filterScopeWithWithout($saveScope, $with, $without);
 
-        $this->compileChild($newBlock, $this->scope);
+        // propagate selfParent to the children where they still can be useful
+        $this->compileChildrenNoReturn($block->children, $this->scope, $selfParent);
 
+        $this->scope = $this->completeScope($this->scope, $saveScope);
         $this->scope = $saveScope;
         $this->env   = $this->extractEnv($envs);
 
@@ -802,152 +967,184 @@ class Compiler
     }
 
     /**
-     * Splice parse tree
+     * Filter at-root scope depending of with/without option
      *
-     * @param array                $envs
-     * @param \Leafo\ScssPhp\Block $block
-     * @param integer              $without
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $scope
+     * @param array                                  $with
+     * @param array                                  $without
      *
-     * @return array
+     * @return mixed
      */
-    private function spliceTree($envs, Block $block, $without)
+    protected function filterScopeWithWithout($scope, $with, $without)
     {
-        $newBlock = null;
+        $filteredScopes = [];
 
-        foreach ($envs as $e) {
-            if (! isset($e->block)) {
-                continue;
-            }
-
-            if ($e->block === $block) {
-                continue;
-            }
-
-            if (isset($e->block->type) && $e->block->type === Type::T_AT_ROOT) {
-                continue;
-            }
-
-            if ($e->block && $this->isWithout($without, $e->block)) {
-                continue;
-            }
-
-            $b = new Block;
-            $b->sourceName   = $e->block->sourceName;
-            $b->sourceIndex  = $e->block->sourceIndex;
-            $b->sourceLine   = $e->block->sourceLine;
-            $b->sourceColumn = $e->block->sourceColumn;
-            $b->selectors    = [];
-            $b->comments     = $e->block->comments;
-            $b->parent       = null;
-
-            if ($newBlock) {
-                $type = isset($newBlock->type) ? $newBlock->type : Type::T_BLOCK;
-
-                $b->children = [[$type, $newBlock]];
-
-                $newBlock->parent = $b;
-            } elseif (count($block->children)) {
-                foreach ($block->children as $child) {
-                    if ($child[0] === Type::T_BLOCK) {
-                        $child[1]->parent = $b;
-                    }
-                }
-
-                $b->children = $block->children;
-            }
-
-            if (isset($e->block->type)) {
-                $b->type = $e->block->type;
-            }
-
-            if (isset($e->block->name)) {
-                $b->name = $e->block->name;
-            }
-
-            if (isset($e->block->queryList)) {
-                $b->queryList = $e->block->queryList;
-            }
-
-            if (isset($e->block->value)) {
-                $b->value = $e->block->value;
-            }
-
-            $newBlock = $b;
+        if ($scope->type === TYPE::T_ROOT) {
+            return $scope;
         }
 
-        $type = isset($newBlock->type) ? $newBlock->type : Type::T_BLOCK;
+        // start from the root
+        while ($scope->parent && $scope->parent->type !== TYPE::T_ROOT) {
+            $scope = $scope->parent;
+        }
 
-        return [$type, $newBlock];
+        for (;;) {
+            if (! $scope) {
+                break;
+            }
+
+            if ($this->isWith($scope, $with, $without)) {
+                $s = clone $scope;
+                $s->children = [];
+                $s->lines = [];
+                $s->parent = null;
+
+                if ($s->type !== Type::T_MEDIA && $s->type !== Type::T_DIRECTIVE) {
+                    $s->selectors = [];
+                }
+
+                $filteredScopes[] = $s;
+            }
+
+            if ($scope->children) {
+                $scope = end($scope->children);
+            } else {
+                $scope = null;
+            }
+        }
+
+        if (! count($filteredScopes)) {
+            return $this->rootBlock;
+        }
+
+        $newScope = array_shift($filteredScopes);
+        $newScope->parent = $this->rootBlock;
+
+        $this->rootBlock->children[] = $newScope;
+
+        $p = &$newScope;
+
+        while (count($filteredScopes)) {
+            $s = array_shift($filteredScopes);
+            $s->parent = $p;
+            $p->children[] = &$s;
+            $p = $s;
+        }
+
+        return $newScope;
     }
 
     /**
-     * Compile @at-root's with: inclusion / without: exclusion into filter flags
+     * found missing selector from a at-root compilation in the previous scope
+     * (if at-root is just enclosing a property, the selector is in the parent tree)
      *
-     * @param array $with
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $scope
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $previousScope
      *
-     * @return integer
+     * @return mixed
      */
-    private function compileWith($with)
+    protected function completeScope($scope, $previousScope)
     {
-        static $mapping = [
-            'rule'     => self::WITH_RULE,
-            'media'    => self::WITH_MEDIA,
-            'supports' => self::WITH_SUPPORTS,
-            'all'      => self::WITH_ALL,
-        ];
+        if (! $scope->type && (! $scope->selectors || ! count($scope->selectors)) && count($scope->lines)) {
+            $scope->selectors = $this->findScopeSelectors($previousScope, $scope->depth);
+        }
 
-        // exclude selectors by default
-        $without = static::WITH_RULE;
+        if ($scope->children) {
+            foreach ($scope->children as $k => $c) {
+                $scope->children[$k] = $this->completeScope($c, $previousScope);
+            }
+        }
 
-        if ($this->libMapHasKey([$with, static::$with])) {
-            $without = static::WITH_ALL;
+        return $scope;
+    }
 
-            $list = $this->coerceList($this->libMapGet([$with, static::$with]));
+    /**
+     * Find a selector by the depth node in the scope
+     *
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $scope
+     * @param integer                                $depth
+     *
+     * @return array
+     */
+    protected function findScopeSelectors($scope, $depth)
+    {
+        if ($scope->depth === $depth && $scope->selectors) {
+            return $scope->selectors;
+        }
 
-            foreach ($list[2] as $item) {
-                $keyword = $this->compileStringContent($this->coerceString($item));
-
-                if (array_key_exists($keyword, $mapping)) {
-                    $without &= ~($mapping[$keyword]);
+        if ($scope->children) {
+            foreach (array_reverse($scope->children) as $c) {
+                if ($s = $this->findScopeSelectors($c, $depth)) {
+                    return $s;
                 }
             }
         }
 
-        if ($this->libMapHasKey([$with, static::$without])) {
-            $without = 0;
+        return [];
+    }
 
-            $list = $this->coerceList($this->libMapGet([$with, static::$without]));
+    /**
+     * Compile @at-root's with: inclusion / without: exclusion into 2 lists uses to filter scope/env later
+     *
+     * @param array $withCondition
+     *
+     * @return array
+     */
+    protected function compileWith($withCondition)
+    {
+        // just compile what we have in 2 lists
+        $with = [];
+        $without = ['rule' => true];
 
-            foreach ($list[2] as $item) {
-                $keyword = $this->compileStringContent($this->coerceString($item));
+        if ($withCondition) {
+            if ($this->libMapHasKey([$withCondition, static::$with])) {
+                $without = []; // cancel the default
+                $list = $this->coerceList($this->libMapGet([$withCondition, static::$with]));
 
-                if (array_key_exists($keyword, $mapping)) {
-                    $without |= $mapping[$keyword];
+                foreach ($list[2] as $item) {
+                    $keyword = $this->compileStringContent($this->coerceString($item));
+
+                    $with[$keyword] = true;
+                }
+            }
+
+            if ($this->libMapHasKey([$withCondition, static::$without])) {
+                $without = []; // cancel the default
+                $list = $this->coerceList($this->libMapGet([$withCondition, static::$without]));
+
+                foreach ($list[2] as $item) {
+                    $keyword = $this->compileStringContent($this->coerceString($item));
+
+                    $without[$keyword] = true;
                 }
             }
         }
 
-        return $without;
+        return [$with, $without];
     }
 
     /**
      * Filter env stack
      *
      * @param array   $envs
-     * @param integer $without
+     * @param array $with
+     * @param array $without
      *
-     * @return \Leafo\ScssPhp\Compiler\Environment
+     * @return \ScssPhp\ScssPhp\Compiler\Environment
      */
-    private function filterWithout($envs, $without)
+    protected function filterWithWithout($envs, $with, $without)
     {
         $filtered = [];
 
         foreach ($envs as $e) {
-            if ($e->block && $this->isWithout($without, $e->block)) {
-                continue;
+            if ($e->block && ! $this->isWith($e->block, $with, $without)) {
+                $ec = clone $e;
+                $ec->block = null;
+                $ec->selectors = [];
+                $filtered[] = $ec;
+            } else {
+                $filtered[] = $e;
             }
-
-            $filtered[] = $e;
         }
 
         return $this->extractEnv($filtered);
@@ -956,31 +1153,64 @@ class Compiler
     /**
      * Filter WITH rules
      *
-     * @param integer              $without
-     * @param \Leafo\ScssPhp\Block $block
+     * @param \ScssPhp\ScssPhp\Block|\ScssPhp\ScssPhp\Formatter\OutputBlock $block
+     * @param array                                                         $with
+     * @param array                                                         $without
      *
      * @return boolean
      */
-    private function isWithout($without, Block $block)
+    protected function isWith($block, $with, $without)
     {
-        if ((($without & static::WITH_RULE) && isset($block->selectors)) ||
-            (($without & static::WITH_MEDIA) &&
-                isset($block->type) && $block->type === Type::T_MEDIA) ||
-            (($without & static::WITH_SUPPORTS) &&
-                isset($block->type) && $block->type === Type::T_DIRECTIVE &&
-                isset($block->name) && $block->name === 'supports')
-        ) {
-            return true;
+        if (isset($block->type)) {
+            if ($block->type === Type::T_MEDIA) {
+                return $this->testWithWithout('media', $with, $without);
+            }
+
+            if ($block->type === Type::T_DIRECTIVE) {
+                if (isset($block->name)) {
+                    return $this->testWithWithout($block->name, $with, $without);
+                }
+                elseif (isset($block->selectors) && preg_match(',@(\w+),ims', json_encode($block->selectors), $m)) {
+                    return $this->testWithWithout($m[1], $with, $without);
+                }
+                else {
+                    return $this->testWithWithout('???', $with, $without);
+                }
+            }
+        }
+        elseif (isset($block->selectors)) {
+            return $this->testWithWithout('rule', $with, $without);
         }
 
-        return false;
+        return true;
     }
 
+    /**
+     * Test a single type of block against with/without lists
+     *
+     * @param string $what
+     * @param array  $with
+     * @param array  $without
+     * @return bool
+     *   true if the block should be kept, false to reject
+     */
+    protected function testWithWithout($what, $with, $without) {
+
+        // if without, reject only if in the list (or 'all' is in the list)
+        if (count($without)) {
+            return (isset($without[$what]) || isset($without['all'])) ? false : true;
+        }
+
+        // otherwise reject all what is not in the with list
+        return (isset($with[$what]) || isset($with['all'])) ? true : false;
+    }
+
+
     /**
      * Compile keyframe block
      *
-     * @param \Leafo\ScssPhp\Block $block
-     * @param array                $selectors
+     * @param \ScssPhp\ScssPhp\Block $block
+     * @param array                  $selectors
      */
     protected function compileKeyframeBlock(Block $block, $selectors)
     {
@@ -1004,11 +1234,44 @@ class Compiler
         $this->popEnv();
     }
 
+    /**
+     * Compile nested properties lines
+     *
+     * @param \ScssPhp\ScssPhp\Block $block
+     * @param OutputBlock            $out
+     */
+    protected function compileNestedPropertiesBlock(Block $block, OutputBlock $out)
+    {
+        $prefix = $this->compileValue($block->prefix) . '-';
+
+        $nested = $this->makeOutputBlock($block->type);
+        $nested->parent = $out;
+
+        if ($block->hasValue) {
+            $nested->depth = $out->depth + 1;
+        }
+
+        $out->children[] = $nested;
+
+        foreach ($block->children as $child) {
+            switch ($child[0]) {
+                case Type::T_ASSIGN:
+                    array_unshift($child[1][2], $prefix);
+                    break;
+
+                case Type::T_NESTED_PROPERTY:
+                    array_unshift($child[1]->prefix[2], $prefix);
+                    break;
+            }
+            $this->compileChild($child, $nested);
+        }
+    }
+
     /**
      * Compile nested block
      *
-     * @param \Leafo\ScssPhp\Block $block
-     * @param array                $selectors
+     * @param \ScssPhp\ScssPhp\Block $block
+     * @param array                  $selectors
      */
     protected function compileNestedBlock(Block $block, $selectors)
     {
@@ -1017,6 +1280,35 @@ class Compiler
         $this->scope = $this->makeOutputBlock($block->type, $selectors);
         $this->scope->parent->children[] = $this->scope;
 
+        // wrap assign children in a block
+        // except for @font-face
+        if ($block->type !== Type::T_DIRECTIVE || $block->name !== "font-face") {
+            // need wrapping?
+            $needWrapping = false;
+
+            foreach ($block->children as $child) {
+                if ($child[0] === Type::T_ASSIGN) {
+                    $needWrapping = true;
+                    break;
+                }
+            }
+
+            if ($needWrapping) {
+                $wrapped = new Block;
+                $wrapped->sourceName = $block->sourceName;
+                $wrapped->sourceIndex = $block->sourceIndex;
+                $wrapped->sourceLine = $block->sourceLine;
+                $wrapped->sourceColumn = $block->sourceColumn;
+                $wrapped->selectors = [];
+                $wrapped->comments = [];
+                $wrapped->parent = $block;
+                $wrapped->children = $block->children;
+                $wrapped->selfParent = $block->selfParent;
+
+                $block->children = [[Type::T_BLOCK, $wrapped]];
+            }
+        }
+
         $this->compileChildrenNoReturn($block->children, $this->scope);
 
         $this->scope = $this->scope->parent;
@@ -1040,7 +1332,7 @@ class Compiler
      *
      * @see Compiler::compileChild()
      *
-     * @param \Leafo\ScssPhp\Block $block
+     * @param \ScssPhp\ScssPhp\Block $block
      */
     protected function compileBlock(Block $block)
     {
@@ -1076,9 +1368,22 @@ class Compiler
         $this->scope->children[] = $out;
 
         if (count($block->children)) {
-            $out->selectors = $this->multiplySelectors($env);
+            $out->selectors = $this->multiplySelectors($env, $block->selfParent);
 
-            $this->compileChildrenNoReturn($block->children, $out);
+            // propagate selfParent to the children where they still can be useful
+            $selfParentSelectors = null;
+
+            if (isset($block->selfParent->selectors)) {
+                $selfParentSelectors = $block->selfParent->selectors;
+                $block->selfParent->selectors = $out->selectors;
+            }
+
+            $this->compileChildrenNoReturn($block->children, $out, $block->selfParent);
+
+            // and revert for the following childs of the same block
+            if ($selfParentSelectors) {
+                $block->selfParent->selectors = $selfParentSelectors;
+            }
         }
 
         $this->formatter->stripSemicolon($out->lines);
@@ -1094,7 +1399,8 @@ class Compiler
     protected function compileComment($block)
     {
         $out = $this->makeOutputBlock(Type::T_COMMENT);
-        $out->lines[] = $block[1];
+        $out->lines[] = is_string($block[1]) ? $block[1] : $this->compileValue($block[1]);
+
         $this->scope->children[] = $out;
     }
 
@@ -1113,6 +1419,7 @@ class Compiler
 
         // after evaluating interpolates, we might need a second pass
         if ($this->shouldEvaluate) {
+            $selectors = $this->revertSelfSelector($selectors);
             $buffer = $this->collapseSelectors($selectors);
             $parser = $this->parserFactory(__METHOD__);
 
@@ -1167,28 +1474,87 @@ class Compiler
     /**
      * Collapse selectors
      *
-     * @param array $selectors
+     * @param array   $selectors
+     * @param boolean $selectorFormat
+     *   if false return a collapsed string
+     *   if true return an array description of a structured selector
      *
      * @return string
      */
-    protected function collapseSelectors($selectors)
+    protected function collapseSelectors($selectors, $selectorFormat = false)
     {
         $parts = [];
 
         foreach ($selectors as $selector) {
-            $output = '';
+            $output = [];
+            $glueNext = false;
 
-            array_walk_recursive(
-                $selector,
-                function ($value, $key) use (&$output) {
-                    $output .= $value;
+            foreach ($selector as $node) {
+                $compound = '';
+
+                array_walk_recursive(
+                    $node,
+                    function ($value, $key) use (&$compound) {
+                        $compound .= $value;
+                    }
+                );
+
+                if ($selectorFormat && $this->isImmediateRelationshipCombinator($compound)) {
+                    if (count($output)) {
+                        $output[count($output) - 1] .= ' ' . $compound;
+                    } else {
+                        $output[] = $compound;
+                    }
+                    $glueNext = true;
+                } elseif ($glueNext) {
+                    $output[count($output) - 1] .= ' ' . $compound;
+                    $glueNext = false;
+                } else {
+                    $output[] = $compound;
                 }
-            );
+            }
+
+            if ($selectorFormat) {
+                foreach ($output as &$o) {
+                    $o = [Type::T_STRING, '', [$o]];
+                }
+                $output = [Type::T_LIST, ' ', $output];
+            } else {
+                $output = implode(' ', $output);
+            }
 
             $parts[] = $output;
         }
 
-        return implode(', ', $parts);
+        if ($selectorFormat) {
+            $parts = [Type::T_LIST, ',', $parts];
+        } else {
+            $parts = implode(', ', $parts);
+        }
+
+        return $parts;
+    }
+
+    /**
+     * Parse down the selector and revert [self] to "&" before a reparsing
+     *
+     * @param array $selectors
+     *
+     * @return array
+     */
+    protected function revertSelfSelector($selectors)
+    {
+        foreach ($selectors as &$part) {
+            if (is_array($part)) {
+                if ($part === [Type::T_SELF]) {
+                    $part = '&';
+                } else {
+                    $part = $this->revertSelfSelector($part);
+                }
+            }
+        }
+
+        return $selectors;
     }
 
     /**
@@ -1295,16 +1661,42 @@ class Compiler
         return false;
     }
 
+    protected function pushCallStack($name = '')
+    {
+        $this->callStack[] = [
+          'n' => $name,
+          Parser::SOURCE_INDEX => $this->sourceIndex,
+          Parser::SOURCE_LINE => $this->sourceLine,
+          Parser::SOURCE_COLUMN => $this->sourceColumn
+        ];
+
+        // infinite calling loop
+        if (count($this->callStack) > 25000) {
+            // not displayed but you can var_dump it to deep debug
+            $msg = $this->callStackMessage(true, 100);
+            $msg = "Infinite calling loop";
+            $this->throwError($msg);
+        }
+    }
+
+    protected function popCallStack()
+    {
+        array_pop($this->callStack);
+    }
+
     /**
      * Compile children and return result
      *
-     * @param array                                $stms
-     * @param \Leafo\ScssPhp\Formatter\OutputBlock $out
+     * @param array                                  $stms
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
+     * @param string                                 $traceName
      *
-     * @return array
+     * @return array|null
      */
-    protected function compileChildren($stms, OutputBlock $out)
+    protected function compileChildren($stms, OutputBlock $out, $traceName = '')
     {
+        $this->pushCallStack($traceName);
+
         foreach ($stms as $stm) {
             $ret = $this->compileChild($stm, $out);
 
@@ -1312,20 +1704,38 @@ class Compiler
                 return $ret;
             }
         }
+
+        $this->popCallStack();
+
+        return null;
     }
 
     /**
      * Compile children and throw exception if unexpected @return
      *
-     * @param array                                $stms
-     * @param \Leafo\ScssPhp\Formatter\OutputBlock $out
+     * @param array                                  $stms
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
+     * @param \ScssPhp\ScssPhp\Block                 $selfParent
+     * @param string                                 $traceName
      *
      * @throws \Exception
      */
-    protected function compileChildrenNoReturn($stms, OutputBlock $out)
+    protected function compileChildrenNoReturn($stms, OutputBlock $out, $selfParent = null, $traceName = '')
     {
+        $this->pushCallStack($traceName);
+
         foreach ($stms as $stm) {
-            $ret = $this->compileChild($stm, $out);
+            if ($selfParent && isset($stm[1]) && is_object($stm[1]) && $stm[1] instanceof Block) {
+                $stm[1]->selfParent = $selfParent;
+                $ret = $this->compileChild($stm, $out);
+                $stm[1]->selfParent = null;
+            } elseif ($selfParent && $stm[0] === TYPE::T_INCLUDE) {
+                $stm['selfParent'] = $selfParent;
+                $ret = $this->compileChild($stm, $out);
+                unset($stm['selfParent']);
+            } else {
+                $ret = $this->compileChild($stm, $out);
+            }
 
             if (isset($ret)) {
                 $this->throwError('@return may only be used within a function');
@@ -1333,6 +1743,64 @@ class Compiler
                 return;
             }
         }
+
+        $this->popCallStack();
+    }
+
+
+    /**
+     * evaluate media query : compile internal value keeping the structure inchanged
+     *
+     * @param array $queryList
+     *
+     * @return array
+     */
+    protected function evaluateMediaQuery($queryList)
+    {
+        static $parser = null;
+        $outQueryList = [];
+        foreach ($queryList as $kql => $query) {
+            $shouldReparse = false;
+            foreach ($query as $kq => $q) {
+                for ($i = 1; $i < count($q); $i++) {
+                    $value = $this->compileValue($q[$i]);
+
+                    // the parser had no mean to know if media type or expression if it was an interpolation
+                    // so you need to reparse if the T_MEDIA_TYPE looks like anything else a media type
+                    if ($q[0] == Type::T_MEDIA_TYPE &&
+                        (strpos($value, '(') !== false ||
+                        strpos($value, ')') !== false ||
+                        strpos($value, ':') !== false ||
+                        strpos($value, ',') !== false)
+                    ) {
+                        $shouldReparse = true;
+                    }
+
+                    $queryList[$kql][$kq][$i] = [Type::T_KEYWORD, $value];
+                }
+            }
+            if ($shouldReparse) {
+                if (is_null($parser)) {
+                    $parser = $this->parserFactory(__METHOD__);
+                }
+                $queryString = $this->compileMediaQuery([$queryList[$kql]]);
+                $queryString = reset($queryString);
+                if (strpos($queryString, '@media ') === 0) {
+                    $queryString = substr($queryString, 7);
+                    $queries = [];
+                    if ($parser->parseMediaQueryList($queryString, $queries)) {
+                        $queries = $this->evaluateMediaQuery($queries[2]);
+                        while (count($queries)) {
+                            $outQueryList[] = array_shift($queries);
+                        }
+                        continue;
+                    }
+                }
+            }
+            $outQueryList[] = $queryList[$kql];
+        }
+
+        return $outQueryList;
     }
 
     /**
@@ -1340,31 +1808,75 @@ class Compiler
      *
      * @param array $queryList
      *
-     * @return string
+     * @return array
      */
     protected function compileMediaQuery($queryList)
     {
-        $out = '@media';
-        $first = true;
+        $start = '@media ';
+        $default = trim($start);
+        $out = [];
+        $current = "";
 
         foreach ($queryList as $query) {
             $type = null;
             $parts = [];
 
+            $mediaTypeOnly = true;
+
+            foreach ($query as $q) {
+                if ($q[0] !== Type::T_MEDIA_TYPE) {
+                    $mediaTypeOnly = false;
+                    break;
+                }
+            }
+
             foreach ($query as $q) {
                 switch ($q[0]) {
                     case Type::T_MEDIA_TYPE:
-                        if ($type) {
-                            $type = $this->mergeMediaTypes(
-                                $type,
-                                array_map([$this, 'compileValue'], array_slice($q, 1))
-                            );
+                        $newType = array_map([$this, 'compileValue'], array_slice($q, 1));
+                        // combining not and anything else than media type is too risky and should be avoided
+                        if (! $mediaTypeOnly) {
+                            if (in_array(Type::T_NOT, $newType) || ($type && in_array(Type::T_NOT, $type) )) {
+                                if ($type) {
+                                    array_unshift($parts, implode(' ', array_filter($type)));
+                                }
 
-                            if (empty($type)) { // merge failed
-                                return null;
+                                if (! empty($parts)) {
+                                    if (strlen($current)) {
+                                        $current .= $this->formatter->tagSeparator;
+                                    }
+
+                                    $current .= implode(' and ', $parts);
+                                }
+
+                                if ($current) {
+                                    $out[] = $start . $current;
+                                }
+
+                                $current = "";
+                                $type = null;
+                                $parts = [];
+                            }
+                        }
+
+                        if ($newType === ['all'] && $default) {
+                            $default = $start . 'all';
+                        }
+
+                        // all can be safely ignored and mixed with whatever else
+                        if ($newType !== ['all']) {
+                            if ($type) {
+                                $type = $this->mergeMediaTypes($type, $newType);
+
+                                if (empty($type)) {
+                                    // merge failed : ignore this query that is not valid, skip to the next one
+                                    $parts = [];
+                                    $default = ''; // if everything fail, no @media at all
+                                    continue 3;
+                                }
+                            } else {
+                                $type = $newType;
                             }
-                        } else {
-                            $type = array_map([$this, 'compileValue'], array_slice($q, 1));
                         }
                         break;
 
@@ -1393,20 +1905,34 @@ class Compiler
             }
 
             if (! empty($parts)) {
-                if ($first) {
-                    $first = false;
-                    $out .= ' ';
-                } else {
-                    $out .= $this->formatter->tagSeparator;
+                if (strlen($current)) {
+                    $current .= $this->formatter->tagSeparator;
                 }
 
-                $out .= implode(' and ', $parts);
+                $current .= implode(' and ', $parts);
             }
         }
 
+        if ($current) {
+            $out[] = $start . $current;
+        }
+
+        // no @media type except all, and no conflict?
+        if (! $out && $default) {
+            $out[] = $default;
+        }
+
         return $out;
     }
 
+    /**
+     * Merge direct relationships between selectors
+     *
+     * @param array $selectors1
+     * @param array $selectors2
+     *
+     * @return array
+     */
     protected function mergeDirectRelationships($selectors1, $selectors2)
     {
         if (empty($selectors1) || empty($selectors2)) {
@@ -1416,7 +1942,7 @@ class Compiler
         $part1 = end($selectors1);
         $part2 = end($selectors2);
 
-        if (! $this->isImmediateRelationshipCombinator($part1[0]) || $part1 !== $part2) {
+        if (! $this->isImmediateRelationshipCombinator($part1[0]) && $part1 !== $part2) {
             return array_merge($selectors1, $selectors2);
         }
 
@@ -1426,13 +1952,18 @@ class Compiler
             $part1 = array_pop($selectors1);
             $part2 = array_pop($selectors2);
 
-            if ($this->isImmediateRelationshipCombinator($part1[0]) && $part1 !== $part2) {
-                $merged = array_merge($selectors1, [$part1], $selectors2, [$part2], $merged);
+            if (! $this->isImmediateRelationshipCombinator($part1[0]) && $part1 !== $part2) {
+                if ($this->isImmediateRelationshipCombinator(reset($merged)[0])) {
+                    array_unshift($merged, [$part1[0] . $part2[0]]);
+                    $merged = array_merge($selectors1, $selectors2, $merged);
+                } else {
+                    $merged = array_merge($selectors1, [$part1], $selectors2, [$part2], $merged);
+                }
+
                 break;
             }
 
             array_unshift($merged, $part1);
-            array_unshift($merged, [array_pop($selectors1)[0] . array_pop($selectors2)[0]]);
         } while (! empty($selectors1) && ! empty($selectors2));
 
         return $merged;
@@ -1507,13 +2038,13 @@ class Compiler
     /**
      * Compile import; returns true if the value was something that could be imported
      *
-     * @param array   $rawPath
-     * @param array   $out
-     * @param boolean $once
+     * @param array                                  $rawPath
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
+     * @param boolean                                $once
      *
      * @return boolean
      */
-    protected function compileImport($rawPath, $out, $once = false)
+    protected function compileImport($rawPath, OutputBlock $out, $once = false)
     {
         if ($rawPath[0] === Type::T_STRING) {
             $path = $this->compileStringContent($rawPath);
@@ -1552,38 +2083,135 @@ class Compiler
         return false;
     }
 
+
+    /**
+     * Append a root directive like @import or @charset as near as the possible from the source code
+     * (keeping before comments, @import and @charset coming before in the source code)
+     *
+     * @param string                                        $line
+     * @param @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
+     * @param array                                         $allowed
+     */
+    protected function appendRootDirective($line, $out, $allowed = [Type::T_COMMENT])
+    {
+        $root = $out;
+
+        while ($root->parent) {
+            $root = $root->parent;
+        }
+
+        $i = 0;
+
+        while ($i < count($root->children)) {
+            if (! isset($root->children[$i]->type) || ! in_array($root->children[$i]->type, $allowed)) {
+                break;
+            }
+
+            $i++;
+        }
+
+        // remove incompatible children from the bottom of the list
+        $saveChildren = [];
+
+        while ($i < count($root->children)) {
+            $saveChildren[] = array_pop($root->children);
+        }
+
+        // insert the directive as a comment
+        $child = $this->makeOutputBlock(Type::T_COMMENT);
+        $child->lines[] = $line;
+        $child->sourceName = $this->sourceNames[$this->sourceIndex];
+        $child->sourceLine = $this->sourceLine;
+        $child->sourceColumn = $this->sourceColumn;
+
+        $root->children[] = $child;
+
+        // repush children
+        while (count($saveChildren)) {
+            $root->children[] = array_pop($saveChildren);
+        }
+    }
+
+    /**
+     * Append lines to the courrent output block:
+     * directly to the block or through a child if necessary
+     *
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
+     * @param string                                 $type
+     * @param string                                 $line
+     */
+    protected function appendOutputLine(OutputBlock $out, $type, $line)
+    {
+        $outWrite = &$out;
+
+        if ($type === Type::T_COMMENT) {
+            $parent = $out->parent;
+
+            if (end($parent->children) !== $out) {
+                $outWrite = &$parent->children[count($parent->children)-1];
+            }
+        }
+
+        // check if it's a flat output or not
+        if (count($out->children)) {
+            $lastChild = &$out->children[count($out->children) -1];
+
+            if ($lastChild->depth === $out->depth && is_null($lastChild->selectors) && ! count($lastChild->children)) {
+                $outWrite = $lastChild;
+            } else {
+                $nextLines = $this->makeOutputBlock($type);
+                $nextLines->parent = $out;
+                $nextLines->depth = $out->depth;
+
+                $out->children[] = $nextLines;
+                $outWrite = &$nextLines;
+            }
+        }
+
+        $outWrite->lines[] = $line;
+    }
+
     /**
      * Compile child; returns a value to halt execution
      *
-     * @param array                                $child
-     * @param \Leafo\ScssPhp\Formatter\OutputBlock $out
+     * @param array                                  $child
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
      *
      * @return array
      */
     protected function compileChild($child, OutputBlock $out)
     {
-        $this->sourceIndex  = isset($child[Parser::SOURCE_INDEX]) ? $child[Parser::SOURCE_INDEX] : null;
-        $this->sourceLine   = isset($child[Parser::SOURCE_LINE]) ? $child[Parser::SOURCE_LINE] : -1;
-        $this->sourceColumn = isset($child[Parser::SOURCE_COLUMN]) ? $child[Parser::SOURCE_COLUMN] : -1;
+        if (isset($child[Parser::SOURCE_LINE])) {
+            $this->sourceIndex = isset($child[Parser::SOURCE_INDEX]) ? $child[Parser::SOURCE_INDEX] : null;
+            $this->sourceLine = isset($child[Parser::SOURCE_LINE]) ? $child[Parser::SOURCE_LINE] : -1;
+            $this->sourceColumn = isset($child[Parser::SOURCE_COLUMN]) ? $child[Parser::SOURCE_COLUMN] : -1;
+        } elseif (is_array($child) && isset($child[1]->sourceLine)) {
+            $this->sourceIndex = $child[1]->sourceIndex;
+            $this->sourceLine = $child[1]->sourceLine;
+            $this->sourceColumn = $child[1]->sourceColumn;
+        } elseif (! empty($out->sourceLine) && ! empty($out->sourceName)) {
+            $this->sourceLine = $out->sourceLine;
+            $this->sourceIndex = array_search($out->sourceName, $this->sourceNames);
+
+            if ($this->sourceIndex === false) {
+                $this->sourceIndex = null;
+            }
+        }
 
         switch ($child[0]) {
             case Type::T_SCSSPHP_IMPORT_ONCE:
-                list(, $rawPath) = $child;
-
-                $rawPath = $this->reduce($rawPath);
+                $rawPath = $this->reduce($child[1]);
 
                 if (! $this->compileImport($rawPath, $out, true)) {
-                    $out->lines[] = '@import ' . $this->compileValue($rawPath) . ';';
+                    $this->appendRootDirective('@import ' . $this->compileValue($rawPath) . ';', $out);
                 }
                 break;
 
             case Type::T_IMPORT:
-                list(, $rawPath) = $child;
-
-                $rawPath = $this->reduce($rawPath);
+                $rawPath = $this->reduce($child[1]);
 
                 if (! $this->compileImport($rawPath, $out)) {
-                    $out->lines[] = '@import ' . $this->compileValue($rawPath) . ';';
+                    $this->appendRootDirective('@import ' . $this->compileValue($rawPath) . ';', $out);
                 }
                 break;
 
@@ -1606,8 +2234,7 @@ class Compiler
             case Type::T_CHARSET:
                 if (! $this->charsetSeen) {
                     $this->charsetSeen = true;
-
-                    $out->lines[] = '@charset ' . $this->compileValue($child[1]) . ';';
+                    $this->appendRootDirective('@charset ' . $this->compileValue($child[1]) . ';', $out);
                 }
                 break;
 
@@ -1620,16 +2247,16 @@ class Compiler
                     $isGlobal = in_array('!global', $flags);
 
                     if ($isGlobal) {
-                        $this->set($name[1], $this->reduce($value), false, $this->rootEnv);
+                        $this->set($name[1], $this->reduce($value), false, $this->rootEnv, $value);
                         break;
                     }
 
                     $shouldSet = $isDefault &&
-                        (($result = $this->get($name[1], false)) === null
-                        || $result === static::$null);
+                        (($result = $this->get($name[1], false)) === null ||
+                        $result === static::$null);
 
                     if (! $isDefault || $shouldSet) {
-                        $this->set($name[1], $this->reduce($value));
+                        $this->set($name[1], $this->reduce($value), true, null, $value);
                     }
                     break;
                 }
@@ -1637,11 +2264,25 @@ class Compiler
                 $compiledName = $this->compileValue($name);
 
                 // handle shorthand syntax: size / line-height
-                if ($compiledName === 'font') {
-                    if ($value[0] === Type::T_EXPRESSION && $value[1] === '/') {
-                        $value = $this->expToString($value);
-                    } elseif ($value[0] === Type::T_LIST) {
-                        foreach ($value[2] as &$item) {
+                if ($compiledName === 'font' || $compiledName === 'grid-row' || $compiledName === 'grid-column') {
+                    if ($value[0] === Type::T_VARIABLE) {
+                        // if the font value comes from variable, the content is already reduced
+                        // (i.e., formulas were already calculated), so we need the original unreduced value
+                        $value = $this->get($value[1], true, null, true);
+                    }
+
+                    $fontValue=&$value;
+
+                    if ($value[0] === Type::T_LIST && $value[1]==',') {
+                        // this is the case if more than one font is given: example: "font: 400 1em/1.3 arial,helvetica"
+                        // we need to handle the first list element
+                        $fontValue=&$value[2][0];
+                    }
+
+                    if ($fontValue[0] === Type::T_EXPRESSION && $fontValue[1] === '/') {
+                        $fontValue = $this->expToString($fontValue);
+                    } elseif ($fontValue[0] === Type::T_LIST) {
+                        foreach ($fontValue[2] as &$item) {
                             if ($item[0] === Type::T_EXPRESSION && $item[1] === '/') {
                                 $item = $this->expToString($item);
                             }
@@ -1661,10 +2302,11 @@ class Compiler
 
                 $compiledValue = $this->compileValue($value);
 
-                $out->lines[] = $this->formatter->property(
+                $line = $this->formatter->property(
                     $compiledName,
                     $compiledValue
                 );
+                $this->appendOutputLine($out, Type::T_ASSIGN, $line);
                 break;
 
             case Type::T_COMMENT:
@@ -1673,20 +2315,18 @@ class Compiler
                     break;
                 }
 
-                $out->lines[] = $child[1];
+                $this->appendOutputLine($out, Type::T_COMMENT, $child[1]);
                 break;
 
             case Type::T_MIXIN:
             case Type::T_FUNCTION:
                 list(, $block) = $child;
 
-                $this->set(static::$namespaces[$block->type] . $block->name, $block);
+                $this->set(static::$namespaces[$block->type] . $block->name, $block, true);
                 break;
 
             case Type::T_EXTEND:
-                list(, $selectors) = $child;
-
-                foreach ($selectors as $sel) {
+                foreach ($child[1] as $sel) {
                     $results = $this->evalSelectors([$sel]);
 
                     foreach ($results as $result) {
@@ -1820,26 +2460,7 @@ class Compiler
                 return $this->reduce($child[1], true);
 
             case Type::T_NESTED_PROPERTY:
-                list(, $prop) = $child;
-
-                $prefixed = [];
-                $prefix = $this->compileValue($prop->prefix) . '-';
-
-                foreach ($prop->children as $child) {
-                    switch ($child[0]) {
-                        case Type::T_ASSIGN:
-                            array_unshift($child[1][2], $prefix);
-                            break;
-
-                        case Type::T_NESTED_PROPERTY:
-                            array_unshift($child[1]->prefix[2], $prefix);
-                            break;
-                    }
-
-                    $prefixed[] = $child;
-                }
-
-                $this->compileChildrenNoReturn($prefixed, $out);
+                $this->compileNestedPropertiesBlock($child[1], $out);
                 break;
 
             case Type::T_INCLUDE:
@@ -1862,10 +2483,36 @@ class Compiler
                 $storeEnv = $this->storeEnv;
                 $this->storeEnv = $this->env;
 
-                if (isset($content)) {
-                    $content->scope = $callingScope;
+                // Find the parent selectors in the env to be able to know what '&' refers to in the mixin
+                // and assign this fake parent to childs
+                $selfParent = null;
 
-                    $this->setRaw(static::$namespaces['special'] . 'content', $content, $this->env);
+                if (isset($child['selfParent']) && isset($child['selfParent']->selectors)) {
+                    $selfParent = $child['selfParent'];
+                } else {
+                    $parentSelectors = $this->multiplySelectors($this->env);
+
+                    if ($parentSelectors) {
+                        $parent = new Block();
+                        $parent->selectors = $parentSelectors;
+
+                        foreach ($mixin->children as $k => $child) {
+                            if (isset($child[1]) && is_object($child[1]) && $child[1] instanceof Block) {
+                                $mixin->children[$k][1]->parent = $parent;
+                            }
+                        }
+                    }
+                }
+
+                // clone the stored content to not have its scope spoiled by a further call to the same mixin
+                // i.e., recursive @include of the same mixin
+                if (isset($content)) {
+                    $copyContent = clone $content;
+                    $copyContent->scope = $callingScope;
+
+                    $this->setRaw(static::$namespaces['special'] . 'content', $copyContent, $this->env);
+                } else {
+                    $this->setRaw(static::$namespaces['special'] . 'content', null, $this->env);
                 }
 
                 if (isset($mixin->args)) {
@@ -1874,7 +2521,7 @@ class Compiler
 
                 $this->env->marker = 'mixin';
 
-                $this->compileChildrenNoReturn($mixin->children, $out);
+                $this->compileChildrenNoReturn($mixin->children, $out, $selfParent, $this->env->marker . " " . $name);
 
                 $this->storeEnv = $storeEnv;
 
@@ -1882,19 +2529,18 @@ class Compiler
                 break;
 
             case Type::T_MIXIN_CONTENT:
-                $content = $this->get(static::$namespaces['special'] . 'content', false, $this->getStoreEnv())
-                         ?: $this->get(static::$namespaces['special'] . 'content', false, $this->env);
+                $env = isset($this->storeEnv) ? $this->storeEnv : $this->env;
+                $content = $this->get(static::$namespaces['special'] . 'content', false, $env);
 
                 if (! $content) {
                     $content = new \stdClass();
                     $content->scope = new \stdClass();
-                    $content->children = $this->storeEnv->parent->block->children;
+                    $content->children = $env->parent->block->children;
                     break;
                 }
 
                 $storeEnv = $this->storeEnv;
                 $this->storeEnv = $content->scope;
-
                 $this->compileChildrenNoReturn($content->children, $out);
 
                 $this->storeEnv = $storeEnv;
@@ -1903,25 +2549,28 @@ class Compiler
             case Type::T_DEBUG:
                 list(, $value) = $child;
 
+                $fname = $this->sourceNames[$this->sourceIndex];
                 $line = $this->sourceLine;
                 $value = $this->compileValue($this->reduce($value, true));
-                fwrite($this->stderr, "Line $line DEBUG: $value\n");
+                fwrite($this->stderr, "File $fname on line $line DEBUG: $value\n");
                 break;
 
             case Type::T_WARN:
                 list(, $value) = $child;
 
+                $fname = $this->sourceNames[$this->sourceIndex];
                 $line = $this->sourceLine;
                 $value = $this->compileValue($this->reduce($value, true));
-                fwrite($this->stderr, "Line $line WARN: $value\n");
+                fwrite($this->stderr, "File $fname on line $line WARN: $value\n");
                 break;
 
             case Type::T_ERROR:
                 list(, $value) = $child;
 
+                $fname = $this->sourceNames[$this->sourceIndex];
                 $line = $this->sourceLine;
                 $value = $this->compileValue($this->reduce($value, true));
-                $this->throwError("Line $line ERROR: $value\n");
+                $this->throwError("File $fname on line $line ERROR: $value\n");
                 break;
 
             case Type::T_CONTROL:
@@ -1966,7 +2615,7 @@ class Compiler
      *
      * @param array $value
      *
-     * @return array
+     * @return boolean
      */
     protected function isTruthy($value)
     {
@@ -1997,7 +2646,7 @@ class Compiler
         switch ($value[0]) {
             case Type::T_EXPRESSION:
                 if ($value[1] === '/') {
-                    return $this->shouldEval($value[2], $value[3]);
+                    return $this->shouldEval($value[2]) || $this->shouldEval($value[3]);
                 }
 
                 // fall-thru
@@ -2015,13 +2664,12 @@ class Compiler
      * @param array   $value
      * @param boolean $inExp
      *
-     * @return array|\Leafo\ScssPhp\Node\Number
+     * @return array|\ScssPhp\ScssPhp\Node\Number
      */
     protected function reduce($value, $inExp = false)
     {
-        list($type) = $value;
 
-        switch ($type) {
+        switch ($value[0]) {
             case Type::T_EXPRESSION:
                 list(, $op, $left, $right, $inParens) = $value;
 
@@ -2035,9 +2683,9 @@ class Compiler
                 }
 
                 // special case: looks like css shorthand
-                if ($opName == 'div' && ! $inParens && ! $inExp && isset($right[2])
-                    && (($right[0] !== Type::T_NUMBER && $right[2] != '')
-                    || ($right[0] === Type::T_NUMBER && ! $right->unitless()))
+                if ($opName == 'div' && ! $inParens && ! $inExp && isset($right[2]) &&
+                    (($right[0] !== Type::T_NUMBER && $right[2] != '') ||
+                    ($right[0] === Type::T_NUMBER && ! $right->unitless()))
                 ) {
                     return $this->expToString($value);
                 }
@@ -2154,9 +2802,7 @@ class Compiler
                 return [Type::T_STRING, '', [$op, $exp]];
 
             case Type::T_VARIABLE:
-                list(, $name) = $value;
-
-                return $this->reduce($this->get($name));
+                return $this->reduce($this->get($value[1]));
 
             case Type::T_LIST:
                 foreach ($value[2] as &$item) {
@@ -2187,13 +2833,19 @@ class Compiler
 
             case Type::T_INTERPOLATE:
                 $value[1] = $this->reduce($value[1]);
+                if ($inExp) {
+                    return $value[1];
+                }
 
                 return $value;
 
             case Type::T_FUNCTION_CALL:
-                list(, $name, $argValues) = $value;
+                return $this->fncall($value[1], $value[2]);
 
-                return $this->fncall($name, $argValues);
+            case Type::T_SELF:
+                $selfSelector = $this->multiplySelectors($this->env);
+                $selfSelector = $this->collapseSelectors($selfSelector, true);
+                return $selfSelector;
 
             default:
                 return $value;
@@ -2208,7 +2860,7 @@ class Compiler
      *
      * @return array|null
      */
-    private function fncall($name, $argValues)
+    protected function fncall($name, $argValues)
     {
         // SCSS @function
         if ($this->callScssFunction($name, $argValues, $returnValue)) {
@@ -2254,9 +2906,8 @@ class Compiler
     public function normalizeValue($value)
     {
         $value = $this->coerceForExpression($this->reduce($value));
-        list($type) = $value;
 
-        switch ($type) {
+        switch ($value[0]) {
             case Type::T_LIST:
                 $value = $this->extractInterpolation($value);
 
@@ -2271,7 +2922,7 @@ class Compiler
                 return $value;
 
             case Type::T_STRING:
-                return [$type, '"', [$this->compileStringContent($value)]];
+                return [$value[0], '"', [$this->compileStringContent($value)]];
 
             case Type::T_NUMBER:
                 return $value->normalize();
@@ -2290,7 +2941,7 @@ class Compiler
      * @param array $left
      * @param array $right
      *
-     * @return \Leafo\ScssPhp\Node\Number
+     * @return \ScssPhp\ScssPhp\Node\Number
      */
     protected function opAddNumberNumber($left, $right)
     {
@@ -2303,7 +2954,7 @@ class Compiler
      * @param array $left
      * @param array $right
      *
-     * @return \Leafo\ScssPhp\Node\Number
+     * @return \ScssPhp\ScssPhp\Node\Number
      */
     protected function opMulNumberNumber($left, $right)
     {
@@ -2316,7 +2967,7 @@ class Compiler
      * @param array $left
      * @param array $right
      *
-     * @return \Leafo\ScssPhp\Node\Number
+     * @return \ScssPhp\ScssPhp\Node\Number
      */
     protected function opSubNumberNumber($left, $right)
     {
@@ -2329,7 +2980,7 @@ class Compiler
      * @param array $left
      * @param array $right
      *
-     * @return array|\Leafo\ScssPhp\Node\Number
+     * @return array|\ScssPhp\ScssPhp\Node\Number
      */
     protected function opDivNumberNumber($left, $right)
     {
@@ -2346,7 +2997,7 @@ class Compiler
      * @param array $left
      * @param array $right
      *
-     * @return \Leafo\ScssPhp\Node\Number
+     * @return \ScssPhp\ScssPhp\Node\Number
      */
     protected function opModNumberNumber($left, $right)
     {
@@ -2359,7 +3010,7 @@ class Compiler
      * @param array $left
      * @param array $right
      *
-     * @return array
+     * @return array|null
      */
     protected function opAdd($left, $right)
     {
@@ -2382,6 +3033,8 @@ class Compiler
 
             return $strRight;
         }
+
+        return null;
     }
 
     /**
@@ -2391,15 +3044,21 @@ class Compiler
      * @param array   $right
      * @param boolean $shouldEval
      *
-     * @return array
+     * @return array|null
      */
     protected function opAnd($left, $right, $shouldEval)
     {
+        $truthy = ($left === static::$null || $right === static::$null) ||
+                  ($left === static::$false || $left === static::$true) &&
+                  ($right === static::$false || $right === static::$true);
+
         if (! $shouldEval) {
-            return;
+            if (! $truthy) {
+                return null;
+            }
         }
 
-        if ($left !== static::$false and $left !== static::$null) {
+        if ($left !== static::$false && $left !== static::$null) {
             return $this->reduce($right, true);
         }
 
@@ -2413,15 +3072,21 @@ class Compiler
      * @param array   $right
      * @param boolean $shouldEval
      *
-     * @return array
+     * @return array|null
      */
     protected function opOr($left, $right, $shouldEval)
     {
+        $truthy = ($left === static::$null || $right === static::$null) ||
+                  ($left === static::$false || $left === static::$true) &&
+                  ($right === static::$false || $right === static::$true);
+
         if (! $shouldEval) {
-            return;
+            if (! $truthy) {
+                return null;
+            }
         }
 
-        if ($left !== static::$false and $left !== static::$null) {
+        if ($left !== static::$false && $left !== static::$null) {
             return $left;
         }
 
@@ -2632,7 +3297,7 @@ class Compiler
      * @param array $left
      * @param array $right
      *
-     * @return \Leafo\ScssPhp\Node\Number
+     * @return \ScssPhp\ScssPhp\Node\Number
      */
     protected function opCmpNumberNumber($left, $right)
     {
@@ -2676,9 +3341,7 @@ class Compiler
     {
         $value = $this->reduce($value);
 
-        list($type) = $value;
-
-        switch ($type) {
+        switch ($value[0]) {
             case Type::T_KEYWORD:
                 return $value[1];
 
@@ -2694,7 +3357,9 @@ class Compiler
                 $b = round($b);
 
                 if (count($value) === 5 && $value[4] !== 1) { // rgba
-                    return 'rgba(' . $r . ', ' . $g . ', ' . $b . ', ' . $value[4] . ')';
+                    $a = new Node\Number($value[4], '');
+
+                    return 'rgba(' . $r . ', ' . $g . ', ' . $b . ', ' . $a . ')';
                 }
 
                 $h = sprintf('#%02x%02x%02x', $r, $g, $b);
@@ -2771,11 +3436,8 @@ class Compiler
                 return $left . $this->compileValue($interpolate) . $right;
 
             case Type::T_INTERPOLATE:
-                // raw parse node
-                list(, $exp) = $value;
-
                 // strip quotes if it's a string
-                $reduced = $this->reduce($exp);
+                $reduced = $this->reduce($value[1]);
 
                 switch ($reduced[0]) {
                     case Type::T_LIST:
@@ -2825,7 +3487,7 @@ class Compiler
                 return 'null';
 
             default:
-                $this->throwError("unknown value type: $type");
+                $this->throwError("unknown value type: ".json_encode($value));
         }
     }
 
@@ -2889,44 +3551,70 @@ class Compiler
     /**
      * Find the final set of selectors
      *
-     * @param \Leafo\ScssPhp\Compiler\Environment $env
+     * @param \ScssPhp\ScssPhp\Compiler\Environment $env
+     * @param \ScssPhp\ScssPhp\Block                $selfParent
      *
      * @return array
      */
-    protected function multiplySelectors(Environment $env)
+    protected function multiplySelectors(Environment $env, $selfParent = null)
     {
         $envs            = $this->compactEnv($env);
         $selectors       = [];
         $parentSelectors = [[]];
 
+        $selfParentSelectors = null;
+
+        if (! is_null($selfParent) && $selfParent->selectors) {
+            $selfParentSelectors = $this->evalSelectors($selfParent->selectors);
+        }
+
         while ($env = array_pop($envs)) {
             if (empty($env->selectors)) {
                 continue;
             }
 
-            $selectors = [];
+            $selectors = $env->selectors;
 
-            foreach ($env->selectors as $selector) {
-                foreach ($parentSelectors as $parent) {
-                    $selectors[] = $this->joinSelectors($parent, $selector);
+            do {
+                $stillHasSelf = false;
+                $prevSelectors = $selectors;
+                $selectors = [];
+
+                foreach ($prevSelectors as $selector) {
+                    foreach ($parentSelectors as $parent) {
+                        if ($selfParentSelectors) {
+                            foreach ($selfParentSelectors as $selfParent) {
+                                // if no '&' in the selector, each call will give same result, only add once
+                                $s = $this->joinSelectors($parent, $selector, $stillHasSelf, $selfParent);
+                                $selectors[serialize($s)] = $s;
+                            }
+                        } else {
+                            $s = $this->joinSelectors($parent, $selector, $stillHasSelf);
+                            $selectors[serialize($s)] = $s;
+                        }
+                    }
                 }
-            }
+            } while ($stillHasSelf);
 
             $parentSelectors = $selectors;
         }
 
+        $selectors = array_values($selectors);
+
         return $selectors;
     }
 
     /**
      * Join selectors; looks for & to replace, or append parent before child
      *
-     * @param array $parent
-     * @param array $child
-     *
+     * @param array   $parent
+     * @param array   $child
+     * @param boolean &$stillHasSelf
+     * @param array   $selfParentSelectors
+
      * @return array
      */
-    protected function joinSelectors($parent, $child)
+    protected function joinSelectors($parent, $child, &$stillHasSelf, $selfParentSelectors = null)
     {
         $setSelf = false;
         $out = [];
@@ -2935,16 +3623,33 @@ class Compiler
             $newPart = [];
 
             foreach ($part as $p) {
-                if ($p === static::$selfSelector) {
+                // only replace & once and should be recalled to be able to make combinations
+                if ($p === static::$selfSelector && $setSelf) {
+                    $stillHasSelf = true;
+                }
+
+                if ($p === static::$selfSelector && ! $setSelf) {
                     $setSelf = true;
 
-                    foreach ($parent as $i => $parentPart) {
+                    if (is_null($selfParentSelectors)) {
+                        $selfParentSelectors = $parent;
+                    }
+
+                    foreach ($selfParentSelectors as $i => $parentPart) {
                         if ($i > 0) {
                             $out[] = $newPart;
                             $newPart = [];
                         }
 
                         foreach ($parentPart as $pp) {
+                            if (is_array($pp)) {
+                                $flatten = [];
+                                array_walk_recursive($pp, function ($a) use (&$flatten) {
+                                    $flatten[] = $a;
+                                });
+                                $pp = implode($flatten);
+                            }
+
                             $newPart[] = $pp;
                         }
                     }
@@ -2962,8 +3667,8 @@ class Compiler
     /**
      * Multiply media
      *
-     * @param \Leafo\ScssPhp\Compiler\Environment $env
-     * @param array                               $childQueries
+     * @param \ScssPhp\ScssPhp\Compiler\Environment $env
+     * @param array                                 $childQueries
      *
      * @return array
      */
@@ -2984,6 +3689,12 @@ class Compiler
             ? $env->block->queryList
             : [[[Type::T_MEDIA_VALUE, $env->block->value]]];
 
+        $store = [$this->env, $this->storeEnv];
+        $this->env = $env;
+        $this->storeEnv = null;
+        $parentQueries = $this->evaluateMediaQuery($parentQueries);
+        list($this->env, $this->storeEnv) = $store;
+
         if ($childQueries === null) {
             $childQueries = $parentQueries;
         } else {
@@ -2992,7 +3703,11 @@ class Compiler
 
             foreach ($parentQueries as $parentQuery) {
                 foreach ($originalQueries as $childQuery) {
-                    $childQueries []= array_merge($parentQuery, $childQuery);
+                    $childQueries[] = array_merge(
+                        $parentQuery,
+                        [[Type::T_MEDIA_TYPE, [Type::T_KEYWORD, 'all']]],
+                        $childQuery
+                    );
                 }
             }
         }
@@ -3003,11 +3718,11 @@ class Compiler
     /**
      * Convert env linked list to stack
      *
-     * @param \Leafo\ScssPhp\Compiler\Environment $env
+     * @param \ScssPhp\ScssPhp\Compiler\Environment $env
      *
      * @return array
      */
-    private function compactEnv(Environment $env)
+    protected function compactEnv(Environment $env)
     {
         for ($envs = []; $env; $env = $env->parent) {
             $envs[] = $env;
@@ -3021,9 +3736,9 @@ class Compiler
      *
      * @param array $envs
      *
-     * @return \Leafo\ScssPhp\Compiler\Environment
+     * @return \ScssPhp\ScssPhp\Compiler\Environment
      */
-    private function extractEnv($envs)
+    protected function extractEnv($envs)
     {
         for ($env = null; $e = array_pop($envs);) {
             $e->parent = $env;
@@ -3036,9 +3751,9 @@ class Compiler
     /**
      * Push environment
      *
-     * @param \Leafo\ScssPhp\Block $block
+     * @param \ScssPhp\ScssPhp\Block $block
      *
-     * @return \Leafo\ScssPhp\Compiler\Environment
+     * @return \ScssPhp\ScssPhp\Compiler\Environment
      */
     protected function pushEnv(Block $block = null)
     {
@@ -3064,7 +3779,7 @@ class Compiler
     /**
      * Get store environment
      *
-     * @return \Leafo\ScssPhp\Compiler\Environment
+     * @return \ScssPhp\ScssPhp\Compiler\Environment
      */
     protected function getStoreEnv()
     {
@@ -3074,12 +3789,13 @@ class Compiler
     /**
      * Set variable
      *
-     * @param string                              $name
-     * @param mixed                               $value
-     * @param boolean                             $shadow
-     * @param \Leafo\ScssPhp\Compiler\Environment $env
+     * @param string                                $name
+     * @param mixed                                 $value
+     * @param boolean                               $shadow
+     * @param \ScssPhp\ScssPhp\Compiler\Environment $env
+     * @param mixed                                 $valueUnreduced
      */
-    protected function set($name, $value, $shadow = false, Environment $env = null)
+    protected function set($name, $value, $shadow = false, Environment $env = null, $valueUnreduced = null)
     {
         $name = $this->normalizeName($name);
 
@@ -3088,20 +3804,21 @@ class Compiler
         }
 
         if ($shadow) {
-            $this->setRaw($name, $value, $env);
+            $this->setRaw($name, $value, $env, $valueUnreduced);
         } else {
-            $this->setExisting($name, $value, $env);
+            $this->setExisting($name, $value, $env, $valueUnreduced);
         }
     }
 
     /**
      * Set existing variable
      *
-     * @param string                              $name
-     * @param mixed                               $value
-     * @param \Leafo\ScssPhp\Compiler\Environment $env
+     * @param string                                $name
+     * @param mixed                                 $value
+     * @param \ScssPhp\ScssPhp\Compiler\Environment $env
+     * @param mixed                                 $valueUnreduced
      */
-    protected function setExisting($name, $value, Environment $env)
+    protected function setExisting($name, $value, Environment $env, $valueUnreduced = null)
     {
         $storeEnv = $env;
 
@@ -3126,18 +3843,27 @@ class Compiler
         }
 
         $env->store[$name] = $value;
+
+        if ($valueUnreduced) {
+            $env->storeUnreduced[$name] = $valueUnreduced;
+        }
     }
 
     /**
      * Set raw variable
      *
-     * @param string                              $name
-     * @param mixed                               $value
-     * @param \Leafo\ScssPhp\Compiler\Environment $env
+     * @param string                                $name
+     * @param mixed                                 $value
+     * @param \ScssPhp\ScssPhp\Compiler\Environment $env
+     * @param mixed                                 $valueUnreduced
      */
-    protected function setRaw($name, $value, Environment $env)
+    protected function setRaw($name, $value, Environment $env, $valueUnreduced = null)
     {
         $env->store[$name] = $value;
+
+        if ($valueUnreduced) {
+            $env->storeUnreduced[$name] = $valueUnreduced;
+        }
     }
 
     /**
@@ -3145,13 +3871,14 @@ class Compiler
      *
      * @api
      *
-     * @param string                              $name
-     * @param boolean                             $shouldThrow
-     * @param \Leafo\ScssPhp\Compiler\Environment $env
+     * @param string                                $name
+     * @param boolean                               $shouldThrow
+     * @param \ScssPhp\ScssPhp\Compiler\Environment $env
+     * @param boolean                               $unreduced
      *
-     * @return mixed
+     * @return mixed|null
      */
-    public function get($name, $shouldThrow = true, Environment $env = null)
+    public function get($name, $shouldThrow = true, Environment $env = null, $unreduced = false)
     {
         $normalizedName = $this->normalizeName($name);
         $specialContentKey = static::$namespaces['special'] . 'content';
@@ -3163,15 +3890,24 @@ class Compiler
         $nextIsRoot = false;
         $hasNamespace = $normalizedName[0] === '^' || $normalizedName[0] === '@' || $normalizedName[0] === '%';
 
+        $maxDepth = 10000;
+
         for (;;) {
+            if ($maxDepth-- <= 0) {
+                break;
+            }
+
             if (array_key_exists($normalizedName, $env->store)) {
+                if ($unreduced && isset($env->storeUnreduced[$normalizedName])) {
+                    return $env->storeUnreduced[$normalizedName];
+                }
+
                 return $env->store[$normalizedName];
             }
 
             if (! $hasNamespace && isset($env->marker)) {
                 if (! $nextIsRoot && ! empty($env->store[$specialContentKey])) {
                     $env = $env->store[$specialContentKey]->scope;
-                    $nextIsRoot = true;
                     continue;
                 }
 
@@ -3187,17 +3923,18 @@ class Compiler
         }
 
         if ($shouldThrow) {
-            $this->throwError("Undefined variable \$$name");
+            $this->throwError("Undefined variable \$$name" . ($maxDepth<=0 ? " (infinite recursion)" : ""));
         }
 
         // found nothing
+        return null;
     }
 
     /**
      * Has variable?
      *
-     * @param string                              $name
-     * @param \Leafo\ScssPhp\Compiler\Environment $env
+     * @param string                                $name
+     * @param \ScssPhp\ScssPhp\Compiler\Environment $env
      *
      * @return boolean
      */
@@ -3299,7 +4036,7 @@ class Compiler
      *
      * @api
      *
-     * @param string $path
+     * @param string|callable $path
      */
     public function addImportPath($path)
     {
@@ -3421,10 +4158,10 @@ class Compiler
     /**
      * Import file
      *
-     * @param string $path
-     * @param array  $out
+     * @param string                                 $path
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
      */
-    protected function importFile($path, $out)
+    protected function importFile($path, OutputBlock $out)
     {
         // see if tree is cached
         $realPath = realpath($path);
@@ -3472,9 +4209,12 @@ class Compiler
             if (is_string($dir)) {
                 // check urls for normal import paths
                 foreach ($urls as $full) {
-                    $full = $dir
-                        . (! empty($dir) && substr($dir, -1) !== '/' ? '/' : '')
-                        . $full;
+                    $separator = (
+                        ! empty($dir) &&
+                        substr($dir, -1) !== '/' &&
+                        substr($full, 0, 1) !== '/'
+                    ) ? '/' : '';
+                    $full = $dir . $separator . $full;
 
                     if ($this->fileExists($file = $full . '.scss') ||
                         ($hasExtension && $this->fileExists($file = $full))
@@ -3514,11 +4254,13 @@ class Compiler
      *
      * @param boolean $ignoreErrors
      *
-     * @return \Leafo\ScssPhp\Compiler
+     * @return \ScssPhp\ScssPhp\Compiler
      */
     public function setIgnoreErrors($ignoreErrors)
     {
         $this->ignoreErrors = $ignoreErrors;
+
+        return $this;
     }
 
     /**
@@ -3528,7 +4270,7 @@ class Compiler
      *
      * @param string $msg Message with optional sprintf()-style vararg parameters
      *
-     * @throws \Leafo\ScssPhp\Exception\CompilerException
+     * @throws \ScssPhp\ScssPhp\Exception\CompilerException
      */
     public function throwError($msg)
     {
@@ -3536,16 +4278,61 @@ class Compiler
             return;
         }
 
+        $line   = $this->sourceLine;
+        $column = $this->sourceColumn;
+
+        $loc = isset($this->sourceNames[$this->sourceIndex])
+             ? $this->sourceNames[$this->sourceIndex] . " on line $line, at column $column"
+             : "line: $line, column: $column";
+
         if (func_num_args() > 1) {
             $msg = call_user_func_array('sprintf', func_get_args());
         }
 
-        $line = $this->sourceLine;
-        $msg = "$msg: line: $line";
+        $msg = "$msg: $loc";
+
+        $callStackMsg = $this->callStackMessage();
+
+        if ($callStackMsg) {
+            $msg .= "\nCall Stack:\n" . $callStackMsg;
+        }
 
         throw new CompilerException($msg);
     }
 
+    /**
+     * Beautify call stack for output
+     *
+     * @param boolean $all
+     * @param null    $limit
+     *
+     * @return string
+     */
+    protected function callStackMessage($all = false, $limit = null)
+    {
+        $callStackMsg = [];
+        $ncall = 0;
+
+        if ($this->callStack) {
+            foreach (array_reverse($this->callStack) as $call) {
+                if ($all || (isset($call['n']) && $call['n'])) {
+                    $msg = "#" . $ncall++ . " " . $call['n'] . " ";
+                    $msg .= (isset($this->sourceNames[$call[Parser::SOURCE_INDEX]])
+                          ? $this->sourceNames[$call[Parser::SOURCE_INDEX]]
+                          : '(unknown file)');
+                    $msg .= " on line " . $call[Parser::SOURCE_LINE];
+                    $callStackMsg[] = $msg;
+
+                    if (! is_null($limit) && $ncall>$limit) {
+                        break;
+                    }
+                }
+            }
+        }
+
+        return implode("\n", $callStackMsg);
+    }
+
     /**
      * Handle import loop
      *
@@ -3611,7 +4398,7 @@ class Compiler
 
         $this->env->marker = 'function';
 
-        $ret = $this->compileChildren($func->children, $tmp);
+        $ret = $this->compileChildren($func->children, $tmp, $this->env->marker . " " . $name);
 
         $this->storeEnv = $storeEnv;
 
@@ -3646,7 +4433,7 @@ class Compiler
             return false;
         }
 
-        list($sorted, $kwargs) = $this->sortArgs($prototype, $args);
+        @list($sorted, $kwargs) = $this->sortArgs($prototype, $args);
 
         if ($name !== 'if' && $name !== 'call') {
             foreach ($sorted as &$val) {
@@ -3693,38 +4480,116 @@ class Compiler
      *
      * @return array
      */
-    protected function sortArgs($prototype, $args)
+    protected function sortArgs($prototypes, $args)
     {
-        $keyArgs = [];
-        $posArgs = [];
+        static $parser = null;
 
-        // separate positional and keyword arguments
-        foreach ($args as $arg) {
-            list($key, $value) = $arg;
+        if (! isset($prototypes)) {
+            $keyArgs = [];
+            $posArgs = [];
 
-            $key = $key[1];
+            // separate positional and keyword arguments
+            foreach ($args as $arg) {
+                list($key, $value) = $arg;
 
-            if (empty($key)) {
-                $posArgs[] = $value;
-            } else {
-                $keyArgs[$key] = $value;
+                $key = $key[1];
+
+                if (empty($key)) {
+                    $posArgs[] = empty($arg[2]) ? $value : $arg;
+                } else {
+                    $keyArgs[$key] = $value;
+                }
             }
-        }
 
-        if (! isset($prototype)) {
             return [$posArgs, $keyArgs];
         }
 
-        // copy positional args
-        $finalArgs = array_pad($posArgs, count($prototype), null);
+        $finalArgs = [];
 
-        // overwrite positional args with keyword args
-        foreach ($prototype as $i => $names) {
-            foreach ((array) $names as $name) {
-                if (isset($keyArgs[$name])) {
-                    $finalArgs[$i] = $keyArgs[$name];
+        if (! is_array(reset($prototypes))) {
+            $prototypes = [$prototypes];
+        }
+
+        $keyArgs = [];
+
+        // trying each prototypes
+        $prototypeHasMatch = false;
+        $exceptionMessage = '';
+
+        foreach ($prototypes as $prototype) {
+            $argDef = [];
+
+            foreach ($prototype as $i => $p) {
+                $default = null;
+                $p       = explode(':', $p, 2);
+                $name    = array_shift($p);
+
+                if (count($p)) {
+                    $p = trim(reset($p));
+
+                    if ($p === 'null') {
+                        // differentiate this null from the static::$null
+                        $default = [Type::T_KEYWORD, 'null'];
+                    } else {
+                        if (is_null($parser)) {
+                            $parser = $this->parserFactory(__METHOD__);
+                        }
+
+                        $parser->parseValue($p, $default);
+                    }
                 }
+
+                $isVariable = false;
+
+                if (substr($name, -3) === '...') {
+                    $isVariable = true;
+                    $name = substr($name, 0, -3);
+                }
+
+                $argDef[] = [$name, $default, $isVariable];
             }
+
+            try {
+                $vars = $this->applyArguments($argDef, $args, false);
+
+                // ensure all args are populated
+                foreach ($prototype as $i => $p) {
+                    $name = explode(':', $p)[0];
+
+                    if (! isset($finalArgs[$i])) {
+                        $finalArgs[$i] = null;
+                    }
+                }
+
+                // apply positional args
+                foreach (array_values($vars) as $i => $val) {
+                    $finalArgs[$i] = $val;
+                }
+
+                $keyArgs = array_merge($keyArgs, $vars);
+                $prototypeHasMatch = true;
+
+                // overwrite positional args with keyword args
+                foreach ($prototype as $i => $p) {
+                    $name = explode(':', $p)[0];
+
+                    if (isset($keyArgs[$name])) {
+                        $finalArgs[$i] = $keyArgs[$name];
+                    }
+
+                    // special null value as default: translate to real null here
+                    if ($finalArgs[$i] === [Type::T_KEYWORD, 'null']) {
+                        $finalArgs[$i] = null;
+                    }
+                }
+                // should we break if this prototype seems fulfilled?
+            } catch (CompilerException $e) {
+                $exceptionMessage = $e->getMessage();
+            }
+        }
+
+        if ($exceptionMessage && ! $prototypeHasMatch) {
+            $this->throwError($exceptionMessage);
         }
 
         return [$finalArgs, $keyArgs];
@@ -3738,12 +4603,16 @@ class Compiler
      *
      * @throws \Exception
      */
-    protected function applyArguments($argDef, $argValues)
+    protected function applyArguments($argDef, $argValues, $storeInEnv = true)
     {
-        $storeEnv = $this->getStoreEnv();
+        $output = [];
 
-        $env = new Environment;
-        $env->store = $storeEnv->store;
+        if ($storeInEnv) {
+            $storeEnv = $this->getStoreEnv();
+
+            $env = new Environment;
+            $env->store = $storeEnv->store;
+        }
 
         $hasVariable = false;
         $args = [];
@@ -3755,14 +4624,18 @@ class Compiler
             $hasVariable |= $isVariable;
         }
 
-        $keywordArgs = [];
+        $splatSeparator      = null;
+        $keywordArgs         = [];
         $deferredKeywordArgs = [];
-        $remaining = [];
+        $remaining           = [];
+        $hasKeywordArgument  = false;
 
         // assign the keyword args
         foreach ((array) $argValues as $arg) {
             if (! empty($arg[0])) {
-                if (! isset($args[$arg[0][1]])) {
+                $hasKeywordArgument = true;
+
+                if (! isset($args[$arg[0][1]]) || $args[$arg[0][1]][3]) {
                     if ($hasVariable) {
                         $deferredKeywordArgs[$arg[0][1]] = $arg[1];
                     } else {
@@ -3775,17 +4648,30 @@ class Compiler
                 } else {
                     $keywordArgs[$arg[0][1]] = $arg[1];
                 }
-            } elseif (count($keywordArgs)) {
-                $this->throwError('Positional arguments must come before keyword arguments.');
-                break;
             } elseif ($arg[2] === true) {
                 $val = $this->reduce($arg[1], true);
 
                 if ($val[0] === Type::T_LIST) {
                     foreach ($val[2] as $name => $item) {
                         if (! is_numeric($name)) {
-                            $keywordArgs[$name] = $item;
+                            if (!isset($args[$name])) {
+                                foreach (array_keys($args) as $an) {
+                                    if (str_replace("_", "-", $an) === str_replace("_", "-", $name)) {
+                                        $name = $an;
+                                        break;
+                                    }
+                                }
+                            }
+
+                            if ($hasVariable) {
+                                $deferredKeywordArgs[$name] = $item;
+                            } else {
+                                $keywordArgs[$name] = $item;
+                            }
                         } else {
+                            if (is_null($splatSeparator)) {
+                                $splatSeparator = $val[1];
+                            }
                             $remaining[] = $item;
                         }
                     }
@@ -3795,14 +4681,32 @@ class Compiler
                         $item = $val[2][$i];
 
                         if (! is_numeric($name)) {
-                            $keywordArgs[$name] = $item;
+                            if (!isset($args[$name])) {
+                                foreach (array_keys($args) as $an) {
+                                    if (str_replace("_", "-", $an) === str_replace("_", "-", $name)) {
+                                        $name = $an;
+                                        break;
+                                    }
+                                }
+                            }
+                            if ($hasVariable) {
+                                $deferredKeywordArgs[$name] = $item;
+                            } else {
+                                $keywordArgs[$name] = $item;
+                            }
                         } else {
+                            if (is_null($splatSeparator)) {
+                                $splatSeparator = $val[1];
+                            }
                             $remaining[] = $item;
                         }
                     }
                 } else {
                     $remaining[] = $val;
                 }
+            } elseif ($hasKeywordArgument) {
+                $this->throwError('Positional arguments must come before keyword arguments.');
+                break;
             } else {
                 $remaining[] = $arg[1];
             }
@@ -3812,7 +4716,7 @@ class Compiler
             list($i, $name, $default, $isVariable) = $arg;
 
             if ($isVariable) {
-                $val = [Type::T_LIST, ',', [], $isVariable];
+                $val = [Type::T_LIST, is_null($splatSeparator) ? ',' : $splatSeparator , [], $isVariable];
 
                 for ($count = count($remaining); $i < $count; $i++) {
                     $val[2][] = $remaining[$i];
@@ -3832,10 +4736,16 @@ class Compiler
                 break;
             }
 
-            $this->set($name, $this->reduce($val, true), true, $env);
+            if ($storeInEnv) {
+                $this->set($name, $this->reduce($val, true), true, $env);
+            } else {
+                $output[$name] = $val;
+            }
         }
 
-        $storeEnv->store = $env->store;
+        if ($storeInEnv) {
+            $storeEnv->store = $env->store;
+        }
 
         foreach ($args as $arg) {
             list($i, $name, $default, $isVariable) = $arg;
@@ -3844,8 +4754,14 @@ class Compiler
                 continue;
             }
 
-            $this->set($name, $this->reduce($default, true), true);
+            if ($storeInEnv) {
+                $this->set($name, $this->reduce($default, true), true);
+            } else {
+                $output[$name] = $default;
+            }
         }
+
+        return $output;
     }
 
     /**
@@ -3853,9 +4769,9 @@ class Compiler
      *
      * @param mixed $value
      *
-     * @return array|\Leafo\ScssPhp\Node\Number
+     * @return array|\ScssPhp\ScssPhp\Node\Number
      */
-    private function coerceValue($value)
+    protected function coerceValue($value)
     {
         if (is_array($value) || $value instanceof \ArrayAccess) {
             return $value;
@@ -3946,10 +4862,20 @@ class Compiler
                 $key = $keys[$i];
                 $value = $values[$i];
 
+                switch ($key[0]) {
+                    case Type::T_LIST:
+                    case Type::T_MAP:
+                        break;
+
+                    default:
+                        $key = [Type::T_KEYWORD, $this->compileStringContent($this->coerceString($key))];
+                        break;
+                }
+
                 $list[] = [
                     Type::T_LIST,
                     '',
-                    [[Type::T_KEYWORD, $this->compileStringContent($this->coerceString($key))], $value]
+                    [$key, $value]
                 ];
             }
 
@@ -4057,7 +4983,7 @@ class Compiler
         $value = $this->coerceMap($value);
 
         if ($value[0] !== Type::T_MAP) {
-            $this->throwError('expecting map');
+            $this->throwError('expecting map, %s received', $value[0]);
         }
 
         return $value;
@@ -4077,7 +5003,7 @@ class Compiler
     public function assertList($value)
     {
         if ($value[0] !== Type::T_LIST) {
-            $this->throwError('expecting list');
+            $this->throwError('expecting list, %s received', $value[0]);
         }
 
         return $value;
@@ -4100,7 +5026,7 @@ class Compiler
             return $color;
         }
 
-        $this->throwError('expecting color');
+        $this->throwError('expecting color, %s received', $value[0]);
     }
 
     /**
@@ -4117,7 +5043,7 @@ class Compiler
     public function assertNumber($value)
     {
         if ($value[0] !== Type::T_NUMBER) {
-            $this->throwError('expecting number');
+            $this->throwError('expecting number, %s received', $value[0]);
         }
 
         return $value[1];
@@ -4194,7 +5120,7 @@ class Compiler
      *
      * @return float
      */
-    private function hueToRGB($m1, $m2, $h)
+    protected function hueToRGB($m1, $m2, $h)
     {
         if ($h < 0) {
             $h += 1;
@@ -4252,28 +5178,27 @@ class Compiler
 
     // Built in functions
 
-    //protected static $libCall = ['name', 'args...'];
+    protected static $libCall = ['name', 'args...'];
     protected function libCall($args, $kwargs)
     {
         $name = $this->compileStringContent($this->coerceString($this->reduce(array_shift($args), true)));
+        $callArgs = [];
 
-        $args = array_map(
-            function ($a) {
-                return [null, $a, false];
-            },
-            $args
-        );
-
-        if (count($kwargs)) {
-            foreach ($kwargs as $key => $value) {
-                $args[] = [[Type::T_VARIABLE, $key], $value, false];
+        // $kwargs['args'] is [Type::T_LIST, ',', [..]]
+        foreach ($kwargs['args'][2] as $varname => $arg) {
+            if (is_numeric($varname)) {
+                $varname = null;
+            } else {
+                $varname = [ 'var', $varname];
             }
+
+            $callArgs[] = [$varname, $arg, false];
         }
 
-        return $this->reduce([Type::T_FUNCTION_CALL, $name, $args]);
+        return $this->reduce([Type::T_FUNCTION_CALL, $name, $callArgs]);
     }
 
-    protected static $libIf = ['condition', 'if-true', 'if-false'];
+    protected static $libIf = ['condition', 'if-true', 'if-false:'];
     protected function libIf($args)
     {
         list($cond, $t, $f) = $args;
@@ -4326,12 +5251,12 @@ class Compiler
     }
 
     protected static $libRgba = [
-        ['red', 'color'],
-        'green', 'blue', 'alpha'];
+        ['color', 'alpha:1'],
+        ['red', 'green', 'blue', 'alpha:1'] ];
     protected function libRgba($args)
     {
         if ($color = $this->coerceColor($args[0])) {
-            $num = ! isset($args[1]) ? $args[3] : $args[1];
+            $num = isset($args[3]) ? $args[3] : $args[1];
             $alpha = $this->assertNumber($num);
             $color[4] = $alpha;
 
@@ -4356,11 +5281,11 @@ class Compiler
             }
         }
 
-        if (isset($args[4]) || isset($args[5]) || isset($args[6])) {
+        if (! empty($args[4]) || ! empty($args[5]) || ! empty($args[6])) {
             $hsl = $this->toHSL($color[1], $color[2], $color[3]);
 
             foreach ([4, 5, 6] as $i) {
-                if (isset($args[$i])) {
+                if (! empty($args[$i])) {
                     $val = $this->assertNumber($args[$i]);
                     $hsl[$i - 3] = call_user_func($fn, $hsl[$i - 3], $val, $i);
                 }
@@ -4379,8 +5304,8 @@ class Compiler
     }
 
     protected static $libAdjustColor = [
-        'color', 'red', 'green', 'blue',
-        'hue', 'saturation', 'lightness', 'alpha'
+        'color', 'red:null', 'green:null', 'blue:null',
+        'hue:null', 'saturation:null', 'lightness:null', 'alpha:null'
     ];
     protected function libAdjustColor($args)
     {
@@ -4390,8 +5315,8 @@ class Compiler
     }
 
     protected static $libChangeColor = [
-        'color', 'red', 'green', 'blue',
-        'hue', 'saturation', 'lightness', 'alpha'
+        'color', 'red:null', 'green:null', 'blue:null',
+        'hue:null', 'saturation:null', 'lightness:null', 'alpha:null'
     ];
     protected function libChangeColor($args)
     {
@@ -4401,8 +5326,8 @@ class Compiler
     }
 
     protected static $libScaleColor = [
-        'color', 'red', 'green', 'blue',
-        'hue', 'saturation', 'lightness', 'alpha'
+        'color', 'red:null', 'green:null', 'blue:null',
+        'hue:null', 'saturation:null', 'lightness:null', 'alpha:null'
     ];
     protected function libScaleColor($args)
     {
@@ -4496,7 +5421,7 @@ class Compiler
     }
 
     // mix two colors
-    protected static $libMix = ['color-1', 'color-2', 'weight'];
+    protected static $libMix = ['color-1', 'color-2', 'weight:0.5'];
     protected function libMix($args)
     {
         list($first, $second, $weight) = $args;
@@ -4526,7 +5451,7 @@ class Compiler
         ];
 
         if ($firstAlpha != 1.0 || $secondAlpha != 1.0) {
-            $new[] = $firstAlpha * $weight + $secondAlpha * ($weight - 1);
+            $new[] = $firstAlpha * $weight + $secondAlpha * (1 - $weight);
         }
 
         return $this->fixColor($new);
@@ -4618,7 +5543,7 @@ class Compiler
         return $this->adjustHsl($color, 3, -$amount);
     }
 
-    protected static $libSaturate = ['color', 'amount'];
+    protected static $libSaturate = [['color', 'amount'], ['number']];
     protected function libSaturate($args)
     {
         $value = $args[0];
@@ -4829,7 +5754,7 @@ class Compiler
             if (null === $unit) {
                 $unit = $number[2];
                 $originalUnit = $item->unitStr();
-            } elseif ($unit !== $number[2]) {
+            } elseif ($number[1] && $unit !== $number[2]) {
                 $this->throwError('Incompatible units: "%s" and "%s".', $originalUnit, $item->unitStr());
                 break;
             }
@@ -4898,7 +5823,7 @@ class Compiler
         if (! isset($list[2][$n])) {
             $this->throwError('Invalid argument for "n"');
 
-            return;
+            return null;
         }
 
         $list[2][$n] = $args[2];
@@ -4910,11 +5835,14 @@ class Compiler
     protected function libMapGet($args)
     {
         $map = $this->assertMap($args[0]);
-        $key = $this->compileStringContent($this->coerceString($args[1]));
+        $key = $args[1];
 
-        for ($i = count($map[1]) - 1; $i >= 0; $i--) {
-            if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) {
-                return $map[2][$i];
+        if (! is_null($key)) {
+            $key = $this->compileStringContent($this->coerceString($key));
+            for ($i = count($map[1]) - 1; $i >= 0; $i--) {
+                if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) {
+                    return $map[2][$i];
+                }
             }
         }
 
@@ -4976,7 +5904,21 @@ class Compiler
         $map1 = $this->assertMap($args[0]);
         $map2 = $this->assertMap($args[1]);
 
-        return [Type::T_MAP, array_merge($map1[1], $map2[1]), array_merge($map1[2], $map2[2])];
+        foreach ($map2[1] as $i2 => $key2) {
+            $key = $this->compileStringContent($this->coerceString($key2));
+
+            foreach ($map1[1] as $i1 => $key1) {
+                if ($key === $this->compileStringContent($this->coerceString($key1))) {
+                    $map1[2][$i1] = $map2[2][$i2];
+                    continue 2;
+                }
+            }
+
+            $map1[1][] = $map2[1][$i2];
+            $map1[2][] = $map2[2][$i2];
+        }
+
+        return $map1;
     }
 
     protected static $libKeywords = ['args'];
@@ -5013,7 +5955,7 @@ class Compiler
         }
     }
 
-    protected static $libJoin = ['list1', 'list2', 'separator'];
+    protected static $libJoin = ['list1', 'list2', 'separator:null'];
     protected function libJoin($args)
     {
         list($list1, $list2, $sep) = $args;
@@ -5025,7 +5967,7 @@ class Compiler
         return [Type::T_LIST, $sep, array_merge($list1[2], $list2[2])];
     }
 
-    protected static $libAppend = ['list', 'val', 'separator'];
+    protected static $libAppend = ['list', 'val', 'separator:null'];
     protected function libAppend($args)
     {
         list($list1, $value, $sep) = $args;
@@ -5122,7 +6064,7 @@ class Compiler
         ) {
             $this->throwError('Invalid argument(s) for "comparable"');
 
-            return;
+            return null;
         }
 
         $number1 = $number1->normalize();
@@ -5170,7 +6112,7 @@ class Compiler
         return new Node\Number(strlen($stringContent), '');
     }
 
-    protected static $libStrSlice = ['string', 'start-at', 'end-at'];
+    protected static $libStrSlice = ['string', 'start-at', 'end-at:null'];
     protected function libStrSlice($args)
     {
         if (isset($args[2]) && $args[2][1] == 0) {
@@ -5302,7 +6244,7 @@ class Compiler
             if ($n < 1) {
                 $this->throwError("limit must be greater than or equal to 1");
 
-                return;
+                return null;
             }
 
             return new Node\Number(mt_rand(1, $n), '');
@@ -5333,4 +6275,630 @@ class Compiler
 
         return $args[0];
     }
+
+    /**
+     * Preprocess selector args
+     *
+     * @param array $arg
+     *
+     * @return array|boolean
+     */
+    protected function getSelectorArg($arg)
+    {
+        static $parser = null;
+
+        if (is_null($parser)) {
+            $parser = $this->parserFactory(__METHOD__);
+        }
+
+        $arg = $this->libUnquote([$arg]);
+        $arg = $this->compileValue($arg);
+
+        $parsedSelector = [];
+
+        if ($parser->parseSelector($arg, $parsedSelector)) {
+            $selector = $this->evalSelectors($parsedSelector);
+            $gluedSelector = $this->glueFunctionSelectors($selector);
+
+            return $gluedSelector;
+        }
+
+        return false;
+    }
+
+    /**
+     * Postprocess selector to output in right format
+     *
+     * @param array $selectors
+     *
+     * @return string
+     */
+    protected function formatOutputSelector($selectors)
+    {
+        $selectors = $this->collapseSelectors($selectors, true);
+
+        return $selectors;
+    }
+
+    protected static $libIsSuperselector = ['super', 'sub'];
+    protected function libIsSuperselector($args)
+    {
+        list($super, $sub) = $args;
+
+        $super = $this->getSelectorArg($super);
+        $sub = $this->getSelectorArg($sub);
+
+        return $this->isSuperSelector($super, $sub);
+    }
+
+    /**
+     * Test a $super selector again $sub
+     *
+     * @param array $super
+     * @param array $sub
+     *
+     * @return boolean
+     */
+    protected function isSuperSelector($super, $sub)
+    {
+        // one and only one selector for each arg
+        if (! $super || count($super) !== 1) {
+            $this->throwError("Invalid super selector for isSuperSelector()");
+        }
+
+        if (! $sub || count($sub) !== 1) {
+            $this->throwError("Invalid sub selector for isSuperSelector()");
+        }
+
+        $super = reset($super);
+        $sub = reset($sub);
+
+        $i = 0;
+        $nextMustMatch = false;
+
+        foreach ($super as $node) {
+            $compound = '';
+
+            array_walk_recursive(
+                $node,
+                function ($value, $key) use (&$compound) {
+                    $compound .= $value;
+                }
+            );
+
+            if ($this->isImmediateRelationshipCombinator($compound)) {
+                if ($node !== $sub[$i]) {
+                    return false;
+                }
+
+                $nextMustMatch = true;
+                $i++;
+            } else {
+                while ($i < count($sub) && ! $this->isSuperPart($node, $sub[$i])) {
+                    if ($nextMustMatch) {
+                        return false;
+                    }
+
+                    $i++;
+                }
+
+                if ($i >= count($sub)) {
+                    return false;
+                }
+
+                $nextMustMatch = false;
+                $i++;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Test a part of super selector again a part of sub selector
+     *
+     * @param array $superParts
+     * @param array $subParts
+     *
+     * @return boolean
+     */
+    protected function isSuperPart($superParts, $subParts)
+    {
+        $i = 0;
+
+        foreach ($superParts as $superPart) {
+            while ($i < count($subParts) && $subParts[$i] !== $superPart) {
+                $i++;
+            }
+
+            if ($i >= count($subParts)) {
+                return false;
+            }
+
+            $i++;
+        }
+
+        return true;
+    }
+
+    protected static $libSelectorAppend = ['selector...'];
+    protected function libSelectorAppend($args)
+    {
+        // get the selector... list
+        $args = reset($args);
+        $args = $args[2];
+        if (count($args) < 1) {
+            $this->throwError("selector-append() needs at least 1 argument");
+        }
+
+        $selectors = array_map([$this, 'getSelectorArg'], $args);
+
+        return $this->formatOutputSelector($this->selectorAppend($selectors));
+    }
+
+    /**
+     * Append parts of the last selector in the list to the previous, recursively
+     *
+     * @param array $selectors
+     *
+     * @return array
+     *
+     * @throws \ScssPhp\ScssPhp\Exception\CompilerException
+     */
+    protected function selectorAppend($selectors)
+    {
+        $lastSelectors = array_pop($selectors);
+
+        if (! $lastSelectors) {
+            $this->throwError("Invalid selector list in selector-append()");
+        }
+
+        while (count($selectors)) {
+            $previousSelectors = array_pop($selectors);
+
+            if (! $previousSelectors) {
+                $this->throwError("Invalid selector list in selector-append()");
+            }
+
+            // do the trick, happening $lastSelector to $previousSelector
+            $appended = [];
+
+            foreach ($lastSelectors as $lastSelector) {
+                $previous = $previousSelectors;
+
+                foreach ($lastSelector as $lastSelectorParts) {
+                    foreach ($lastSelectorParts as $lastSelectorPart) {
+                        foreach ($previous as $i => $previousSelector) {
+                            foreach ($previousSelector as $j => $previousSelectorParts) {
+                                $previous[$i][$j][] = $lastSelectorPart;
+                            }
+                        }
+                    }
+                }
+
+                foreach ($previous as $ps) {
+                    $appended[] = $ps;
+                }
+            }
+
+            $lastSelectors = $appended;
+        }
+
+        return $lastSelectors;
+    }
+
+    protected static $libSelectorExtend = ['selectors', 'extendee', 'extender'];
+    protected function libSelectorExtend($args)
+    {
+        list($selectors, $extendee, $extender) = $args;
+
+        $selectors = $this->getSelectorArg($selectors);
+        $extendee = $this->getSelectorArg($extendee);
+        $extender = $this->getSelectorArg($extender);
+
+        if (! $selectors || ! $extendee || ! $extender) {
+            $this->throwError("selector-extend() invalid arguments");
+        }
+
+        $extended = $this->extendOrReplaceSelectors($selectors, $extendee, $extender);
+
+        return $this->formatOutputSelector($extended);
+    }
+
+    protected static $libSelectorReplace = ['selectors', 'original', 'replacement'];
+    protected function libSelectorReplace($args)
+    {
+        list($selectors, $original, $replacement) = $args;
+
+        $selectors = $this->getSelectorArg($selectors);
+        $original = $this->getSelectorArg($original);
+        $replacement = $this->getSelectorArg($replacement);
+
+        if (! $selectors || ! $original || ! $replacement) {
+            $this->throwError("selector-replace() invalid arguments");
+        }
+
+        $replaced = $this->extendOrReplaceSelectors($selectors, $original, $replacement, true);
+
+        return $this->formatOutputSelector($replaced);
+    }
+
+    /**
+     * Extend/replace in selectors
+     * used by selector-extend and selector-replace that use the same logic
+     *
+     * @param array   $selectors
+     * @param array   $extendee
+     * @param array   $extender
+     * @param boolean $replace
+     *
+     * @return array
+     */
+    protected function extendOrReplaceSelectors($selectors, $extendee, $extender, $replace = false)
+    {
+        $saveExtends = $this->extends;
+        $saveExtendsMap = $this->extendsMap;
+
+        $this->extends = [];
+        $this->extendsMap = [];
+
+        foreach ($extendee as $es) {
+            // only use the first one
+            $this->pushExtends(reset($es), $extender, null);
+        }
+
+        $extended = [];
+
+        foreach ($selectors as $selector) {
+            if (! $replace) {
+                $extended[] = $selector;
+            }
+
+            $n = count($extended);
+
+            $this->matchExtends($selector, $extended);
+
+            // if didnt match, keep the original selector if we are in a replace operation
+            if ($replace and count($extended) === $n) {
+                $extended[] = $selector;
+            }
+        }
+
+        $this->extends = $saveExtends;
+        $this->extendsMap = $saveExtendsMap;
+
+        return $extended;
+    }
+
+    protected static $libSelectorNest = ['selector...'];
+    protected function libSelectorNest($args)
+    {
+        // get the selector... list
+        $args = reset($args);
+        $args = $args[2];
+        if (count($args) < 1) {
+            $this->throwError("selector-nest() needs at least 1 argument");
+        }
+
+        $selectorsMap = array_map([$this, 'getSelectorArg'], $args);
+
+        $envs = [];
+        foreach ($selectorsMap as $selectors) {
+            $env = new Environment();
+            $env->selectors = $selectors;
+
+            $envs[] = $env;
+        }
+
+        $envs = array_reverse($envs);
+        $env = $this->extractEnv($envs);
+        $outputSelectors = $this->multiplySelectors($env);
+
+        return $this->formatOutputSelector($outputSelectors);
+    }
+
+    protected static $libSelectorParse = ['selectors'];
+    protected function libSelectorParse($args)
+    {
+        $selectors = reset($args);
+        $selectors = $this->getSelectorArg($selectors);
+
+        return $this->formatOutputSelector($selectors);
+    }
+
+    protected static $libSelectorUnify = ['selectors1', 'selectors2'];
+    protected function libSelectorUnify($args)
+    {
+        list($selectors1, $selectors2) = $args;
+
+        $selectors1 = $this->getSelectorArg($selectors1);
+        $selectors2 = $this->getSelectorArg($selectors2);
+
+        if (! $selectors1 || ! $selectors2) {
+            $this->throwError("selector-unify() invalid arguments");
+        }
+
+        // only consider the first compound of each
+        $compound1 = reset($selectors1);
+        $compound2 = reset($selectors2);
+
+        // unify them and that's it
+        $unified = $this->unifyCompoundSelectors($compound1, $compound2);
+
+        return $this->formatOutputSelector($unified);
+    }
+
+    /**
+     * The selector-unify magic as its best
+     * (at least works as expected on test cases)
+     *
+     * @param array $compound1
+     * @param array $compound2
+     * @return array|mixed
+     */
+    protected function unifyCompoundSelectors($compound1, $compound2)
+    {
+        if (! count($compound1)) {
+            return $compound2;
+        }
+
+        if (! count($compound2)) {
+            return $compound1;
+        }
+
+        // check that last part are compatible
+        $lastPart1 = array_pop($compound1);
+        $lastPart2 = array_pop($compound2);
+        $last = $this->mergeParts($lastPart1, $lastPart2);
+
+        if (! $last) {
+            return [[]];
+        }
+
+        $unifiedCompound = [$last];
+        $unifiedSelectors = [$unifiedCompound];
+
+        // do the rest
+        while (count($compound1) || count($compound2)) {
+            $part1 = end($compound1);
+            $part2 = end($compound2);
+
+            if ($part1 && ($match2 = $this->matchPartInCompound($part1, $compound2))) {
+                list($compound2, $part2, $after2) = $match2;
+
+                if ($after2) {
+                    $unifiedSelectors = $this->prependSelectors($unifiedSelectors, $after2);
+                }
+
+                $c = $this->mergeParts($part1, $part2);
+                $unifiedSelectors = $this->prependSelectors($unifiedSelectors, [$c]);
+                $part1 = $part2 = null;
+
+                array_pop($compound1);
+            }
+
+            if ($part2 && ($match1 = $this->matchPartInCompound($part2, $compound1))) {
+                list($compound1, $part1, $after1) = $match1;
+
+                if ($after1) {
+                    $unifiedSelectors = $this->prependSelectors($unifiedSelectors, $after1);
+                }
+
+                $c = $this->mergeParts($part2, $part1);
+                $unifiedSelectors = $this->prependSelectors($unifiedSelectors, [$c]);
+                $part1 = $part2 = null;
+
+                array_pop($compound2);
+            }
+
+            $new = [];
+
+            if ($part1 && $part2) {
+                array_pop($compound1);
+                array_pop($compound2);
+
+                $s = $this->prependSelectors($unifiedSelectors, [$part2]);
+                $new = array_merge($new, $this->prependSelectors($s, [$part1]));
+                $s = $this->prependSelectors($unifiedSelectors, [$part1]);
+                $new = array_merge($new, $this->prependSelectors($s, [$part2]));
+            } elseif ($part1) {
+                array_pop($compound1);
+
+                $new = array_merge($new, $this->prependSelectors($unifiedSelectors, [$part1]));
+            } elseif ($part2) {
+                array_pop($compound2);
+
+                $new = array_merge($new, $this->prependSelectors($unifiedSelectors, [$part2]));
+            }
+
+            if ($new) {
+                $unifiedSelectors = $new;
+            }
+        }
+
+        return $unifiedSelectors;
+    }
+
+    /**
+     * Prepend each selector from $selectors with $parts
+     *
+     * @param array $selectors
+     * @param array $parts
+     *
+     * @return array
+     */
+    protected function prependSelectors($selectors, $parts)
+    {
+        $new = [];
+
+        foreach ($selectors as $compoundSelector) {
+            array_unshift($compoundSelector, $parts);
+
+            $new[] = $compoundSelector;
+        }
+
+        return $new;
+    }
+
+    /**
+     * Try to find a matching part in a compound:
+     * - with same html tag name
+     * - with some class or id or something in common
+     *
+     * @param array $part
+     * @param array $compound
+     *
+     * @return array|boolean
+     */
+    protected function matchPartInCompound($part, $compound)
+    {
+        $partTag = $this->findTagName($part);
+        $before = $compound;
+        $after = [];
+
+        // try to find a match by tag name first
+        while (count($before)) {
+            $p = array_pop($before);
+
+            if ($partTag && $partTag !== '*' && $partTag == $this->findTagName($p)) {
+                return [$before, $p, $after];
+            }
+
+            $after[] = $p;
+        }
+
+        // try again matching a non empty intersection and a compatible tagname
+        $before = $compound;
+        $after = [];
+
+        while (count($before)) {
+            $p = array_pop($before);
+
+            if ($this->checkCompatibleTags($partTag, $this->findTagName($p))) {
+                if (count(array_intersect($part, $p))) {
+                    return [$before, $p, $after];
+                }
+            }
+
+            $after[] = $p;
+        }
+
+        return false;
+    }
+
+    /**
+     * Merge two part list taking care that
+     * - the html tag is coming first - if any
+     * - the :something are coming last
+     *
+     * @param array $parts1
+     * @param array $parts2
+     *
+     * @return array
+     */
+    protected function mergeParts($parts1, $parts2)
+    {
+        $tag1 = $this->findTagName($parts1);
+        $tag2 = $this->findTagName($parts2);
+        $tag = $this->checkCompatibleTags($tag1, $tag2);
+
+        // not compatible tags
+        if ($tag === false) {
+            return [];
+        }
+
+        if ($tag) {
+            if ($tag1) {
+                $parts1 = array_diff($parts1, [$tag1]);
+            }
+
+            if ($tag2) {
+                $parts2 = array_diff($parts2, [$tag2]);
+            }
+        }
+
+        $mergedParts = array_merge($parts1, $parts2);
+        $mergedOrderedParts = [];
+
+        foreach ($mergedParts as $part) {
+            if (strpos($part, ':') === 0) {
+                $mergedOrderedParts[] = $part;
+            }
+        }
+
+        $mergedParts = array_diff($mergedParts, $mergedOrderedParts);
+        $mergedParts = array_merge($mergedParts, $mergedOrderedParts);
+
+        if ($tag) {
+            array_unshift($mergedParts, $tag);
+        }
+
+        return $mergedParts;
+    }
+
+    /**
+     * Check the compatibility between two tag names:
+     * if both are defined they should be identical or one has to be '*'
+     *
+     * @param string $tag1
+     * @param string $tag2
+     *
+     * @return array|boolean
+     */
+    protected function checkCompatibleTags($tag1, $tag2)
+    {
+        $tags = [$tag1, $tag2];
+        $tags = array_unique($tags);
+        $tags = array_filter($tags);
+
+        if (count($tags)>1) {
+            $tags = array_diff($tags, ['*']);
+        }
+
+        // not compatible nodes
+        if (count($tags)>1) {
+            return false;
+        }
+
+        return $tags;
+    }
+
+    /**
+     * Find the html tag name in a selector parts list
+     *
+     * @param array $parts
+     *
+     * @return mixed|string
+     */
+    protected function findTagName($parts)
+    {
+        foreach ($parts as $part) {
+            if (! preg_match('/^[\[.:#%_-]/', $part)) {
+                return $part;
+            }
+        }
+
+        return '';
+    }
+
+    protected static $libSimpleSelectors = ['selector'];
+    protected function libSimpleSelectors($args)
+    {
+        $selector = reset($args);
+        $selector = $this->getSelectorArg($selector);
+
+        // remove selectors list layer, keeping the first one
+        $selector = reset($selector);
+
+        // remove parts list layer, keeping the first part
+        $part = reset($selector);
+
+        $listParts = [];
+
+        foreach ($part as $p) {
+            $listParts[] = [Type::T_STRING, '', [$p]];
+        }
+
+        return [Type::T_LIST, ',', $listParts];
+    }
 }
diff --git a/lib/scssphp/Compiler/Environment.php b/lib/scssphp/Compiler/Environment.php
index fe309dd30f8..03eb86a5d57 100644
--- a/lib/scssphp/Compiler/Environment.php
+++ b/lib/scssphp/Compiler/Environment.php
@@ -2,14 +2,14 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp\Compiler;
+namespace ScssPhp\ScssPhp\Compiler;
 
 /**
  * Compiler environment
@@ -19,12 +19,12 @@ namespace Leafo\ScssPhp\Compiler;
 class Environment
 {
     /**
-     * @var \Leafo\ScssPhp\Block
+     * @var \ScssPhp\ScssPhp\Block
      */
     public $block;
 
     /**
-     * @var \Leafo\ScssPhp\Compiler\Environment
+     * @var \ScssPhp\ScssPhp\Compiler\Environment
      */
     public $parent;
 
@@ -33,6 +33,11 @@ class Environment
      */
     public $store;
 
+    /**
+     * @var array
+     */
+    public $storeUnreduced;
+
     /**
      * @var integer
      */
diff --git a/lib/scssphp/Exception/CompilerException.php b/lib/scssphp/Exception/CompilerException.php
index 7ca2e2b3bb9..a9d134fca09 100644
--- a/lib/scssphp/Exception/CompilerException.php
+++ b/lib/scssphp/Exception/CompilerException.php
@@ -2,14 +2,14 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp\Exception;
+namespace ScssPhp\ScssPhp\Exception;
 
 /**
  * Compiler exception
diff --git a/lib/scssphp/Exception/ParserException.php b/lib/scssphp/Exception/ParserException.php
index 6d64335fe7c..2fa12dd7a8a 100644
--- a/lib/scssphp/Exception/ParserException.php
+++ b/lib/scssphp/Exception/ParserException.php
@@ -2,14 +2,14 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp\Exception;
+namespace ScssPhp\ScssPhp\Exception;
 
 /**
  * Parser Exception
diff --git a/lib/scssphp/Exception/RangeException.php b/lib/scssphp/Exception/RangeException.php
index 3ba6bf143b1..ee36c97e186 100644
--- a/lib/scssphp/Exception/RangeException.php
+++ b/lib/scssphp/Exception/RangeException.php
@@ -2,14 +2,14 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp\Exception;
+namespace ScssPhp\ScssPhp\Exception;
 
 /**
  * Range exception
diff --git a/lib/scssphp/Exception/ServerException.php b/lib/scssphp/Exception/ServerException.php
index d0ed0842739..d4a207aff8d 100644
--- a/lib/scssphp/Exception/ServerException.php
+++ b/lib/scssphp/Exception/ServerException.php
@@ -2,14 +2,14 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp\Exception;
+namespace ScssPhp\ScssPhp\Exception;
 
 /**
  * Server Exception
diff --git a/lib/scssphp/Formatter.php b/lib/scssphp/Formatter.php
index b4f90aa9d87..478aa6a56fd 100644
--- a/lib/scssphp/Formatter.php
+++ b/lib/scssphp/Formatter.php
@@ -2,17 +2,17 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp;
+namespace ScssPhp\ScssPhp;
 
-use Leafo\ScssPhp\Formatter\OutputBlock;
-use Leafo\ScssPhp\SourceMap\SourceMapGenerator;
+use ScssPhp\ScssPhp\Formatter\OutputBlock;
+use ScssPhp\ScssPhp\SourceMap\SourceMapGenerator;
 
 /**
  * Base formatter
@@ -62,7 +62,7 @@ abstract class Formatter
     public $keepSemicolons;
 
     /**
-     * @var \Leafo\ScssPhp\Formatter\OutputBlock
+     * @var \ScssPhp\ScssPhp\Formatter\OutputBlock
      */
     protected $currentBlock;
 
@@ -77,7 +77,7 @@ abstract class Formatter
     protected $currentColumn;
 
     /**
-     * @var \Leafo\ScssPhp\SourceMap\SourceMapGenerator
+     * @var \ScssPhp\ScssPhp\SourceMap\SourceMapGenerator
      */
     protected $sourceMapGenerator;
 
@@ -126,9 +126,7 @@ abstract class Formatter
             return;
         }
 
-        if (($count = count($lines))
-            && substr($lines[$count - 1], -1) === ';'
-        ) {
+        if (($count = count($lines)) && substr($lines[$count - 1], -1) === ';') {
             $lines[$count - 1] = substr($lines[$count - 1], 0, -1);
         }
     }
@@ -136,7 +134,7 @@ abstract class Formatter
     /**
      * Output lines inside a block
      *
-     * @param \Leafo\ScssPhp\Formatter\OutputBlock $block
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
      */
     protected function blockLines(OutputBlock $block)
     {
@@ -154,7 +152,7 @@ abstract class Formatter
     /**
      * Output block selectors
      *
-     * @param \Leafo\ScssPhp\Formatter\OutputBlock $block
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
      */
     protected function blockSelectors(OutputBlock $block)
     {
@@ -168,7 +166,7 @@ abstract class Formatter
     /**
      * Output block children
      *
-     * @param \Leafo\ScssPhp\Formatter\OutputBlock $block
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
      */
     protected function blockChildren(OutputBlock $block)
     {
@@ -180,7 +178,7 @@ abstract class Formatter
     /**
      * Output non-empty block
      *
-     * @param \Leafo\ScssPhp\Formatter\OutputBlock $block
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
      */
     protected function block(OutputBlock $block)
     {
@@ -217,13 +215,37 @@ abstract class Formatter
         }
     }
 
+    /**
+     * Test and clean safely empty children
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
+     * @return bool
+     */
+    protected function testEmptyChildren($block)
+    {
+        $isEmpty = empty($block->lines);
+
+        if ($block->children) {
+            foreach ($block->children as $k => &$child) {
+                if (! $this->testEmptyChildren($child)) {
+                    $isEmpty = false;
+                } else {
+                    if ($child->type === Type::T_MEDIA || $child->type === Type::T_DIRECTIVE) {
+                        $child->children = [];
+                        $child->selectors = null;
+                    }
+                }
+            }
+        }
+        return $isEmpty;
+    }
+
     /**
      * Entry point to formatting a block
      *
      * @api
      *
-     * @param \Leafo\ScssPhp\Formatter\OutputBlock             $block              An abstract syntax tree
-     * @param \Leafo\ScssPhp\SourceMap\SourceMapGenerator|null $sourceMapGenerator Optional source map generator
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock             $block              An abstract syntax tree
+     * @param \ScssPhp\ScssPhp\SourceMap\SourceMapGenerator|null $sourceMapGenerator Optional source map generator
      *
      * @return string
      */
@@ -237,6 +259,8 @@ abstract class Formatter
             $this->sourceMapGenerator = $sourceMapGenerator;
         }
 
+        $this->testEmptyChildren($block);
+
         ob_start();
 
         $this->block($block);
@@ -256,7 +280,8 @@ abstract class Formatter
                 $this->currentLine,
                 $this->currentColumn,
                 $this->currentBlock->sourceLine,
-                $this->currentBlock->sourceColumn - 1, //columns from parser are off by one
+                //columns from parser are off by one
+                $this->currentBlock->sourceColumn > 0 ? $this->currentBlock->sourceColumn - 1 : 0,
                 $this->currentBlock->sourceName
             );
 
diff --git a/lib/scssphp/Formatter/Compact.php b/lib/scssphp/Formatter/Compact.php
index 4efa1a089a3..591f0c92ef9 100644
--- a/lib/scssphp/Formatter/Compact.php
+++ b/lib/scssphp/Formatter/Compact.php
@@ -2,16 +2,16 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp\Formatter;
+namespace ScssPhp\ScssPhp\Formatter;
 
-use Leafo\ScssPhp\Formatter;
+use ScssPhp\ScssPhp\Formatter;
 
 /**
  * Compact formatter
diff --git a/lib/scssphp/Formatter/Compressed.php b/lib/scssphp/Formatter/Compressed.php
index 1faa7e11e5d..ec4722eaf4b 100644
--- a/lib/scssphp/Formatter/Compressed.php
+++ b/lib/scssphp/Formatter/Compressed.php
@@ -2,17 +2,17 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp\Formatter;
+namespace ScssPhp\ScssPhp\Formatter;
 
-use Leafo\ScssPhp\Formatter;
-use Leafo\ScssPhp\Formatter\OutputBlock;
+use ScssPhp\ScssPhp\Formatter;
+use ScssPhp\ScssPhp\Formatter\OutputBlock;
 
 /**
  * Compressed formatter
@@ -59,4 +59,23 @@ class Compressed extends Formatter
             $this->write($this->break);
         }
     }
+
+    /**
+     * Output block selectors
+     *
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
+     */
+    protected function blockSelectors(OutputBlock $block)
+    {
+        $inner = $this->indentStr();
+
+        $this->write(
+            $inner
+            . implode(
+                $this->tagSeparator,
+                str_replace([' > ', ' + ', ' ~ '], ['>', '+', '~'], $block->selectors)
+            )
+            . $this->open . $this->break
+        );
+    }
 }
diff --git a/lib/scssphp/Formatter/Crunched.php b/lib/scssphp/Formatter/Crunched.php
index 42d77b5f784..51ccb516d84 100644
--- a/lib/scssphp/Formatter/Crunched.php
+++ b/lib/scssphp/Formatter/Crunched.php
@@ -2,17 +2,17 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp\Formatter;
+namespace ScssPhp\ScssPhp\Formatter;
 
-use Leafo\ScssPhp\Formatter;
-use Leafo\ScssPhp\Formatter\OutputBlock;
+use ScssPhp\ScssPhp\Formatter;
+use ScssPhp\ScssPhp\Formatter\OutputBlock;
 
 /**
  * Crunched formatter
@@ -57,4 +57,23 @@ class Crunched extends Formatter
             $this->write($this->break);
         }
     }
+
+    /**
+     * Output block selectors
+     *
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
+     */
+    protected function blockSelectors(OutputBlock $block)
+    {
+        $inner = $this->indentStr();
+
+        $this->write(
+            $inner
+            . implode(
+                $this->tagSeparator,
+                str_replace([' > ', ' + ', ' ~ '], ['>', '+', '~'], $block->selectors)
+            )
+            . $this->open . $this->break
+        );
+    }
 }
diff --git a/lib/scssphp/Formatter/Debug.php b/lib/scssphp/Formatter/Debug.php
index bfcbf41ad7f..94e70c815df 100644
--- a/lib/scssphp/Formatter/Debug.php
+++ b/lib/scssphp/Formatter/Debug.php
@@ -2,17 +2,17 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp\Formatter;
+namespace ScssPhp\ScssPhp\Formatter;
 
-use Leafo\ScssPhp\Formatter;
-use Leafo\ScssPhp\Formatter\OutputBlock;
+use ScssPhp\ScssPhp\Formatter;
+use ScssPhp\ScssPhp\Formatter\OutputBlock;
 
 /**
  * Debug formatter
diff --git a/lib/scssphp/Formatter/Expanded.php b/lib/scssphp/Formatter/Expanded.php
index d8c1e8879e8..8eec475878a 100644
--- a/lib/scssphp/Formatter/Expanded.php
+++ b/lib/scssphp/Formatter/Expanded.php
@@ -2,17 +2,17 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp\Formatter;
+namespace ScssPhp\ScssPhp\Formatter;
 
-use Leafo\ScssPhp\Formatter;
-use Leafo\ScssPhp\Formatter\OutputBlock;
+use ScssPhp\ScssPhp\Formatter;
+use ScssPhp\ScssPhp\Formatter\OutputBlock;
 
 /**
  * Expanded formatter
diff --git a/lib/scssphp/Formatter/Nested.php b/lib/scssphp/Formatter/Nested.php
index 8f72206fd16..50a70ce6ae7 100644
--- a/lib/scssphp/Formatter/Nested.php
+++ b/lib/scssphp/Formatter/Nested.php
@@ -2,17 +2,18 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp\Formatter;
+namespace ScssPhp\ScssPhp\Formatter;
 
-use Leafo\ScssPhp\Formatter;
-use Leafo\ScssPhp\Formatter\OutputBlock;
+use ScssPhp\ScssPhp\Formatter;
+use ScssPhp\ScssPhp\Formatter\OutputBlock;
+use ScssPhp\ScssPhp\Type;
 
 /**
  * Nested formatter
@@ -67,44 +68,17 @@ class Nested extends Formatter
         }
 
         $this->write($inner . implode($glue, $block->lines));
-
-        if (! empty($block->children)) {
-            $this->write($this->break);
-        }
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    protected function blockSelectors(OutputBlock $block)
+    protected function hasFlatChild($block)
     {
-        $inner = $this->indentStr();
-
-        $this->write($inner
-            . implode($this->tagSeparator, $block->selectors)
-            . $this->open . $this->break);
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    protected function blockChildren(OutputBlock $block)
-    {
-        foreach ($block->children as $i => $child) {
-            $this->block($child);
-
-            if ($i < count($block->children) - 1) {
-                $this->write($this->break);
-
-                if (isset($block->children[$i + 1])) {
-                    $next = $block->children[$i + 1];
-
-                    if ($next->depth === max($block->depth, 1) && $child->depth >= $next->depth) {
-                        $this->write($this->break);
-                    }
-                }
+        foreach ($block->children as $child) {
+            if (empty($child->selectors)) {
+                return true;
             }
         }
+
+        return false;
     }
 
     /**
@@ -112,8 +86,38 @@ class Nested extends Formatter
      */
     protected function block(OutputBlock $block)
     {
+        static $depths;
+        static $downLevel;
+        static $closeBlock;
+        static $previousEmpty;
+        static $previousHasSelector;
+
         if ($block->type === 'root') {
-            $this->adjustAllChildren($block);
+            $depths = [ 0 ];
+            $downLevel = '';
+            $closeBlock = '';
+            $this->depth = 0;
+            $previousEmpty = false;
+            $previousHasSelector = false;
+        }
+
+        $isMediaOrDirective = in_array($block->type, [Type::T_DIRECTIVE, Type::T_MEDIA]);
+        $isSupport = ($block->type === Type::T_DIRECTIVE
+            && $block->selectors && strpos(implode('', $block->selectors), '@supports') !== false);
+
+        while ($block->depth < end($depths) || ($block->depth == 1 && end($depths) == 1)) {
+            array_pop($depths);
+            $this->depth--;
+
+            if (!$this->depth && ($block->depth <= 1 || (!$this->indentLevel && $block->type === Type::T_COMMENT)) &&
+                (($block->selectors && ! $isMediaOrDirective) || $previousHasSelector)
+            ) {
+                $downLevel = $this->break;
+            }
+
+            if (empty($block->lines) && empty($block->children)) {
+                $previousEmpty = true;
+            }
         }
 
         if (empty($block->lines) && empty($block->children)) {
@@ -122,80 +126,87 @@ class Nested extends Formatter
 
         $this->currentBlock = $block;
 
+        if (! empty($block->lines) || (! empty($block->children) && ($this->depth < 1 || $isSupport))) {
+            if ($block->depth > end($depths)) {
+                if (! $previousEmpty || $this->depth < 1) {
+                    $this->depth++;
+                    $depths[] = $block->depth;
+                } else {
+                    // keep the current depth unchanged but take the block depth as a new reference for following blocks
+                    array_pop($depths);
+                    $depths[] = $block->depth;
+                }
+            }
+        }
 
-        $this->depth = $block->depth;
+        $previousEmpty = ($block->type === Type::T_COMMENT);
+        $previousHasSelector = false;
 
         if (! empty($block->selectors)) {
+            if ($closeBlock) {
+                $this->write($closeBlock);
+                $closeBlock = '';
+            }
+
+            if ($downLevel) {
+                $this->write($downLevel);
+                $downLevel = '';
+            }
+
             $this->blockSelectors($block);
 
             $this->indentLevel++;
         }
 
         if (! empty($block->lines)) {
+            if ($closeBlock) {
+                $this->write($closeBlock);
+                $closeBlock = '';
+            }
+
+            if ($downLevel) {
+                $this->write($downLevel);
+                $downLevel = '';
+            }
+
             $this->blockLines($block);
+            $closeBlock = $this->break;
         }
 
         if (! empty($block->children)) {
-            $this->blockChildren($block);
+            if ($this->depth>0 && ($isMediaOrDirective || ! $this->hasFlatChild($block))) {
+                array_pop($depths);
+                $this->depth--;
+                $this->blockChildren($block);
+                $this->depth++;
+                $depths[] = $block->depth;
+            } else {
+                $this->blockChildren($block);
+            }
+        }
+
+        // reclear to not be spoiled by children if T_DIRECTIVE
+        if ($block->type === Type::T_DIRECTIVE) {
+            $previousHasSelector = false;
         }
 
         if (! empty($block->selectors)) {
             $this->indentLevel--;
 
             $this->write($this->close);
+            $closeBlock = $this->break;
+
+            if ($this->depth > 1 && ! empty($block->children)) {
+                array_pop($depths);
+                $this->depth--;
+            }
+            if (! $isMediaOrDirective) {
+                $previousHasSelector = true;
+            }
         }
 
         if ($block->type === 'root') {
             $this->write($this->break);
         }
     }
-
-    /**
-     * Adjust the depths of all children, depth first
-     *
-     * @param \Leafo\ScssPhp\Formatter\OutputBlock $block
-     */
-    private function adjustAllChildren(OutputBlock $block)
-    {
-        // flatten empty nested blocks
-        $children = [];
-
-        foreach ($block->children as $i => $child) {
-            if (empty($child->lines) && empty($child->children)) {
-                if (isset($block->children[$i + 1])) {
-                    $block->children[$i + 1]->depth = $child->depth;
-                }
-
-                continue;
-            }
-
-            $children[] = $child;
-        }
-
-        $count = count($children);
-
-        for ($i = 0; $i < $count; $i++) {
-            $depth = $children[$i]->depth;
-            $j = $i + 1;
-
-            if (isset($children[$j]) && $depth < $children[$j]->depth) {
-                $childDepth = $children[$j]->depth;
-
-                for (; $j < $count; $j++) {
-                    if ($depth < $children[$j]->depth && $childDepth >= $children[$j]->depth) {
-                        $children[$j]->depth = $depth + 1;
-                    }
-                }
-            }
-        }
-
-        $block->children = $children;
-
-        // make relative to parent
-        foreach ($block->children as $child) {
-            $this->adjustAllChildren($child);
-
-            $child->depth = $child->depth - $block->depth;
-        }
-    }
 }
diff --git a/lib/scssphp/Formatter/OutputBlock.php b/lib/scssphp/Formatter/OutputBlock.php
index 5eb589c9459..3e6fd9289d1 100644
--- a/lib/scssphp/Formatter/OutputBlock.php
+++ b/lib/scssphp/Formatter/OutputBlock.php
@@ -2,14 +2,14 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp\Formatter;
+namespace ScssPhp\ScssPhp\Formatter;
 
 /**
  * Output block
@@ -44,7 +44,7 @@ class OutputBlock
     public $children;
 
     /**
-     * @var \Leafo\ScssPhp\Formatter\OutputBlock
+     * @var \ScssPhp\ScssPhp\Formatter\OutputBlock
      */
     public $parent;
 
diff --git a/lib/scssphp/LICENSE.md b/lib/scssphp/LICENSE.md
index 2f5412f9b53..afcfdfb264e 100644
--- a/lib/scssphp/LICENSE.md
+++ b/lib/scssphp/LICENSE.md
@@ -1,4 +1,4 @@
-Copyright (c) 2015 Leaf Corcoran, http://leafo.github.io/scssphp
+Copyright (c) 2015 Leaf Corcoran, http://scssphp.github.io/scssphp
  
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/lib/scssphp/Node.php b/lib/scssphp/Node.php
index b9f7945a353..dab565a63c1 100644
--- a/lib/scssphp/Node.php
+++ b/lib/scssphp/Node.php
@@ -2,14 +2,14 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp;
+namespace ScssPhp\ScssPhp;
 
 /**
  * Base node
diff --git a/lib/scssphp/Node/Number.php b/lib/scssphp/Node/Number.php
index 42c168037fa..1e83bf8ce9c 100644
--- a/lib/scssphp/Node/Number.php
+++ b/lib/scssphp/Node/Number.php
@@ -2,18 +2,18 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp\Node;
+namespace ScssPhp\ScssPhp\Node;
 
-use Leafo\ScssPhp\Compiler;
-use Leafo\ScssPhp\Node;
-use Leafo\ScssPhp\Type;
+use ScssPhp\ScssPhp\Compiler;
+use ScssPhp\ScssPhp\Node;
+use ScssPhp\ScssPhp\Type;
 
 /**
  * Dimension + optional units
@@ -100,7 +100,7 @@ class Number extends Node implements \ArrayAccess
      *
      * @param array $units
      *
-     * @return \Leafo\ScssPhp\Node\Number
+     * @return \ScssPhp\ScssPhp\Node\Number
      */
     public function coerce($units)
     {
@@ -123,7 +123,7 @@ class Number extends Node implements \ArrayAccess
     /**
      * Normalize number
      *
-     * @return \Leafo\ScssPhp\Node\Number
+     * @return \ScssPhp\ScssPhp\Node\Number
      */
     public function normalize()
     {
@@ -148,10 +148,10 @@ class Number extends Node implements \ArrayAccess
             return $this->sourceLine !== null;
         }
 
-        if ($offset === -1
-            || $offset === 0
-            || $offset === 1
-            || $offset === 2
+        if ($offset === -1 ||
+            $offset === 0 ||
+            $offset === 1 ||
+            $offset === 2
         ) {
             return true;
         }
@@ -259,7 +259,7 @@ class Number extends Node implements \ArrayAccess
     /**
      * Output number
      *
-     * @param \Leafo\ScssPhp\Compiler $compiler
+     * @param \ScssPhp\ScssPhp\Compiler $compiler
      *
      * @return string
      */
diff --git a/lib/scssphp/Parser.php b/lib/scssphp/Parser.php
index 6fdea3e262f..ed9b28fafc8 100644
--- a/lib/scssphp/Parser.php
+++ b/lib/scssphp/Parser.php
@@ -2,20 +2,21 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp;
+namespace ScssPhp\ScssPhp;
 
-use Leafo\ScssPhp\Block;
-use Leafo\ScssPhp\Compiler;
-use Leafo\ScssPhp\Exception\ParserException;
-use Leafo\ScssPhp\Node;
-use Leafo\ScssPhp\Type;
+use ScssPhp\ScssPhp\Block;
+use ScssPhp\ScssPhp\Cache;
+use ScssPhp\ScssPhp\Compiler;
+use ScssPhp\ScssPhp\Exception\ParserException;
+use ScssPhp\ScssPhp\Node;
+use ScssPhp\ScssPhp\Type;
 
 /**
  * Parser
@@ -53,6 +54,8 @@ class Parser
     protected static $operatorPattern;
     protected static $whitePattern;
 
+    protected $cache;
+
     private $sourceName;
     private $sourceIndex;
     private $sourcePositions;
@@ -61,27 +64,32 @@ class Parser
     private $env;
     private $inParens;
     private $eatWhiteDefault;
+    private $discardComments;
     private $buffer;
     private $utf8;
     private $encoding;
     private $patternModifiers;
+    private $commentsSeen;
 
     /**
      * Constructor
      *
      * @api
      *
-     * @param string  $sourceName
-     * @param integer $sourceIndex
-     * @param string  $encoding
+     * @param string                 $sourceName
+     * @param integer                $sourceIndex
+     * @param string                 $encoding
+     * @param \ScssPhp\ScssPhp\Cache $cache
      */
-    public function __construct($sourceName, $sourceIndex = 0, $encoding = 'utf-8')
+    public function __construct($sourceName, $sourceIndex = 0, $encoding = 'utf-8', $cache = null)
     {
         $this->sourceName       = $sourceName ?: '(stdin)';
         $this->sourceIndex      = $sourceIndex;
         $this->charset          = null;
         $this->utf8             = ! $encoding || strtolower($encoding) === 'utf-8';
         $this->patternModifiers = $this->utf8 ? 'Aisu' : 'Ais';
+        $this->commentsSeen     = [];
+        $this->discardComments  = false;
 
         if (empty(static::$operatorPattern)) {
             static::$operatorPattern = '([*\/%+-]|[!=]\=|\>\=?|\<\=\>|\<\=?|and|or)';
@@ -95,6 +103,10 @@ class Parser
                 ? '/' . $commentSingle . '[^\n]*\s*|(' . static::$commentPattern . ')\s*|\s+/AisuS'
                 : '/' . $commentSingle . '[^\n]*\s*|(' . static::$commentPattern . ')\s*|\s+/AisS';
         }
+
+        if ($cache) {
+            $this->cache = $cache;
+        }
     }
 
     /**
@@ -116,13 +128,15 @@ class Parser
      *
      * @param string $msg
      *
-     * @throws \Leafo\ScssPhp\Exception\ParserException
+     * @throws \ScssPhp\ScssPhp\Exception\ParserException
      */
     public function throwParseError($msg = 'parse error')
     {
-        list($line, /* $column */) = $this->getSourcePosition($this->count);
+        list($line, $column) = $this->getSourcePosition($this->count);
 
-        $loc = empty($this->sourceName) ? "line: $line" : "$this->sourceName on line $line";
+        $loc = empty($this->sourceName)
+             ? "line: $line, column: $column"
+             : "$this->sourceName on line $line, at column $column";
 
         if ($this->peek("(.*?)(\n|$)", $m, $this->count)) {
             throw new ParserException("$msg: failed at `$m[1]` $loc");
@@ -138,10 +152,23 @@ class Parser
      *
      * @param string $buffer
      *
-     * @return \Leafo\ScssPhp\Block
+     * @return \ScssPhp\ScssPhp\Block
      */
     public function parse($buffer)
     {
+        if ($this->cache) {
+            $cacheKey = $this->sourceName . ":" . md5($buffer);
+            $parseOptions = [
+                'charset' => $this->charset,
+                'utf8' => $this->utf8,
+            ];
+            $v = $this->cache->getCache("parse", $cacheKey, $parseOptions);
+
+            if (! is_null($v)) {
+                return $v;
+            }
+        }
+
         // strip BOM (byte order marker)
         if (substr($buffer, 0, 3) === "\xef\xbb\xbf") {
             $buffer = substr($buffer, 3);
@@ -177,10 +204,12 @@ class Parser
             array_unshift($this->env->children, $this->charset);
         }
 
-        $this->env->isRoot    = true;
-
         $this->restoreEncoding();
 
+        if ($this->cache) {
+            $this->cache->setCache("parse", $cacheKey, $this->env, $parseOptions);
+        }
+
         return $this->env;
     }
 
@@ -238,6 +267,34 @@ class Parser
         return $selector;
     }
 
+    /**
+     * Parse a media Query
+     *
+     * @api
+     *
+     * @param string $buffer
+     * @param string $out
+     *
+     * @return array
+     */
+    public function parseMediaQueryList($buffer, &$out)
+    {
+        $this->count           = 0;
+        $this->env             = null;
+        $this->inParens        = false;
+        $this->eatWhiteDefault = true;
+        $this->buffer          = (string) $buffer;
+
+        $this->saveEncoding();
+
+
+        $isMediaQuery = $this->mediaQueryList($out);
+
+        $this->restoreEncoding();
+
+        return $isMediaQuery;
+    }
+
     /**
      * Parse a single chunk off the head of the buffer and append it to the
      * current parse environment.
@@ -271,7 +328,7 @@ class Parser
      * the buffer position will be left at an invalid state. In order to
      * avoid this, Compiler::seek() is used to remember and set buffer positions.
      *
-     * Before parsing a chain, use $s = $this->seek() to remember the current
+     * Before parsing a chain, use $s = $this->count to remember the current
      * position into $s. Then if a chain fails, use $this->seek($s) to
      * go back where we started.
      *
@@ -279,14 +336,14 @@ class Parser
      */
     protected function parseChunk()
     {
-        $s = $this->seek();
+        $s = $this->count;
 
         // the directives
         if (isset($this->buffer[$this->count]) && $this->buffer[$this->count] === '@') {
-            if ($this->literal('@at-root') &&
+            if ($this->literal('@at-root', 8) &&
                 ($this->selectors($selector) || true) &&
                 ($this->map($with) || true) &&
-                $this->literal('{')
+                $this->matchChar('{', false)
             ) {
                 $atRoot = $this->pushSpecialBlock(Type::T_AT_ROOT, $s);
                 $atRoot->selector = $selector;
@@ -297,7 +354,7 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@media') && $this->mediaQueryList($mediaQueryList) && $this->literal('{')) {
+            if ($this->literal('@media', 6) && $this->mediaQueryList($mediaQueryList) && $this->matchChar('{', false)) {
                 $media = $this->pushSpecialBlock(Type::T_MEDIA, $s);
                 $media->queryList = $mediaQueryList[2];
 
@@ -306,10 +363,10 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@mixin') &&
+            if ($this->literal('@mixin', 6) &&
                 $this->keyword($mixinName) &&
                 ($this->argumentDef($args) || true) &&
-                $this->literal('{')
+                $this->matchChar('{', false)
             ) {
                 $mixin = $this->pushSpecialBlock(Type::T_MIXIN, $s);
                 $mixin->name = $mixinName;
@@ -320,13 +377,13 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@include') &&
+            if ($this->literal('@include', 8) &&
                 $this->keyword($mixinName) &&
-                ($this->literal('(') &&
+                ($this->matchChar('(') &&
                     ($this->argValues($argValues) || true) &&
-                    $this->literal(')') || true) &&
+                    $this->matchChar(')') || true) &&
                 ($this->end() ||
-                    $this->literal('{') && $hasBlock = true)
+                    $this->matchChar('{') && $hasBlock = true)
             ) {
                 $child = [Type::T_INCLUDE, $mixinName, isset($argValues) ? $argValues : null, null];
 
@@ -342,7 +399,7 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@scssphp-import-once') &&
+            if ($this->literal('@scssphp-import-once', 20) &&
                 $this->valueList($importPath) &&
                 $this->end()
             ) {
@@ -353,7 +410,7 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@import') &&
+            if ($this->literal('@import', 7) &&
                 $this->valueList($importPath) &&
                 $this->end()
             ) {
@@ -364,7 +421,7 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@import') &&
+            if ($this->literal('@import', 7) &&
                 $this->url($importPath) &&
                 $this->end()
             ) {
@@ -375,7 +432,7 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@extend') &&
+            if ($this->literal('@extend', 7) &&
                 $this->selectors($selectors) &&
                 $this->end()
             ) {
@@ -388,10 +445,10 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@function') &&
+            if ($this->literal('@function', 9) &&
                 $this->keyword($fnName) &&
                 $this->argumentDef($args) &&
-                $this->literal('{')
+                $this->matchChar('{', false)
             ) {
                 $func = $this->pushSpecialBlock(Type::T_FUNCTION, $s);
                 $func->name = $fnName;
@@ -402,7 +459,7 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@break') && $this->end()) {
+            if ($this->literal('@break', 6) && $this->end()) {
                 $this->append([Type::T_BREAK], $s);
 
                 return true;
@@ -410,7 +467,7 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@continue') && $this->end()) {
+            if ($this->literal('@continue', 9) && $this->end()) {
                 $this->append([Type::T_CONTINUE], $s);
 
                 return true;
@@ -418,8 +475,7 @@ class Parser
 
             $this->seek($s);
 
-
-            if ($this->literal('@return') && ($this->valueList($retVal) || true) && $this->end()) {
+            if ($this->literal('@return', 7) && ($this->valueList($retVal) || true) && $this->end()) {
                 $this->append([Type::T_RETURN, isset($retVal) ? $retVal : [Type::T_NULL]], $s);
 
                 return true;
@@ -427,11 +483,11 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@each') &&
+            if ($this->literal('@each', 5) &&
                 $this->genericList($varNames, 'variable', ',', false) &&
-                $this->literal('in') &&
+                $this->literal('in', 2) &&
                 $this->valueList($list) &&
-                $this->literal('{')
+                $this->matchChar('{', false)
             ) {
                 $each = $this->pushSpecialBlock(Type::T_EACH, $s);
 
@@ -446,9 +502,9 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@while') &&
+            if ($this->literal('@while', 6) &&
                 $this->expression($cond) &&
-                $this->literal('{')
+                $this->matchChar('{', false)
             ) {
                 $while = $this->pushSpecialBlock(Type::T_WHILE, $s);
                 $while->cond = $cond;
@@ -458,14 +514,14 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@for') &&
+            if ($this->literal('@for', 4) &&
                 $this->variable($varName) &&
-                $this->literal('from') &&
+                $this->literal('from', 4) &&
                 $this->expression($start) &&
-                ($this->literal('through') ||
-                    ($forUntil = true && $this->literal('to'))) &&
+                ($this->literal('through', 7) ||
+                    ($forUntil = true && $this->literal('to', 2))) &&
                 $this->expression($end) &&
-                $this->literal('{')
+                $this->matchChar('{', false)
             ) {
                 $for = $this->pushSpecialBlock(Type::T_FOR, $s);
                 $for->var = $varName[1];
@@ -478,7 +534,7 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@if') && $this->valueList($cond) && $this->literal('{')) {
+            if ($this->literal('@if', 3) && $this->valueList($cond) && $this->matchChar('{', false)) {
                 $if = $this->pushSpecialBlock(Type::T_IF, $s);
                 $if->cond = $cond;
                 $if->cases = [];
@@ -488,7 +544,7 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@debug') &&
+            if ($this->literal('@debug', 6) &&
                 $this->valueList($value) &&
                 $this->end()
             ) {
@@ -499,7 +555,7 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@warn') &&
+            if ($this->literal('@warn', 5) &&
                 $this->valueList($value) &&
                 $this->end()
             ) {
@@ -510,7 +566,7 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@error') &&
+            if ($this->literal('@error', 6) &&
                 $this->valueList($value) &&
                 $this->end()
             ) {
@@ -521,7 +577,7 @@ class Parser
 
             $this->seek($s);
 
-            if ($this->literal('@content') && $this->end()) {
+            if ($this->literal('@content', 8) && $this->end()) {
                 $this->append([Type::T_MIXIN_CONTENT], $s);
 
                 return true;
@@ -534,10 +590,10 @@ class Parser
             if (isset($last) && $last[0] === Type::T_IF) {
                 list(, $if) = $last;
 
-                if ($this->literal('@else')) {
-                    if ($this->literal('{')) {
+                if ($this->literal('@else', 5)) {
+                    if ($this->matchChar('{', false)) {
                         $else = $this->pushSpecialBlock(Type::T_ELSE, $s);
-                    } elseif ($this->literal('if') && $this->valueList($cond) && $this->literal('{')) {
+                    } elseif ($this->literal('if', 2) && $this->valueList($cond) && $this->matchChar('{', false)) {
                         $else = $this->pushSpecialBlock(Type::T_ELSEIF, $s);
                         $else->cond = $cond;
                     }
@@ -554,7 +610,7 @@ class Parser
             }
 
             // only retain the first @charset directive encountered
-            if ($this->literal('@charset') &&
+            if ($this->literal('@charset', 8) &&
                 $this->valueList($charset) &&
                 $this->end()
             ) {
@@ -575,11 +631,23 @@ class Parser
 
             $this->seek($s);
 
+            if ($this->literal('@supports', 9) &&
+                ($t1=$this->supportsQuery($supportQuery)) &&
+                ($t2=$this->matchChar('{', false)) ) {
+                $directive = $this->pushSpecialBlock(Type::T_DIRECTIVE, $s);
+                $directive->name = 'supports';
+                $directive->value = $supportQuery;
+
+                return true;
+            }
+
+            $this->seek($s);
+
             // doesn't match built in directive, do generic one
-            if ($this->literal('@', false) &&
+            if ($this->matchChar('@', false) &&
                 $this->keyword($dirName) &&
                 ($this->variable($dirValue) || $this->openString('{', $dirValue) || true) &&
-                $this->literal('{')
+                $this->matchChar('{', false)
             ) {
                 if ($dirName === 'media') {
                     $directive = $this->pushSpecialBlock(Type::T_MEDIA, $s);
@@ -603,7 +671,7 @@ class Parser
         // property shortcut
         // captures most properties before having to parse a selector
         if ($this->keyword($name, false) &&
-            $this->literal(': ') &&
+            $this->literal(': ', 2) &&
             $this->valueList($value) &&
             $this->end()
         ) {
@@ -617,7 +685,7 @@ class Parser
 
         // variable assigns
         if ($this->variable($name) &&
-            $this->literal(':') &&
+            $this->matchChar(':') &&
             $this->valueList($value) &&
             $this->end()
         ) {
@@ -631,31 +699,42 @@ class Parser
         $this->seek($s);
 
         // misc
-        if ($this->literal('-->')) {
+        if ($this->literal('-->', 3)) {
             return true;
         }
 
         // opening css block
-        if ($this->selectors($selectors) && $this->literal('{')) {
+        if ($this->selectors($selectors) && $this->matchChar('{', false)) {
             $this->pushBlock($selectors, $s);
 
+            if ($this->eatWhiteDefault) {
+                $this->whitespace();
+                $this->append(null); // collect comments at the begining if needed
+            }
+
             return true;
         }
 
         $this->seek($s);
 
         // property assign, or nested assign
-        if ($this->propertyName($name) && $this->literal(':')) {
+        if ($this->propertyName($name) && $this->matchChar(':')) {
             $foundSomething = false;
 
             if ($this->valueList($value)) {
+                if (empty($this->env->parent)) {
+                    $this->throwParseError('expected "{"');
+                }
+
                 $this->append([Type::T_ASSIGN, $name, $value], $s);
                 $foundSomething = true;
             }
 
-            if ($this->literal('{')) {
+            if ($this->matchChar('{', false)) {
                 $propBlock = $this->pushSpecialBlock(Type::T_NESTED_PROPERTY, $s);
                 $propBlock->prefix = $name;
+                $propBlock->hasValue = $foundSomething;
+
                 $foundSomething = true;
             } elseif ($foundSomething) {
                 $foundSomething = $this->end();
@@ -669,9 +748,15 @@ class Parser
         $this->seek($s);
 
         // closing a block
-        if ($this->literal('}')) {
+        if ($this->matchChar('}', false)) {
             $block = $this->popBlock();
 
+            if (!isset($block->type) || $block->type !== Type::T_IF) {
+                if ($this->env->parent) {
+                    $this->append(null); // collect comments before next statement if needed
+                }
+            }
+
             if (isset($block->type) && $block->type === Type::T_INCLUDE) {
                 $include = $block->child;
                 unset($block->child);
@@ -682,12 +767,21 @@ class Parser
                 $this->append([$type, $block], $s);
             }
 
+            // collect comments just after the block closing if needed
+            if ($this->eatWhiteDefault) {
+                $this->whitespace();
+
+                if ($this->env->comments) {
+                    $this->append(null);
+                }
+            }
+
             return true;
         }
 
         // extra stuff
-        if ($this->literal(';') ||
-            $this->literal('<!--')
+        if ($this->matchChar(';') ||
+            $this->literal('<!--', 4)
         ) {
             return true;
         }
@@ -701,7 +795,7 @@ class Parser
      * @param array   $selectors
      * @param integer $pos
      *
-     * @return \Leafo\ScssPhp\Block
+     * @return \ScssPhp\ScssPhp\Block
      */
     protected function pushBlock($selectors, $pos = 0)
     {
@@ -729,6 +823,15 @@ class Parser
 
         $this->env = $b;
 
+        // collect comments at the begining of a block if needed
+        if ($this->eatWhiteDefault) {
+            $this->whitespace();
+
+            if ($this->env->comments) {
+                $this->append(null);
+            }
+        }
+
         return $b;
     }
 
@@ -738,7 +841,7 @@ class Parser
      * @param string  $type
      * @param integer $pos
      *
-     * @return \Leafo\ScssPhp\Block
+     * @return \ScssPhp\ScssPhp\Block
      */
     protected function pushSpecialBlock($type, $pos)
     {
@@ -751,27 +854,34 @@ class Parser
     /**
      * Pop scope and return last block
      *
-     * @return \Leafo\ScssPhp\Block
+     * @return \ScssPhp\ScssPhp\Block
      *
      * @throws \Exception
      */
     protected function popBlock()
     {
+
+        // collect comments ending just before of a block closing
+        if ($this->env->comments) {
+            $this->append(null);
+        }
+
+        // pop the block
         $block = $this->env;
 
         if (empty($block->parent)) {
             $this->throwParseError('unexpected }');
         }
 
-        $this->env = $block->parent;
-        unset($block->parent);
-
-        $comments = $block->comments;
-        if (count($comments)) {
-            $this->env->comments = $comments;
-            unset($block->comments);
+        if ($block->type == Type::T_AT_ROOT) {
+            // keeps the parent in case of self selector &
+            $block->selfParent = $block->parent;
         }
 
+        $this->env = $block->parent;
+
+        unset($block->parent);
+
         return $block;
     }
 
@@ -800,18 +910,10 @@ class Parser
      * Seek to position in input stream (or return current position in input stream)
      *
      * @param integer $where
-     *
-     * @return integer
      */
-    protected function seek($where = null)
+    protected function seek($where)
     {
-        if ($where === null) {
-            return $this->count;
-        }
-
         $this->count = $where;
-
-        return true;
     }
 
     /**
@@ -866,52 +968,78 @@ class Parser
      */
     protected function match($regex, &$out, $eatWhitespace = null)
     {
+        $r = '/' . $regex . '/' . $this->patternModifiers;
+
+        if (! preg_match($r, $this->buffer, $out, null, $this->count)) {
+            return false;
+        }
+
+        $this->count += strlen($out[0]);
+
         if (! isset($eatWhitespace)) {
             $eatWhitespace = $this->eatWhiteDefault;
         }
 
-        $r = '/' . $regex . '/' . $this->patternModifiers;
-
-        if (preg_match($r, $this->buffer, $out, null, $this->count)) {
-            $this->count += strlen($out[0]);
-
-            if ($eatWhitespace) {
-                $this->whitespace();
-            }
-
-            return true;
+        if ($eatWhitespace) {
+            $this->whitespace();
         }
 
-        return false;
+        return true;
+    }
+
+    /**
+     * Match a single string
+     *
+     * @param string  $char
+     * @param boolean $eatWhitespace
+     *
+     * @return boolean
+     */
+    protected function matchChar($char, $eatWhitespace = null)
+    {
+        if (! isset($this->buffer[$this->count]) || $this->buffer[$this->count] !== $char) {
+            return false;
+        }
+
+        $this->count++;
+
+        if (! isset($eatWhitespace)) {
+            $eatWhitespace = $this->eatWhiteDefault;
+        }
+
+        if ($eatWhitespace) {
+            $this->whitespace();
+        }
+
+        return true;
     }
 
     /**
      * Match literal string
      *
      * @param string  $what
+     * @param integer $len
      * @param boolean $eatWhitespace
      *
      * @return boolean
      */
-    protected function literal($what, $eatWhitespace = null)
+    protected function literal($what, $len, $eatWhitespace = null)
     {
+        if (strcasecmp(substr($this->buffer, $this->count, $len), $what) !== 0) {
+            return false;
+        }
+
+        $this->count += $len;
+
         if (! isset($eatWhitespace)) {
             $eatWhitespace = $this->eatWhiteDefault;
         }
 
-        $len = strlen($what);
-
-        if (strcasecmp(substr($this->buffer, $this->count, $len), $what) === 0) {
-            $this->count += $len;
-
-            if ($eatWhitespace) {
-                $this->whitespace();
-            }
-
-            return true;
+        if ($eatWhitespace) {
+            $this->whitespace();
         }
 
-        return false;
+        return true;
     }
 
     /**
@@ -925,12 +1053,57 @@ class Parser
 
         while (preg_match(static::$whitePattern, $this->buffer, $m, null, $this->count)) {
             if (isset($m[1]) && empty($this->commentsSeen[$this->count])) {
-                $this->appendComment([Type::T_COMMENT, $m[1]]);
+                // comment that are kept in the output CSS
+                $comment = [];
+                $endCommentCount = $this->count + strlen($m[1]);
+
+                // find interpolations in comment
+                $p = strpos($this->buffer, '#{', $this->count);
+
+                while ($p !== false && $p < $endCommentCount) {
+                    $c = substr($this->buffer, $this->count, $p - $this->count);
+                    $comment[] = $c;
+                    $this->count = $p;
+                    $out = null;
+
+                    if ($this->interpolation($out)) {
+                        // keep right spaces in the following string part
+                        if ($out[3]) {
+                            while ($this->buffer[$this->count-1] !== '}') {
+                                $this->count--;
+                            }
+
+                            $out[3] = '';
+                        }
+
+                        $comment[] = $out;
+                    } else {
+                        $comment[] = substr($this->buffer, $this->count, 2);
+
+                        $this->count += 2;
+                    }
+
+                    $p = strpos($this->buffer, '#{', $this->count);
+                }
+
+                // remaining part
+                $c = substr($this->buffer, $this->count, $endCommentCount - $this->count);
+
+                if (! $comment) {
+                    // single part static comment
+                    $this->appendComment([Type::T_COMMENT, $c]);
+                } else {
+                    $comment[] = $c;
+                    $this->appendComment([Type::T_COMMENT, [Type::T_STRING, '', $comment]]);
+                }
 
                 $this->commentsSeen[$this->count] = true;
+                $this->count = $endCommentCount;
+            } else {
+                // comment that are ignored and not kept in the output css
+                $this->count += strlen($m[0]);
             }
 
-            $this->count += strlen($m[0]);
             $gotWhite = true;
         }
 
@@ -944,9 +1117,13 @@ class Parser
      */
     protected function appendComment($comment)
     {
-        $comment[1] = substr(preg_replace(['/^\s+/m', '/^(.)/m'], ['', ' \1'], $comment[1]), 1);
+        if (! $this->discardComments) {
+            if ($comment[0] === Type::T_COMMENT && is_string($comment[1])) {
+                $comment[1] = substr(preg_replace(['/^\s+/m', '/^(.)/m'], ['', ' \1'], $comment[1]), 1);
+            }
 
-        $this->env->comments[] = $comment;
+            $this->env->comments[] = $comment;
+        }
     }
 
     /**
@@ -957,19 +1134,21 @@ class Parser
      */
     protected function append($statement, $pos = null)
     {
-        if ($pos !== null) {
-            list($line, $column) = $this->getSourcePosition($pos);
+        if (! is_null($statement)) {
+            if ($pos !== null) {
+                list($line, $column) = $this->getSourcePosition($pos);
 
-            $statement[static::SOURCE_LINE]   = $line;
-            $statement[static::SOURCE_COLUMN] = $column;
-            $statement[static::SOURCE_INDEX]  = $this->sourceIndex;
+                $statement[static::SOURCE_LINE]   = $line;
+                $statement[static::SOURCE_COLUMN] = $column;
+                $statement[static::SOURCE_INDEX]  = $this->sourceIndex;
+            }
+
+            $this->env->children[] = $statement;
         }
 
-        $this->env->children[] = $statement;
-
         $comments = $this->env->comments;
 
-        if (count($comments)) {
+        if ($comments) {
             $this->env->children = array_merge($this->env->children, $comments);
             $this->env->comments = [];
         }
@@ -1013,7 +1192,7 @@ class Parser
         $expressions = null;
         $parts = [];
 
-        if (($this->literal('only') && ($only = true) || $this->literal('not') && ($not = true) || true) &&
+        if (($this->literal('only', 4) && ($only = true) || $this->literal('not', 3) && ($not = true) || true) &&
             $this->mixedKeyword($mediaType)
         ) {
             $prop = [Type::T_MEDIA_TYPE];
@@ -1040,7 +1219,7 @@ class Parser
             $parts[] = $prop;
         }
 
-        if (empty($parts) || $this->literal('and')) {
+        if (empty($parts) || $this->literal('and', 3)) {
             $this->genericList($expressions, 'mediaExpression', 'and', false);
 
             if (is_array($expressions)) {
@@ -1053,6 +1232,118 @@ class Parser
         return true;
     }
 
+    /**
+     * Parse supports query
+     *
+     * @param array $out
+     *
+     * @return boolean
+     */
+    protected function supportsQuery(&$out)
+    {
+        $expressions = null;
+        $parts = [];
+
+        $s = $this->count;
+
+        $not = false;
+        if (($this->literal('not', 3) && ($not = true) || true) &&
+            $this->matchChar('(') &&
+            ($this->expression($property)) &&
+            $this->literal(': ', 2) &&
+            $this->valueList($value) &&
+            $this->matchChar(')')) {
+            $support = [Type::T_STRING, '', [[Type::T_KEYWORD, ($not ? 'not ' : '') . '(']]];
+            $support[2][] = $property;
+            $support[2][] = [Type::T_KEYWORD, ': '];
+            $support[2][] = $value;
+            $support[2][] = [Type::T_KEYWORD, ')'];
+
+            $parts[] = $support;
+            $s = $this->count;
+        } else {
+            $this->seek($s);
+        }
+
+        if ($this->matchChar('(') &&
+            $this->supportsQuery($subQuery) &&
+            $this->matchChar(')')) {
+            $parts[] = [Type::T_STRING, '', [[Type::T_KEYWORD, '('], $subQuery, [Type::T_KEYWORD, ')']]];
+            $s = $this->count;
+        } else {
+            $this->seek($s);
+        }
+
+        if ($this->literal('not', 3) &&
+            $this->supportsQuery($subQuery)) {
+            $parts[] = [Type::T_STRING, '', [[Type::T_KEYWORD, 'not '], $subQuery]];
+            $s = $this->count;
+        } else {
+            $this->seek($s);
+        }
+
+        if ($this->literal('selector(', 9) &&
+            $this->selector($selector) &&
+            $this->matchChar(')')) {
+            $support = [Type::T_STRING, '', [[Type::T_KEYWORD, 'selector(']]];
+
+            $selectorList = [Type::T_LIST, '', []];
+            foreach ($selector as $sc) {
+                $compound = [Type::T_STRING, '', []];
+                foreach ($sc as $scp) {
+                    if (is_array($scp)) {
+                        $compound[2][] = $scp;
+                    } else {
+                        $compound[2][] = [Type::T_KEYWORD, $scp];
+                    }
+                }
+                $selectorList[2][] = $compound;
+            }
+            $support[2][] = $selectorList;
+            $support[2][] = [Type::T_KEYWORD, ')'];
+            $parts[] = $support;
+            $s = $this->count;
+        } else {
+            $this->seek($s);
+        }
+
+        if ($this->variable($var) or $this->interpolation($var)) {
+            $parts[] = $var;
+            $s = $this->count;
+        } else {
+            $this->seek($s);
+        }
+
+        if ($this->literal('and', 3) &&
+            $this->genericList($expressions, 'supportsQuery', ' and', false)) {
+            array_unshift($expressions[2], [Type::T_STRING, '', $parts]);
+            $parts = [$expressions];
+            $s = $this->count;
+        } else {
+            $this->seek($s);
+        }
+
+        if ($this->literal('or', 2) &&
+            $this->genericList($expressions, 'supportsQuery', ' or', false)) {
+            array_unshift($expressions[2], [Type::T_STRING, '', $parts]);
+            $parts = [$expressions];
+            $s = $this->count;
+        } else {
+            $this->seek($s);
+        }
+
+        if (count($parts)) {
+            if ($this->eatWhiteDefault) {
+                $this->whitespace();
+            }
+            $out = [Type::T_STRING, '', $parts];
+            return true;
+        }
+
+        return false;
+    }
+
+
     /**
      * Parse media expression
      *
@@ -1062,13 +1353,13 @@ class Parser
      */
     protected function mediaExpression(&$out)
     {
-        $s = $this->seek();
+        $s = $this->count;
         $value = null;
 
-        if ($this->literal('(') &&
+        if ($this->matchChar('(') &&
             $this->expression($feature) &&
-            ($this->literal(':') && $this->expression($value) || true) &&
-            $this->literal(')')
+            ($this->matchChar(':') && $this->expression($value) || true) &&
+            $this->matchChar(')')
         ) {
             $out = [Type::T_MEDIA_EXPRESSION, $feature];
 
@@ -1111,20 +1402,20 @@ class Parser
      */
     protected function argValue(&$out)
     {
-        $s = $this->seek();
+        $s = $this->count;
 
         $keyword = null;
 
-        if (! $this->variable($keyword) || ! $this->literal(':')) {
+        if (! $this->variable($keyword) || ! $this->matchChar(':')) {
             $this->seek($s);
             $keyword = null;
         }
 
         if ($this->genericList($value, 'expression')) {
             $out = [$keyword, $value, false];
-            $s = $this->seek();
+            $s = $this->count;
 
-            if ($this->literal('...')) {
+            if ($this->literal('...', 3)) {
                 $out[2] = true;
             } else {
                 $this->seek($s);
@@ -1139,7 +1430,7 @@ class Parser
     /**
      * Parse comma separated value list
      *
-     * @param string $out
+     * @param array $out
      *
      * @return boolean
      */
@@ -1172,20 +1463,21 @@ class Parser
      */
     protected function genericList(&$out, $parseItem, $delim = '', $flatten = true)
     {
-        $s = $this->seek();
+        $s = $this->count;
         $items = [];
+        $value = null;
 
         while ($this->$parseItem($value)) {
             $items[] = $value;
 
             if ($delim) {
-                if (! $this->literal($delim)) {
+                if (! $this->literal($delim, strlen($delim))) {
                     break;
                 }
             }
         }
 
-        if (count($items) === 0) {
+        if (! $items) {
             $this->seek($s);
 
             return false;
@@ -1209,22 +1501,26 @@ class Parser
      */
     protected function expression(&$out)
     {
-        $s = $this->seek();
+        $s = $this->count;
+        $discard = $this->discardComments;
+        $this->discardComments = true;
 
-        if ($this->literal('(')) {
-            if ($this->literal(')')) {
-                $out = [Type::T_LIST, '', []];
-
-                return true;
-            }
-
-            if ($this->valueList($out) && $this->literal(')') && $out[0] === Type::T_LIST) {
+        if ($this->matchChar('(')) {
+            if ($this->parenExpression($out, $s, ")")) {
+                $this->discardComments = $discard;
                 return true;
             }
 
             $this->seek($s);
+        }
 
-            if ($this->map($out)) {
+        if ($this->matchChar('[')) {
+            if ($this->parenExpression($out, $s, "]", [Type::T_LIST, Type::T_KEYWORD])) {
+                if ($out[0] !== Type::T_LIST && $out[0] !== Type::T_MAP) {
+                    $out = [Type::T_STRING, '', [ '[', $out, ']' ]];
+                }
+
+                $this->discardComments = $discard;
                 return true;
             }
 
@@ -1234,6 +1530,39 @@ class Parser
         if ($this->value($lhs)) {
             $out = $this->expHelper($lhs, 0);
 
+            $this->discardComments = $discard;
+            return true;
+        }
+
+        $this->discardComments = $discard;
+        return false;
+    }
+
+    /**
+     * Parse expression specifically checking for lists in parenthesis or brackets
+     *
+     * @param array   $out
+     * @param integer $s
+     * @param string  $closingParen
+     * @param array   $allowedTypes
+     *
+     * @return boolean
+     */
+    protected function parenExpression(&$out, $s, $closingParen = ")", $allowedTypes = [Type::T_LIST, Type::T_MAP])
+    {
+        if ($this->matchChar($closingParen)) {
+            $out = [Type::T_LIST, '', []];
+
+            return true;
+        }
+
+        if ($this->valueList($out) && $this->matchChar($closingParen) && in_array($out[0], $allowedTypes)) {
+            return true;
+        }
+
+        $this->seek($s);
+
+        if (in_array(Type::T_MAP, $allowedTypes) && $this->map($out)) {
             return true;
         }
 
@@ -1252,7 +1581,7 @@ class Parser
     {
         $operators = static::$operatorPattern;
 
-        $ss = $this->seek();
+        $ss = $this->count;
         $whiteBefore = isset($this->buffer[$this->count - 1]) &&
             ctype_space($this->buffer[$this->count - 1]);
 
@@ -1281,7 +1610,7 @@ class Parser
             }
 
             $lhs = [Type::T_EXPRESSION, $op, $lhs, $rhs, $this->inParens, $whiteBefore, $whiteAfter];
-            $ss = $this->seek();
+            $ss = $this->count;
             $whiteBefore = isset($this->buffer[$this->count - 1]) &&
                 ctype_space($this->buffer[$this->count - 1]);
         }
@@ -1300,58 +1629,138 @@ class Parser
      */
     protected function value(&$out)
     {
-        $s = $this->seek();
+        if (! isset($this->buffer[$this->count])) {
+            return false;
+        }
 
-        if ($this->literal('not', false) && $this->whitespace() && $this->value($inner)) {
-            $out = [Type::T_UNARY, 'not', $inner, $this->inParens];
+        $s = $this->count;
+        $char = $this->buffer[$this->count];
 
-            return true;
+        if ($this->literal('url(', 4) && $this->match('data:([a-z]+)\/([a-z0-9.+-]+);base64,', $m, false)) {
+            $len = strspn(
+                $this->buffer,
+                'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwyxz0123456789+/=',
+                $this->count
+            );
+
+            $this->count += $len;
+
+            if ($this->matchChar(')')) {
+                $content = substr($this->buffer, $s, $this->count - $s);
+                $out = [Type::T_KEYWORD, $content];
+
+                return true;
+            }
         }
 
         $this->seek($s);
 
-        if ($this->literal('not', false) && $this->parenValue($inner)) {
-            $out = [Type::T_UNARY, 'not', $inner, $this->inParens];
+        if ($this->literal('url(', 4, false) && $this->match('\s*(\/\/\S+)\s*', $m)) {
+            $content = 'url(' . $m[1];
 
-            return true;
+            if ($this->matchChar(')')) {
+                $content .= ')';
+                $out = [Type::T_KEYWORD, $content];
+
+                return true;
+            }
         }
 
         $this->seek($s);
 
-        if ($this->literal('+') && $this->value($inner)) {
-            $out = [Type::T_UNARY, '+', $inner, $this->inParens];
+        // not
+        if ($char === 'n' && $this->literal('not', 3, false)) {
+            if ($this->whitespace() && $this->value($inner)) {
+                $out = [Type::T_UNARY, 'not', $inner, $this->inParens];
 
-            return true;
+                return true;
+            }
+
+            $this->seek($s);
+
+            if ($this->parenValue($inner)) {
+                $out = [Type::T_UNARY, 'not', $inner, $this->inParens];
+
+                return true;
+            }
+
+            $this->seek($s);
         }
 
-        $this->seek($s);
+        // addition
+        if ($char === '+') {
+            $this->count++;
+
+            if ($this->value($inner)) {
+                $out = [Type::T_UNARY, '+', $inner, $this->inParens];
+
+                return true;
+            }
+
+            $this->count--;
+
+            return false;
+        }
 
         // negation
-        if ($this->literal('-', false) &&
-            ($this->variable($inner) ||
-            $this->unit($inner) ||
-            $this->parenValue($inner))
-        ) {
-            $out = [Type::T_UNARY, '-', $inner, $this->inParens];
+        if ($char === '-') {
+            $this->count++;
+
+            if ($this->variable($inner) || $this->unit($inner) || $this->parenValue($inner)) {
+                $out = [Type::T_UNARY, '-', $inner, $this->inParens];
+
+                return true;
+            }
+
+            $this->count--;
+        }
+
+        // paren
+        if ($char === '(' && $this->parenValue($out)) {
+            return true;
+        }
+
+        if ($char === '#') {
+            if ($this->interpolation($out) || $this->color($out)) {
+                return true;
+            }
+        }
+
+        if ($this->matchChar('&', true)) {
+            $out = [Type::T_SELF];
 
             return true;
         }
 
-        $this->seek($s);
-
-        if ($this->parenValue($out) ||
-            $this->interpolation($out) ||
-            $this->variable($out) ||
-            $this->color($out) ||
-            $this->unit($out) ||
-            $this->string($out) ||
-            $this->func($out) ||
-            $this->progid($out)
-        ) {
+        if ($char === '$' && $this->variable($out)) {
             return true;
         }
 
-        if ($this->keyword($keyword)) {
+        if ($char === 'p' && $this->progid($out)) {
+            return true;
+        }
+
+        if (($char === '"' || $char === "'") && $this->string($out)) {
+            return true;
+        }
+
+        if ($this->unit($out)) {
+            return true;
+        }
+
+        // unicode range with wildcards
+        if ($this->literal('U+', 2) && $this->match('([0-9A-F]+\?*)(-([0-9A-F]+))?', $m, false)) {
+            $out = [Type::T_KEYWORD, 'U+' . $m[0]];
+            return true;
+        }
+
+        if ($this->keyword($keyword, false)) {
+            if ($this->func($keyword, $out)) {
+                return true;
+            }
+
+            $this->whitespace();
+
             if ($keyword === 'null') {
                 $out = [Type::T_NULL];
             } else {
@@ -1373,12 +1782,12 @@ class Parser
      */
     protected function parenValue(&$out)
     {
-        $s = $this->seek();
+        $s = $this->count;
 
         $inParens = $this->inParens;
 
-        if ($this->literal('(')) {
-            if ($this->literal(')')) {
+        if ($this->matchChar('(')) {
+            if ($this->matchChar(')')) {
                 $out = [Type::T_LIST, '', []];
 
                 return true;
@@ -1386,7 +1795,7 @@ class Parser
 
             $this->inParens = true;
 
-            if ($this->expression($exp) && $this->literal(')')) {
+            if ($this->expression($exp) && $this->matchChar(')')) {
                 $out = $exp;
                 $this->inParens = $inParens;
 
@@ -1409,15 +1818,15 @@ class Parser
      */
     protected function progid(&$out)
     {
-        $s = $this->seek();
+        $s = $this->count;
 
-        if ($this->literal('progid:', false) &&
+        if ($this->literal('progid:', 7, false) &&
             $this->openString('(', $fn) &&
-            $this->literal('(')
+            $this->matchChar('(')
         ) {
             $this->openString(')', $args, '(');
 
-            if ($this->literal(')')) {
+            if ($this->matchChar(')')) {
                 $out = [Type::T_STRING, '', [
                     'progid:', $fn, '(', $args, ')'
                 ]];
@@ -1434,17 +1843,16 @@ class Parser
     /**
      * Parse function call
      *
-     * @param array $out
+     * @param string $name
+     * @param array  $func
      *
      * @return boolean
      */
-    protected function func(&$func)
+    protected function func($name, &$func)
     {
-        $s = $this->seek();
+        $s = $this->count;
 
-        if ($this->keyword($name, false) &&
-            $this->literal('(')
-        ) {
+        if ($this->matchChar('(')) {
             if ($name === 'alpha' && $this->argumentList($args)) {
                 $func = [Type::T_FUNCTION, $name, [Type::T_STRING, '', $args]];
 
@@ -1452,9 +1860,9 @@ class Parser
             }
 
             if ($name !== 'expression' && ! preg_match('/^(-[a-z]+-)?calc$/', $name)) {
-                $ss = $this->seek();
+                $ss = $this->count;
 
-                if ($this->argValues($args) && $this->literal(')')) {
+                if ($this->argValues($args) && $this->matchChar(')')) {
                     $func = [Type::T_FUNCTION_CALL, $name, $args];
 
                     return true;
@@ -1464,7 +1872,7 @@ class Parser
             }
 
             if (($this->openString(')', $str, '(') || true) &&
-                $this->literal(')')
+                $this->matchChar(')')
             ) {
                 $args = [];
 
@@ -1492,13 +1900,13 @@ class Parser
      */
     protected function argumentList(&$out)
     {
-        $s = $this->seek();
-        $this->literal('(');
+        $s = $this->count;
+        $this->matchChar('(');
 
         $args = [];
 
         while ($this->keyword($var)) {
-            if ($this->literal('=') && $this->expression($exp)) {
+            if ($this->matchChar('=') && $this->expression($exp)) {
                 $args[] = [Type::T_STRING, '', [$var . '=']];
                 $arg = $exp;
             } else {
@@ -1507,14 +1915,14 @@ class Parser
 
             $args[] = $arg;
 
-            if (! $this->literal(',')) {
+            if (! $this->matchChar(',')) {
                 break;
             }
 
             $args[] = [Type::T_STRING, '', [', ']];
         }
 
-        if (! $this->literal(')') || ! count($args)) {
+        if (! $this->matchChar(')') || ! $args) {
             $this->seek($s);
 
             return false;
@@ -1534,28 +1942,28 @@ class Parser
      */
     protected function argumentDef(&$out)
     {
-        $s = $this->seek();
-        $this->literal('(');
+        $s = $this->count;
+        $this->matchChar('(');
 
         $args = [];
 
         while ($this->variable($var)) {
             $arg = [$var[1], null, false];
 
-            $ss = $this->seek();
+            $ss = $this->count;
 
-            if ($this->literal(':') && $this->genericList($defaultVal, 'expression')) {
+            if ($this->matchChar(':') && $this->genericList($defaultVal, 'expression')) {
                 $arg[1] = $defaultVal;
             } else {
                 $this->seek($ss);
             }
 
-            $ss = $this->seek();
+            $ss = $this->count;
 
-            if ($this->literal('...')) {
-                $sss = $this->seek();
+            if ($this->literal('...', 3)) {
+                $sss = $this->count;
 
-                if (! $this->literal(')')) {
+                if (! $this->matchChar(')')) {
                     $this->throwParseError('... has to be after the final argument');
                 }
 
@@ -1567,12 +1975,12 @@ class Parser
 
             $args[] = $arg;
 
-            if (! $this->literal(',')) {
+            if (! $this->matchChar(',')) {
                 break;
             }
         }
 
-        if (! $this->literal(')')) {
+        if (! $this->matchChar(')')) {
             $this->seek($s);
 
             return false;
@@ -1592,27 +2000,27 @@ class Parser
      */
     protected function map(&$out)
     {
-        $s = $this->seek();
+        $s = $this->count;
 
-        if (! $this->literal('(')) {
+        if (! $this->matchChar('(')) {
             return false;
         }
 
         $keys = [];
         $values = [];
 
-        while ($this->genericList($key, 'expression') && $this->literal(':') &&
+        while ($this->genericList($key, 'expression') && $this->matchChar(':') &&
             $this->genericList($value, 'expression')
         ) {
             $keys[] = $key;
             $values[] = $value;
 
-            if (! $this->literal(',')) {
+            if (! $this->matchChar(',')) {
                 break;
             }
         }
 
-        if (! count($keys) || ! $this->literal(')')) {
+        if (! $keys || ! $this->matchChar(')')) {
             $this->seek($s);
 
             return false;
@@ -1633,22 +2041,48 @@ class Parser
     protected function color(&$out)
     {
         $color = [Type::T_COLOR];
+        $s     = $this->count;
 
-        if ($this->match('(#([0-9a-f]{6})|#([0-9a-f]{3}))', $m)) {
-            if (isset($m[3])) {
-                $num = hexdec($m[3]);
+        if ($this->match('(#([0-9a-f]+))', $m)) {
+            $nofValues = strlen($m[2]);
+            $hasAlpha  = $nofValues === 4 || $nofValues === 8;
+            $channels  = $hasAlpha ? [4, 3, 2, 1] : [3, 2, 1];
 
-                foreach ([3, 2, 1] as $i) {
-                    $t = $num & 0xf;
-                    $color[$i] = $t << 4 | $t;
-                    $num >>= 4;
-                }
-            } else {
-                $num = hexdec($m[2]);
+            switch ($nofValues) {
+                case 3:
+                case 4:
+                    $num = hexdec($m[2]);
 
-                foreach ([3, 2, 1] as $i) {
-                    $color[$i] = $num & 0xff;
-                    $num >>= 8;
+                    foreach ($channels as $i) {
+                        $t = $num & 0xf;
+                        $color[$i] = $t << 4 | $t;
+                        $num >>= 4;
+                    }
+
+                    break;
+
+                case 6:
+                case 8:
+                    $num = hexdec($m[2]);
+
+                    foreach ($channels as $i) {
+                        $color[$i] = $num & 0xff;
+                        $num >>= 8;
+                    }
+
+                    break;
+
+                default:
+                    $this->seek($s);
+
+                    return false;
+            }
+
+            if ($hasAlpha) {
+                if ($color[4] === 255) {
+                    $color[4] = 1; // fully opaque
+                } else {
+                    $color[4] = round($color[4] / 255, 3);
                 }
             }
 
@@ -1663,16 +2097,24 @@ class Parser
     /**
      * Parse number with unit
      *
-     * @param array $out
+     * @param array $unit
      *
      * @return boolean
      */
     protected function unit(&$unit)
     {
-        if ($this->match('([0-9]*(\.)?[0-9]+)([%a-zA-Z]+)?', $m)) {
-            $unit = new Node\Number($m[1], empty($m[3]) ? '' : $m[3]);
+        $s = $this->count;
 
-            return true;
+        if ($this->match('([0-9]*(\.)?[0-9]+)([%a-zA-Z]+)?', $m, false)) {
+            if (strlen($this->buffer) === $this->count || ! ctype_digit($this->buffer[$this->count])) {
+                $this->whitespace();
+
+                $unit = new Node\Number($m[1], empty($m[3]) ? '' : $m[3]);
+
+                return true;
+            }
+
+            $this->seek($s);
         }
 
         return false;
@@ -1687,11 +2129,11 @@ class Parser
      */
     protected function string(&$out)
     {
-        $s = $this->seek();
+        $s = $this->count;
 
-        if ($this->literal('"', false)) {
+        if ($this->matchChar('"', false)) {
             $delim = '"';
-        } elseif ($this->literal("'", false)) {
+        } elseif ($this->matchChar("'", false)) {
             $delim = "'";
         } else {
             return false;
@@ -1718,10 +2160,18 @@ class Parser
                     $content[] = '#{'; // ignore it
                 }
             } elseif ($m[2] === '\\') {
-                if ($this->literal('"', false)) {
+                if ($this->matchChar('"', false)) {
                     $content[] = $m[2] . '"';
-                } elseif ($this->literal("'", false)) {
+                } elseif ($this->matchChar("'", false)) {
                     $content[] = $m[2] . "'";
+                } elseif ($this->literal("\\", 1, false)) {
+                    $content[] = $m[2] . "\\";
+                } elseif ($this->literal("\r\n", 2, false) ||
+                  $this->matchChar("\r", false) ||
+                  $this->matchChar("\n", false) ||
+                  $this->matchChar("\f", false)
+                ) {
+                    // this is a continuation escaping, to be ignored
                 } else {
                     $content[] = $m[2];
                 }
@@ -1733,12 +2183,14 @@ class Parser
 
         $this->eatWhiteDefault = $oldWhite;
 
-        if ($this->literal($delim)) {
+        if ($this->literal($delim, strlen($delim))) {
             if ($hasInterpolation) {
                 $delim = '"';
 
                 foreach ($content as &$string) {
-                    if ($string === "\\'") {
+                    if ($string === "\\\\") {
+                        $string = "\\";
+                    } elseif ($string === "\\'") {
                         $string = "'";
                     } elseif ($string === '\\"') {
                         $string = '"';
@@ -1759,11 +2211,12 @@ class Parser
     /**
      * Parse keyword or interpolation
      *
-     * @param array $out
+     * @param array   $out
+     * @param boolean $restricted
      *
      * @return boolean
      */
-    protected function mixedKeyword(&$out)
+    protected function mixedKeyword(&$out, $restricted = false)
     {
         $parts = [];
 
@@ -1771,7 +2224,7 @@ class Parser
         $this->eatWhiteDefault = false;
 
         for (;;) {
-            if ($this->keyword($key)) {
+            if ($restricted ? $this->restrictedKeyword($key) : $this->keyword($key)) {
                 $parts[] = $key;
                 continue;
             }
@@ -1786,7 +2239,7 @@ class Parser
 
         $this->eatWhiteDefault = $oldWhite;
 
-        if (count($parts) === 0) {
+        if (! $parts) {
             return false;
         }
 
@@ -1852,7 +2305,7 @@ class Parser
 
         $this->eatWhiteDefault = $oldWhite;
 
-        if (count($content) === 0) {
+        if (! $content) {
             return false;
         }
 
@@ -1879,17 +2332,22 @@ class Parser
         $oldWhite = $this->eatWhiteDefault;
         $this->eatWhiteDefault = true;
 
-        $s = $this->seek();
+        $s = $this->count;
 
-        if ($this->literal('#{') && $this->valueList($value) && $this->literal('}', false)) {
-            if ($lookWhite) {
-                $left = preg_match('/\s/', $this->buffer[$s - 1]) ? ' ' : '';
-                $right = preg_match('/\s/', $this->buffer[$this->count]) ? ' ': '';
+        if ($this->literal('#{', 2) && $this->valueList($value) && $this->matchChar('}', false)) {
+            if ($value === [Type::T_SELF]) {
+                $out = $value;
             } else {
-                $left = $right = false;
+                if ($lookWhite) {
+                    $left = ($s > 0 && preg_match('/\s/', $this->buffer[$s - 1])) ? ' ' : '';
+                    $right = preg_match('/\s/', $this->buffer[$this->count]) ? ' ': '';
+                } else {
+                    $left = $right = false;
+                }
+
+                $out = [Type::T_INTERPOLATE, $value, $left, $right];
             }
 
-            $out = [Type::T_INTERPOLATE, $value, $left, $right];
             $this->eatWhiteDefault = $oldWhite;
 
             if ($this->eatWhiteDefault) {
@@ -1900,6 +2358,7 @@ class Parser
         }
 
         $this->seek($s);
+
         $this->eatWhiteDefault = $oldWhite;
 
         return false;
@@ -1930,7 +2389,7 @@ class Parser
                 continue;
             }
 
-            if (count($parts) === 0 && $this->match('[:.#]', $m, false)) {
+            if (! $parts && $this->match('[:.#]', $m, false)) {
                 // css hacks
                 $parts[] = $m[0];
                 continue;
@@ -1941,7 +2400,7 @@ class Parser
 
         $this->eatWhiteDefault = $oldWhite;
 
-        if (count($parts) === 0) {
+        if (! $parts) {
             return false;
         }
 
@@ -1973,24 +2432,24 @@ class Parser
      *
      * @return boolean
      */
-    protected function selectors(&$out)
+    protected function selectors(&$out, $subSelector = false)
     {
-        $s = $this->seek();
+        $s = $this->count;
         $selectors = [];
 
-        while ($this->selector($sel)) {
+        while ($this->selector($sel, $subSelector)) {
             $selectors[] = $sel;
 
-            if (! $this->literal(',')) {
+            if (! $this->matchChar(',', true)) {
                 break;
             }
 
-            while ($this->literal(',')) {
+            while ($this->matchChar(',', true)) {
                 ; // ignore extra
             }
         }
 
-        if (count($selectors) === 0) {
+        if (! $selectors) {
             $this->seek($s);
 
             return false;
@@ -2008,23 +2467,23 @@ class Parser
      *
      * @return boolean
      */
-    protected function selector(&$out)
+    protected function selector(&$out, $subSelector = false)
     {
         $selector = [];
 
         for (;;) {
-            if ($this->match('[>+~]+', $m)) {
+            if ($this->match('[>+~]+', $m, true)) {
                 $selector[] = [$m[0]];
                 continue;
             }
 
-            if ($this->selectorSingle($part)) {
+            if ($this->selectorSingle($part, $subSelector)) {
                 $selector[] = $part;
                 $this->match('\s+', $m);
                 continue;
             }
 
-            if ($this->match('\/[^\/]+\/', $m)) {
+            if ($this->match('\/[^\/]+\/', $m, true)) {
                 $selector[] = [$m[0]];
                 continue;
             }
@@ -2032,11 +2491,12 @@ class Parser
             break;
         }
 
-        if (count($selector) === 0) {
+        if (! $selector) {
             return false;
         }
 
         $out = $selector;
+
         return true;
     }
 
@@ -2051,108 +2511,155 @@ class Parser
      *
      * @return boolean
      */
-    protected function selectorSingle(&$out)
+    protected function selectorSingle(&$out, $subSelector = false)
     {
         $oldWhite = $this->eatWhiteDefault;
         $this->eatWhiteDefault = false;
 
         $parts = [];
 
-        if ($this->literal('*', false)) {
+        if ($this->matchChar('*', false)) {
             $parts[] = '*';
         }
 
         for (;;) {
-            // see if we can stop early
-            if ($this->match('\s*[{,]', $m)) {
-                $this->count--;
+            if (! isset($this->buffer[$this->count])) {
                 break;
             }
 
-            $s = $this->seek();
+            $s = $this->count;
+            $char = $this->buffer[$this->count];
 
-            // self
-            if ($this->literal('&', false)) {
-                $parts[] = Compiler::$selfSelector;
-                continue;
+            // see if we can stop early
+            if ($char === '{' || $char === ',' || $char === ';' || $char === '}' || $char === '@') {
+                break;
             }
 
-            if ($this->literal('.', false)) {
-                $parts[] = '.';
-                continue;
+            // parsing a sub selector in () stop with the closing )
+            if ($subSelector && $char === ')') {
+                break;
             }
 
-            if ($this->literal('|', false)) {
-                $parts[] = '|';
-                continue;
+            //self
+            switch ($char) {
+                case '&':
+                    $parts[] = Compiler::$selfSelector;
+                    $this->count++;
+                    continue 2;
+
+                case '.':
+                    $parts[] = '.';
+                    $this->count++;
+                    continue 2;
+
+                case '|':
+                    $parts[] = '|';
+                    $this->count++;
+                    continue 2;
             }
 
-            if ($this->match('\\\\\S', $m)) {
+            if ($char === '\\' && $this->match('\\\\\S', $m)) {
                 $parts[] = $m[0];
                 continue;
             }
 
-            // for keyframes
-            if ($this->unit($unit)) {
-                $parts[] = $unit;
-                continue;
+            if ($char === '%') {
+                $this->count++;
+
+                if ($this->placeholder($placeholder)) {
+                    $parts[] = '%';
+                    $parts[] = $placeholder;
+                    continue;
+                }
+
+                break;
             }
 
-            if ($this->keyword($name)) {
-                $parts[] = $name;
-                continue;
-            }
+            if ($char === '#') {
+                if ($this->interpolation($inter)) {
+                    $parts[] = $inter;
+                    continue;
+                }
 
-            if ($this->interpolation($inter)) {
-                $parts[] = $inter;
-                continue;
-            }
-
-            if ($this->literal('%', false) && $this->placeholder($placeholder)) {
-                $parts[] = '%';
-                $parts[] = $placeholder;
-                continue;
-            }
-
-            if ($this->literal('#', false)) {
                 $parts[] = '#';
+                $this->count++;
                 continue;
             }
 
             // a pseudo selector
-            if ($this->match('::?', $m) && $this->mixedKeyword($nameParts)) {
-                $parts[] = $m[0];
-
-                foreach ($nameParts as $sub) {
-                    $parts[] = $sub;
+            if ($char === ':') {
+                if ($this->buffer[$this->count + 1] === ':') {
+                    $this->count += 2;
+                    $part = '::';
+                } else {
+                    $this->count++;
+                    $part = ':';
                 }
 
-                $ss = $this->seek();
+                if ($this->mixedKeyword($nameParts, true)) {
+                    $parts[] = $part;
 
-                if ($this->literal('(') &&
-                    ($this->openString(')', $str, '(') || true) &&
-                    $this->literal(')')
-                ) {
-                    $parts[] = '(';
-
-                    if (! empty($str)) {
-                        $parts[] = $str;
+                    foreach ($nameParts as $sub) {
+                        $parts[] = $sub;
                     }
 
-                    $parts[] = ')';
-                } else {
-                    $this->seek($ss);
-                }
+                    $ss = $this->count;
 
-                continue;
+                    if ($nameParts === ['not'] || $nameParts === ['is'] ||
+                        $nameParts === ['has'] || $nameParts === ['where']
+                    ) {
+                        if ($this->matchChar('(') &&
+                          ($this->selectors($subs, true) || true) &&
+                          $this->matchChar(')')
+                        ) {
+                            $parts[] = '(';
+
+                            while ($sub = array_shift($subs)) {
+                                while ($ps = array_shift($sub)) {
+                                    foreach ($ps as &$p) {
+                                        $parts[] = $p;
+                                    }
+                                    if (count($sub) && reset($sub)) {
+                                        $parts[] = ' ';
+                                    }
+                                }
+                                if (count($subs) && reset($subs)) {
+                                    $parts[] = ', ';
+                                }
+                            }
+
+                            $parts[] = ')';
+                        } else {
+                            $this->seek($ss);
+                        }
+                    } else {
+                        if ($this->matchChar('(') &&
+                          ($this->openString(')', $str, '(') || true) &&
+                          $this->matchChar(')')
+                        ) {
+                            $parts[] = '(';
+
+                            if (! empty($str)) {
+                                $parts[] = $str;
+                            }
+
+                            $parts[] = ')';
+                        } else {
+                            $this->seek($ss);
+                        }
+                    }
+
+                    continue;
+                }
             }
 
             $this->seek($s);
 
             // attribute selector
-            if ($this->literal('[') &&
-               ($this->openString(']', $str, '[') || true) &&
-               $this->literal(']')
+            if ($char === '[' &&
+                $this->matchChar('[') &&
+                ($this->openString(']', $str, '[') || true) &&
+                $this->matchChar(']')
             ) {
                 $parts[] = '[';
 
@@ -2161,18 +2668,28 @@ class Parser
                 }
 
                 $parts[] = ']';
-
                 continue;
             }
 
             $this->seek($s);
 
+            // for keyframes
+            if ($this->unit($unit)) {
+                $parts[] = $unit;
+                continue;
+            }
+
+            if ($this->restrictedKeyword($name)) {
+                $parts[] = $name;
+                continue;
+            }
+
             break;
         }
 
         $this->eatWhiteDefault = $oldWhite;
 
-        if (count($parts) === 0) {
+        if (! $parts) {
             return false;
         }
 
@@ -2190,9 +2707,9 @@ class Parser
      */
     protected function variable(&$out)
     {
-        $s = $this->seek();
+        $s = $this->count;
 
-        if ($this->literal('$', false) && $this->keyword($name)) {
+        if ($this->matchChar('$', false) && $this->keyword($name)) {
             $out = [Type::T_VARIABLE, $name];
 
             return true;
@@ -2215,7 +2732,7 @@ class Parser
     {
         if ($this->match(
             $this->utf8
-                ? '(([\pL\w_\-\*!"\']|[\\\\].)([\pL\w\-_"\']|[\\\\].)*)'
+                ? '(([\pL\w\x{00A0}-\x{10FFFF}_\-\*!"\']|[\\\\].)([\pL\w\x{00A0}-\x{10FFFF}\-_"\']|[\\\\].)*)'
                 : '(([\w_\-\*!"\']|[\\\\].)([\w\-_"\']|[\\\\].)*)',
             $m,
             $eatWhitespace
@@ -2228,6 +2745,27 @@ class Parser
         return false;
     }
 
+    /**
+     * Parse a keyword that should not start with a number
+     *
+     * @param string  $word
+     * @param boolean $eatWhitespace
+     *
+     * @return boolean
+     */
+    protected function restrictedKeyword(&$word, $eatWhitespace = null)
+    {
+        $s = $this->count;
+
+        if ($this->keyword($word, $eatWhitespace) && (ord($word[0]) > 57 || ord($word[0]) < 48)) {
+            return true;
+        }
+
+        $this->seek($s);
+
+        return false;
+    }
+
     /**
      * Parse a placeholder
      *
@@ -2239,14 +2777,17 @@ class Parser
     {
         if ($this->match(
             $this->utf8
-                ? '([\pL\w\-_]+|#[{][$][\pL\w\-_]+[}])'
-                : '([\w\-_]+|#[{][$][\w\-_]+[}])',
+                ? '([\pL\w\-_]+)'
+                : '([\w\-_]+)',
             $m
         )) {
             $placeholder = $m[1];
 
             return true;
         }
+        if ($this->interpolation($placeholder)) {
+            return true;
+        }
 
         return false;
     }
@@ -2276,7 +2817,7 @@ class Parser
      */
     protected function end()
     {
-        if ($this->literal(';')) {
+        if ($this->matchChar(';')) {
             return true;
         }
 
@@ -2438,7 +2979,7 @@ class Parser
      *
      * @param integer $pos
      *
-     * @return integer
+     * @return array
      */
     private function getSourcePosition($pos)
     {
diff --git a/lib/scssphp/SourceMap/Base64.php b/lib/scssphp/SourceMap/Base64.php
new file mode 100644
index 00000000000..93c6c1b47f4
--- /dev/null
+++ b/lib/scssphp/SourceMap/Base64.php
@@ -0,0 +1,184 @@
+<?php
+/**
+ * SCSSPHP
+ *
+ * @copyright 2012-2019 Leaf Corcoran
+ *
+ * @license http://opensource.org/licenses/MIT MIT
+ *
+ * @link http://scssphp.github.io/scssphp
+ */
+
+namespace ScssPhp\ScssPhp\SourceMap;
+
+/**
+ * Base 64 Encode/Decode
+ *
+ * @author Anthon Pang <anthon.pang@gmail.com>
+ */
+class Base64
+{
+    /**
+     * @var array
+     */
+    private static $encodingMap = [
+        0 => 'A',
+        1 => 'B',
+        2 => 'C',
+        3 => 'D',
+        4 => 'E',
+        5 => 'F',
+        6 => 'G',
+        7 => 'H',
+        8 => 'I',
+        9 => 'J',
+        10 => 'K',
+        11 => 'L',
+        12 => 'M',
+        13 => 'N',
+        14 => 'O',
+        15 => 'P',
+        16 => 'Q',
+        17 => 'R',
+        18 => 'S',
+        19 => 'T',
+        20 => 'U',
+        21 => 'V',
+        22 => 'W',
+        23 => 'X',
+        24 => 'Y',
+        25 => 'Z',
+        26 => 'a',
+        27 => 'b',
+        28 => 'c',
+        29 => 'd',
+        30 => 'e',
+        31 => 'f',
+        32 => 'g',
+        33 => 'h',
+        34 => 'i',
+        35 => 'j',
+        36 => 'k',
+        37 => 'l',
+        38 => 'm',
+        39 => 'n',
+        40 => 'o',
+        41 => 'p',
+        42 => 'q',
+        43 => 'r',
+        44 => 's',
+        45 => 't',
+        46 => 'u',
+        47 => 'v',
+        48 => 'w',
+        49 => 'x',
+        50 => 'y',
+        51 => 'z',
+        52 => '0',
+        53 => '1',
+        54 => '2',
+        55 => '3',
+        56 => '4',
+        57 => '5',
+        58 => '6',
+        59 => '7',
+        60 => '8',
+        61 => '9',
+        62 => '+',
+        63 => '/',
+    ];
+
+    /**
+     * @var array
+     */
+    private static $decodingMap = [
+        'A' => 0,
+        'B' => 1,
+        'C' => 2,
+        'D' => 3,
+        'E' => 4,
+        'F' => 5,
+        'G' => 6,
+        'H' => 7,
+        'I' => 8,
+        'J' => 9,
+        'K' => 10,
+        'L' => 11,
+        'M' => 12,
+        'N' => 13,
+        'O' => 14,
+        'P' => 15,
+        'Q' => 16,
+        'R' => 17,
+        'S' => 18,
+        'T' => 19,
+        'U' => 20,
+        'V' => 21,
+        'W' => 22,
+        'X' => 23,
+        'Y' => 24,
+        'Z' => 25,
+        'a' => 26,
+        'b' => 27,
+        'c' => 28,
+        'd' => 29,
+        'e' => 30,
+        'f' => 31,
+        'g' => 32,
+        'h' => 33,
+        'i' => 34,
+        'j' => 35,
+        'k' => 36,
+        'l' => 37,
+        'm' => 38,
+        'n' => 39,
+        'o' => 40,
+        'p' => 41,
+        'q' => 42,
+        'r' => 43,
+        's' => 44,
+        't' => 45,
+        'u' => 46,
+        'v' => 47,
+        'w' => 48,
+        'x' => 49,
+        'y' => 50,
+        'z' => 51,
+        0 => 52,
+        1 => 53,
+        2 => 54,
+        3 => 55,
+        4 => 56,
+        5 => 57,
+        6 => 58,
+        7 => 59,
+        8 => 60,
+        9 => 61,
+        '+' => 62,
+        '/' => 63,
+    ];
+
+    /**
+     * Convert to base64
+     *
+     * @param integer $value
+     *
+     * @return string
+     */
+    public static function encode($value)
+    {
+        return self::$encodingMap[$value];
+    }
+
+    /**
+     * Convert from base64
+     *
+     * @param string $value
+     *
+     * @return integer
+     */
+    public static function decode($value)
+    {
+        return self::$decodingMap[$value];
+    }
+}
diff --git a/lib/scssphp/SourceMap/Base64VLQ.php b/lib/scssphp/SourceMap/Base64VLQ.php
new file mode 100644
index 00000000000..d6f6452b5c5
--- /dev/null
+++ b/lib/scssphp/SourceMap/Base64VLQ.php
@@ -0,0 +1,137 @@
+<?php
+/**
+ * SCSSPHP
+ *
+ * @copyright 2012-2019 Leaf Corcoran
+ *
+ * @license http://opensource.org/licenses/MIT MIT
+ *
+ * @link http://scssphp.github.io/scssphp
+ */
+
+namespace ScssPhp\ScssPhp\SourceMap;
+
+use ScssPhp\ScssPhp\SourceMap\Base64;
+
+/**
+ * Base 64 VLQ
+ *
+ * Based on the Base 64 VLQ implementation in Closure Compiler:
+ * https://github.com/google/closure-compiler/blob/master/src/com/google/debugging/sourcemap/Base64VLQ.java
+ *
+ * Copyright 2011 The Closure Compiler Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @author John Lenz <johnlenz@google.com>
+ * @author Anthon Pang <anthon.pang@gmail.com>
+ */
+class Base64VLQ
+{
+    // A Base64 VLQ digit can represent 5 bits, so it is base-32.
+    const VLQ_BASE_SHIFT = 5;
+
+    // A mask of bits for a VLQ digit (11111), 31 decimal.
+    const VLQ_BASE_MASK = 31;
+
+    // The continuation bit is the 6th bit.
+    const VLQ_CONTINUATION_BIT = 32;
+
+    /**
+     * Returns the VLQ encoded value.
+     *
+     * @param integer $value
+     *
+     * @return string
+     */
+    public static function encode($value)
+    {
+        $encoded = '';
+        $vlq = self::toVLQSigned($value);
+
+        do {
+            $digit = $vlq & self::VLQ_BASE_MASK;
+            $vlq >>= self::VLQ_BASE_SHIFT;
+
+            if ($vlq > 0) {
+                $digit |= self::VLQ_CONTINUATION_BIT;
+            }
+
+            $encoded .= Base64::encode($digit);
+        } while ($vlq > 0);
+
+        return $encoded;
+    }
+
+    /**
+     * Decodes VLQValue.
+     *
+     * @param string $str
+     * @param integer $index
+     *
+     * @return integer
+     */
+    public static function decode($str, &$index)
+    {
+        $result = 0;
+        $shift = 0;
+
+        do {
+            $c = $str[$index++];
+            $digit = Base64::decode($c);
+            $continuation = ($digit & self::VLQ_CONTINUATION_BIT) != 0;
+            $digit &= self::VLQ_BASE_MASK;
+            $result = $result + ($digit << $shift);
+            $shift = $shift + self::VLQ_BASE_SHIFT;
+        } while ($continuation);
+
+        return self::fromVLQSigned($result);
+    }
+
+    /**
+     * Converts from a two-complement value to a value where the sign bit is
+     * is placed in the least significant bit.  For example, as decimals:
+     *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
+     *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
+     *
+     * @param integer $value
+     *
+     * @return integer
+     */
+    private static function toVLQSigned($value)
+    {
+        if ($value < 0) {
+            return ((-$value) << 1) + 1;
+        }
+
+        return ($value << 1) + 0;
+    }
+
+    /**
+     * Converts to a two-complement value from a value where the sign bit is
+     * is placed in the least significant bit.  For example, as decimals:
+     *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
+     *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
+     *
+     * @param integer $value
+     *
+     * @return integer
+     */
+    private static function fromVLQSigned($value)
+    {
+        $negate = ($value & 1) === 1;
+        $value = $value >> 1;
+
+        return $negate ? -$value : $value;
+    }
+}
diff --git a/lib/scssphp/SourceMap/Base64VLQEncoder.php b/lib/scssphp/SourceMap/Base64VLQEncoder.php
index 1189ce0e5a5..365b4d93042 100644
--- a/lib/scssphp/SourceMap/Base64VLQEncoder.php
+++ b/lib/scssphp/SourceMap/Base64VLQEncoder.php
@@ -2,14 +2,14 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp\SourceMap;
+namespace ScssPhp\ScssPhp\SourceMap;
 
 /**
  * Base64 VLQ Encoder
@@ -47,7 +47,7 @@ class Base64VLQEncoder
      *
      * @var array
      */
-    private $charToIntMap = array(
+    private $charToIntMap = [
         'A' => 0,  'B' => 1,  'C' => 2,  'D' => 3,  'E' => 4,  'F' => 5,  'G' => 6,  'H' => 7,
         'I' => 8,  'J' => 9,  'K' => 10, 'L' => 11, 'M' => 12, 'N' => 13, 'O' => 14, 'P' => 15,
         'Q' => 16, 'R' => 17, 'S' => 18, 'T' => 19, 'U' => 20, 'V' => 21, 'W' => 22, 'X' => 23,
@@ -56,14 +56,14 @@ class Base64VLQEncoder
         'o' => 40, 'p' => 41, 'q' => 42, 'r' => 43, 's' => 44, 't' => 45, 'u' => 46, 'v' => 47,
         'w' => 48, 'x' => 49, 'y' => 50, 'z' => 51,   0 => 52,   1 => 53,   2 => 54,   3 => 55,
           4 => 56,   5 => 57,   6 => 58,   7 => 59,   8 => 60,   9 => 61, '+' => 62, '/' => 63,
-    );
+    ];
 
     /**
      * Integer to char map
      *
      * @var array
      */
-    private $intToCharMap = array(
+    private $intToCharMap = [
          0 => 'A',  1 => 'B',  2 => 'C',  3 => 'D',  4 => 'E',  5 => 'F',  6 => 'G',  7 => 'H',
          8 => 'I',  9 => 'J', 10 => 'K', 11 => 'L', 12 => 'M', 13 => 'N', 14 => 'O', 15 => 'P',
         16 => 'Q', 17 => 'R', 18 => 'S', 19 => 'T', 20 => 'U', 21 => 'V', 22 => 'W', 23 => 'X',
@@ -72,7 +72,7 @@ class Base64VLQEncoder
         40 => 'o', 41 => 'p', 42 => 'q', 43 => 'r', 44 => 's', 45 => 't', 46 => 'u', 47 => 'v',
         48 => 'w', 49 => 'x', 50 => 'y', 51 => 'z', 52 => '0', 53 => '1', 54 => '2', 55 => '3',
         56 => '4', 57 => '5', 58 => '6', 59 => '7', 60 => '8', 61 => '9', 62 => '+', 63 => '/',
-    );
+    ];
 
     /**
      * Constructor
diff --git a/lib/scssphp/SourceMap/SourceMapGenerator.php b/lib/scssphp/SourceMap/SourceMapGenerator.php
index 70b47cdc7a4..d0231b49d35 100644
--- a/lib/scssphp/SourceMap/SourceMapGenerator.php
+++ b/lib/scssphp/SourceMap/SourceMapGenerator.php
@@ -2,16 +2,16 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp\SourceMap;
+namespace ScssPhp\ScssPhp\SourceMap;
 
-use Leafo\ScssPhp\Exception\CompilerException;
+use ScssPhp\ScssPhp\Exception\CompilerException;
 
 /**
  * Source Map Generator
@@ -33,7 +33,7 @@ class SourceMapGenerator
      *
      * @var array
      */
-    protected $defaultOptions = array(
+    protected $defaultOptions = [
         // an optional source root, useful for relocating source files
         // on a server or removing repeated values in the 'sources' entry.
         // This value is prepended to the individual entries in the 'source' field.
@@ -56,12 +56,12 @@ class SourceMapGenerator
 
         // base path for filename normalization
         'sourceMapBasepath' => ''
-    );
+    ];
 
     /**
      * The base64 VLQ encoder
      *
-     * @var \Leafo\ScssPhp\SourceMap\Base64VLQEncoder
+     * @var \ScssPhp\ScssPhp\SourceMap\Base64VLQ
      */
     protected $encoder;
 
@@ -70,22 +70,22 @@ class SourceMapGenerator
      *
      * @var array
      */
-    protected $mappings = array();
+    protected $mappings = [];
 
     /**
      * Array of contents map
      *
      * @var array
      */
-    protected $contentsMap = array();
+    protected $contentsMap = [];
 
     /**
      * File to content map
      *
      * @var array
      */
-    protected $sources = array();
-    protected $source_keys = array();
+    protected $sources = [];
+    protected $sourceKeys = [];
 
     /**
      * @var array
@@ -95,7 +95,7 @@ class SourceMapGenerator
     public function __construct(array $options = [])
     {
         $this->options = array_merge($this->defaultOptions, $options);
-        $this->encoder = new Base64VLQEncoder();
+        $this->encoder = new Base64VLQ();
     }
 
     /**
@@ -109,13 +109,13 @@ class SourceMapGenerator
      */
     public function addMapping($generatedLine, $generatedColumn, $originalLine, $originalColumn, $sourceFile)
     {
-        $this->mappings[] = array(
-            'generated_line' => $generatedLine,
+        $this->mappings[] = [
+            'generated_line'   => $generatedLine,
             'generated_column' => $generatedColumn,
-            'original_line' => $originalLine,
-            'original_column' => $originalColumn,
-            'source_file' => $sourceFile
-        );
+            'original_line'    => $originalLine,
+            'original_column'  => $originalColumn,
+            'source_file'      => $sourceFile
+        ];
 
         $this->sources[$sourceFile] = $sourceFile;
     }
@@ -123,10 +123,11 @@ class SourceMapGenerator
     /**
      * Saves the source map to a file
      *
-     * @param string $file    The absolute path to a file
      * @param string $content The content to write
      *
-     * @throws \Leafo\ScssPhp\Exception\CompilerException If the file could not be saved
+     * @return string
+     *
+     * @throws \ScssPhp\ScssPhp\Exception\CompilerException If the file could not be saved
      */
     public function saveMap($content)
     {
@@ -136,7 +137,9 @@ class SourceMapGenerator
         // directory does not exist
         if (! is_dir($dir)) {
             // FIXME: create the dir automatically?
-            throw new CompilerException(sprintf('The directory "%s" does not exist. Cannot save the source map.', $dir));
+            throw new CompilerException(
+                sprintf('The directory "%s" does not exist. Cannot save the source map.', $dir)
+            );
         }
 
         // FIXME: proper saving, with dir write check!
@@ -156,7 +159,7 @@ class SourceMapGenerator
      */
     public function generateJson()
     {
-        $sourceMap = array();
+        $sourceMap = [];
         $mappings  = $this->generateMappings();
 
         // File version (always the first entry in the object) and must be a positive integer.
@@ -178,14 +181,14 @@ class SourceMapGenerator
         }
 
         // A list of original sources used by the 'mappings' entry.
-        $sourceMap['sources'] = array();
+        $sourceMap['sources'] = [];
 
-        foreach ($this->sources as $source_uri => $source_filename) {
-            $sourceMap['sources'][] = $this->normalizeFilename($source_filename);
+        foreach ($this->sources as $sourceUri => $sourceFilename) {
+            $sourceMap['sources'][] = $this->normalizeFilename($sourceFilename);
         }
 
         // A list of symbol names used by the 'mappings' entry.
-        $sourceMap['names'] = array();
+        $sourceMap['names'] = [];
 
         // A string with the encoded mapping data.
         $sourceMap['mappings'] = $mappings;
@@ -202,7 +205,7 @@ class SourceMapGenerator
             unset($sourceMap['sourceRoot']);
         }
 
-        return json_encode($sourceMap);
+        return json_encode($sourceMap, JSON_UNESCAPED_SLASHES);
     }
 
     /**
@@ -216,7 +219,7 @@ class SourceMapGenerator
             return null;
         }
 
-        $content = array();
+        $content = [];
 
         foreach ($this->sources as $sourceFile) {
             $content[] = file_get_contents($sourceFile);
@@ -236,10 +239,10 @@ class SourceMapGenerator
             return '';
         }
 
-        $this->source_keys = array_flip(array_keys($this->sources));
+        $this->sourceKeys = array_flip(array_keys($this->sources));
 
         // group mappings by generated line number.
-        $groupedMap = $groupedMapEncoded = array();
+        $groupedMap = $groupedMapEncoded = [];
 
         foreach ($this->mappings as $m) {
             $groupedMap[$m['generated_line']][] = $m;
@@ -248,15 +251,15 @@ class SourceMapGenerator
         ksort($groupedMap);
         $lastGeneratedLine = $lastOriginalIndex = $lastOriginalLine = $lastOriginalColumn = 0;
 
-        foreach ($groupedMap as $lineNumber => $line_map) {
+        foreach ($groupedMap as $lineNumber => $lineMap) {
             while (++$lastGeneratedLine < $lineNumber) {
                 $groupedMapEncoded[] = ';';
             }
 
-            $lineMapEncoded = array();
+            $lineMapEncoded = [];
             $lastGeneratedColumn = 0;
 
-            foreach ($line_map as $m) {
+            foreach ($lineMap as $m) {
                 $mapEncoded = $this->encoder->encode($m['generated_column'] - $lastGeneratedColumn);
                 $lastGeneratedColumn = $m['generated_column'];
 
@@ -293,9 +296,16 @@ class SourceMapGenerator
      */
     protected function findFileIndex($filename)
     {
-        return $this->source_keys[$filename];
+        return $this->sourceKeys[$filename];
     }
 
+    /**
+     * Normalize filename
+     *
+     * @param string $filename
+     *
+     * @return string
+     */
     protected function normalizeFilename($filename)
     {
         $filename = $this->fixWindowsPath($filename);
@@ -303,7 +313,7 @@ class SourceMapGenerator
         $basePath = $this->options['sourceMapBasepath'];
 
         // "Trim" the 'sourceMapBasepath' from the output filename.
-        if (strpos($filename, $basePath) === 0) {
+        if (strlen($basePath) && strpos($filename, $basePath) === 0) {
             $filename = substr($filename, strlen($basePath));
         }
 
diff --git a/lib/scssphp/Type.php b/lib/scssphp/Type.php
index e84c47e4032..a12da72f2bb 100644
--- a/lib/scssphp/Type.php
+++ b/lib/scssphp/Type.php
@@ -2,14 +2,14 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp;
+namespace ScssPhp\ScssPhp;
 
 /**
  * Block/node types
diff --git a/lib/scssphp/Util.php b/lib/scssphp/Util.php
index 7526e020566..b0b76fdb42e 100644
--- a/lib/scssphp/Util.php
+++ b/lib/scssphp/Util.php
@@ -2,17 +2,17 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp;
+namespace ScssPhp\ScssPhp;
 
-use Leafo\ScssPhp\Base\Range;
-use Leafo\ScssPhp\Exception\RangeException;
+use ScssPhp\ScssPhp\Base\Range;
+use ScssPhp\ScssPhp\Exception\RangeException;
 
 /**
  * Utilty functions
@@ -26,13 +26,13 @@ class Util
      * room for slight floating-point errors.
      *
      * @param string                    $name  The name of the value. Used in the error message.
-     * @param \Leafo\ScssPhp\Base\Range $range Range of values.
+     * @param \ScssPhp\ScssPhp\Base\Range $range Range of values.
      * @param array                     $value The value to check.
      * @param string                    $unit  The unit of the value. Used in error reporting.
      *
      * @return mixed `value` adjusted to fall within range, if it was outside by a floating-point margin.
      *
-     * @throws \Leafo\ScssPhp\Exception\RangeException
+     * @throws \ScssPhp\ScssPhp\Exception\RangeException
      */
     public static function checkRange($name, Range $range, $value, $unit = '')
     {
@@ -63,7 +63,7 @@ class Util
      */
     public static function encodeURIComponent($string)
     {
-        $revert = array('%21' => '!', '%2A' => '*', '%27' => "'", '%28' => '(', '%29' => ')');
+        $revert = ['%21' => '!', '%2A' => '*', '%27' => "'", '%28' => '(', '%29' => ')'];
 
         return strtr(rawurlencode($string), $revert);
     }
diff --git a/lib/scssphp/Version.php b/lib/scssphp/Version.php
index 3b8dcd00795..d5e6dc08762 100644
--- a/lib/scssphp/Version.php
+++ b/lib/scssphp/Version.php
@@ -2,14 +2,14 @@
 /**
  * SCSSPHP
  *
- * @copyright 2012-2018 Leaf Corcoran
+ * @copyright 2012-2019 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
- * @link http://leafo.github.io/scssphp
+ * @link http://scssphp.github.io/scssphp
  */
 
-namespace Leafo\ScssPhp;
+namespace ScssPhp\ScssPhp;
 
 /**
  * SCSSPHP version
@@ -18,5 +18,5 @@ namespace Leafo\ScssPhp;
  */
 class Version
 {
-    const VERSION = 'v0.7.5';
+    const VERSION = 'v1.0.2';
 }
diff --git a/lib/scssphp/moodle_readme.txt b/lib/scssphp/moodle_readme.txt
index 44fd815da84..592a0663ca8 100644
--- a/lib/scssphp/moodle_readme.txt
+++ b/lib/scssphp/moodle_readme.txt
@@ -1,7 +1,7 @@
 scssphp
 -------
 
-Downloaded from: https://github.com/leafo/scssphp
+Downloaded from: https://github.com/scssphp/scssphp
 
 Import procedure:
 
diff --git a/lib/thirdpartylibs.xml b/lib/thirdpartylibs.xml
index a7c79f64f23..6c5552b5741 100644
--- a/lib/thirdpartylibs.xml
+++ b/lib/thirdpartylibs.xml
@@ -222,7 +222,7 @@
     <location>scssphp</location>
     <name>scssphp</name>
     <license>MIT</license>
-    <version>0.7.5</version>
+    <version>1.0.2</version>
   </library>
   <library>
     <location>spout</location>
diff --git a/lib/upgrade.txt b/lib/upgrade.txt
index 634b99563d0..420edb4d9fa 100644
--- a/lib/upgrade.txt
+++ b/lib/upgrade.txt
@@ -19,6 +19,7 @@ information provided here is intended especially for developers.
     a button. Action elements which perform actions on the selected checkboxes can also be enabled/disabled depending on whether
     at least a single checkbox item is selected or not.
 * Final deprecation (removal) of the core/modal_confirm dialogue.
+* Upgrade scssphp to v1.0.2, This involves renaming classes from Leafo => ScssPhp as the repo has changed.
 
 === 3.7 ===