diff --git a/scssphp/bin/pscss b/scssphp/bin/pscss
index 02c761f..d48af2f 100755
--- a/scssphp/bin/pscss
+++ b/scssphp/bin/pscss
@@ -1,9 +1,10 @@
 #!/usr/bin/env php
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -24,13 +25,11 @@ use ScssPhp\ScssPhp\Version;
 
 $style = null;
 $loadPaths = null;
-$precision = null;
 $dumpTree = false;
 $inputFile = null;
 $changeDir = false;
 $debugInfo = false;
 $lineNumbers = false;
-$ignoreErrors = false;
 $encoding = false;
 $sourceMap = false;
 
@@ -62,7 +61,7 @@ function parseArgument(&$i, $options) {
 }
 
 for ($i = 1; $i < $argc; $i++) {
-    if ($argv[$i] === '-h' || $argv[$i] === '--help') {
+    if ($argv[$i] === '-?' || $argv[$i] === '-h' || $argv[$i] === '--help') {
         $exe = $argv[0];
 
         $HELP = <<<EOT
@@ -70,17 +69,17 @@ Usage: $exe [options] [input-file]
 
 Options include:
 
-    -h, --help          Show this message
-    --continue-on-error Continue compilation (as best as possible) when error encountered
-    --debug-info        Annotate selectors with CSS referring to the source file and line number
-    -f=format           Set the output format (compact, compressed, crunched, expanded, or nested)
-    -i=path             Set import path
-    --iso8859-1         Use iso8859-1 encoding instead of utf-8 (default utf-8)
-    --line-numbers      Annotate selectors with comments referring to the source file and line number
-    -p=precision        Set decimal number precision (default 10)
+    --help              Show this message [-h, -?]
+    --continue-on-error [deprecated] Ignored
+    --debug-info        Annotate selectors with CSS referring to the source file and line number [-g]
+    --dump-tree         Dump formatted parse tree [-T]
+    --iso8859-1         Use iso8859-1 encoding instead of default utf-8
+    --line-numbers      Annotate selectors with comments referring to the source file and line number [--line-comments]
+    --load-path=PATH    Set import path [-I]
+    --precision=N       [deprecated] Ignored. (default 10) [-p]
     --sourcemap         Create source map file
-    -T                  Dump formatted parse tree
-    -v, --version       Print the version
+    --style=FORMAT      Set the output format (compact, compressed, crunched, expanded, or nested) [-s, -t]
+    --version           Print the version [-v]
 
 EOT;
         exit($HELP);
@@ -90,12 +89,13 @@ EOT;
         exit(Version::VERSION . "\n");
     }
 
+    // Keep parsing --continue-on-error to avoid BC breaks for scripts using it
     if ($argv[$i] === '--continue-on-error') {
-        $ignoreErrors = true;
+        // TODO report it as a warning ?
         continue;
     }
 
-    if ($argv[$i] === '--debug-info') {
+    if ($argv[$i] === '-g' || $argv[$i] === '--debug-info') {
         $debugInfo = true;
         continue;
     }
@@ -115,29 +115,30 @@ EOT;
         continue;
     }
 
-    if ($argv[$i] === '-T') {
+    if ($argv[$i] === '-T' || $argv[$i] === '--dump-tree') {
         $dumpTree = true;
         continue;
     }
 
-    $value = parseArgument($i, array('-f', '--style'));
+    $value = parseArgument($i, array('-t', '-s', '--style'));
 
     if (isset($value)) {
         $style = $value;
         continue;
     }
 
-    $value = parseArgument($i, array('-i', '--load_paths'));
+    $value = parseArgument($i, array('-I', '--load-path'));
 
     if (isset($value)) {
         $loadPaths = $value;
         continue;
     }
 
+    // Keep parsing --precision to avoid BC breaks for scripts using it
     $value = parseArgument($i, array('-p', '--precision'));
 
     if (isset($value)) {
-        $precision = $value;
+        // TODO report it as a warning ?
         continue;
     }
 
@@ -184,18 +185,10 @@ if ($lineNumbers) {
     $scss->setLineNumberStyle(Compiler::LINE_COMMENTS);
 }
 
-if ($ignoreErrors) {
-    $scss->setIgnoreErrors($ignoreErrors);
-}
-
 if ($loadPaths) {
     $scss->setImportPaths(explode(PATH_SEPARATOR, $loadPaths));
 }
 
-if ($precision) {
-    $scss->setNumberPrecision($precision);
-}
-
 if ($style) {
     $scss->setFormatter('ScssPhp\\ScssPhp\\Formatter\\' . ucfirst($style));
 }
diff --git a/scssphp/scss.inc.php b/scssphp/scss.inc.php
old mode 100755
new mode 100644
index 27793a5..abbd9d2
--- a/scssphp/scss.inc.php
+++ b/scssphp/scss.inc.php
@@ -1,34 +1,36 @@
 <?php
+
 if (version_compare(PHP_VERSION, '5.6') < 0) {
-  throw new \Exception('scssphp requires PHP 5.6 or above');
+    throw new \Exception('scssphp requires PHP 5.6 or above');
 }
 
 if (! class_exists('ScssPhp\ScssPhp\Version', false)) {
-  include_once __DIR__ . '/src/Base/Range.php';
-  include_once __DIR__ . '/src/Block.php';
-  include_once __DIR__ . '/src/Cache.php';
-  include_once __DIR__ . '/src/Colors.php';
-  include_once __DIR__ . '/src/Compiler.php';
-  include_once __DIR__ . '/src/Compiler/Environment.php';
-  include_once __DIR__ . '/src/Exception/CompilerException.php';
-  include_once __DIR__ . '/src/Exception/ParserException.php';
-  include_once __DIR__ . '/src/Exception/RangeException.php';
-  include_once __DIR__ . '/src/Exception/ServerException.php';
-  include_once __DIR__ . '/src/Formatter.php';
-  include_once __DIR__ . '/src/Formatter/Compact.php';
-  include_once __DIR__ . '/src/Formatter/Compressed.php';
-  include_once __DIR__ . '/src/Formatter/Crunched.php';
-  include_once __DIR__ . '/src/Formatter/Debug.php';
-  include_once __DIR__ . '/src/Formatter/Expanded.php';
-  include_once __DIR__ . '/src/Formatter/Nested.php';
-  include_once __DIR__ . '/src/Formatter/OutputBlock.php';
-  include_once __DIR__ . '/src/Node.php';
-  include_once __DIR__ . '/src/Node/Number.php';
-  include_once __DIR__ . '/src/Parser.php';
-  include_once __DIR__ . '/src/SourceMap/Base64.php';
-  include_once __DIR__ . '/src/SourceMap/Base64VLQ.php';
-  include_once __DIR__ . '/src/SourceMap/SourceMapGenerator.php';
-  include_once __DIR__ . '/src/Type.php';
-  include_once __DIR__ . '/src/Util.php';
-  include_once __DIR__ . '/src/Version.php';
+    include_once __DIR__ . '/src/Base/Range.php';
+    include_once __DIR__ . '/src/Block.php';
+    include_once __DIR__ . '/src/Cache.php';
+    include_once __DIR__ . '/src/Colors.php';
+    include_once __DIR__ . '/src/Compiler.php';
+    include_once __DIR__ . '/src/Compiler/Environment.php';
+    include_once __DIR__ . '/src/Exception/SassException.php';
+    include_once __DIR__ . '/src/Exception/CompilerException.php';
+    include_once __DIR__ . '/src/Exception/ParserException.php';
+    include_once __DIR__ . '/src/Exception/RangeException.php';
+    include_once __DIR__ . '/src/Exception/ServerException.php';
+    include_once __DIR__ . '/src/Formatter.php';
+    include_once __DIR__ . '/src/Formatter/Compact.php';
+    include_once __DIR__ . '/src/Formatter/Compressed.php';
+    include_once __DIR__ . '/src/Formatter/Crunched.php';
+    include_once __DIR__ . '/src/Formatter/Debug.php';
+    include_once __DIR__ . '/src/Formatter/Expanded.php';
+    include_once __DIR__ . '/src/Formatter/Nested.php';
+    include_once __DIR__ . '/src/Formatter/OutputBlock.php';
+    include_once __DIR__ . '/src/Node.php';
+    include_once __DIR__ . '/src/Node/Number.php';
+    include_once __DIR__ . '/src/Parser.php';
+    include_once __DIR__ . '/src/SourceMap/Base64.php';
+    include_once __DIR__ . '/src/SourceMap/Base64VLQ.php';
+    include_once __DIR__ . '/src/SourceMap/SourceMapGenerator.php';
+    include_once __DIR__ . '/src/Type.php';
+    include_once __DIR__ . '/src/Util.php';
+    include_once __DIR__ . '/src/Version.php';
 }
diff --git a/scssphp/src/Base/Range.php b/scssphp/src/Base/Range.php
index 094e903..2846746 100644
--- a/scssphp/src/Base/Range.php
+++ b/scssphp/src/Base/Range.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2015-2019 Leaf Corcoran
+ * @copyright 2015-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
diff --git a/scssphp/src/Block.php b/scssphp/src/Block.php
index bb1afdd..aaeba71 100644
--- a/scssphp/src/Block.php
+++ b/scssphp/src/Block.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
diff --git a/scssphp/src/Cache.php b/scssphp/src/Cache.php
index 1cf496f..02d47ac 100644
--- a/scssphp/src/Cache.php
+++ b/scssphp/src/Cache.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -22,13 +23,12 @@
  * 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
+ * @author Cedric Morin <cedric@yterium.com>
  */
 class Cache
 {
@@ -57,12 +57,12 @@ class Cache
     public function __construct($options)
     {
         // check $cacheDir
-        if (isset($options['cache_dir'])) {
-            self::$cacheDir = $options['cache_dir'];
+        if (isset($options['cacheDir'])) {
+            self::$cacheDir = $options['cacheDir'];
         }
 
         if (empty(self::$cacheDir)) {
-            throw new Exception('cache_dir not set');
+            throw new Exception('cacheDir not set');
         }
 
         if (isset($options['prefix'])) {
@@ -74,7 +74,7 @@ public function __construct($options)
         }
 
         if (isset($options['forceRefresh'])) {
-            self::$forceRefresh = $options['force_refresh'];
+            self::$forceRefresh = $options['forceRefresh'];
         }
 
         self::checkCacheDir();
@@ -97,18 +97,20 @@ public function getCache($operation, $what, $options = [], $lastModified = null)
     {
         $fileCache = self::$cacheDir . self::cacheName($operation, $what, $options);
 
-        if ((! self::$forceRefresh || (self::$forceRefresh === 'once' &&
+        if (
+            ((self::$forceRefresh === false) || (self::$forceRefresh === 'once' &&
             isset(self::$refreshed[$fileCache]))) && file_exists($fileCache)
         ) {
             $cacheTime = filemtime($fileCache);
 
-            if ((is_null($lastModified) || $cacheTime > $lastModified) &&
+            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'])) {
+                if (\is_array($c) && isset($c['value'])) {
                     return $c['value'];
                 }
             }
@@ -132,6 +134,7 @@ public function setCache($operation, $what, $value, $options = [])
 
         $c = ['value' => $value];
         $c = serialize($c);
+
         file_put_contents($fileCache, $c);
 
         if (self::$forceRefresh === 'once') {
@@ -176,13 +179,11 @@ 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)) {
+        if (! is_dir(self::$cacheDir)) {
             throw new Exception('Cache directory doesn\'t exist: ' . self::$cacheDir);
-        } elseif (! is_writable(self::$cacheDir)) {
+        }
+
+        if (! is_writable(self::$cacheDir)) {
             throw new Exception('Cache directory isn\'t writable: ' . self::$cacheDir);
         }
     }
diff --git a/scssphp/src/Colors.php b/scssphp/src/Colors.php
index ad45924..4b62c36 100644
--- a/scssphp/src/Colors.php
+++ b/scssphp/src/Colors.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -25,9 +26,10 @@ class Colors
      *
      * @var array
      */
-    public static $cssColors = [
+    protected static $cssColors = [
         'aliceblue' => '240,248,255',
         'antiquewhite' => '250,235,215',
+        'cyan' => '0,255,255',
         'aqua' => '0,255,255',
         'aquamarine' => '127,255,212',
         'azure' => '240,255,255',
@@ -46,13 +48,12 @@ class Colors
         'cornflowerblue' => '100,149,237',
         'cornsilk' => '255,248,220',
         'crimson' => '220,20,60',
-        'cyan' => '0,255,255',
         'darkblue' => '0,0,139',
         'darkcyan' => '0,139,139',
         'darkgoldenrod' => '184,134,11',
         'darkgray' => '169,169,169',
-        'darkgreen' => '0,100,0',
         'darkgrey' => '169,169,169',
+        'darkgreen' => '0,100,0',
         'darkkhaki' => '189,183,107',
         'darkmagenta' => '139,0,139',
         'darkolivegreen' => '85,107,47',
@@ -74,15 +75,16 @@ class Colors
         'firebrick' => '178,34,34',
         'floralwhite' => '255,250,240',
         'forestgreen' => '34,139,34',
+        'magenta' => '255,0,255',
         'fuchsia' => '255,0,255',
         'gainsboro' => '220,220,220',
         'ghostwhite' => '248,248,255',
         'gold' => '255,215,0',
         'goldenrod' => '218,165,32',
         'gray' => '128,128,128',
+        'grey' => '128,128,128',
         'green' => '0,128,0',
         'greenyellow' => '173,255,47',
-        'grey' => '128,128,128',
         'honeydew' => '240,255,240',
         'hotpink' => '255,105,180',
         'indianred' => '205,92,92',
@@ -98,8 +100,8 @@ class Colors
         'lightcyan' => '224,255,255',
         'lightgoldenrodyellow' => '250,250,210',
         'lightgray' => '211,211,211',
-        'lightgreen' => '144,238,144',
         'lightgrey' => '211,211,211',
+        'lightgreen' => '144,238,144',
         'lightpink' => '255,182,193',
         'lightsalmon' => '255,160,122',
         'lightseagreen' => '32,178,170',
@@ -111,7 +113,6 @@ class Colors
         'lime' => '0,255,0',
         'limegreen' => '50,205,50',
         'linen' => '250,240,230',
-        'magenta' => '255,0,255',
         'maroon' => '128,0,0',
         'mediumaquamarine' => '102,205,170',
         'mediumblue' => '0,0,205',
@@ -145,7 +146,6 @@ class Colors
         'plum' => '221,160,221',
         'powderblue' => '176,224,230',
         'purple' => '128,0,128',
-        'rebeccapurple' => '102,51,153',
         'red' => '255,0,0',
         'rosybrown' => '188,143,143',
         'royalblue' => '65,105,225',
@@ -167,7 +167,6 @@ class Colors
         'teal' => '0,128,128',
         'thistle' => '216,191,216',
         'tomato' => '255,99,71',
-        'transparent' => '0,0,0,0',
         'turquoise' => '64,224,208',
         'violet' => '238,130,238',
         'wheat' => '245,222,179',
@@ -175,5 +174,72 @@ class Colors
         'whitesmoke' => '245,245,245',
         'yellow' => '255,255,0',
         'yellowgreen' => '154,205,50',
+        'rebeccapurple' => '102,51,153',
+        'transparent' => '0,0,0,0',
     ];
+
+    /**
+     * Convert named color in a [r,g,b[,a]] array
+     *
+     * @param string $colorName
+     *
+     * @return array|null
+     */
+    public static function colorNameToRGBa($colorName)
+    {
+        if (\is_string($colorName) && isset(static::$cssColors[$colorName])) {
+            $rgba = explode(',', static::$cssColors[$colorName]);
+
+            // only case with opacity is transparent, with opacity=0, so we can intval on opacity also
+            $rgba = array_map('intval', $rgba);
+
+            return $rgba;
+        }
+
+        return null;
+    }
+
+    /**
+     * Reverse conversion : from RGBA to a color name if possible
+     *
+     * @param integer $r
+     * @param integer $g
+     * @param integer $b
+     * @param integer $a
+     *
+     * @return string|null
+     */
+    public static function RGBaToColorName($r, $g, $b, $a = 1)
+    {
+        static $reverseColorTable = null;
+
+        if (! is_numeric($r) || ! is_numeric($g) || ! is_numeric($b) || ! is_numeric($a)) {
+            return null;
+        }
+
+        if ($a < 1) {
+            return null;
+        }
+
+        if (\is_null($reverseColorTable)) {
+            $reverseColorTable = [];
+
+            foreach (static::$cssColors as $name => $rgb_str) {
+                $rgb_str = explode(',', $rgb_str);
+
+                if (
+                    \count($rgb_str) == 3 &&
+                    ! isset($reverseColorTable[\intval($rgb_str[0])][\intval($rgb_str[1])][\intval($rgb_str[2])])
+                ) {
+                    $reverseColorTable[\intval($rgb_str[0])][\intval($rgb_str[1])][\intval($rgb_str[2])] = $name;
+                }
+            }
+        }
+
+        if (isset($reverseColorTable[\intval($r)][\intval($g)][\intval($b)])) {
+            return $reverseColorTable[\intval($r)][\intval($g)][\intval($b)];
+        }
+
+        return null;
+    }
 }
diff --git a/scssphp/src/Compiler.php b/scssphp/src/Compiler.php
index 8f26740..9eb8dec 100644
--- a/scssphp/src/Compiler.php
+++ b/scssphp/src/Compiler.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -73,7 +74,7 @@ class Compiler
     /**
      * @var array
      */
-    static protected $operatorNames = [
+    protected static $operatorNames = [
         '+'   => 'add',
         '-'   => 'sub',
         '*'   => 'mul',
@@ -93,23 +94,25 @@ class Compiler
     /**
      * @var array
      */
-    static protected $namespaces = [
+    protected static $namespaces = [
         'special'  => '%',
         'mixin'    => '@',
         '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 $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'];
+    public static $true         = [Type::T_KEYWORD, 'true'];
+    public static $false        = [Type::T_KEYWORD, 'false'];
+    public static $NaN          = [Type::T_KEYWORD, 'NaN'];
+    public static $Infinity     = [Type::T_KEYWORD, 'Infinity'];
+    public static $null         = [Type::T_NULL];
+    public static $nullString   = [Type::T_STRING, '', []];
+    public static $defaultValue = [Type::T_KEYWORD, ''];
+    public static $selfSelector = [Type::T_SELF];
+    public static $emptyList    = [Type::T_LIST, '', []];
+    public static $emptyMap     = [Type::T_MAP, [], []];
+    public static $emptyString  = [Type::T_STRING, '"', []];
+    public static $with         = [Type::T_KEYWORD, 'with'];
+    public static $without      = [Type::T_KEYWORD, 'without'];
 
     protected $importPaths = [''];
     protected $importCache = [];
@@ -159,11 +162,14 @@ class Compiler
     protected $stderr;
     protected $shouldEvaluate;
     protected $ignoreErrors;
+    protected $ignoreCallStackMessage = false;
 
     protected $callStack = [];
 
     /**
      * Constructor
+     *
+     * @param array|null $cacheOptions
      */
     public function __construct($cacheOptions = null)
     {
@@ -173,8 +179,15 @@ public function __construct($cacheOptions = null)
         if ($cacheOptions) {
             $this->cache = new Cache($cacheOptions);
         }
+
+        $this->stderr = fopen('php://stderr', 'w');
     }
 
+    /**
+     * Get compiler options
+     *
+     * @return array
+     */
     public function getCompileOptions()
     {
         $options = [
@@ -190,6 +203,16 @@ public function getCompileOptions()
         return $options;
     }
 
+    /**
+     * Set an alternative error output stream, for testing purpose only
+     *
+     * @param resource $handle
+     */
+    public function setErrorOuput($handle)
+    {
+        $this->stderr = $handle;
+    }
+
     /**
      * Compile scss
      *
@@ -203,14 +226,14 @@ public function getCompileOptions()
     public function compile($code, $path = null)
     {
         if ($this->cache) {
-            $cacheKey       = ($path ? $path : "(stdin)") . ":" . md5($code);
+            $cacheKey       = ($path ? $path : '(stdin)') . ':' . md5($code);
             $compileOptions = $this->getCompileOptions();
-            $cache          = $this->cache->getCache("compile", $cacheKey, $compileOptions);
+            $cache          = $this->cache->getCache('compile', $cacheKey, $compileOptions);
 
-            if (is_array($cache) && isset($cache['dependencies']) && isset($cache['out'])) {
+            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) {
+                    if (! is_file($file) || filemtime($file) !== $mtime) {
                         unset($cache);
                         break;
                     }
@@ -234,7 +257,7 @@ public function compile($code, $path = null)
         $this->storeEnv       = null;
         $this->charsetSeen    = null;
         $this->shouldEvaluate = null;
-        $this->stderr         = fopen('php://stderr', 'w');
+        $this->ignoreCallStackMessage = false;
 
         $this->parser = $this->parserFactory($path);
         $tree         = $this->parser->parse($code);
@@ -251,7 +274,7 @@ public function compile($code, $path = null)
         $sourceMapGenerator = null;
 
         if ($this->sourceMap) {
-            if (is_object($this->sourceMap) && $this->sourceMap instanceof SourceMapGenerator) {
+            if (\is_object($this->sourceMap) && $this->sourceMap instanceof SourceMapGenerator) {
                 $sourceMapGenerator = $this->sourceMap;
                 $this->sourceMap = self::SOURCE_MAP_FILE;
             } elseif ($this->sourceMap !== self::SOURCE_MAP_NONE) {
@@ -284,7 +307,7 @@ public function compile($code, $path = null)
                 'out' => &$out,
             ];
 
-            $this->cache->setCache("compile", $cacheKey, $v, $compileOptions);
+            $this->cache->setCache('compile', $cacheKey, $v, $compileOptions);
         }
 
         return $out;
@@ -299,7 +322,18 @@ public function compile($code, $path = null)
      */
     protected function parserFactory($path)
     {
-        $parser = new Parser($path, count($this->sourceNames), $this->encoding, $this->cache);
+        // https://sass-lang.com/documentation/at-rules/import
+        // CSS files imported by Sass don’t allow any special Sass features.
+        // In order to make sure authors don’t accidentally write Sass in their CSS,
+        // all Sass features that aren’t also valid CSS will produce errors.
+        // Otherwise, the CSS will be rendered as-is. It can even be extended!
+        $cssOnly = false;
+
+        if (substr($path, '-4') === '.css') {
+            $cssOnly = true;
+        }
+
+        $parser = new Parser($path, \count($this->sourceNames), $this->encoding, $this->cache, $cssOnly);
 
         $this->sourceNames[] = $path;
         $this->addParsedFile($path);
@@ -318,7 +352,7 @@ protected function parserFactory($path)
     protected function isSelfExtend($target, $origin)
     {
         foreach ($origin as $sel) {
-            if (in_array($target, $sel)) {
+            if (\in_array($target, $sel)) {
                 return true;
             }
         }
@@ -329,17 +363,13 @@ protected function isSelfExtend($target, $origin)
     /**
      * Push extends
      *
-     * @param array     $target
-     * @param array     $origin
-     * @param \stdClass $block
+     * @param array      $target
+     * @param array      $origin
+     * @param array|null $block
      */
     protected function pushExtends($target, $origin, $block)
     {
-        if ($this->isSelfExtend($target, $origin)) {
-            return;
-        }
-
-        $i = count($this->extends);
+        $i = \count($this->extends);
         $this->extends[] = [$target, $origin, $block];
 
         foreach ($target as $part) {
@@ -361,13 +391,13 @@ protected function pushExtends($target, $origin, $block)
      */
     protected function makeOutputBlock($type, $selectors = null)
     {
-        $out = new OutputBlock;
-        $out->type         = $type;
-        $out->lines        = [];
-        $out->children     = [];
-        $out->parent       = $this->scope;
-        $out->selectors    = $selectors;
-        $out->depth        = $this->env->depth;
+        $out = new OutputBlock();
+        $out->type      = $type;
+        $out->lines     = [];
+        $out->children  = [];
+        $out->parent    = $this->scope;
+        $out->selectors = $selectors;
+        $out->depth     = $this->env->depth;
 
         if ($this->env->block instanceof Block) {
             $out->sourceName   = $this->env->block->sourceName;
@@ -417,7 +447,7 @@ protected function missingSelectors()
             $origin = $this->collapseSelectors($origin);
 
             $this->sourceLine = $block[Parser::SOURCE_LINE];
-            $this->throwError("\"$origin\" failed to @extend \"$target\". The selector \"$target\" was not found.");
+            throw $this->error("\"$origin\" failed to @extend \"$target\". The selector \"$target\" was not found.");
         }
     }
 
@@ -435,7 +465,7 @@ protected function flattenSelectors(OutputBlock $block, $parentKey = null)
             foreach ($block->selectors as $s) {
                 $selectors[] = $s;
 
-                if (! is_array($s)) {
+                if (! \is_array($s)) {
                     continue;
                 }
 
@@ -468,7 +498,7 @@ protected function flattenSelectors(OutputBlock $block, $parentKey = null)
                 $block->selectors[] = $this->compileSelector($selector);
             }
 
-            if ($placeholderSelector && 0 === count($block->selectors) && null !== $parentKey) {
+            if ($placeholderSelector && 0 === \count($block->selectors) && null !== $parentKey) {
                 unset($block->parent->children[$parentKey]);
 
                 return;
@@ -492,16 +522,20 @@ protected function glueFunctionSelectors($parts)
         $new = [];
 
         foreach ($parts as $part) {
-            if (is_array($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
+                if (
+                    \count($new) && \is_string($new[\count($new) - 1]) &&
+                    \strlen($part) && substr($part, -1) === ')' && strpos($part, '(') === false
                 ) {
-                    $new[count($new) - 1] .= $part;
+                    while (\count($new) > 1 && substr($new[\count($new) - 1], -1) !== '(') {
+                        $part = array_pop($new) . $part;
+                    }
+                    $new[\count($new) - 1] .= $part;
                 } else {
                     $new[] = $part;
                 }
@@ -522,13 +556,14 @@ protected function glueFunctionSelectors($parts)
     protected function matchExtends($selector, &$out, $from = 0, $initial = true)
     {
         static $partsPile = [];
-
         $selector = $this->glueFunctionSelectors($selector);
 
-        if (count($selector) == 1 && in_array(reset($selector), $partsPile)) {
+        if (\count($selector) == 1 && \in_array(reset($selector), $partsPile)) {
             return;
         }
 
+        $outRecurs = [];
+
         foreach ($selector as $i => $part) {
             if ($i < $from) {
                 continue;
@@ -536,39 +571,43 @@ protected function matchExtends($selector, &$out, $from = 0, $initial = true)
 
             // 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) {
+            if (\count($part) > 1) {
                 foreach ($partsPile as $previousPart) {
-                    if (! count(array_diff($previousPart, $part))) {
+                    if (! \count(array_diff($previousPart, $part))) {
                         continue 2;
                     }
                 }
             }
 
-            if ($this->matchExtendsSingle($part, $origin)) {
-                $partsPile[] = $part;
-                $after       = array_slice($selector, $i + 1);
-                $before      = array_slice($selector, 0, $i);
+            $partsPile[] = $part;
 
+            if ($this->matchExtendsSingle($part, $origin, $initial)) {
+                $after       = \array_slice($selector, $i + 1);
+                $before      = \array_slice($selector, 0, $i);
                 list($before, $nonBreakableBefore) = $this->extractRelationshipFromFragment($before);
 
                 foreach ($origin as $new) {
                     $k = 0;
 
                     // remove shared parts
-                    if (count($new) > 1) {
+                    if (\count($new) > 1) {
                         while ($k < $i && isset($new[$k]) && $selector[$k] === $new[$k]) {
                             $k++;
                         }
                     }
 
+                    if (\count($nonBreakableBefore) && $k === \count($new)) {
+                        $k--;
+                    }
+
                     $replacement = [];
-                    $tempReplacement = $k > 0 ? array_slice($new, $k) : $new;
+                    $tempReplacement = $k > 0 ? \array_slice($new, $k) : $new;
 
-                    for ($l = count($tempReplacement) - 1; $l >= 0; $l--) {
+                    for ($l = \count($tempReplacement) - 1; $l >= 0; $l--) {
                         $slice = [];
 
                         foreach ($tempReplacement[$l] as $chunk) {
-                            if (! in_array($chunk, $slice)) {
+                            if (! \in_array($chunk, $slice)) {
                                 $slice[] = $chunk;
                             }
                         }
@@ -580,7 +619,7 @@ protected function matchExtends($selector, &$out, $from = 0, $initial = true)
                         }
                     }
 
-                    $afterBefore = $l != 0 ? array_slice($tempReplacement, 0, $l) : [];
+                    $afterBefore = $l != 0 ? \array_slice($tempReplacement, 0, $l) : [];
 
                     // Merge shared direct relationships.
                     $mergedBefore = $this->mergeDirectRelationships($afterBefore, $nonBreakableBefore);
@@ -596,64 +635,137 @@ protected function matchExtends($selector, &$out, $from = 0, $initial = true)
                         continue;
                     }
 
-                    $out[] = $result;
+                    $this->pushOrMergeExtentedSelector($out, $result);
 
                     // recursively check for more matches
-                    $startRecurseFrom = count($before) + min(count($nonBreakableBefore), count($mergedBefore));
-                    $this->matchExtends($result, $out, $startRecurseFrom, false);
+                    $startRecurseFrom = \count($before) + min(\count($nonBreakableBefore), \count($mergedBefore));
+
+                    if (\count($origin) > 1) {
+                        $this->matchExtends($result, $out, $startRecurseFrom, false);
+                    } else {
+                        $this->matchExtends($result, $outRecurs, $startRecurseFrom, false);
+                    }
 
                     // selector sequence merging
-                    if (! empty($before) && count($new) > 1) {
-                        $preSharedParts = $k > 0 ? array_slice($before, 0, $k) : [];
-                        $postSharedParts = $k > 0 ? array_slice($before, $k) : $before;
+                    if (! empty($before) && \count($new) > 1) {
+                        $preSharedParts = $k > 0 ? \array_slice($before, 0, $k) : [];
+                        $postSharedParts = $k > 0 ? \array_slice($before, $k) : $before;
 
-                        list($betweenSharedParts, $nonBreakable2) = $this->extractRelationshipFromFragment($afterBefore);
+                        list($betweenSharedParts, $nonBreakabl2) = $this->extractRelationshipFromFragment($afterBefore);
 
                         $result2 = array_merge(
                             $preSharedParts,
                             $betweenSharedParts,
                             $postSharedParts,
-                            $nonBreakable2,
+                            $nonBreakabl2,
                             $nonBreakableBefore,
                             $replacement,
                             $after
                         );
 
-                        $out[] = $result2;
+                        $this->pushOrMergeExtentedSelector($out, $result2);
                     }
                 }
+            }
+            array_pop($partsPile);
+        }
+
+        while (\count($outRecurs)) {
+            $result = array_shift($outRecurs);
+            $this->pushOrMergeExtentedSelector($out, $result);
+        }
+    }
 
-                array_pop($partsPile);
+    /**
+     * Test a part for being a pseudo selector
+     *
+     * @param string $part
+     * @param array  $matches
+     *
+     * @return boolean
+     */
+    protected function isPseudoSelector($part, &$matches)
+    {
+        if (
+            strpos($part, ':') === 0 &&
+            preg_match(",^::?([\w-]+)\((.+)\)$,", $part, $matches)
+        ) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Push extended selector except if
+     *  - this is a pseudo selector
+     *  - same as previous
+     *  - in a white list
+     * in this case we merge the pseudo selector content
+     *
+     * @param array $out
+     * @param array $extended
+     */
+    protected function pushOrMergeExtentedSelector(&$out, $extended)
+    {
+        if (\count($out) && \count($extended) === 1 && \count(reset($extended)) === 1) {
+            $single = reset($extended);
+            $part = reset($single);
+
+            if (
+                $this->isPseudoSelector($part, $matchesExtended) &&
+                \in_array($matchesExtended[1], [ 'slotted' ])
+            ) {
+                $prev = end($out);
+                $prev = $this->glueFunctionSelectors($prev);
+
+                if (\count($prev) === 1 && \count(reset($prev)) === 1) {
+                    $single = reset($prev);
+                    $part = reset($single);
+
+                    if (
+                        $this->isPseudoSelector($part, $matchesPrev) &&
+                        $matchesPrev[1] === $matchesExtended[1]
+                    ) {
+                        $extended = explode($matchesExtended[1] . '(', $matchesExtended[0], 2);
+                        $extended[1] = $matchesPrev[2] . ', ' . $extended[1];
+                        $extended = implode($matchesExtended[1] . '(', $extended);
+                        $extended = [ [ $extended ]];
+                        array_pop($out);
+                    }
+                }
             }
         }
+        $out[] = $extended;
     }
 
     /**
      * Match extends single
      *
-     * @param array $rawSingle
-     * @param array $outOrigin
+     * @param array   $rawSingle
+     * @param array   $outOrigin
+     * @param boolean $initial
      *
      * @return boolean
      */
-    protected function matchExtendsSingle($rawSingle, &$outOrigin)
+    protected function matchExtendsSingle($rawSingle, &$outOrigin, $initial = true)
     {
         $counts = [];
         $single = [];
 
         // simple usual cases, no need to do the whole trick
-        if (in_array($rawSingle, [['>'],['+'],['~']])) {
+        if (\in_array($rawSingle, [['>'],['+'],['~']])) {
             return false;
         }
 
         foreach ($rawSingle as $part) {
             // matches Number
-            if (! is_string($part)) {
+            if (! \is_string($part)) {
                 return false;
             }
 
-            if (! preg_match('/^[\[.:#%]/', $part) && count($single)) {
-                $single[count($single) - 1] .= $part;
+            if (! preg_match('/^[\[.:#%]/', $part) && \count($single)) {
+                $single[\count($single) - 1] .= $part;
             } else {
                 $single[] = $part;
             }
@@ -661,21 +773,52 @@ protected function matchExtendsSingle($rawSingle, &$outOrigin)
 
         $extendingDecoratedTag = false;
 
-        if (count($single) > 1) {
+        if (\count($single) > 1) {
             $matches = null;
             $extendingDecoratedTag = preg_match('/^[a-z0-9]+$/i', $single[0], $matches) ? $matches[0] : false;
         }
 
-        foreach ($single as $part) {
+        $outOrigin = [];
+        $found = false;
+
+        foreach ($single as $k => $part) {
             if (isset($this->extendsMap[$part])) {
                 foreach ($this->extendsMap[$part] as $idx) {
                     $counts[$idx] = isset($counts[$idx]) ? $counts[$idx] + 1 : 1;
                 }
             }
-        }
 
-        $outOrigin = [];
-        $found = false;
+            if (
+                $initial &&
+                $this->isPseudoSelector($part, $matches) &&
+                ! \in_array($matches[1], [ 'not' ])
+            ) {
+                $buffer    = $matches[2];
+                $parser    = $this->parserFactory(__METHOD__);
+
+                if ($parser->parseSelector($buffer, $subSelectors)) {
+                    foreach ($subSelectors as $ksub => $subSelector) {
+                        $subExtended = [];
+                        $this->matchExtends($subSelector, $subExtended, 0, false);
+
+                        if ($subExtended) {
+                            $subSelectorsExtended = $subSelectors;
+                            $subSelectorsExtended[$ksub] = $subExtended;
+
+                            foreach ($subSelectorsExtended as $ksse => $sse) {
+                                $subSelectorsExtended[$ksse] = $this->collapseSelectors($sse);
+                            }
+
+                            $subSelectorsExtended = implode(', ', $subSelectorsExtended);
+                            $singleExtended = $single;
+                            $singleExtended[$k] = str_replace('(' . $buffer . ')', "($subSelectorsExtended)", $part);
+                            $outOrigin[] = [ $singleExtended ];
+                            $found = true;
+                        }
+                    }
+                }
+            }
+        }
 
         foreach ($counts as $idx => $count) {
             list($target, $origin, /* $block */) = $this->extends[$idx];
@@ -683,7 +826,7 @@ protected function matchExtendsSingle($rawSingle, &$outOrigin)
             $origin = $this->glueFunctionSelectors($origin);
 
             // check count
-            if ($count !== count($target)) {
+            if ($count !== \count($target)) {
                 continue;
             }
 
@@ -693,14 +836,15 @@ protected function matchExtendsSingle($rawSingle, &$outOrigin)
 
             foreach ($origin as $j => $new) {
                 // prevent infinite loop when target extends itself
-                if ($this->isSelfExtend($single, $origin)) {
+                if ($this->isSelfExtend($single, $origin) && ! $initial) {
                     return false;
                 }
 
                 $replacement = end($new);
 
                 // Extending a decorated tag with another tag is not possible.
-                if ($extendingDecoratedTag && $replacement[0] != $extendingDecoratedTag &&
+                if (
+                    $extendingDecoratedTag && $replacement[0] != $extendingDecoratedTag &&
                     preg_match('/^[a-z0-9]+$/i', $replacement[0])
                 ) {
                     unset($origin[$j]);
@@ -709,8 +853,8 @@ protected function matchExtendsSingle($rawSingle, &$outOrigin)
 
                 $combined = $this->combineSelectorSingle($replacement, $rem);
 
-                if (count(array_diff($combined, $origin[$j][count($origin[$j]) - 1]))) {
-                    $origin[$j][count($origin[$j]) - 1] = $combined;
+                if (\count(array_diff($combined, $origin[$j][\count($origin[$j]) - 1]))) {
+                    $origin[$j][\count($origin[$j]) - 1] = $combined;
                 }
             }
 
@@ -738,12 +882,13 @@ protected function extractRelationshipFromFragment(array $fragment)
     {
         $parents = [];
         $children = [];
-        $j = $i = count($fragment);
+
+        $j = $i = \count($fragment);
 
         for (;;) {
-            $children = $j != $i ? array_slice($fragment, $j, $i - $j) : [];
-            $parents = array_slice($fragment, 0, $j);
-            $slice = end($parents);
+            $children = $j != $i ? \array_slice($fragment, $j, $i - $j) : [];
+            $parents  = \array_slice($fragment, 0, $j);
+            $slice    = end($parents);
 
             if (empty($slice) || ! $this->isImmediateRelationshipCombinator($slice[0])) {
                 break;
@@ -765,30 +910,45 @@ protected function extractRelationshipFromFragment(array $fragment)
      */
     protected function combineSelectorSingle($base, $other)
     {
-        $tag = [];
-        $out = [];
-        $wasTag = true;
+        $tag    = [];
+        $out    = [];
+        $wasTag = false;
+        $pseudo = [];
+
+        while (\count($other) && strpos(end($other), ':') === 0) {
+            array_unshift($pseudo, array_pop($other));
+        }
+
+        foreach ([array_reverse($base), array_reverse($other)] as $single) {
+            $rang = count($single);
 
-        foreach ([$base, $other] as $single) {
             foreach ($single as $part) {
-                if (preg_match('/^[\[.:#]/', $part)) {
+                if (preg_match('/^[\[:]/', $part)) {
                     $out[] = $part;
                     $wasTag = false;
-                } elseif (preg_match('/^[^_-]/', $part)) {
+                } elseif (preg_match('/^[\.#]/', $part)) {
+                    array_unshift($out, $part);
+                    $wasTag = false;
+                } elseif (preg_match('/^[^_-]/', $part) && $rang === 1) {
                     $tag[] = $part;
                     $wasTag = true;
                 } elseif ($wasTag) {
-                    $tag[count($tag) - 1] .= $part;
+                    $tag[\count($tag) - 1] .= $part;
                 } else {
-                    $out[count($out) - 1] .= $part;
+                    array_unshift($out, $part);
                 }
+                $rang--;
             }
         }
 
-        if (count($tag)) {
+        if (\count($tag)) {
             array_unshift($out, $tag[0]);
         }
 
+        while (\count($pseudo)) {
+            $out[] = array_shift($pseudo);
+        }
+
         return $out;
     }
 
@@ -820,7 +980,8 @@ protected function compileMedia(Block $media)
             foreach ($media->children as $child) {
                 $type = $child[0];
 
-                if ($type !== Type::T_BLOCK &&
+                if (
+                    $type !== Type::T_BLOCK &&
                     $type !== Type::T_MEDIA &&
                     $type !== Type::T_DIRECTIVE &&
                     $type !== Type::T_IMPORT
@@ -831,17 +992,18 @@ protected function compileMedia(Block $media)
             }
 
             if ($needsWrap) {
-                $wrapped = new Block;
-                $wrapped->sourceName = $media->sourceName;
-                $wrapped->sourceIndex = $media->sourceIndex;
-                $wrapped->sourceLine = $media->sourceLine;
+                $wrapped = new Block();
+                $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;
@@ -898,23 +1060,61 @@ protected function mediaParent(OutputBlock $scope)
     /**
      * Compile directive
      *
-     * @param \ScssPhp\ScssPhp\Block $block
+     * @param \ScssPhp\ScssPhp\Block|array $block
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
      */
-    protected function compileDirective(Block $block)
+    protected function compileDirective($directive, OutputBlock $out)
     {
-        $s = '@' . $block->name;
+        if (\is_array($directive)) {
+            $directiveName = $this->compileDirectiveName($directive[0]);
+            $s = '@' . $directiveName;
 
-        if (! empty($block->value)) {
-            $s .= ' ' . $this->compileValue($block->value);
-        }
+            if (! empty($directive[1])) {
+                $s .= ' ' . $this->compileValue($directive[1]);
+            }
+            // sass-spec compliance on newline after directives, a bit tricky :/
+            $appendNewLine = (! empty($directive[2]) || strpos($s, "\n")) ? "\n" : "";
+            if (\is_array($directive[0]) && empty($directive[1])) {
+                $appendNewLine = "\n";
+            }
 
-        if ($block->name === 'keyframes' || substr($block->name, -10) === '-keyframes') {
-            $this->compileKeyframeBlock($block, [$s]);
+            if (empty($directive[3])) {
+                $this->appendRootDirective($s . ';' . $appendNewLine, $out, [Type::T_COMMENT, Type::T_DIRECTIVE]);
+            } else {
+                $this->appendOutputLine($out, Type::T_DIRECTIVE, $s . ';');
+            }
         } else {
-            $this->compileNestedBlock($block, [$s]);
+            $directive->name = $this->compileDirectiveName($directive->name);
+            $s = '@' . $directive->name;
+
+            if (! empty($directive->value)) {
+                $s .= ' ' . $this->compileValue($directive->value);
+            }
+
+            if ($directive->name === 'keyframes' || substr($directive->name, -10) === '-keyframes') {
+                $this->compileKeyframeBlock($directive, [$s]);
+            } else {
+                $this->compileNestedBlock($directive, [$s]);
+            }
         }
     }
 
+    /**
+     * directive names can include some interpolation
+     *
+     * @param string|array $directiveName
+     * @return array|string
+     * @throws CompilerException
+     */
+    protected function compileDirectiveName($directiveName)
+    {
+        if (is_string($directiveName)) {
+            return $directiveName;
+        }
+
+        return $this->compileValue($directiveName);
+    }
+
     /**
      * Compile at-root
      *
@@ -928,7 +1128,7 @@ protected function compileAtRoot(Block $block)
 
         // wrap inline selector
         if ($block->selector) {
-            $wrapped = new Block;
+            $wrapped = new Block();
             $wrapped->sourceName   = $block->sourceName;
             $wrapped->sourceIndex  = $block->sourceIndex;
             $wrapped->sourceLine   = $block->sourceLine;
@@ -945,7 +1145,9 @@ protected function compileAtRoot(Block $block)
 
         $selfParent = $block->selfParent;
 
-        if (! $block->selfParent->selectors && isset($block->parent) && $block->parent &&
+        if (
+            ! $block->selfParent->selectors &&
+            isset($block->parent) && $block->parent &&
             isset($block->parent->selectors) && $block->parent->selectors
         ) {
             $selfParent = $block->parent;
@@ -978,6 +1180,7 @@ protected function compileAtRoot(Block $block)
     protected function filterScopeWithWithout($scope, $with, $without)
     {
         $filteredScopes = [];
+        $childStash = [];
 
         if ($scope->type === TYPE::T_ROOT) {
             return $scope;
@@ -985,6 +1188,7 @@ protected function filterScopeWithWithout($scope, $with, $without)
 
         // start from the root
         while ($scope->parent && $scope->parent->type !== TYPE::T_ROOT) {
+            array_unshift($childStash, $scope);
             $scope = $scope->parent;
         }
 
@@ -996,8 +1200,8 @@ protected function filterScopeWithWithout($scope, $with, $without)
             if ($this->isWith($scope, $with, $without)) {
                 $s = clone $scope;
                 $s->children = [];
-                $s->lines = [];
-                $s->parent = null;
+                $s->lines    = [];
+                $s->parent   = null;
 
                 if ($s->type !== Type::T_MEDIA && $s->type !== Type::T_DIRECTIVE) {
                     $s->selectors = [];
@@ -1006,14 +1210,16 @@ protected function filterScopeWithWithout($scope, $with, $without)
                 $filteredScopes[] = $s;
             }
 
-            if ($scope->children) {
+            if (\count($childStash)) {
+                $scope = array_shift($childStash);
+            } elseif ($scope->children) {
                 $scope = end($scope->children);
             } else {
                 $scope = null;
             }
         }
 
-        if (! count($filteredScopes)) {
+        if (! \count($filteredScopes)) {
             return $this->rootBlock;
         }
 
@@ -1024,11 +1230,12 @@ protected function filterScopeWithWithout($scope, $with, $without)
 
         $p = &$newScope;
 
-        while (count($filteredScopes)) {
+        while (\count($filteredScopes)) {
             $s = array_shift($filteredScopes);
             $s->parent = $p;
-            $p->children[] = &$s;
-            $p = $s;
+            $p->children[] = $s;
+            $newScope = &$p->children[0];
+            $p = &$p->children[0];
         }
 
         return $newScope;
@@ -1045,7 +1252,7 @@ protected function filterScopeWithWithout($scope, $with, $without)
      */
     protected function completeScope($scope, $previousScope)
     {
-        if (! $scope->type && (! $scope->selectors || ! count($scope->selectors)) && count($scope->lines)) {
+        if (! $scope->type && (! $scope->selectors || ! \count($scope->selectors)) && \count($scope->lines)) {
             $scope->selectors = $this->findScopeSelectors($previousScope, $scope->depth);
         }
 
@@ -1097,6 +1304,17 @@ protected function compileWith($withCondition)
         $without = ['rule' => true];
 
         if ($withCondition) {
+            if ($withCondition[0] === Type::T_INTERPOLATE) {
+                $w = $this->compileValue($withCondition);
+
+                $buffer = "($w)";
+                $parser = $this->parserFactory(__METHOD__);
+
+                if ($parser->parseValue($buffer, $reParsedWith)) {
+                    $withCondition = $reParsedWith;
+                }
+            }
+
             if ($this->libMapHasKey([$withCondition, static::$with])) {
                 $without = []; // cancel the default
                 $list = $this->coerceList($this->libMapGet([$withCondition, static::$with]));
@@ -1126,7 +1344,7 @@ protected function compileWith($withCondition)
     /**
      * Filter env stack
      *
-     * @param array   $envs
+     * @param array $envs
      * @param array $with
      * @param array $without
      *
@@ -1139,8 +1357,9 @@ protected function filterWithWithout($envs, $with, $without)
         foreach ($envs as $e) {
             if ($e->block && ! $this->isWith($e->block, $with, $without)) {
                 $ec = clone $e;
-                $ec->block = null;
+                $ec->block     = null;
                 $ec->selectors = [];
+
                 $filtered[] = $ec;
             } else {
                 $filtered[] = $e;
@@ -1168,17 +1387,27 @@ protected function isWith($block, $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($this->compileDirectiveName($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 {
+                } else {
                     return $this->testWithWithout('???', $with, $without);
                 }
             }
-        }
-        elseif (isset($block->selectors)) {
+        } elseif (isset($block->selectors)) {
+            // a selector starting with number is a keyframe rule
+            if (\count($block->selectors)) {
+                $s = reset($block->selectors);
+
+                while (\is_array($s)) {
+                    $s = reset($s);
+                }
+
+                if (\is_object($s) && $s instanceof Node\Number) {
+                    return $this->testWithWithout('keyframes', $with, $without);
+                }
+            }
+
             return $this->testWithWithout('rule', $with, $without);
         }
 
@@ -1191,13 +1420,14 @@ protected function isWith($block, $with, $without)
      * @param string $what
      * @param array  $with
      * @param array  $without
-     * @return bool
+     *
+     * @return boolean
      *   true if the block should be kept, false to reject
      */
-    protected function testWithWithout($what, $with, $without) {
-
+    protected function testWithWithout($what, $with, $without)
+    {
         // if without, reject only if in the list (or 'all' is in the list)
-        if (count($without)) {
+        if (\count($without)) {
             return (isset($without[$what]) || isset($without['all'])) ? false : true;
         }
 
@@ -1237,8 +1467,8 @@ protected function compileKeyframeBlock(Block $block, $selectors)
     /**
      * Compile nested properties lines
      *
-     * @param \ScssPhp\ScssPhp\Block $block
-     * @param OutputBlock            $out
+     * @param \ScssPhp\ScssPhp\Block                 $block
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
      */
     protected function compileNestedPropertiesBlock(Block $block, OutputBlock $out)
     {
@@ -1263,6 +1493,7 @@ protected function compileNestedPropertiesBlock(Block $block, OutputBlock $out)
                     array_unshift($child[1]->prefix[2], $prefix);
                     break;
             }
+
             $this->compileChild($child, $nested);
         }
     }
@@ -1282,7 +1513,7 @@ protected function compileNestedBlock(Block $block, $selectors)
 
         // wrap assign children in a block
         // except for @font-face
-        if ($block->type !== Type::T_DIRECTIVE || $block->name !== "font-face") {
+        if ($block->type !== Type::T_DIRECTIVE || $this->compileDirectiveName($block->name) !== 'font-face') {
             // need wrapping?
             $needWrapping = false;
 
@@ -1294,16 +1525,16 @@ protected function compileNestedBlock(Block $block, $selectors)
             }
 
             if ($needWrapping) {
-                $wrapped = new Block;
-                $wrapped->sourceName = $block->sourceName;
-                $wrapped->sourceIndex = $block->sourceIndex;
-                $wrapped->sourceLine = $block->sourceLine;
+                $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;
+                $wrapped->selectors    = [];
+                $wrapped->comments     = [];
+                $wrapped->parent       = $block;
+                $wrapped->children     = $block->children;
+                $wrapped->selfParent   = $block->selfParent;
 
                 $block->children = [[Type::T_BLOCK, $wrapped]];
             }
@@ -1341,7 +1572,7 @@ protected function compileBlock(Block $block)
 
         $out = $this->makeOutputBlock(null);
 
-        if (isset($this->lineNumberStyle) && count($env->selectors) && count($block->children)) {
+        if (isset($this->lineNumberStyle) && \count($env->selectors) && \count($block->children)) {
             $annotation = $this->makeOutputBlock(Type::T_COMMENT);
             $annotation->depth = 0;
 
@@ -1367,7 +1598,7 @@ protected function compileBlock(Block $block)
 
         $this->scope->children[] = $out;
 
-        if (count($block->children)) {
+        if (\count($block->children)) {
             $out->selectors = $this->multiplySelectors($env, $block->selfParent);
 
             // propagate selfParent to the children where they still can be useful
@@ -1380,17 +1611,52 @@ protected function compileBlock(Block $block)
 
             $this->compileChildrenNoReturn($block->children, $out, $block->selfParent);
 
-            // and revert for the following childs of the same block
+            // and revert for the following children of the same block
             if ($selfParentSelectors) {
                 $block->selfParent->selectors = $selfParentSelectors;
             }
         }
 
-        $this->formatter->stripSemicolon($out->lines);
-
         $this->popEnv();
     }
 
+
+    /**
+     * Compile the value of a comment that can have interpolation
+     *
+     * @param array   $value
+     * @param boolean $pushEnv
+     *
+     * @return array|mixed|string
+     */
+    protected function compileCommentValue($value, $pushEnv = false)
+    {
+        $c = $value[1];
+
+        if (isset($value[2])) {
+            if ($pushEnv) {
+                $this->pushEnv();
+            }
+
+            $ignoreCallStackMessage = $this->ignoreCallStackMessage;
+            $this->ignoreCallStackMessage = true;
+
+            try {
+                $c = $this->compileValue($value[2]);
+            } catch (\Exception $e) {
+                // ignore error in comment compilation which are only interpolation
+            }
+
+            $this->ignoreCallStackMessage = $ignoreCallStackMessage;
+
+            if ($pushEnv) {
+                $this->popEnv();
+            }
+        }
+
+        return $c;
+    }
+
     /**
      * Compile root level comment
      *
@@ -1399,7 +1665,7 @@ protected function compileBlock(Block $block)
     protected function compileComment($block)
     {
         $out = $this->makeOutputBlock(Type::T_COMMENT);
-        $out->lines[] = is_string($block[1]) ? $block[1] : $this->compileValue($block[1]);
+        $out->lines[] = $this->compileCommentValue($block, true);
 
         $this->scope->children[] = $out;
     }
@@ -1419,9 +1685,9 @@ protected function evalSelectors($selectors)
 
         // after evaluating interpolates, we might need a second pass
         if ($this->shouldEvaluate) {
-            $selectors = $this->revertSelfSelector($selectors);
-            $buffer = $this->collapseSelectors($selectors);
-            $parser = $this->parserFactory(__METHOD__);
+            $selectors = $this->replaceSelfSelector($selectors, '&');
+            $buffer    = $this->collapseSelectors($selectors);
+            $parser    = $this->parserFactory(__METHOD__);
 
             if ($parser->parseSelector($buffer, $newSelectors)) {
                 $selectors = array_map([$this, 'evalSelector'], $newSelectors);
@@ -1453,14 +1719,15 @@ protected function evalSelector($selector)
     protected function evalSelectorPart($part)
     {
         foreach ($part as &$p) {
-            if (is_array($p) && ($p[0] === Type::T_INTERPOLATE || $p[0] === Type::T_STRING)) {
+            if (\is_array($p) && ($p[0] === Type::T_INTERPOLATE || $p[0] === Type::T_STRING)) {
                 $p = $this->compileValue($p);
 
                 // force re-evaluation
                 if (strpos($p, '&') !== false || strpos($p, ',') !== false) {
                     $this->shouldEvaluate = true;
                 }
-            } elseif (is_string($p) && strlen($p) >= 2 &&
+            } elseif (
+                \is_string($p) && \strlen($p) >= 2 &&
                 ($first = $p[0]) && ($first === '"' || $first === "'") &&
                 substr($p, -1) === $first
             ) {
@@ -1500,14 +1767,15 @@ function ($value, $key) use (&$compound) {
                 );
 
                 if ($selectorFormat && $this->isImmediateRelationshipCombinator($compound)) {
-                    if (count($output)) {
-                        $output[count($output) - 1] .= ' ' . $compound;
+                    if (\count($output)) {
+                        $output[\count($output) - 1] .= ' ' . $compound;
                     } else {
                         $output[] = $compound;
                     }
+
                     $glueNext = true;
                 } elseif ($glueNext) {
-                    $output[count($output) - 1] .= ' ' . $compound;
+                    $output[\count($output) - 1] .= ' ' . $compound;
                     $glueNext = false;
                 } else {
                     $output[] = $compound;
@@ -1518,6 +1786,7 @@ function ($value, $key) use (&$compound) {
                 foreach ($output as &$o) {
                     $o = [Type::T_STRING, '', [$o]];
                 }
+
                 $output = [Type::T_LIST, ' ', $output];
             } else {
                 $output = implode(' ', $output);
@@ -1542,14 +1811,18 @@ function ($value, $key) use (&$compound) {
      *
      * @return array
      */
-    protected function revertSelfSelector($selectors)
+    protected function replaceSelfSelector($selectors, $replace = null)
     {
         foreach ($selectors as &$part) {
-            if (is_array($part)) {
+            if (\is_array($part)) {
                 if ($part === [Type::T_SELF]) {
-                    $part = '&';
+                    if (\is_null($replace)) {
+                        $replace = $this->reduce([Type::T_SELF]);
+                        $replace = $this->compileValue($replace);
+                    }
+                    $part = $replace;
                 } else {
-                    $part = $this->revertSelfSelector($part);
+                    $part = $this->replaceSelfSelector($part, $replace);
                 }
             }
         }
@@ -1569,18 +1842,19 @@ protected function flattenSelectorSingle($single)
         $joined = [];
 
         foreach ($single as $part) {
-            if (empty($joined) ||
-                ! is_string($part) ||
+            if (
+                empty($joined) ||
+                ! \is_string($part) ||
                 preg_match('/[\[.:#%]/', $part)
             ) {
                 $joined[] = $part;
                 continue;
             }
 
-            if (is_array(end($joined))) {
+            if (\is_array(end($joined))) {
                 $joined[] = $part;
             } else {
-                $joined[count($joined) - 1] .= $part;
+                $joined[\count($joined) - 1] .= $part;
             }
         }
 
@@ -1596,7 +1870,7 @@ protected function flattenSelectorSingle($single)
      */
     protected function compileSelector($selector)
     {
-        if (! is_array($selector)) {
+        if (! \is_array($selector)) {
             return $selector; // media and the like
         }
 
@@ -1619,7 +1893,7 @@ protected function compileSelector($selector)
     protected function compileSelectorPart($piece)
     {
         foreach ($piece as &$p) {
-            if (! is_array($p)) {
+            if (! \is_array($p)) {
                 continue;
             }
 
@@ -1646,13 +1920,13 @@ protected function compileSelectorPart($piece)
      */
     protected function hasSelectorPlaceholder($selector)
     {
-        if (! is_array($selector)) {
+        if (! \is_array($selector)) {
             return false;
         }
 
         foreach ($selector as $parts) {
             foreach ($parts as $part) {
-                if (strlen($part) && '%' === $part[0]) {
+                if (\strlen($part) && '%' === $part[0]) {
                     return true;
                 }
             }
@@ -1671,11 +1945,12 @@ protected function pushCallStack($name = '')
         ];
 
         // infinite calling loop
-        if (count($this->callStack) > 25000) {
+        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);
+            $msg = 'Infinite calling loop';
+
+            throw $this->error($msg);
         }
     }
 
@@ -1701,6 +1976,8 @@ protected function compileChildren($stms, OutputBlock $out, $traceName = '')
             $ret = $this->compileChild($stm, $out);
 
             if (isset($ret)) {
+                $this->popCallStack();
+
                 return $ret;
             }
         }
@@ -1725,11 +2002,11 @@ protected function compileChildrenNoReturn($stms, OutputBlock $out, $selfParent
         $this->pushCallStack($traceName);
 
         foreach ($stms as $stm) {
-            if ($selfParent && isset($stm[1]) && is_object($stm[1]) && $stm[1] instanceof Block) {
+            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) {
+            } elseif ($selfParent && \in_array($stm[0], [TYPE::T_INCLUDE, TYPE::T_EXTEND])) {
                 $stm['selfParent'] = $selfParent;
                 $ret = $this->compileChild($stm, $out);
                 unset($stm['selfParent']);
@@ -1738,9 +2015,7 @@ protected function compileChildrenNoReturn($stms, OutputBlock $out, $selfParent
             }
 
             if (isset($ret)) {
-                $this->throwError('@return may only be used within a function');
-
-                return;
+                throw $this->error('@return may only be used within a function');
             }
         }
 
@@ -1758,16 +2033,20 @@ protected function compileChildrenNoReturn($stms, OutputBlock $out, $selfParent
     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++) {
+                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 &&
+                    if (
+                        $q[0] == Type::T_MEDIA_TYPE &&
                         (strpos($value, '(') !== false ||
                         strpos($value, ')') !== false ||
                         strpos($value, ':') !== false ||
@@ -1779,24 +2058,31 @@ protected function evaluateMediaQuery($queryList)
                     $queryList[$kql][$kq][$i] = [Type::T_KEYWORD, $value];
                 }
             }
+
             if ($shouldReparse) {
-                if (is_null($parser)) {
+                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)) {
+
+                        while (\count($queries)) {
                             $outQueryList[] = array_shift($queries);
                         }
+
                         continue;
                     }
                 }
             }
+
             $outQueryList[] = $queryList[$kql];
         }
 
@@ -1812,10 +2098,10 @@ protected function evaluateMediaQuery($queryList)
      */
     protected function compileMediaQuery($queryList)
     {
-        $start = '@media ';
+        $start   = '@media ';
         $default = trim($start);
-        $out = [];
-        $current = "";
+        $out     = [];
+        $current = '';
 
         foreach ($queryList as $query) {
             $type = null;
@@ -1833,16 +2119,17 @@ protected function compileMediaQuery($queryList)
             foreach ($query as $q) {
                 switch ($q[0]) {
                     case Type::T_MEDIA_TYPE:
-                        $newType = 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 (\in_array(Type::T_NOT, $newType) || ($type && \in_array(Type::T_NOT, $type) )) {
                                 if ($type) {
                                     array_unshift($parts, implode(' ', array_filter($type)));
                                 }
 
                                 if (! empty($parts)) {
-                                    if (strlen($current)) {
+                                    if (\strlen($current)) {
                                         $current .= $this->formatter->tagSeparator;
                                     }
 
@@ -1853,9 +2140,9 @@ protected function compileMediaQuery($queryList)
                                     $out[] = $start . $current;
                                 }
 
-                                $current = "";
-                                $type = null;
-                                $parts = [];
+                                $current = '';
+                                $type    = null;
+                                $parts   = [];
                             }
                         }
 
@@ -1905,7 +2192,7 @@ protected function compileMediaQuery($queryList)
             }
 
             if (! empty($parts)) {
-                if (strlen($current)) {
+                if (\strlen($current)) {
                     $current .= $this->formatter->tagSeparator;
                 }
 
@@ -1987,23 +2274,19 @@ protected function mergeMediaTypes($type1, $type2)
             return $type1;
         }
 
-        $m1 = '';
-        $t1 = '';
-
-        if (count($type1) > 1) {
-            $m1= strtolower($type1[0]);
-            $t1= strtolower($type1[1]);
+        if (\count($type1) > 1) {
+            $m1 = strtolower($type1[0]);
+            $t1 = strtolower($type1[1]);
         } else {
+            $m1 = '';
             $t1 = strtolower($type1[0]);
         }
 
-        $m2 = '';
-        $t2 = '';
-
-        if (count($type2) > 1) {
+        if (\count($type2) > 1) {
             $m2 = strtolower($type2[0]);
             $t2 = strtolower($type2[1]);
         } else {
+            $m2 = '';
             $t2 = strtolower($type2[0]);
         }
 
@@ -2032,7 +2315,7 @@ protected function mergeMediaTypes($type1, $type2)
         }
 
         // t1 == t2, neither m1 nor m2 are "not"
-        return [empty($m1)? $m2 : $m1, $t1];
+        return [empty($m1) ? $m2 : $m1, $t1];
     }
 
     /**
@@ -2049,8 +2332,8 @@ protected function compileImport($rawPath, OutputBlock $out, $once = false)
         if ($rawPath[0] === Type::T_STRING) {
             $path = $this->compileStringContent($rawPath);
 
-            if ($path = $this->findImport($path)) {
-                if (! $once || ! in_array($path, $this->importedFiles)) {
+            if (strpos($path, 'url(') !== 0 && $path = $this->findImport($path)) {
+                if (! $once || ! \in_array($path, $this->importedFiles)) {
                     $this->importFile($path, $out);
                     $this->importedFiles[] = $path;
                 }
@@ -2058,31 +2341,84 @@ protected function compileImport($rawPath, OutputBlock $out, $once = false)
                 return true;
             }
 
+            $this->appendRootDirective('@import ' . $this->compileImportPath($rawPath) . ';', $out);
+
             return false;
         }
 
         if ($rawPath[0] === Type::T_LIST) {
             // handle a list of strings
-            if (count($rawPath[2]) === 0) {
+            if (\count($rawPath[2]) === 0) {
                 return false;
             }
 
             foreach ($rawPath[2] as $path) {
                 if ($path[0] !== Type::T_STRING) {
+                    $this->appendRootDirective('@import ' . $this->compileImportPath($rawPath) . ';', $out);
+
                     return false;
                 }
             }
 
             foreach ($rawPath[2] as $path) {
-                $this->compileImport($path, $out);
+                $this->compileImport($path, $out, $once);
             }
 
             return true;
         }
 
+        $this->appendRootDirective('@import ' . $this->compileImportPath($rawPath) . ';', $out);
+
         return false;
     }
 
+    /**
+     * @param $rawPath
+     * @return string
+     * @throws CompilerException
+     */
+    protected function compileImportPath($rawPath)
+    {
+        $path = $this->compileValue($rawPath);
+
+        // case url() without quotes : supress \r \n remaining in the path
+        // if this is a real string there can not be CR or LF char
+        if (strpos($path, 'url(') === 0) {
+            $path = str_replace(array("\r", "\n"), array('', ' '), $path);
+        } else {
+            // if this is a file name in a string, spaces shoudl be escaped
+            $path = $this->reduce($rawPath);
+            $path = $this->escapeImportPathString($path);
+            $path = $this->compileValue($path);
+        }
+
+        return $path;
+    }
+
+    /**
+     * @param array $path
+     * @return array
+     * @throws CompilerException
+     */
+    protected function escapeImportPathString($path)
+    {
+        switch ($path[0]) {
+            case Type::T_LIST:
+                foreach ($path[2] as $k => $v) {
+                    $path[2][$k] = $this->escapeImportPathString($v);
+                }
+                break;
+            case Type::T_STRING:
+                if ($path[1]) {
+                    $path = $this->compileValue($path);
+                    $path = str_replace(' ', '\\ ', $path);
+                    $path = [Type::T_KEYWORD, $path];
+                }
+                break;
+        }
+
+        return $path;
+    }
 
     /**
      * Append a root directive like @import or @charset as near as the possible from the source code
@@ -2102,8 +2438,8 @@ protected function appendRootDirective($line, $out, $allowed = [Type::T_COMMENT]
 
         $i = 0;
 
-        while ($i < count($root->children)) {
-            if (! isset($root->children[$i]->type) || ! in_array($root->children[$i]->type, $allowed)) {
+        while ($i < \count($root->children)) {
+            if (! isset($root->children[$i]->type) || ! \in_array($root->children[$i]->type, $allowed)) {
                 break;
             }
 
@@ -2113,55 +2449,51 @@ protected function appendRootDirective($line, $out, $allowed = [Type::T_COMMENT]
         // remove incompatible children from the bottom of the list
         $saveChildren = [];
 
-        while ($i < count($root->children)) {
+        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->lines[]      = $line;
+        $child->sourceName   = $this->sourceNames[$this->sourceIndex];
+        $child->sourceLine   = $this->sourceLine;
         $child->sourceColumn = $this->sourceColumn;
 
         $root->children[] = $child;
 
         // repush children
-        while (count($saveChildren)) {
+        while (\count($saveChildren)) {
             $root->children[] = array_pop($saveChildren);
         }
     }
 
     /**
-     * Append lines to the courrent output block:
+     * Append lines to the current output block:
      * directly to the block or through a child if necessary
      *
      * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
      * @param string                                 $type
-     * @param string                                 $line
+     * @param string|mixed                           $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 (\count($out->children)) {
+            $lastChild = &$out->children[\count($out->children) - 1];
 
-            if ($lastChild->depth === $out->depth && is_null($lastChild->selectors) && ! count($lastChild->children)) {
+            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;
+                $nextLines->depth  = $out->depth;
 
                 $out->children[] = $nextLines;
                 $outWrite = &$nextLines;
@@ -2182,16 +2514,17 @@ protected function appendOutputLine(OutputBlock $out, $type, $line)
     protected function compileChild($child, OutputBlock $out)
     {
         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->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;
+        } 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);
+            $this->sourceLine   = $out->sourceLine;
+            $this->sourceIndex  = array_search($out->sourceName, $this->sourceNames);
+            $this->sourceColumn = $out->sourceColumn;
 
             if ($this->sourceIndex === false) {
                 $this->sourceIndex = null;
@@ -2202,21 +2535,17 @@ protected function compileChild($child, OutputBlock $out)
             case Type::T_SCSSPHP_IMPORT_ONCE:
                 $rawPath = $this->reduce($child[1]);
 
-                if (! $this->compileImport($rawPath, $out, true)) {
-                    $this->appendRootDirective('@import ' . $this->compileValue($rawPath) . ';', $out);
-                }
+                $this->compileImport($rawPath, $out, true);
                 break;
 
             case Type::T_IMPORT:
                 $rawPath = $this->reduce($child[1]);
 
-                if (! $this->compileImport($rawPath, $out)) {
-                    $this->appendRootDirective('@import ' . $this->compileValue($rawPath) . ';', $out);
-                }
+                $this->compileImport($rawPath, $out);
                 break;
 
             case Type::T_DIRECTIVE:
-                $this->compileDirective($child[1]);
+                $this->compileDirective($child[1], $out);
                 break;
 
             case Type::T_AT_ROOT:
@@ -2238,13 +2567,37 @@ protected function compileChild($child, OutputBlock $out)
                 }
                 break;
 
+            case Type::T_CUSTOM_PROPERTY:
+                list(, $name, $value) = $child;
+                $compiledName = $this->compileValue($name);
+
+                // if the value reduces to null from something else then
+                // the property should be discarded
+                if ($value[0] !== Type::T_NULL) {
+                    $value = $this->reduce($value);
+
+                    if ($value[0] === Type::T_NULL || $value === static::$nullString) {
+                        break;
+                    }
+                }
+
+                $compiledValue = $this->compileValue($value);
+
+                $line = $this->formatter->customProperty(
+                    $compiledName,
+                    $compiledValue
+                );
+
+                $this->appendOutputLine($out, Type::T_ASSIGN, $line);
+                break;
+
             case Type::T_ASSIGN:
                 list(, $name, $value) = $child;
 
                 if ($name[0] === Type::T_VARIABLE) {
-                    $flags = isset($child[3]) ? $child[3] : [];
-                    $isDefault = in_array('!default', $flags);
-                    $isGlobal = in_array('!global', $flags);
+                    $flags     = isset($child[3]) ? $child[3] : [];
+                    $isDefault = \in_array('!default', $flags);
+                    $isGlobal  = \in_array('!global', $flags);
 
                     if ($isGlobal) {
                         $this->set($name[1], $this->reduce($value), false, $this->rootEnv, $value);
@@ -2252,7 +2605,7 @@ protected function compileChild($child, OutputBlock $out)
                     }
 
                     $shouldSet = $isDefault &&
-                        (($result = $this->get($name[1], false)) === null ||
+                        (\is_null($result = $this->get($name[1], false)) ||
                         $result === static::$null);
 
                     if (! $isDefault || $shouldSet) {
@@ -2263,28 +2616,78 @@ protected function compileChild($child, OutputBlock $out)
 
                 $compiledName = $this->compileValue($name);
 
-                // handle shorthand syntax: size / line-height
-                if ($compiledName === 'font' || $compiledName === 'grid-row' || $compiledName === 'grid-column') {
+                // handle shorthand syntaxes : size / line-height...
+                if (\in_array($compiledName, ['font', 'grid-row', 'grid-column', 'border-radius'])) {
                     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;
+                    $shorthandValue=&$value;
+
+                    $shorthandDividerNeedsUnit = false;
+                    $maxListElements           = null;
+                    $maxShorthandDividers      = 1;
+
+                    switch ($compiledName) {
+                        case 'border-radius':
+                            $maxListElements = 4;
+                            $shorthandDividerNeedsUnit = true;
+                            break;
+                    }
 
-                    if ($value[0] === Type::T_LIST && $value[1]==',') {
+                    if ($compiledName === 'font' && $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];
+                        $shorthandValue=&$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 ($shorthandValue[0] === Type::T_EXPRESSION && $shorthandValue[1] === '/') {
+                        $revert = true;
+
+                        if ($shorthandDividerNeedsUnit) {
+                            $divider = $shorthandValue[3];
+
+                            if (\is_array($divider)) {
+                                $divider = $this->reduce($divider, true);
+                            }
+
+                            if (\intval($divider->dimension) && ! \count($divider->units)) {
+                                $revert = false;
+                            }
+                        }
+
+                        if ($revert) {
+                            $shorthandValue = $this->expToString($shorthandValue);
+                        }
+                    } elseif ($shorthandValue[0] === Type::T_LIST) {
+                        foreach ($shorthandValue[2] as &$item) {
                             if ($item[0] === Type::T_EXPRESSION && $item[1] === '/') {
-                                $item = $this->expToString($item);
+                                if ($maxShorthandDividers > 0) {
+                                    $revert = true;
+
+                                    // if the list of values is too long, this has to be a shorthand,
+                                    // otherwise it could be a real division
+                                    if (\is_null($maxListElements) || \count($shorthandValue[2]) <= $maxListElements) {
+                                        if ($shorthandDividerNeedsUnit) {
+                                            $divider = $item[3];
+
+                                            if (\is_array($divider)) {
+                                                $divider = $this->reduce($divider, true);
+                                            }
+
+                                            if (\intval($divider->dimension) && ! \count($divider->units)) {
+                                                $revert = false;
+                                            }
+                                        }
+                                    }
+
+                                    if ($revert) {
+                                        $item = $this->expToString($item);
+                                        $maxShorthandDividers--;
+                                    }
+                                }
                             }
                         }
                     }
@@ -2302,11 +2705,14 @@ protected function compileChild($child, OutputBlock $out)
 
                 $compiledValue = $this->compileValue($value);
 
-                $line = $this->formatter->property(
-                    $compiledName,
-                    $compiledValue
-                );
-                $this->appendOutputLine($out, Type::T_ASSIGN, $line);
+                // ignore empty value
+                if (\strlen($compiledValue)) {
+                    $line = $this->formatter->property(
+                        $compiledName,
+                        $compiledValue
+                    );
+                    $this->appendOutputLine($out, Type::T_ASSIGN, $line);
+                }
                 break;
 
             case Type::T_COMMENT:
@@ -2315,25 +2721,33 @@ protected function compileChild($child, OutputBlock $out)
                     break;
                 }
 
-                $this->appendOutputLine($out, Type::T_COMMENT, $child[1]);
+                $line = $this->compileCommentValue($child, true);
+                $this->appendOutputLine($out, Type::T_COMMENT, $line);
                 break;
 
             case Type::T_MIXIN:
             case Type::T_FUNCTION:
                 list(, $block) = $child;
-
+                // the block need to be able to go up to it's parent env to resolve vars
+                $block->parentEnv = $this->getStoreEnv();
                 $this->set(static::$namespaces[$block->type] . $block->name, $block, true);
                 break;
 
             case Type::T_EXTEND:
                 foreach ($child[1] as $sel) {
+                    $sel = $this->replaceSelfSelector($sel);
                     $results = $this->evalSelectors([$sel]);
 
                     foreach ($results as $result) {
                         // only use the first one
                         $result = current($result);
+                        $selectors = $out->selectors;
+
+                        if (! $selectors && isset($child['selfParent'])) {
+                            $selectors = $this->multiplySelectors($this->env, $child['selfParent']);
+                        }
 
-                        $this->pushExtends($result, $out->selectors, $child);
+                        $this->pushExtends($result, $selectors, $child);
                     }
                 }
                 break;
@@ -2346,7 +2760,8 @@ protected function compileChild($child, OutputBlock $out)
                 }
 
                 foreach ($if->cases as $case) {
-                    if ($case->type === Type::T_ELSE ||
+                    if (
+                        $case->type === Type::T_ELSE ||
                         $case->type === Type::T_ELSEIF && $this->isTruthy($this->reduce($case->cond))
                     ) {
                         return $this->compileChildren($case->children, $out);
@@ -2357,12 +2772,12 @@ protected function compileChild($child, OutputBlock $out)
             case Type::T_EACH:
                 list(, $each) = $child;
 
-                $list = $this->coerceList($this->reduce($each->list));
+                $list = $this->coerceList($this->reduce($each->list), ',', true);
 
                 $this->pushEnv();
 
                 foreach ($list[2] as $item) {
-                    if (count($each->vars) === 1) {
+                    if (\count($each->vars) === 1) {
                         $this->set($each->vars[0], $item, true);
                     } else {
                         list(,, $values) = $this->coerceList($item);
@@ -2376,7 +2791,9 @@ protected function compileChild($child, OutputBlock $out)
 
                     if ($ret) {
                         if ($ret[0] !== Type::T_CONTROL) {
+                            $store = $this->env->store;
                             $this->popEnv();
+                            $this->backPropagateEnv($store, $each->vars);
 
                             return $ret;
                         }
@@ -2386,8 +2803,10 @@ protected function compileChild($child, OutputBlock $out)
                         }
                     }
                 }
-
+                $store = $this->env->store;
                 $this->popEnv();
+                $this->backPropagateEnv($store, $each->vars);
+
                 break;
 
             case Type::T_WHILE:
@@ -2414,10 +2833,16 @@ protected function compileChild($child, OutputBlock $out)
                 $start = $this->reduce($for->start, true);
                 $end   = $this->reduce($for->end, true);
 
-                if (! ($start[2] == $end[2] || $end->unitless())) {
-                    $this->throwError('Incompatible units: "%s" and "%s".', $start->unitStr(), $end->unitStr());
+                if (! $start instanceof Node\Number) {
+                    throw $this->error('%s is not a number', $start[0]);
+                }
 
-                    break;
+                if (! $end instanceof Node\Number) {
+                    throw $this->error('%s is not a number', $end[0]);
+                }
+
+                if (! ($start[2] == $end[2] || $end->unitless())) {
+                    throw $this->error('Incompatible units: "%s" && "%s".', $start->unitStr(), $end->unitStr());
                 }
 
                 $unit  = $start[2];
@@ -2426,8 +2851,11 @@ protected function compileChild($child, OutputBlock $out)
 
                 $d = $start < $end ? 1 : -1;
 
+                $this->pushEnv();
+
                 for (;;) {
-                    if ((! $for->until && $start - $d == $end) ||
+                    if (
+                        (! $for->until && $start - $d == $end) ||
                         ($for->until && $start == $end)
                     ) {
                         break;
@@ -2440,6 +2868,10 @@ protected function compileChild($child, OutputBlock $out)
 
                     if ($ret) {
                         if ($ret[0] !== Type::T_CONTROL) {
+                            $store = $this->env->store;
+                            $this->popEnv();
+                            $this->backPropagateEnv($store, [$for->var]);
+
                             return $ret;
                         }
 
@@ -2448,6 +2880,11 @@ protected function compileChild($child, OutputBlock $out)
                         }
                     }
                 }
+
+                $store = $this->env->store;
+                $this->popEnv();
+                $this->backPropagateEnv($store, [$for->var]);
+
                 break;
 
             case Type::T_BREAK:
@@ -2465,13 +2902,12 @@ protected function compileChild($child, OutputBlock $out)
 
             case Type::T_INCLUDE:
                 // including a mixin
-                list(, $name, $argValues, $content) = $child;
+                list(, $name, $argValues, $content, $argUsing) = $child;
 
                 $mixin = $this->get(static::$namespaces['mixin'] . $name, false);
 
                 if (! $mixin) {
-                    $this->throwError("Undefined mixin $name");
-                    break;
+                    throw $this->error("Undefined mixin $name");
                 }
 
                 $callingScope = $this->getStoreEnv();
@@ -2480,9 +2916,6 @@ protected function compileChild($child, OutputBlock $out)
                 $this->pushEnv();
                 $this->env->depth--;
 
-                $storeEnv = $this->storeEnv;
-                $this->storeEnv = $this->env;
-
                 // 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;
@@ -2497,7 +2930,7 @@ protected function compileChild($child, OutputBlock $out)
                         $parent->selectors = $parentSelectors;
 
                         foreach ($mixin->children as $k => $child) {
-                            if (isset($child[1]) && is_object($child[1]) && $child[1] instanceof Block) {
+                            if (isset($child[1]) && \is_object($child[1]) && $child[1] instanceof Block) {
                                 $mixin->children[$k][1]->parent = $parent;
                             }
                         }
@@ -2508,39 +2941,64 @@ protected function compileChild($child, OutputBlock $out)
                 // i.e., recursive @include of the same mixin
                 if (isset($content)) {
                     $copyContent = clone $content;
-                    $copyContent->scope = $callingScope;
+                    $copyContent->scope = clone $callingScope;
 
                     $this->setRaw(static::$namespaces['special'] . 'content', $copyContent, $this->env);
                 } else {
                     $this->setRaw(static::$namespaces['special'] . 'content', null, $this->env);
                 }
 
+                // save the "using" argument list for applying it to when "@content" is invoked
+                if (isset($argUsing)) {
+                    $this->setRaw(static::$namespaces['special'] . 'using', $argUsing, $this->env);
+                } else {
+                    $this->setRaw(static::$namespaces['special'] . 'using', null, $this->env);
+                }
+
                 if (isset($mixin->args)) {
                     $this->applyArguments($mixin->args, $argValues);
                 }
 
                 $this->env->marker = 'mixin';
 
-                $this->compileChildrenNoReturn($mixin->children, $out, $selfParent, $this->env->marker . " " . $name);
+                if (! empty($mixin->parentEnv)) {
+                    $this->env->declarationScopeParent = $mixin->parentEnv;
+                } else {
+                    throw $this->error("@mixin $name() without parentEnv");
+                }
 
-                $this->storeEnv = $storeEnv;
+                $this->compileChildrenNoReturn($mixin->children, $out, $selfParent, $this->env->marker . ' ' . $name);
 
                 $this->popEnv();
                 break;
 
             case Type::T_MIXIN_CONTENT:
-                $env = isset($this->storeEnv) ? $this->storeEnv : $this->env;
-                $content = $this->get(static::$namespaces['special'] . 'content', false, $env);
+                $env        = isset($this->storeEnv) ? $this->storeEnv : $this->env;
+                $content    = $this->get(static::$namespaces['special'] . 'content', false, $env);
+                $argUsing   = $this->get(static::$namespaces['special'] . 'using', false, $env);
+                $argContent = $child[1];
 
                 if (! $content) {
-                    $content = new \stdClass();
-                    $content->scope = new \stdClass();
-                    $content->children = $env->parent->block->children;
                     break;
                 }
 
                 $storeEnv = $this->storeEnv;
+                $varsUsing = [];
+
+                if (isset($argUsing) && isset($argContent)) {
+                    // Get the arguments provided for the content with the names provided in the "using" argument list
+                    $this->storeEnv = null;
+                    $varsUsing = $this->applyArguments($argUsing, $argContent, false);
+                }
+
+                // restore the scope from the @content
                 $this->storeEnv = $content->scope;
+
+                // append the vars from using if any
+                foreach ($varsUsing as $name => $val) {
+                    $this->set($name, $val, true, $this->storeEnv);
+                }
+
                 $this->compileChildrenNoReturn($content->children, $out);
 
                 $this->storeEnv = $storeEnv;
@@ -2550,35 +3008,36 @@ protected function compileChild($child, OutputBlock $out)
                 list(, $value) = $child;
 
                 $fname = $this->sourceNames[$this->sourceIndex];
-                $line = $this->sourceLine;
-                $value = $this->compileValue($this->reduce($value, true));
-                fwrite($this->stderr, "File $fname on line $line DEBUG: $value\n");
+                $line  = $this->sourceLine;
+                $value = $this->compileDebugValue($value);
+
+                fwrite($this->stderr, "$fname:$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, "File $fname on line $line WARN: $value\n");
+                $line  = $this->sourceLine;
+                $value = $this->compileDebugValue($value);
+
+                fwrite($this->stderr, "WARNING: $value\n         on line $line of $fname\n\n");
                 break;
 
             case Type::T_ERROR:
                 list(, $value) = $child;
 
                 $fname = $this->sourceNames[$this->sourceIndex];
-                $line = $this->sourceLine;
+                $line  = $this->sourceLine;
                 $value = $this->compileValue($this->reduce($value, true));
-                $this->throwError("File $fname on line $line ERROR: $value\n");
-                break;
+
+                throw $this->error("File $fname on line $line ERROR: $value\n");
 
             case Type::T_CONTROL:
-                $this->throwError('@break/@continue not permitted in this scope');
-                break;
+                throw $this->error('@break/@continue not permitted in this scope');
 
             default:
-                $this->throwError("unknown child type: $child[0]");
+                throw $this->error("unknown child type: $child[0]");
         }
     }
 
@@ -2586,14 +3045,21 @@ protected function compileChild($child, OutputBlock $out)
      * Reduce expression to string
      *
      * @param array $exp
+     * @param true $keepParens
      *
      * @return array
      */
-    protected function expToString($exp)
+    protected function expToString($exp, $keepParens = false)
     {
-        list(, $op, $left, $right, /* $inParens */, $whiteLeft, $whiteRight) = $exp;
+        list(, $op, $left, $right, $inParens, $whiteLeft, $whiteRight) = $exp;
 
-        $content = [$this->reduce($left)];
+        $content = [];
+
+        if ($keepParens && $inParens) {
+            $content[] = '(';
+        }
+
+        $content[] = $this->reduce($left);
 
         if ($whiteLeft) {
             $content[] = ' ';
@@ -2607,6 +3073,10 @@ protected function expToString($exp)
 
         $content[] = $this->reduce($right);
 
+        if ($keepParens && $inParens) {
+            $content[] = ')';
+        }
+
         return [Type::T_STRING, '', $content];
     }
 
@@ -2664,10 +3134,13 @@ protected function shouldEval($value)
      * @param array   $value
      * @param boolean $inExp
      *
-     * @return array|\ScssPhp\ScssPhp\Node\Number
+     * @return null|string|array|\ScssPhp\ScssPhp\Node\Number
      */
     protected function reduce($value, $inExp = false)
     {
+        if (\is_null($value)) {
+            return null;
+        }
 
         switch ($value[0]) {
             case Type::T_EXPRESSION:
@@ -2683,16 +3156,16 @@ protected function reduce($value, $inExp = false)
                 }
 
                 // special case: looks like css shorthand
-                if ($opName == 'div' && ! $inParens && ! $inExp && isset($right[2]) &&
+                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);
                 }
 
-                $left = $this->coerceForExpression($left);
+                $left  = $this->coerceForExpression($left);
                 $right = $this->coerceForExpression($right);
-
                 $ltype = $left[0];
                 $rtype = $right[0];
 
@@ -2706,17 +3179,19 @@ protected function reduce($value, $inExp = false)
                 // 3. op[op name]
                 $fn = "op${ucOpName}${ucLType}${ucRType}";
 
-                if (is_callable([$this, $fn]) ||
+                if (
+                    \is_callable([$this, $fn]) ||
                     (($fn = "op${ucLType}${ucRType}") &&
-                        is_callable([$this, $fn]) &&
+                        \is_callable([$this, $fn]) &&
                         $passOp = true) ||
                     (($fn = "op${ucOpName}") &&
-                        is_callable([$this, $fn]) &&
+                        \is_callable([$this, $fn]) &&
                         $genOp = true)
                 ) {
                     $coerceUnit = false;
 
-                    if (! isset($genOp) &&
+                    if (
+                        ! isset($genOp) &&
                         $left[0] === Type::T_NUMBER && $right[0] === Type::T_NUMBER
                     ) {
                         $coerceUnit = true;
@@ -2746,9 +3221,14 @@ protected function reduce($value, $inExp = false)
                                 $targetUnit = $left->unitless() ? $right[2] : $left[2];
                         }
 
-                        if (! $left->unitless() && ! $right->unitless()) {
+                        $baseUnitLeft = $left->isNormalizable();
+                        $baseUnitRight = $right->isNormalizable();
+
+                        if ($baseUnitLeft && $baseUnitRight && $baseUnitLeft === $baseUnitRight) {
                             $left = $left->normalize();
                             $right = $right->normalize();
+                        } elseif ($coerceUnit) {
+                            $left = new Node\Number($left[1], []);
                         }
                     }
 
@@ -2824,7 +3304,7 @@ protected function reduce($value, $inExp = false)
 
             case Type::T_STRING:
                 foreach ($value[2] as &$item) {
-                    if (is_array($item) || $item instanceof \ArrayAccess) {
+                    if (\is_array($item) || $item instanceof \ArrayAccess) {
                         $item = $this->reduce($item);
                     }
                 }
@@ -2833,6 +3313,7 @@ protected function reduce($value, $inExp = false)
 
             case Type::T_INTERPOLATE:
                 $value[1] = $this->reduce($value[1]);
+
                 if ($inExp) {
                     return $value[1];
                 }
@@ -2843,8 +3324,10 @@ protected function reduce($value, $inExp = false)
                 return $this->fncall($value[1], $value[2]);
 
             case Type::T_SELF:
-                $selfSelector = $this->multiplySelectors($this->env);
+                $selfParent = ! empty($this->env->block->selfParent) ? $this->env->block->selfParent : null;
+                $selfSelector = $this->multiplySelectors($this->env, $selfParent);
                 $selfSelector = $this->collapseSelectors($selfSelector, true);
+
                 return $selfSelector;
 
             default:
@@ -2860,30 +3343,233 @@ protected function reduce($value, $inExp = false)
      *
      * @return array|null
      */
-    protected function fncall($name, $argValues)
+    protected function fncall($functionReference, $argValues)
+    {
+        // a string means this is a static hard reference coming from the parsing
+        if (is_string($functionReference)) {
+            $name = $functionReference;
+
+            $functionReference = $this->getFunctionReference($name);
+            if ($functionReference === static::$null || $functionReference[0] !== Type::T_FUNCTION_REFERENCE) {
+                $functionReference = [Type::T_FUNCTION, $name, [Type::T_LIST, ',', []]];
+            }
+        }
+
+        // a function type means we just want a plain css function call
+        if ($functionReference[0] === Type::T_FUNCTION) {
+            // for CSS functions, simply flatten the arguments into a list
+            $listArgs = [];
+
+            foreach ((array) $argValues as $arg) {
+                if (empty($arg[0]) || count($argValues) === 1) {
+                    $listArgs[] = $this->reduce($this->stringifyFncallArgs($arg[1]));
+                }
+            }
+
+            return [Type::T_FUNCTION, $functionReference[1], [Type::T_LIST, ',', $listArgs]];
+        }
+
+        if ($functionReference === static::$null || $functionReference[0] !== Type::T_FUNCTION_REFERENCE) {
+            return static::$defaultValue;
+        }
+
+
+        switch ($functionReference[1]) {
+            // SCSS @function
+            case 'scss':
+                return $this->callScssFunction($functionReference[3], $argValues);
+
+            // native PHP functions
+            case 'user':
+            case 'native':
+                list(,,$name, $fn, $prototype) = $functionReference;
+
+                // special cases of css valid functions min/max
+                $name = strtolower($name);
+                if (\in_array($name, ['min', 'max'])) {
+                    $cssFunction = $this->cssValidArg(
+                        [Type::T_FUNCTION_CALL, $name, $argValues],
+                        ['min', 'max', 'calc', 'env', 'var']
+                    );
+                    if ($cssFunction !== false) {
+                        return $cssFunction;
+                    }
+                }
+                $returnValue = $this->callNativeFunction($name, $fn, $prototype, $argValues);
+
+                if (! isset($returnValue)) {
+                    return $this->fncall([Type::T_FUNCTION, $name, [Type::T_LIST, ',', []]], $argValues);
+                }
+
+                return $returnValue;
+
+            default:
+                return static::$defaultValue;
+        }
+    }
+
+    protected function cssValidArg($arg, $allowed_function = [], $inFunction = false)
+    {
+        switch ($arg[0]) {
+            case Type::T_INTERPOLATE:
+                return [Type::T_KEYWORD, $this->CompileValue($arg)];
+
+            case Type::T_FUNCTION:
+                if (! \in_array($arg[1], $allowed_function)) {
+                    return false;
+                }
+                if ($arg[2][0] === Type::T_LIST) {
+                    foreach ($arg[2][2] as $k => $subarg) {
+                        $arg[2][2][$k] = $this->cssValidArg($subarg, $allowed_function, $arg[1]);
+                        if ($arg[2][2][$k] === false) {
+                            return false;
+                        }
+                    }
+                }
+                return $arg;
+
+            case Type::T_FUNCTION_CALL:
+                if (! \in_array($arg[1], $allowed_function)) {
+                    return false;
+                }
+                $cssArgs = [];
+                foreach ($arg[2] as $argValue) {
+                    if ($argValue === static::$null) {
+                        return false;
+                    }
+                    $cssArg = $this->cssValidArg($argValue[1], $allowed_function, $arg[1]);
+                    if (empty($argValue[0]) && $cssArg !== false) {
+                        $cssArgs[] = [$argValue[0], $cssArg];
+                    } else {
+                        return false;
+                    }
+                }
+
+                return $this->fncall([Type::T_FUNCTION, $arg[1], [Type::T_LIST, ',', []]], $cssArgs);
+
+            case Type::T_STRING:
+            case Type::T_KEYWORD:
+                if (!$inFunction or !\in_array($inFunction, ['calc', 'env', 'var'])) {
+                    return false;
+                }
+                return $this->stringifyFncallArgs($arg);
+
+            case Type::T_NUMBER:
+                return $this->stringifyFncallArgs($arg);
+
+            case Type::T_LIST:
+                if (!$inFunction) {
+                    return false;
+                }
+                if (empty($arg['enclosing']) and $arg[1] === '') {
+                    foreach ($arg[2] as $k => $subarg) {
+                        $arg[2][$k] = $this->cssValidArg($subarg, $allowed_function, $inFunction);
+                        if ($arg[2][$k] === false) {
+                            return false;
+                        }
+                    }
+                    $arg[0] = Type::T_STRING;
+                    return $arg;
+                }
+                return false;
+
+            case Type::T_EXPRESSION:
+                if (! \in_array($arg[1], ['+', '-', '/', '*'])) {
+                    return false;
+                }
+                $arg[2] = $this->cssValidArg($arg[2], $allowed_function, $inFunction);
+                $arg[3] = $this->cssValidArg($arg[3], $allowed_function, $inFunction);
+                if ($arg[2] === false || $arg[3] === false) {
+                    return false;
+                }
+                return $this->expToString($arg, true);
+
+            case Type::T_VARIABLE:
+            case Type::T_SELF:
+            default:
+                return false;
+        }
+    }
+
+
+    /**
+     * Reformat fncall arguments to proper css function output
+     * @param $arg
+     * @return array|\ArrayAccess|Node\Number|string|null
+     */
+    protected function stringifyFncallArgs($arg)
+    {
+
+        switch ($arg[0]) {
+            case Type::T_LIST:
+                foreach ($arg[2] as $k => $v) {
+                    $arg[2][$k] = $this->stringifyFncallArgs($v);
+                }
+                break;
+
+            case Type::T_EXPRESSION:
+                if ($arg[1] === '/') {
+                    $arg[2] = $this->stringifyFncallArgs($arg[2]);
+                    $arg[3] = $this->stringifyFncallArgs($arg[3]);
+                    $arg[5] = $arg[6] = false; // no space around /
+                    $arg = $this->expToString($arg);
+                }
+                break;
+
+            case Type::T_FUNCTION_CALL:
+                $name = strtolower($arg[1]);
+
+                if (in_array($name, ['max', 'min', 'calc'])) {
+                    $args = $arg[2];
+                    $arg = $this->fncall([Type::T_FUNCTION, $name, [Type::T_LIST, ',', []]], $args);
+                }
+                break;
+        }
+
+        return $arg;
+    }
+
+    /**
+     * Find a function reference
+     * @param string $name
+     * @param bool $safeCopy
+     * @return array
+     */
+    protected function getFunctionReference($name, $safeCopy = false)
     {
         // SCSS @function
-        if ($this->callScssFunction($name, $argValues, $returnValue)) {
-            return $returnValue;
+        if ($func = $this->get(static::$namespaces['function'] . $name, false)) {
+            if ($safeCopy) {
+                $func = clone $func;
+            }
+
+            return [Type::T_FUNCTION_REFERENCE, 'scss', $name, $func];
         }
 
         // native PHP functions
-        if ($this->callNativeFunction($name, $argValues, $returnValue)) {
-            return $returnValue;
+
+        // try to find a native lib function
+        $normalizedName = $this->normalizeName($name);
+        $libName = null;
+
+        if (isset($this->userFunctions[$normalizedName])) {
+            // see if we can find a user function
+            list($f, $prototype) = $this->userFunctions[$normalizedName];
+
+            return [Type::T_FUNCTION_REFERENCE, 'user', $name, $f, $prototype];
         }
 
-        // for CSS functions, simply flatten the arguments into a list
-        $listArgs = [];
+        if (($f = $this->getBuiltinFunction($normalizedName)) && \is_callable($f)) {
+            $libName   = $f[1];
+            $prototype = isset(static::$$libName) ? static::$$libName : null;
 
-        foreach ((array) $argValues as $arg) {
-            if (empty($arg[0])) {
-                $listArgs[] = $this->reduce($arg[1]);
-            }
+            return [Type::T_FUNCTION_REFERENCE, 'native', $name, $f, $prototype];
         }
 
-        return [Type::T_FUNCTION, $name, [Type::T_LIST, ',', $listArgs]];
+        return static::$null;
     }
 
+
     /**
      * Normalize name
      *
@@ -2919,6 +3605,10 @@ public function normalizeValue($value)
                     $value[2][$key] = $this->normalizeValue($item);
                 }
 
+                if (! empty($value['enclosing'])) {
+                    unset($value['enclosing']);
+                }
+
                 return $value;
 
             case Type::T_STRING:
@@ -2985,7 +3675,7 @@ protected function opSubNumberNumber($left, $right)
     protected function opDivNumberNumber($left, $right)
     {
         if ($right[1] == 0) {
-            return [Type::T_STRING, '', [$left[1] . $left[2] . '/' . $right[1] . $right[2]]];
+            return ($left[1] == 0) ? static::$NaN : static::$Infinity;
         }
 
         return new Node\Number($left[1] / $right[1], $left[2]);
@@ -3001,6 +3691,10 @@ protected function opDivNumberNumber($left, $right)
      */
     protected function opModNumberNumber($left, $right)
     {
+        if ($right[1] == 0) {
+            return static::$NaN;
+        }
+
         return new Node\Number($left[1] % $right[1], $left[2]);
     }
 
@@ -3124,13 +3818,16 @@ protected function opColorColor($op, $left, $right)
                     break;
 
                 case '%':
+                    if ($rval == 0) {
+                        throw $this->error("color: Can't take modulo by zero");
+                    }
+
                     $out[] = $lval % $rval;
                     break;
 
                 case '/':
                     if ($rval == 0) {
-                        $this->throwError("color: Can't divide by zero");
-                        break 2;
+                        throw $this->error("color: Can't divide by zero");
                     }
 
                     $out[] = (int) ($lval / $rval);
@@ -3143,8 +3840,7 @@ protected function opColorColor($op, $left, $right)
                     return $this->opNeq($left, $right);
 
                 default:
-                    $this->throwError("color: unknown op $op");
-                    break 2;
+                    throw $this->error("color: unknown op $op");
             }
         }
 
@@ -3335,7 +4031,7 @@ public function toBool($thing)
      *
      * @param array $value
      *
-     * @return string
+     * @return string|array
      */
     public function compileValue($value)
     {
@@ -3352,14 +4048,38 @@ public function compileValue($value)
                 // [4] - optional alpha component
                 list(, $r, $g, $b) = $value;
 
-                $r = round($r);
-                $g = round($g);
-                $b = round($b);
+                $r = $this->compileRGBAValue($r);
+                $g = $this->compileRGBAValue($g);
+                $b = $this->compileRGBAValue($b);
+
+                if (\count($value) === 5) {
+                    $alpha = $this->compileRGBAValue($value[4], true);
+
+                    if (! is_numeric($alpha) || $alpha < 1) {
+                        $colorName = Colors::RGBaToColorName($r, $g, $b, $alpha);
+
+                        if (! \is_null($colorName)) {
+                            return $colorName;
+                        }
+
+                        if (is_numeric($alpha)) {
+                            $a = new Node\Number($alpha, '');
+                        } else {
+                            $a = $alpha;
+                        }
+
+                        return 'rgba(' . $r . ', ' . $g . ', ' . $b . ', ' . $a . ')';
+                    }
+                }
+
+                if (! is_numeric($r) || ! is_numeric($g) || ! is_numeric($b)) {
+                    return 'rgb(' . $r . ', ' . $g . ', ' . $b . ')';
+                }
 
-                if (count($value) === 5 && $value[4] !== 1) { // rgba
-                    $a = new Node\Number($value[4], '');
+                $colorName = Colors::RGBaToColorName($r, $g, $b);
 
-                    return 'rgba(' . $r . ', ' . $g . ', ' . $b . ', ' . $a . ')';
+                if (! \is_null($colorName)) {
+                    return $colorName;
                 }
 
                 $h = sprintf('#%02x%02x%02x', $r, $g, $b);
@@ -3375,13 +4095,36 @@ public function compileValue($value)
                 return $value->output($this);
 
             case Type::T_STRING:
-                return $value[1] . $this->compileStringContent($value) . $value[1];
+                $content = $this->compileStringContent($value);
+
+                if ($value[1]) {
+                    // force double quote as string quote for the output in certain cases
+                    if (
+                        $value[1] === "'" &&
+                        strpos($content, '"') === false &&
+                        strpbrk($content, '{}') !== false
+                    ) {
+                        $value[1] = '"';
+                    }
+                    $content = str_replace(
+                        array('\\a', "\n", "\f" , '\\'  , "\r" , $value[1]),
+                        array("\r" , ' ' , '\\f', '\\\\', '\\a', '\\' . $value[1]),
+                        $content
+                    );
+                }
+
+                return $value[1] . $content . $value[1];
 
             case Type::T_FUNCTION:
                 $args = ! empty($value[2]) ? $this->compileValue($value[2]) : '';
 
                 return "$value[1]($args)";
 
+            case Type::T_FUNCTION_REFERENCE:
+                $name = ! empty($value[2]) ? $value[2] : '';
+
+                return "get-function(\"$name\")";
+
             case Type::T_LIST:
                 $value = $this->extractInterpolation($value);
 
@@ -3390,9 +4133,30 @@ public function compileValue($value)
                 }
 
                 list(, $delim, $items) = $value;
+                $pre = $post = '';
+
+                if (! empty($value['enclosing'])) {
+                    switch ($value['enclosing']) {
+                        case 'parent':
+                            //$pre = '(';
+                            //$post = ')';
+                            break;
+                        case 'forced_parent':
+                            $pre = '(';
+                            $post = ')';
+                            break;
+                        case 'bracket':
+                        case 'forced_bracket':
+                            $pre = '[';
+                            $post = ']';
+                            break;
+                    }
+                }
+
+                $prefix_value = '';
 
                 if ($delim !== ' ') {
-                    $delim .= ' ';
+                    $prefix_value = ' ';
                 }
 
                 $filtered = [];
@@ -3402,17 +4166,23 @@ public function compileValue($value)
                         continue;
                     }
 
-                    $filtered[] = $this->compileValue($item);
+                    $compiled = $this->compileValue($item);
+
+                    if ($prefix_value && \strlen($compiled)) {
+                        $compiled = $prefix_value . $compiled;
+                    }
+
+                    $filtered[] = $compiled;
                 }
 
-                return implode("$delim", $filtered);
+                return $pre . substr(implode("$delim", $filtered), \strlen($prefix_value)) . $post;
 
             case Type::T_MAP:
-                $keys = $value[1];
-                $values = $value[2];
+                $keys     = $value[1];
+                $values   = $value[2];
                 $filtered = [];
 
-                for ($i = 0, $s = count($keys); $i < $s; $i++) {
+                for ($i = 0, $s = \count($keys); $i < $s; $i++) {
                     $filtered[$this->compileValue($keys[$i])] = $this->compileValue($values[$i]);
                 }
 
@@ -3427,11 +4197,24 @@ public function compileValue($value)
                 list(, $interpolate, $left, $right) = $value;
                 list(,, $whiteLeft, $whiteRight) = $interpolate;
 
-                $left = count($left[2]) > 0 ?
-                    $this->compileValue($left) . $whiteLeft : '';
+                $delim = $left[1];
+
+                if ($delim && $delim !== ' ' && ! $whiteLeft) {
+                    $delim .= ' ';
+                }
+
+                $left = \count($left[2]) > 0
+                    ?  $this->compileValue($left) . $delim . $whiteLeft
+                    : '';
+
+                $delim = $right[1];
+
+                if ($delim && $delim !== ' ') {
+                    $delim .= ' ';
+                }
 
-                $right = count($right[2]) > 0 ?
-                    $whiteRight . $this->compileValue($right) : '';
+                $right = \count($right[2]) > 0 ?
+                    $whiteRight . $delim . $this->compileValue($right) : '';
 
                 return $left . $this->compileValue($interpolate) . $right;
 
@@ -3461,6 +4244,7 @@ public function compileValue($value)
                             }
 
                             $temp = $this->compileValue([Type::T_KEYWORD, $item]);
+
                             if ($temp[0] === Type::T_STRING) {
                                 $filtered[] = $this->compileStringContent($temp);
                             } elseif ($temp[0] === Type::T_KEYWORD) {
@@ -3486,8 +4270,29 @@ public function compileValue($value)
             case Type::T_NULL:
                 return 'null';
 
+            case Type::T_COMMENT:
+                return $this->compileCommentValue($value);
+
+            default:
+                throw $this->error('unknown value type: ' . json_encode($value));
+        }
+    }
+
+    /**
+     * @param array $value
+     *
+     * @return array|string
+     */
+    protected function compileDebugValue($value)
+    {
+        $value = $this->reduce($value, true);
+
+        switch ($value[0]) {
+            case Type::T_STRING:
+                return $this->compileStringContent($value);
+
             default:
-                $this->throwError("unknown value type: ".json_encode($value));
+                return $this->compileValue($value);
         }
     }
 
@@ -3515,7 +4320,7 @@ protected function compileStringContent($string)
         $parts = [];
 
         foreach ($string[2] as $part) {
-            if (is_array($part) || $part instanceof \ArrayAccess) {
+            if (\is_array($part) || $part instanceof \ArrayAccess) {
                 $parts[] = $this->compileValue($part);
             } else {
                 $parts[] = $part;
@@ -3538,8 +4343,8 @@ protected function extractInterpolation($list)
 
         foreach ($items as $i => $item) {
             if ($item[0] === Type::T_INTERPOLATE) {
-                $before = [Type::T_LIST, $list[1], array_slice($items, 0, $i)];
-                $after  = [Type::T_LIST, $list[1], array_slice($items, $i + 1)];
+                $before = [Type::T_LIST, $list[1], \array_slice($items, 0, $i)];
+                $after  = [Type::T_LIST, $list[1], \array_slice($items, $i + 1)];
 
                 return [Type::T_INTERPOLATED, $item, $before, $after];
             }
@@ -3564,7 +4369,7 @@ protected function multiplySelectors(Environment $env, $selfParent = null)
 
         $selfParentSelectors = null;
 
-        if (! is_null($selfParent) && $selfParent->selectors) {
+        if (! \is_null($selfParent) && $selfParent->selectors) {
             $selfParentSelectors = $this->evalSelectors($selfParent->selectors);
         }
 
@@ -3576,12 +4381,12 @@ protected function multiplySelectors(Environment $env, $selfParent = null)
             $selectors = $env->selectors;
 
             do {
-                $stillHasSelf = false;
+                $stillHasSelf  = false;
                 $prevSelectors = $selectors;
-                $selectors = [];
+                $selectors     = [];
 
-                foreach ($prevSelectors as $selector) {
-                    foreach ($parentSelectors as $parent) {
+                foreach ($parentSelectors as $parent) {
+                    foreach ($prevSelectors as $selector) {
                         if ($selfParentSelectors) {
                             foreach ($selfParentSelectors as $selfParent) {
                                 // if no '&' in the selector, each call will give same result, only add once
@@ -3601,6 +4406,11 @@ protected function multiplySelectors(Environment $env, $selfParent = null)
 
         $selectors = array_values($selectors);
 
+        // case we are just starting a at-root : nothing to multiply but parentSelectors
+        if (! $selectors && $selfParentSelectors) {
+            $selectors = $selfParentSelectors;
+        }
+
         return $selectors;
     }
 
@@ -3609,7 +4419,7 @@ protected function multiplySelectors(Environment $env, $selfParent = null)
      *
      * @param array   $parent
      * @param array   $child
-     * @param boolean &$stillHasSelf
+     * @param boolean $stillHasSelf
      * @param array   $selfParentSelectors
 
      * @return array
@@ -3631,7 +4441,7 @@ protected function joinSelectors($parent, $child, &$stillHasSelf, $selfParentSel
                 if ($p === static::$selfSelector && ! $setSelf) {
                     $setSelf = true;
 
-                    if (is_null($selfParentSelectors)) {
+                    if (\is_null($selfParentSelectors)) {
                         $selfParentSelectors = $parent;
                     }
 
@@ -3642,11 +4452,13 @@ protected function joinSelectors($parent, $child, &$stillHasSelf, $selfParentSel
                         }
 
                         foreach ($parentPart as $pp) {
-                            if (is_array($pp)) {
+                            if (\is_array($pp)) {
                                 $flatten = [];
+
                                 array_walk_recursive($pp, function ($a) use (&$flatten) {
                                     $flatten[] = $a;
                                 });
+
                                 $pp = implode($flatten);
                             }
 
@@ -3674,7 +4486,8 @@ protected function joinSelectors($parent, $child, &$stillHasSelf, $selfParentSel
      */
     protected function multiplyMedia(Environment $env = null, $childQueries = null)
     {
-        if (! isset($env) ||
+        if (
+            ! isset($env) ||
             ! empty($env->block->type) && $env->block->type !== Type::T_MEDIA
         ) {
             return $childQueries;
@@ -3690,12 +4503,14 @@ protected function multiplyMedia(Environment $env = null, $childQueries = null)
             : [[[Type::T_MEDIA_VALUE, $env->block->value]]];
 
         $store = [$this->env, $this->storeEnv];
-        $this->env = $env;
+
+        $this->env      = $env;
         $this->storeEnv = null;
-        $parentQueries = $this->evaluateMediaQuery($parentQueries);
+        $parentQueries  = $this->evaluateMediaQuery($parentQueries);
+
         list($this->env, $this->storeEnv) = $store;
 
-        if ($childQueries === null) {
+        if (\is_null($childQueries)) {
             $childQueries = $parentQueries;
         } else {
             $originalQueries = $childQueries;
@@ -3757,13 +4572,15 @@ protected function extractEnv($envs)
      */
     protected function pushEnv(Block $block = null)
     {
-        $env = new Environment;
+        $env = new Environment();
         $env->parent = $this->env;
+        $env->parentStore = $this->storeEnv;
         $env->store  = [];
         $env->block  = $block;
         $env->depth  = isset($this->env->depth) ? $this->env->depth + 1 : 0;
 
         $this->env = $env;
+        $this->storeEnv = null;
 
         return $env;
     }
@@ -3773,9 +4590,25 @@ protected function pushEnv(Block $block = null)
      */
     protected function popEnv()
     {
+        $this->storeEnv = $this->env->parentStore;
         $this->env = $this->env->parent;
     }
 
+    /**
+     * Propagate vars from a just poped Env (used in @each and @for)
+     *
+     * @param array      $store
+     * @param null|array $excludedVars
+     */
+    protected function backPropagateEnv($store, $excludedVars = null)
+    {
+        foreach ($store as $key => $value) {
+            if (empty($excludedVars) || ! \in_array($key, $excludedVars)) {
+                $this->set($key, $value, true);
+            }
+        }
+    }
+
     /**
      * Get store environment
      *
@@ -3821,26 +4654,45 @@ protected function set($name, $value, $shadow = false, Environment $env = null,
     protected function setExisting($name, $value, Environment $env, $valueUnreduced = null)
     {
         $storeEnv = $env;
+        $specialContentKey = static::$namespaces['special'] . 'content';
 
         $hasNamespace = $name[0] === '^' || $name[0] === '@' || $name[0] === '%';
 
+        $maxDepth = 10000;
+
         for (;;) {
-            if (array_key_exists($name, $env->store)) {
+            if ($maxDepth-- <= 0) {
                 break;
             }
 
-            if (! $hasNamespace && isset($env->marker)) {
-                $env = $storeEnv;
+            if (\array_key_exists($name, $env->store)) {
                 break;
             }
 
-            if (! isset($env->parent)) {
-                $env = $storeEnv;
-                break;
-            }
+            if (! $hasNamespace && isset($env->marker)) {
+                if (! empty($env->store[$specialContentKey])) {
+                    $env = $env->store[$specialContentKey]->scope;
+                    continue;
+                }
 
-            $env = $env->parent;
-        }
+                if (! empty($env->declarationScopeParent)) {
+                    $env = $env->declarationScopeParent;
+                    continue;
+                } else {
+                    $env = $storeEnv;
+                    break;
+                }
+            }
+
+            if (isset($env->parentStore)) {
+                $env = $env->parentStore;
+            } elseif (isset($env->parent)) {
+                $env = $env->parent;
+            } else {
+                $env = $storeEnv;
+                break;
+            }
+        }
 
         $env->store[$name] = $value;
 
@@ -3887,7 +4739,6 @@ public function get($name, $shouldThrow = true, Environment $env = null, $unredu
             $env = $this->getStoreEnv();
         }
 
-        $nextIsRoot = false;
         $hasNamespace = $normalizedName[0] === '^' || $normalizedName[0] === '@' || $normalizedName[0] === '%';
 
         $maxDepth = 10000;
@@ -3897,7 +4748,7 @@ public function get($name, $shouldThrow = true, Environment $env = null, $unredu
                 break;
             }
 
-            if (array_key_exists($normalizedName, $env->store)) {
+            if (\array_key_exists($normalizedName, $env->store)) {
                 if ($unreduced && isset($env->storeUnreduced[$normalizedName])) {
                     return $env->storeUnreduced[$normalizedName];
                 }
@@ -3906,24 +4757,30 @@ public function get($name, $shouldThrow = true, Environment $env = null, $unredu
             }
 
             if (! $hasNamespace && isset($env->marker)) {
-                if (! $nextIsRoot && ! empty($env->store[$specialContentKey])) {
+                if (! empty($env->store[$specialContentKey])) {
                     $env = $env->store[$specialContentKey]->scope;
                     continue;
                 }
 
-                $env = $this->rootEnv;
+                if (! empty($env->declarationScopeParent)) {
+                    $env = $env->declarationScopeParent;
+                } else {
+                    $env = $this->rootEnv;
+                }
                 continue;
             }
 
-            if (! isset($env->parent)) {
+            if (isset($env->parentStore)) {
+                $env = $env->parentStore;
+            } elseif (isset($env->parent)) {
+                $env = $env->parent;
+            } else {
                 break;
             }
-
-            $env = $env->parent;
         }
 
         if ($shouldThrow) {
-            $this->throwError("Undefined variable \$$name" . ($maxDepth<=0 ? " (infinite recursion)" : ""));
+            throw $this->error("Undefined variable \$$name" . ($maxDepth <= 0 ? ' (infinite recursion)' : ''));
         }
 
         // found nothing
@@ -3940,7 +4797,7 @@ public function get($name, $shouldThrow = true, Environment $env = null, $unredu
      */
     protected function has($name, Environment $env = null)
     {
-        return $this->get($name, false, $env) !== null;
+        return ! \is_null($this->get($name, false, $env));
     }
 
     /**
@@ -4014,7 +4871,7 @@ public function getVariables()
      */
     public function addParsedFile($path)
     {
-        if (isset($path) && file_exists($path)) {
+        if (isset($path) && is_file($path)) {
             $this->parsedFiles[realpath($path)] = filemtime($path);
         }
     }
@@ -4040,7 +4897,7 @@ public function getParsedFiles()
      */
     public function addImportPath($path)
     {
-        if (! in_array($path, $this->importPaths)) {
+        if (! \in_array($path, $this->importPaths)) {
             $this->importPaths[] = $path;
         }
     }
@@ -4063,10 +4920,13 @@ public function setImportPaths($path)
      * @api
      *
      * @param integer $numberPrecision
+     *
+     * @deprecated The number precision is not configurable anymore. The default is enough for all browsers.
      */
     public function setNumberPrecision($numberPrecision)
     {
-        Node\Number::$precision = $numberPrecision;
+        @trigger_error('The number precision is not configurable anymore. '
+            . 'The default is enough for all browsers.', E_USER_DEPRECATED);
     }
 
     /**
@@ -4163,6 +5023,7 @@ public function addFeature($name)
      */
     protected function importFile($path, OutputBlock $out)
     {
+        $this->pushCallStack('import ' . $path);
         // see if tree is cached
         $realPath = realpath($path);
 
@@ -4179,9 +5040,11 @@ protected function importFile($path, OutputBlock $out)
         }
 
         $pi = pathinfo($path);
+
         array_unshift($this->importPaths, $pi['dirname']);
         $this->compileChildrenNoReturn($tree->children, $out);
         array_shift($this->importPaths);
+        $this->popCallStack();
     }
 
     /**
@@ -4197,18 +5060,31 @@ public function findImport($url)
     {
         $urls = [];
 
+        $hasExtension = preg_match('/[.]s?css$/', $url);
+
         // for "normal" scss imports (ignore vanilla css and external requests)
-        if (! preg_match('/\.css$|^https?:\/\//', $url)) {
+        if (! preg_match('~\.css$|^https?://|^//~', $url)) {
+            $isPartial = (strpos(basename($url), '_') === 0);
+
             // try both normal and the _partial filename
-            $urls = [$url, preg_replace('/[^\/]+$/', '_\0', $url)];
-        }
+            $urls = [$url . ($hasExtension ? '' : '.scss')];
 
-        $hasExtension = preg_match('/[.]s?css$/', $url);
+            if (! $isPartial) {
+                $urls[] = preg_replace('~[^/]+$~', '_\0', $url) . ($hasExtension ? '' : '.scss');
+            }
+
+            if (! $hasExtension) {
+                $urls[] = "$url/index.scss";
+                // allow to find a plain css file, *if* no scss or partial scss is found
+                $urls[] .= $url . '.css';
+            }
+        }
 
         foreach ($this->importPaths as $dir) {
-            if (is_string($dir)) {
+            if (\is_string($dir)) {
                 // check urls for normal import paths
                 foreach ($urls as $full) {
+                    $found = [];
                     $separator = (
                         ! empty($dir) &&
                         substr($dir, -1) !== '/' &&
@@ -4216,22 +5092,42 @@ public function findImport($url)
                     ) ? '/' : '';
                     $full = $dir . $separator . $full;
 
-                    if ($this->fileExists($file = $full . '.scss') ||
-                        ($hasExtension && $this->fileExists($file = $full))
-                    ) {
-                        return $file;
+                    if (is_file($file = $full)) {
+                        $found[] = $file;
+                    }
+                    if (! $isPartial) {
+                        $full = dirname($full) . '/_' . basename($full);
+                        if (is_file($file = $full)) {
+                            $found[] = $file;
+                        }
+                    }
+                    if ($found) {
+                        if (\count($found) === 1) {
+                            return reset($found);
+                        }
+                        if (\count($found) > 1) {
+                            throw $this->error(
+                                "Error: It's not clear which file to import. Found: " . implode(', ', $found)
+                            );
+                        }
                     }
                 }
-            } elseif (is_callable($dir)) {
+            } elseif (\is_callable($dir)) {
                 // check custom callback for import path
-                $file = call_user_func($dir, $url);
+                $file = \call_user_func($dir, $url);
 
-                if ($file !== null) {
+                if (! \is_null($file)) {
                     return $file;
                 }
             }
         }
 
+        if ($urls) {
+            if (! $hasExtension || preg_match('/[.]scss$/', $url)) {
+                throw $this->error("`$url` file not found for @import");
+            }
+        }
+
         return null;
     }
 
@@ -4255,14 +5151,30 @@ public function setEncoding($encoding)
      * @param boolean $ignoreErrors
      *
      * @return \ScssPhp\ScssPhp\Compiler
+     *
+     * @deprecated Ignoring Sass errors is not longer supported.
      */
     public function setIgnoreErrors($ignoreErrors)
     {
-        $this->ignoreErrors = $ignoreErrors;
+        @trigger_error('Ignoring Sass errors is not longer supported.', E_USER_DEPRECATED);
 
         return $this;
     }
 
+    /**
+     * Get source position
+     *
+     * @api
+     *
+     * @return array
+     */
+    public function getSourcePosition()
+    {
+        $sourceFile = isset($this->sourceNames[$this->sourceIndex]) ? $this->sourceNames[$this->sourceIndex] : '';
+
+        return [$sourceFile, $this->sourceLine, $this->sourceColumn];
+    }
+
     /**
      * Throw error (exception)
      *
@@ -4271,33 +5183,85 @@ public function setIgnoreErrors($ignoreErrors)
      * @param string $msg Message with optional sprintf()-style vararg parameters
      *
      * @throws \ScssPhp\ScssPhp\Exception\CompilerException
+     *
+     * @deprecated use "error" and throw the exception in the caller instead.
      */
     public function throwError($msg)
     {
-        if ($this->ignoreErrors) {
-            return;
+        @trigger_error(
+            'The method "throwError" is deprecated. Use "error" and throw the exception in the caller instead',
+            E_USER_DEPRECATED
+        );
+
+        throw $this->error(...func_get_args());
+    }
+
+    /**
+     * Build an error (exception)
+     *
+     * @api
+     *
+     * @param string $msg Message with optional sprintf()-style vararg parameters
+     *
+     * @return CompilerException
+     */
+    public function error($msg, ...$args)
+    {
+        if ($args) {
+            $msg = sprintf($msg, ...$args);
         }
 
-        $line   = $this->sourceLine;
-        $column = $this->sourceColumn;
+        if (! $this->ignoreCallStackMessage) {
+            $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";
 
-        $loc = isset($this->sourceNames[$this->sourceIndex])
-             ? $this->sourceNames[$this->sourceIndex] . " on line $line, at column $column"
-             : "line: $line, column: $column";
+            $msg = "$msg: $loc";
 
-        if (func_num_args() > 1) {
-            $msg = call_user_func_array('sprintf', func_get_args());
+            $callStackMsg = $this->callStackMessage();
+
+            if ($callStackMsg) {
+                $msg .= "\nCall Stack:\n" . $callStackMsg;
+            }
         }
 
-        $msg = "$msg: $loc";
+        return new CompilerException($msg);
+    }
+
+    /**
+     * @param string $functionName
+     * @param array $ExpectedArgs
+     * @param int $nbActual
+     * @return CompilerException
+     */
+    public function errorArgsNumber($functionName, $ExpectedArgs, $nbActual)
+    {
+        $nbExpected = \count($ExpectedArgs);
 
-        $callStackMsg = $this->callStackMessage();
+        if ($nbActual > $nbExpected) {
+            return $this->error(
+                'Error: Only %d arguments allowed in %s(), but %d were passed.',
+                $nbExpected,
+                $functionName,
+                $nbActual
+            );
+        } else {
+            $missing = [];
 
-        if ($callStackMsg) {
-            $msg .= "\nCall Stack:\n" . $callStackMsg;
-        }
+            while (count($ExpectedArgs) && count($ExpectedArgs) > $nbActual) {
+                array_unshift($missing, array_pop($ExpectedArgs));
+            }
 
-        throw new CompilerException($msg);
+            return $this->error(
+                'Error: %s() argument%s %s missing.',
+                $functionName,
+                count($missing) > 1 ? 's' : '',
+                implode(', ', $missing)
+            );
+        }
     }
 
     /**
@@ -4316,14 +5280,15 @@ protected function callStackMessage($all = false, $limit = null)
         if ($this->callStack) {
             foreach (array_reverse($this->callStack) as $call) {
                 if ($all || (isset($call['n']) && $call['n'])) {
-                    $msg = "#" . $ncall++ . " " . $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];
+                    $msg .= ' on line ' . $call[Parser::SOURCE_LINE];
+
                     $callStackMsg[] = $msg;
 
-                    if (! is_null($limit) && $ncall>$limit) {
+                    if (! \is_null($limit) && $ncall > $limit) {
                         break;
                     }
                 }
@@ -4343,113 +5308,99 @@ protected function callStackMessage($all = false, $limit = null)
     protected function handleImportLoop($name)
     {
         for ($env = $this->env; $env; $env = $env->parent) {
+            if (! $env->block) {
+                continue;
+            }
+
             $file = $this->sourceNames[$env->block->sourceIndex];
 
             if (realpath($file) === $name) {
-                $this->throwError('An @import loop has been found: %s imports %s', $file, basename($file));
-                break;
+                throw $this->error('An @import loop has been found: %s imports %s', $file, basename($file));
             }
         }
     }
 
-    /**
-     * Does file exist?
-     *
-     * @param string $name
-     *
-     * @return boolean
-     */
-    protected function fileExists($name)
-    {
-        return file_exists($name) && is_file($name);
-    }
-
     /**
      * Call SCSS @function
      *
-     * @param string $name
+     * @param Object $func
      * @param array  $argValues
-     * @param array  $returnValue
      *
-     * @return boolean Returns true if returnValue is set; otherwise, false
+     * @return array $returnValue
      */
-    protected function callScssFunction($name, $argValues, &$returnValue)
+    protected function callScssFunction($func, $argValues)
     {
-        $func = $this->get(static::$namespaces['function'] . $name, false);
-
         if (! $func) {
-            return false;
+            return static::$defaultValue;
         }
+        $name = $func->name;
 
         $this->pushEnv();
 
-        $storeEnv = $this->storeEnv;
-        $this->storeEnv = $this->env;
-
         // set the args
         if (isset($func->args)) {
             $this->applyArguments($func->args, $argValues);
         }
 
         // throw away lines and children
-        $tmp = new OutputBlock;
+        $tmp = new OutputBlock();
         $tmp->lines    = [];
         $tmp->children = [];
 
         $this->env->marker = 'function';
 
-        $ret = $this->compileChildren($func->children, $tmp, $this->env->marker . " " . $name);
+        if (! empty($func->parentEnv)) {
+            $this->env->declarationScopeParent = $func->parentEnv;
+        } else {
+            throw $this->error("@function $name() without parentEnv");
+        }
 
-        $this->storeEnv = $storeEnv;
+        $ret = $this->compileChildren($func->children, $tmp, $this->env->marker . ' ' . $name);
 
         $this->popEnv();
 
-        $returnValue = ! isset($ret) ? static::$defaultValue : $ret;
-
-        return true;
+        return ! isset($ret) ? static::$defaultValue : $ret;
     }
 
     /**
      * Call built-in and registered (PHP) functions
      *
      * @param string $name
+     * @param string|array $function
+     * @param array  $prototype
      * @param array  $args
-     * @param array  $returnValue
      *
-     * @return boolean Returns true if returnValue is set; otherwise, false
+     * @return array
      */
-    protected function callNativeFunction($name, $args, &$returnValue)
+    protected function callNativeFunction($name, $function, $prototype, $args)
     {
-        // try a lib function
-        $name = $this->normalizeName($name);
+        $libName = (is_array($function) ? end($function) : null);
+        $sorted_kwargs = $this->sortNativeFunctionArgs($libName, $prototype, $args);
 
-        if (isset($this->userFunctions[$name])) {
-            // see if we can find a user function
-            list($f, $prototype) = $this->userFunctions[$name];
-        } elseif (($f = $this->getBuiltinFunction($name)) && is_callable($f)) {
-            $libName   = $f[1];
-            $prototype = isset(static::$$libName) ? static::$$libName : null;
-        } else {
-            return false;
+        if (\is_null($sorted_kwargs)) {
+            return null;
         }
-
-        @list($sorted, $kwargs) = $this->sortArgs($prototype, $args);
+        @list($sorted, $kwargs) = $sorted_kwargs;
 
         if ($name !== 'if' && $name !== 'call') {
+            $inExp = true;
+
+            if ($name === 'join') {
+                $inExp = false;
+            }
+
             foreach ($sorted as &$val) {
-                $val = $this->reduce($val, true);
+                $val = $this->reduce($val, $inExp);
             }
         }
 
-        $returnValue = call_user_func($f, $sorted, $kwargs);
+        $returnValue = \call_user_func($function, $sorted, $kwargs);
 
         if (! isset($returnValue)) {
-            return false;
+            return null;
         }
 
-        $returnValue = $this->coerceValue($returnValue);
-
-        return true;
+        return $this->coerceValue($returnValue);
     }
 
     /**
@@ -4461,6 +5412,18 @@ protected function callNativeFunction($name, $args, &$returnValue)
      */
     protected function getBuiltinFunction($name)
     {
+        $libName = self::normalizeNativeFunctionName($name);
+        return [$this, $libName];
+    }
+
+    /**
+     * Normalize native function name
+     * @param $name
+     * @return string
+     */
+    public static function normalizeNativeFunctionName($name)
+    {
+        $name = str_replace("-", "_", $name);
         $libName = 'lib' . preg_replace_callback(
             '/_(.)/',
             function ($m) {
@@ -4468,19 +5431,29 @@ function ($m) {
             },
             ucfirst($name)
         );
+        return $libName;
+    }
 
-        return [$this, $libName];
+    /**
+     * Check if a function is a native built-in scss function, for css parsing
+     * @param $name
+     * @return bool
+     */
+    public static function isNativeFunction($name)
+    {
+        return method_exists(Compiler::class, self::normalizeNativeFunctionName($name));
     }
 
     /**
      * Sorts keyword arguments
      *
-     * @param array $prototype
-     * @param array $args
+     * @param string $functionName
+     * @param array  $prototypes
+     * @param array  $args
      *
-     * @return array
+     * @return array|null
      */
-    protected function sortArgs($prototypes, $args)
+    protected function sortNativeFunctionArgs($functionName, $prototypes, $args)
     {
         static $parser = null;
 
@@ -4488,25 +5461,44 @@ protected function sortArgs($prototypes, $args)
             $keyArgs = [];
             $posArgs = [];
 
+            if (\is_array($args) && \count($args) && \end($args) === static::$null) {
+                array_pop($args);
+            }
+
             // separate positional and keyword arguments
             foreach ($args as $arg) {
                 list($key, $value) = $arg;
 
-                $key = $key[1];
-
-                if (empty($key)) {
+                if (empty($key) or empty($key[1])) {
                     $posArgs[] = empty($arg[2]) ? $value : $arg;
                 } else {
-                    $keyArgs[$key] = $value;
+                    $keyArgs[$key[1]] = $value;
                 }
             }
 
             return [$posArgs, $keyArgs];
         }
 
+        // specific cases ?
+        if (\in_array($functionName, ['libRgb', 'libRgba', 'libHsl', 'libHsla'])) {
+            // notation 100 127 255 / 0 is in fact a simple list of 4 values
+            foreach ($args as $k => $arg) {
+                if ($arg[1][0] === Type::T_LIST && \count($arg[1][2]) === 3) {
+                    $last = end($arg[1][2]);
+
+                    if ($last[0] === Type::T_EXPRESSION && $last[1] === '/') {
+                        array_pop($arg[1][2]);
+                        $arg[1][2][] = $last[2];
+                        $arg[1][2][] = $last[3];
+                        $args[$k] = $arg;
+                    }
+                }
+            }
+        }
+
         $finalArgs = [];
 
-        if (! is_array(reset($prototypes))) {
+        if (! \is_array(reset($prototypes))) {
             $prototypes = [$prototypes];
         }
 
@@ -4524,14 +5516,14 @@ protected function sortArgs($prototypes, $args)
                 $p       = explode(':', $p, 2);
                 $name    = array_shift($p);
 
-                if (count($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)) {
+                        if (\is_null($parser)) {
                             $parser = $this->parserFactory(__METHOD__);
                         }
 
@@ -4549,8 +5541,19 @@ protected function sortArgs($prototypes, $args)
                 $argDef[] = [$name, $default, $isVariable];
             }
 
+            $ignoreCallStackMessage = $this->ignoreCallStackMessage;
+            $this->ignoreCallStackMessage = true;
+
             try {
-                $vars = $this->applyArguments($argDef, $args, false);
+                if (\count($args) > \count($argDef)) {
+                    $lastDef = end($argDef);
+
+                    // check that last arg is not a ...
+                    if (empty($lastDef[2])) {
+                        throw $this->errorArgsNumber($functionName, $argDef, \count($args));
+                    }
+                }
+                $vars = $this->applyArguments($argDef, $args, false, false);
 
                 // ensure all args are populated
                 foreach ($prototype as $i => $p) {
@@ -4586,10 +5589,20 @@ protected function sortArgs($prototypes, $args)
             } catch (CompilerException $e) {
                 $exceptionMessage = $e->getMessage();
             }
+            $this->ignoreCallStackMessage = $ignoreCallStackMessage;
         }
 
         if ($exceptionMessage && ! $prototypeHasMatch) {
-            $this->throwError($exceptionMessage);
+            if (\in_array($functionName, ['libRgb', 'libRgba', 'libHsl', 'libHsla'])) {
+                // if var() or calc() is used as an argument, return as a css function
+                foreach ($args as $arg) {
+                    if ($arg[1][0] === Type::T_FUNCTION_CALL && in_array($arg[1][1], ['var'])) {
+                        return null;
+                    }
+                }
+            }
+
+            throw $this->error($exceptionMessage);
         }
 
         return [$finalArgs, $keyArgs];
@@ -4598,19 +5611,28 @@ protected function sortArgs($prototypes, $args)
     /**
      * Apply argument values per definition
      *
-     * @param array $argDef
-     * @param array $argValues
+     * @param array   $argDef
+     * @param array   $argValues
+     * @param boolean $storeInEnv
+     * @param boolean $reduce
+     *   only used if $storeInEnv = false
+     *
+     * @return array
      *
      * @throws \Exception
      */
-    protected function applyArguments($argDef, $argValues, $storeInEnv = true)
+    protected function applyArguments($argDef, $argValues, $storeInEnv = true, $reduce = true)
     {
         $output = [];
 
+        if (\is_array($argValues) && \count($argValues) && end($argValues) === static::$null) {
+            array_pop($argValues);
+        }
+
         if ($storeInEnv) {
             $storeEnv = $this->getStoreEnv();
 
-            $env = new Environment;
+            $env = new Environment();
             $env->store = $storeEnv->store;
         }
 
@@ -4627,6 +5649,7 @@ protected function applyArguments($argDef, $argValues, $storeInEnv = true)
         $splatSeparator      = null;
         $keywordArgs         = [];
         $deferredKeywordArgs = [];
+        $deferredNamedKeywordArgs = [];
         $remaining           = [];
         $hasKeywordArgument  = false;
 
@@ -4635,28 +5658,38 @@ protected function applyArguments($argDef, $argValues, $storeInEnv = true)
             if (! empty($arg[0])) {
                 $hasKeywordArgument = true;
 
-                if (! isset($args[$arg[0][1]]) || $args[$arg[0][1]][3]) {
+                $name = $arg[0][1];
+
+                if (! isset($args[$name])) {
+                    foreach (array_keys($args) as $an) {
+                        if (str_replace('_', '-', $an) === str_replace('_', '-', $name)) {
+                            $name = $an;
+                            break;
+                        }
+                    }
+                }
+
+                if (! isset($args[$name]) || $args[$name][3]) {
                     if ($hasVariable) {
-                        $deferredKeywordArgs[$arg[0][1]] = $arg[1];
+                        $deferredNamedKeywordArgs[$name] = $arg[1];
                     } else {
-                        $this->throwError("Mixin or function doesn't have an argument named $%s.", $arg[0][1]);
-                        break;
+                        throw $this->error("Mixin or function doesn't have an argument named $%s.", $arg[0][1]);
                     }
-                } elseif ($args[$arg[0][1]][0] < count($remaining)) {
-                    $this->throwError("The argument $%s was passed both by position and by name.", $arg[0][1]);
-                    break;
+                } elseif ($args[$name][0] < \count($remaining)) {
+                    throw $this->error("The argument $%s was passed both by position and by name.", $arg[0][1]);
                 } else {
-                    $keywordArgs[$arg[0][1]] = $arg[1];
+                    $keywordArgs[$name] = $arg[1];
                 }
-            } elseif ($arg[2] === true) {
+            } elseif (! empty($arg[2])) {
+                // $arg[2] means a var followed by ... in the arg ($list... )
                 $val = $this->reduce($arg[1], true);
 
                 if ($val[0] === Type::T_LIST) {
                     foreach ($val[2] as $name => $item) {
                         if (! is_numeric($name)) {
-                            if (!isset($args[$name])) {
+                            if (! isset($args[$name])) {
                                 foreach (array_keys($args) as $an) {
-                                    if (str_replace("_", "-", $an) === str_replace("_", "-", $name)) {
+                                    if (str_replace('_', '-', $an) === str_replace('_', '-', $name)) {
                                         $name = $an;
                                         break;
                                     }
@@ -4669,9 +5702,10 @@ protected function applyArguments($argDef, $argValues, $storeInEnv = true)
                                 $keywordArgs[$name] = $item;
                             }
                         } else {
-                            if (is_null($splatSeparator)) {
+                            if (\is_null($splatSeparator)) {
                                 $splatSeparator = $val[1];
                             }
+
                             $remaining[] = $item;
                         }
                     }
@@ -4681,23 +5715,25 @@ protected function applyArguments($argDef, $argValues, $storeInEnv = true)
                         $item = $val[2][$i];
 
                         if (! is_numeric($name)) {
-                            if (!isset($args[$name])) {
+                            if (! isset($args[$name])) {
                                 foreach (array_keys($args) as $an) {
-                                    if (str_replace("_", "-", $an) === str_replace("_", "-", $name)) {
+                                    if (str_replace('_', '-', $an) === str_replace('_', '-', $name)) {
                                         $name = $an;
                                         break;
                                     }
                                 }
                             }
+
                             if ($hasVariable) {
                                 $deferredKeywordArgs[$name] = $item;
                             } else {
                                 $keywordArgs[$name] = $item;
                             }
                         } else {
-                            if (is_null($splatSeparator)) {
+                            if (\is_null($splatSeparator)) {
                                 $splatSeparator = $val[1];
                             }
+
                             $remaining[] = $item;
                         }
                     }
@@ -4705,8 +5741,7 @@ protected function applyArguments($argDef, $argValues, $storeInEnv = true)
                     $remaining[] = $val;
                 }
             } elseif ($hasKeywordArgument) {
-                $this->throwError('Positional arguments must come before keyword arguments.');
-                break;
+                throw $this->error('Positional arguments must come before keyword arguments.');
             } else {
                 $remaining[] = $arg[1];
             }
@@ -4716,15 +5751,27 @@ protected function applyArguments($argDef, $argValues, $storeInEnv = true)
             list($i, $name, $default, $isVariable) = $arg;
 
             if ($isVariable) {
-                $val = [Type::T_LIST, is_null($splatSeparator) ? ',' : $splatSeparator , [], $isVariable];
+                // only if more than one arg : can not be passed as position and value
+                // see https://github.com/sass/libsass/issues/2927
+                if (count($args) > 1) {
+                    if (isset($remaining[$i]) && isset($deferredNamedKeywordArgs[$name])) {
+                        throw $this->error("The argument $%s was passed both by position and by name.", $name);
+                    }
+                }
 
-                for ($count = count($remaining); $i < $count; $i++) {
+                $val = [Type::T_LIST, \is_null($splatSeparator) ? ',' : $splatSeparator , [], $isVariable];
+
+                for ($count = \count($remaining); $i < $count; $i++) {
                     $val[2][] = $remaining[$i];
                 }
 
                 foreach ($deferredKeywordArgs as $itemName => $item) {
                     $val[2][$itemName] = $item;
                 }
+
+                foreach ($deferredNamedKeywordArgs as $itemName => $item) {
+                    $val[2][$itemName] = $item;
+                }
             } elseif (isset($remaining[$i])) {
                 $val = $remaining[$i];
             } elseif (isset($keywordArgs[$name])) {
@@ -4732,14 +5779,13 @@ protected function applyArguments($argDef, $argValues, $storeInEnv = true)
             } elseif (! empty($default)) {
                 continue;
             } else {
-                $this->throwError("Missing argument $name");
-                break;
+                throw $this->error("Missing argument $name");
             }
 
             if ($storeInEnv) {
                 $this->set($name, $this->reduce($val, true), true, $env);
             } else {
-                $output[$name] = $val;
+                $output[$name] = ($reduce ? $this->reduce($val, true) : $val);
             }
         }
 
@@ -4757,7 +5803,7 @@ protected function applyArguments($argDef, $argValues, $storeInEnv = true)
             if ($storeInEnv) {
                 $this->set($name, $this->reduce($default, true), true);
             } else {
-                $output[$name] = $default;
+                $output[$name] = ($reduce ? $this->reduce($default, true) : $default);
             }
         }
 
@@ -4773,15 +5819,15 @@ protected function applyArguments($argDef, $argValues, $storeInEnv = true)
      */
     protected function coerceValue($value)
     {
-        if (is_array($value) || $value instanceof \ArrayAccess) {
+        if (\is_array($value) || $value instanceof \ArrayAccess) {
             return $value;
         }
 
-        if (is_bool($value)) {
+        if (\is_bool($value)) {
             return $this->toBool($value);
         }
 
-        if ($value === null) {
+        if (\is_null($value)) {
             return static::$null;
         }
 
@@ -4793,30 +5839,14 @@ protected function coerceValue($value)
             return static::$emptyString;
         }
 
-        if (preg_match('/^(#([0-9a-f]{6})|#([0-9a-f]{3}))$/i', $value, $m)) {
-            $color = [Type::T_COLOR];
-
-            if (isset($m[3])) {
-                $num = hexdec($m[3]);
-
-                foreach ([3, 2, 1] as $i) {
-                    $t = $num & 0xf;
-                    $color[$i] = $t << 4 | $t;
-                    $num >>= 4;
-                }
-            } else {
-                $num = hexdec($m[2]);
-
-                foreach ([3, 2, 1] as $i) {
-                    $color[$i] = $num & 0xff;
-                    $num >>= 8;
-                }
-            }
+        $value = [Type::T_KEYWORD, $value];
+        $color = $this->coerceColor($value);
 
+        if ($color) {
             return $color;
         }
 
-        return [Type::T_KEYWORD, $value];
+        return $value;
     }
 
     /**
@@ -4832,24 +5862,34 @@ protected function coerceMap($item)
             return $item;
         }
 
-        if ($item === static::$emptyList) {
+        if (
+            $item[0] === static::$emptyList[0] &&
+            $item[1] === static::$emptyList[1] &&
+            $item[2] === static::$emptyList[2]
+        ) {
             return static::$emptyMap;
         }
 
-        return [Type::T_MAP, [$item], [static::$null]];
+        return $item;
     }
 
     /**
      * Coerce something to list
      *
-     * @param array  $item
-     * @param string $delim
+     * @param array   $item
+     * @param string  $delim
+     * @param boolean $removeTrailingNull
      *
      * @return array
      */
-    protected function coerceList($item, $delim = ',')
+    protected function coerceList($item, $delim = ',', $removeTrailingNull = false)
     {
         if (isset($item) && $item[0] === Type::T_LIST) {
+            // remove trailing null from the list
+            if ($removeTrailingNull && end($item[2]) === static::$null) {
+                array_pop($item[2]);
+            }
+
             return $item;
         }
 
@@ -4858,13 +5898,15 @@ protected function coerceList($item, $delim = ',')
             $values = $item[2];
             $list = [];
 
-            for ($i = 0, $s = count($keys); $i < $s; $i++) {
+            for ($i = 0, $s = \count($keys); $i < $s; $i++) {
                 $key = $keys[$i];
                 $value = $values[$i];
 
                 switch ($key[0]) {
                     case Type::T_LIST:
                     case Type::T_MAP:
+                    case Type::T_STRING:
+                    case Type::T_NULL:
                         break;
 
                     default:
@@ -4882,7 +5924,7 @@ protected function coerceList($item, $delim = ',')
             return [Type::T_LIST, ',', $list];
         }
 
-        return [Type::T_LIST, $delim, ! isset($item) ? []: [$item]];
+        return [Type::T_LIST, $delim, ! isset($item) ? [] : [$item]];
     }
 
     /**
@@ -4908,21 +5950,107 @@ protected function coerceForExpression($value)
      *
      * @return array|null
      */
-    protected function coerceColor($value)
+    protected function coerceColor($value, $inRGBFunction = false)
     {
         switch ($value[0]) {
             case Type::T_COLOR:
+                for ($i = 1; $i <= 3; $i++) {
+                    if (! is_numeric($value[$i])) {
+                        $cv = $this->compileRGBAValue($value[$i]);
+
+                        if (! is_numeric($cv)) {
+                            return null;
+                        }
+
+                        $value[$i] = $cv;
+                    }
+
+                    if (isset($value[4])) {
+                        if (! is_numeric($value[4])) {
+                            $cv = $this->compileRGBAValue($value[4], true);
+
+                            if (! is_numeric($cv)) {
+                                return null;
+                            }
+
+                            $value[4] = $cv;
+                        }
+                    }
+                }
+
                 return $value;
 
+            case Type::T_LIST:
+                if ($inRGBFunction) {
+                    if (\count($value[2]) == 3 || \count($value[2]) == 4) {
+                        $color = $value[2];
+                        array_unshift($color, Type::T_COLOR);
+
+                        return $this->coerceColor($color);
+                    }
+                }
+
+                return null;
+
             case Type::T_KEYWORD:
+                if (! \is_string($value[1])) {
+                    return null;
+                }
+
                 $name = strtolower($value[1]);
 
-                if (isset(Colors::$cssColors[$name])) {
-                    $rgba = explode(',', Colors::$cssColors[$name]);
+                // hexa color?
+                if (preg_match('/^#([0-9a-f]+)$/i', $name, $m)) {
+                    $nofValues = \strlen($m[1]);
+
+                    if (\in_array($nofValues, [3, 4, 6, 8])) {
+                        $nbChannels = 3;
+                        $color      = [];
+                        $num        = hexdec($m[1]);
+
+                        switch ($nofValues) {
+                            case 4:
+                                $nbChannels = 4;
+                                // then continuing with the case 3:
+                            case 3:
+                                for ($i = 0; $i < $nbChannels; $i++) {
+                                    $t = $num & 0xf;
+                                    array_unshift($color, $t << 4 | $t);
+                                    $num >>= 4;
+                                }
 
+                                break;
+
+                            case 8:
+                                $nbChannels = 4;
+                                // then continuing with the case 6:
+                            case 6:
+                                for ($i = 0; $i < $nbChannels; $i++) {
+                                    array_unshift($color, $num & 0xff);
+                                    $num >>= 8;
+                                }
+
+                                break;
+                        }
+
+                        if ($nbChannels === 4) {
+                            if ($color[3] === 255) {
+                                $color[3] = 1; // fully opaque
+                            } else {
+                                $color[3] = round($color[3] / 255, Node\Number::PRECISION);
+                            }
+                        }
+
+                        array_unshift($color, Type::T_COLOR);
+
+                        return $color;
+                    }
+                }
+
+                if ($rgba = Colors::colorNameToRGBa($name)) {
                     return isset($rgba[3])
-                        ? [Type::T_COLOR, (int) $rgba[0], (int) $rgba[1], (int) $rgba[2], (int) $rgba[3]]
-                        : [Type::T_COLOR, (int) $rgba[0], (int) $rgba[1], (int) $rgba[2]];
+                        ? [Type::T_COLOR, $rgba[0], $rgba[1], $rgba[2], $rgba[3]]
+                        : [Type::T_COLOR, $rgba[0], $rgba[1], $rgba[2]];
                 }
 
                 return null;
@@ -4931,6 +6059,88 @@ protected function coerceColor($value)
         return null;
     }
 
+    /**
+     * @param integer|\ScssPhp\ScssPhp\Node\Number $value
+     * @param boolean                              $isAlpha
+     *
+     * @return integer|mixed
+     */
+    protected function compileRGBAValue($value, $isAlpha = false)
+    {
+        if ($isAlpha) {
+            return $this->compileColorPartValue($value, 0, 1, false);
+        }
+
+        return $this->compileColorPartValue($value, 0, 255, true);
+    }
+
+    /**
+     * @param mixed         $value
+     * @param integer|float $min
+     * @param integer|float $max
+     * @param boolean       $isInt
+     * @param boolean       $clamp
+     * @param boolean       $modulo
+     *
+     * @return integer|mixed
+     */
+    protected function compileColorPartValue($value, $min, $max, $isInt = true, $clamp = true, $modulo = false)
+    {
+        if (! is_numeric($value)) {
+            if (\is_array($value)) {
+                $reduced = $this->reduce($value);
+
+                if (\is_object($reduced) && $value->type === Type::T_NUMBER) {
+                    $value = $reduced;
+                }
+            }
+
+            if (\is_object($value) && $value->type === Type::T_NUMBER) {
+                $num = $value->dimension;
+
+                if (\count($value->units)) {
+                    $unit = array_keys($value->units);
+                    $unit = reset($unit);
+
+                    switch ($unit) {
+                        case '%':
+                            $num *= $max / 100;
+                            break;
+                        default:
+                            break;
+                    }
+                }
+
+                $value = $num;
+            } elseif (\is_array($value)) {
+                $value = $this->compileValue($value);
+            }
+        }
+
+        if (is_numeric($value)) {
+            if ($isInt) {
+                $value = round($value);
+            }
+
+            if ($clamp) {
+                $value = min($max, max($min, $value));
+            }
+
+            if ($modulo) {
+                $value = $value % $max;
+
+                // still negative?
+                while ($value < $min) {
+                    $value += $max;
+                }
+            }
+
+            return $value;
+        }
+
+        return $value;
+    }
+
     /**
      * Coerce value to string
      *
@@ -4947,6 +6157,36 @@ protected function coerceString($value)
         return [Type::T_STRING, '', [$this->compileValue($value)]];
     }
 
+    /**
+     * Assert value is a string (or keyword)
+     *
+     * @api
+     *
+     * @param array $value
+     * @param string $varName
+     *
+     * @return array
+     *
+     * @throws \Exception
+     */
+    public function assertString($value, $varName = null)
+    {
+        // case of url(...) parsed a a function
+        if ($value[0] === Type::T_FUNCTION) {
+            $value = $this->coerceString($value);
+        }
+
+        if (! \in_array($value[0], [Type::T_STRING, Type::T_KEYWORD])) {
+            $value = $this->compileValue($value);
+            $var_display = ($varName ? " \${$varName}:" : '');
+            throw $this->error("Error:{$var_display} $value is not a string.");
+        }
+
+        $value = $this->coerceString($value);
+
+        return $value;
+    }
+
     /**
      * Coerce value to a percentage
      *
@@ -4983,7 +6223,7 @@ public function assertMap($value)
         $value = $this->coerceMap($value);
 
         if ($value[0] !== Type::T_MAP) {
-            $this->throwError('expecting map, %s received', $value[0]);
+            throw $this->error('expecting map, %s received', $value[0]);
         }
 
         return $value;
@@ -5003,7 +6243,7 @@ public function assertMap($value)
     public function assertList($value)
     {
         if ($value[0] !== Type::T_LIST) {
-            $this->throwError('expecting list, %s received', $value[0]);
+            throw $this->error('expecting list, %s received', $value[0]);
         }
 
         return $value;
@@ -5026,29 +6266,57 @@ public function assertColor($value)
             return $color;
         }
 
-        $this->throwError('expecting color, %s received', $value[0]);
+        throw $this->error('expecting color, %s received', $value[0]);
+    }
+
+    /**
+     * Assert value is a number
+     *
+     * @api
+     *
+     * @param array $value
+     * @param string $varName
+     *
+     * @return integer|float
+     *
+     * @throws \Exception
+     */
+    public function assertNumber($value, $varName = null)
+    {
+        if ($value[0] !== Type::T_NUMBER) {
+            $value = $this->compileValue($value);
+            $var_display = ($varName ? " \${$varName}:" : '');
+            throw $this->error("Error:{$var_display} $value is not a number.");
+        }
+
+        return $value[1];
     }
 
     /**
-     * Assert value is a number
+     * Assert value is a integer
      *
      * @api
      *
      * @param array $value
+     * @param string $varName
      *
      * @return integer|float
      *
      * @throws \Exception
      */
-    public function assertNumber($value)
+    public function assertInteger($value, $varName = null)
     {
-        if ($value[0] !== Type::T_NUMBER) {
-            $this->throwError('expecting number, %s received', $value[0]);
+
+        $value = $this->assertNumber($value, $varName);
+        if (round($value - \intval($value), Node\Number::PRECISION) > 0) {
+            $var_display = ($varName ? " \${$varName}:" : '');
+            throw $this->error("Error:{$var_display} $value is not an integer.");
         }
 
-        return $value[1];
+        return intval($value);
     }
 
+
     /**
      * Make sure a color's components don't go out of bounds
      *
@@ -5137,7 +6405,7 @@ protected function hueToRGB($m1, $m2, $h)
         }
 
         if ($h * 3 < 2) {
-            return $m1 + ($m2 - $m1) * (2/3 - $h) * 6;
+            return $m1 + ($m2 - $m1) * (2 / 3 - $h) * 6;
         }
 
         return $m1;
@@ -5167,9 +6435,9 @@ public function toRGB($hue, $saturation, $lightness)
         $m2 = $l <= 0.5 ? $l * ($s + 1) : $l + $s - $l * $s;
         $m1 = $l * 2 - $m2;
 
-        $r = $this->hueToRGB($m1, $m2, $h + 1/3) * 255;
+        $r = $this->hueToRGB($m1, $m2, $h + 1 / 3) * 255;
         $g = $this->hueToRGB($m1, $m2, $h) * 255;
-        $b = $this->hueToRGB($m1, $m2, $h - 1/3) * 255;
+        $b = $this->hueToRGB($m1, $m2, $h - 1 / 3) * 255;
 
         $out = [Type::T_COLOR, $r, $g, $b];
 
@@ -5178,10 +6446,27 @@ public function toRGB($hue, $saturation, $lightness)
 
     // Built in functions
 
-    protected static $libCall = ['name', 'args...'];
+    protected static $libCall = ['function', 'args...'];
     protected function libCall($args, $kwargs)
     {
-        $name = $this->compileStringContent($this->coerceString($this->reduce(array_shift($args), true)));
+        $functionReference = $this->reduce(array_shift($args), true);
+
+        if (in_array($functionReference[0], [Type::T_STRING, Type::T_KEYWORD])) {
+            $name = $this->compileStringContent($this->coerceString($this->reduce($functionReference, true)));
+            $warning = "DEPRECATION WARNING: Passing a string to call() is deprecated and will be illegal\n"
+                . "in Sass 4.0. Use call(function-reference($name)) instead.";
+            fwrite($this->stderr, "$warning\n\n");
+            $functionReference = $this->libGetFunction([$functionReference]);
+        }
+
+        if ($functionReference === static::$null) {
+            return static::$null;
+        }
+
+        if (! in_array($functionReference[0], [Type::T_FUNCTION_REFERENCE, Type::T_FUNCTION])) {
+            throw $this->error('Function reference expected, got ' . $functionReference[0]);
+        }
+
         $callArgs = [];
 
         // $kwargs['args'] is [Type::T_LIST, ',', [..]]
@@ -5195,7 +6480,29 @@ protected function libCall($args, $kwargs)
             $callArgs[] = [$varname, $arg, false];
         }
 
-        return $this->reduce([Type::T_FUNCTION_CALL, $name, $callArgs]);
+        return $this->reduce([Type::T_FUNCTION_CALL, $functionReference, $callArgs]);
+    }
+
+
+    protected static $libGetFunction = [
+        ['name'],
+        ['name', 'css']
+    ];
+    protected function libGetFunction($args)
+    {
+        $name = $this->compileStringContent($this->coerceString($this->reduce(array_shift($args), true)));
+        $isCss = false;
+
+        if (count($args)) {
+            $isCss = $this->reduce(array_shift($args), true);
+            $isCss = (($isCss === static::$true) ? true : false);
+        }
+
+        if ($isCss) {
+            return [Type::T_FUNCTION, $name, [Type::T_LIST, ',', []]];
+        }
+
+        return $this->getFunctionReference($name, true);
     }
 
     protected static $libIf = ['condition', 'if-true', 'if-false:'];
@@ -5215,11 +6522,8 @@ protected function libIndex($args)
     {
         list($list, $value) = $args;
 
-        if ($value[0] === Type::T_MAP) {
-            return static::$null;
-        }
-
-        if ($list[0] === Type::T_MAP ||
+        if (
+            $list[0] === Type::T_MAP ||
             $list[0] === Type::T_STRING ||
             $list[0] === Type::T_KEYWORD ||
             $list[0] === Type::T_INTERPOLATE
@@ -5242,30 +6546,68 @@ protected function libIndex($args)
         return false === $key ? static::$null : $key + 1;
     }
 
-    protected static $libRgb = ['red', 'green', 'blue'];
-    protected function libRgb($args)
+    protected static $libRgb = [
+        ['color'],
+        ['color', 'alpha'],
+        ['channels'],
+        ['red', 'green', 'blue'],
+        ['red', 'green', 'blue', 'alpha'] ];
+    protected function libRgb($args, $kwargs, $funcName = 'rgb')
     {
-        list($r, $g, $b) = $args;
+        switch (\count($args)) {
+            case 1:
+                if (! $color = $this->coerceColor($args[0], true)) {
+                    $color = [Type::T_STRING, '', [$funcName . '(', $args[0], ')']];
+                }
+                break;
 
-        return [Type::T_COLOR, $r[1], $g[1], $b[1]];
-    }
+            case 3:
+                $color = [Type::T_COLOR, $args[0], $args[1], $args[2]];
 
-    protected static $libRgba = [
-        ['color', 'alpha:1'],
-        ['red', 'green', 'blue', 'alpha:1'] ];
-    protected function libRgba($args)
-    {
-        if ($color = $this->coerceColor($args[0])) {
-            $num = isset($args[3]) ? $args[3] : $args[1];
-            $alpha = $this->assertNumber($num);
-            $color[4] = $alpha;
+                if (! $color = $this->coerceColor($color)) {
+                    $color = [Type::T_STRING, '', [$funcName . '(', $args[0], ', ', $args[1], ', ', $args[2], ')']];
+                }
 
-            return $color;
+                return $color;
+
+            case 2:
+                if ($color = $this->coerceColor($args[0], true)) {
+                    $alpha = $this->compileRGBAValue($args[1], true);
+
+                    if (is_numeric($alpha)) {
+                        $color[4] = $alpha;
+                    } else {
+                        $color = [Type::T_STRING, '',
+                            [$funcName . '(', $color[1], ', ', $color[2], ', ', $color[3], ', ', $alpha, ')']];
+                    }
+                } else {
+                    $color = [Type::T_STRING, '', [$funcName . '(', $args[0], ')']];
+                }
+                break;
+
+            case 4:
+            default:
+                $color = [Type::T_COLOR, $args[0], $args[1], $args[2], $args[3]];
+
+                if (! $color = $this->coerceColor($color)) {
+                    $color = [Type::T_STRING, '',
+                        [$funcName . '(', $args[0], ', ', $args[1], ', ', $args[2], ', ', $args[3], ')']];
+                }
+                break;
         }
 
-        list($r, $g, $b, $a) = $args;
+        return $color;
+    }
 
-        return [Type::T_COLOR, $r[1], $g[1], $b[1], $a[1]];
+    protected static $libRgba = [
+        ['color'],
+        ['color', 'alpha'],
+        ['channels'],
+        ['red', 'green', 'blue'],
+        ['red', 'green', 'blue', 'alpha'] ];
+    protected function libRgba($args, $kwargs)
+    {
+        return $this->libRgb($args, $kwargs, 'rgba');
     }
 
     // helper function for adjust_color, change_color, and scale_color
@@ -5273,21 +6615,25 @@ protected function alterColor($args, $fn)
     {
         $color = $this->assertColor($args[0]);
 
-        foreach ([1, 2, 3, 7] as $i) {
-            if (isset($args[$i])) {
-                $val = $this->assertNumber($args[$i]);
-                $ii = $i === 7 ? 4 : $i; // alpha
-                $color[$ii] = call_user_func($fn, isset($color[$ii]) ? $color[$ii] : 0, $val, $i);
+        foreach ([1 => 1, 2 => 2, 3 => 3, 7 => 4] as $iarg => $irgba) {
+            if (isset($args[$iarg])) {
+                $val = $this->assertNumber($args[$iarg]);
+
+                if (! isset($color[$irgba])) {
+                    $color[$irgba] = (($irgba < 4) ? 0 : 1);
+                }
+
+                $color[$irgba] = \call_user_func($fn, $color[$irgba], $val, $iarg);
             }
         }
 
         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 (! empty($args[$i])) {
-                    $val = $this->assertNumber($args[$i]);
-                    $hsl[$i - 3] = call_user_func($fn, $hsl[$i - 3], $val, $i);
+            foreach ([4 => 1, 5 => 2, 6 => 3] as $iarg => $ihsl) {
+                if (! empty($args[$iarg])) {
+                    $val = $this->assertNumber($args[$iarg]);
+                    $hsl[$ihsl] = \call_user_func($fn, $hsl[$ihsl], $val, $iarg);
                 }
             }
 
@@ -5368,9 +6714,14 @@ protected function libScaleColor($args)
     protected function libIeHexStr($args)
     {
         $color = $this->coerceColor($args[0]);
+
+        if (\is_null($color)) {
+            $this->throwError('Error: argument `$color` of `ie-hex-str($color)` must be a color');
+        }
+
         $color[4] = isset($color[4]) ? round(255 * $color[4]) : 255;
 
-        return sprintf('#%02X%02X%02X%02X', $color[4], $color[1], $color[2], $color[3]);
+        return [Type::T_STRING, '', [sprintf('#%02X%02X%02X%02X', $color[4], $color[1], $color[2], $color[3])]];
     }
 
     protected static $libRed = ['color'];
@@ -5378,6 +6729,10 @@ protected function libRed($args)
     {
         $color = $this->coerceColor($args[0]);
 
+        if (\is_null($color)) {
+            $this->throwError('Error: argument `$color` of `red($color)` must be a color');
+        }
+
         return $color[1];
     }
 
@@ -5386,6 +6741,10 @@ protected function libGreen($args)
     {
         $color = $this->coerceColor($args[0]);
 
+        if (\is_null($color)) {
+            $this->throwError('Error: argument `$color` of `green($color)` must be a color');
+        }
+
         return $color[2];
     }
 
@@ -5394,6 +6753,10 @@ protected function libBlue($args)
     {
         $color = $this->coerceColor($args[0]);
 
+        if (\is_null($color)) {
+            $this->throwError('Error: argument `$color` of `blue($color)` must be a color');
+        }
+
         return $color[3];
     }
 
@@ -5421,7 +6784,10 @@ protected function libOpacity($args)
     }
 
     // mix two colors
-    protected static $libMix = ['color-1', 'color-2', 'weight:0.5'];
+    protected static $libMix = [
+        ['color1', 'color2', 'weight:0.5'],
+        ['color-1', 'color-2', 'weight:0.5']
+        ];
     protected function libMix($args)
     {
         list($first, $second, $weight) = $args;
@@ -5457,25 +6823,85 @@ protected function libMix($args)
         return $this->fixColor($new);
     }
 
-    protected static $libHsl = ['hue', 'saturation', 'lightness'];
-    protected function libHsl($args)
+    protected static $libHsl = [
+        ['channels'],
+        ['hue', 'saturation', 'lightness'],
+        ['hue', 'saturation', 'lightness', 'alpha'] ];
+    protected function libHsl($args, $kwargs, $funcName = 'hsl')
     {
-        list($h, $s, $l) = $args;
+        $args_to_check = $args;
 
-        return $this->toRGB($h[1], $s[1], $l[1]);
-    }
+        if (\count($args) == 1) {
+            if ($args[0][0] !== Type::T_LIST || \count($args[0][2]) < 3 || \count($args[0][2]) > 4) {
+                return [Type::T_STRING, '', [$funcName . '(', $args[0], ')']];
+            }
 
-    protected static $libHsla = ['hue', 'saturation', 'lightness', 'alpha'];
-    protected function libHsla($args)
-    {
-        list($h, $s, $l, $a) = $args;
+            $args = $args[0][2];
+            $args_to_check = $kwargs['channels'][2];
+        }
+
+        $hue = $this->compileColorPartValue($args[0], 0, 360, false, false, true);
+        $saturation = $this->compileColorPartValue($args[1], 0, 100, false);
+        $lightness = $this->compileColorPartValue($args[2], 0, 100, false);
+
+        foreach ($kwargs as $k => $arg) {
+            if (in_array($arg[0], [Type::T_FUNCTION_CALL]) && in_array($arg[1], ['min', 'max'])) {
+                return null;
+            }
+        }
+
+        foreach ($args_to_check as $k => $arg) {
+            if (in_array($arg[0], [Type::T_FUNCTION_CALL]) && in_array($arg[1], ['min', 'max'])) {
+                if (count($kwargs) > 1 || ($k >= 2 && count($args) === 4)) {
+                    return null;
+                }
+
+                $args[$k] = $this->stringifyFncallArgs($arg);
+                $hue = '';
+            }
 
-        $color = $this->toRGB($h[1], $s[1], $l[1]);
-        $color[4] = $a[1];
+            if (
+                $k >= 2 && count($args) === 4 &&
+                in_array($arg[0], [Type::T_FUNCTION_CALL, Type::T_FUNCTION]) &&
+                in_array($arg[1], ['calc','env'])
+            ) {
+                return null;
+            }
+        }
+
+        $alpha = null;
+
+        if (\count($args) === 4) {
+            $alpha = $this->compileColorPartValue($args[3], 0, 100, false);
+
+            if (! is_numeric($hue) || ! is_numeric($saturation) || ! is_numeric($lightness) || ! is_numeric($alpha)) {
+                return [Type::T_STRING, '',
+                    [$funcName . '(', $args[0], ', ', $args[1], ', ', $args[2], ', ', $args[3], ')']];
+            }
+        } else {
+            if (! is_numeric($hue) || ! is_numeric($saturation) || ! is_numeric($lightness)) {
+                return [Type::T_STRING, '', [$funcName . '(', $args[0], ', ', $args[1], ', ', $args[2], ')']];
+            }
+        }
+
+        $color = $this->toRGB($hue, $saturation, $lightness);
+
+        if (! \is_null($alpha)) {
+            $color[4] = $alpha;
+        }
 
         return $color;
     }
 
+    protected static $libHsla = [
+            ['channels'],
+            ['hue', 'saturation', 'lightness'],
+            ['hue', 'saturation', 'lightness', 'alpha']];
+    protected function libHsla($args, $kwargs)
+    {
+        return $this->libHsl($args, $kwargs, 'hsla');
+    }
+
     protected static $libHue = ['color'];
     protected function libHue($args)
     {
@@ -5543,7 +6969,7 @@ protected function libDarken($args)
         return $this->adjustHsl($color, 3, -$amount);
     }
 
-    protected static $libSaturate = [['color', 'amount'], ['number']];
+    protected static $libSaturate = [['color', 'amount'], ['amount']];
     protected function libSaturate($args)
     {
         $value = $args[0];
@@ -5552,6 +6978,11 @@ protected function libSaturate($args)
             return null;
         }
 
+        if (count($args) === 1) {
+            $val = $this->compileValue($value);
+            throw $this->error("\$amount: $val is not a number");
+        }
+
         $color = $this->assertColor($value);
         $amount = 100 * $this->coercePercent($args[1]);
 
@@ -5585,21 +7016,32 @@ protected function libComplement($args)
         return $this->adjustHsl($this->assertColor($args[0]), 1, 180);
     }
 
-    protected static $libInvert = ['color'];
+    protected static $libInvert = ['color', 'weight:1'];
     protected function libInvert($args)
     {
-        $value = $args[0];
+        list($value, $weight) = $args;
+
+        if (! isset($weight)) {
+            $weight = 1;
+        } else {
+            $weight = $this->coercePercent($weight);
+        }
 
         if ($value[0] === Type::T_NUMBER) {
             return null;
         }
 
         $color = $this->assertColor($value);
-        $color[1] = 255 - $color[1];
-        $color[2] = 255 - $color[2];
-        $color[3] = 255 - $color[3];
+        $inverted = $color;
+        $inverted[1] = 255 - $inverted[1];
+        $inverted[2] = 255 - $inverted[2];
+        $inverted[3] = 255 - $inverted[3];
 
-        return $color;
+        if ($weight < 1) {
+            return $this->libMix([$inverted, $color, [Type::T_NUMBER, $weight]]);
+        }
+
+        return $inverted;
     }
 
     // increases opacity by amount
@@ -5664,13 +7106,13 @@ protected function libQuote($args)
         return [Type::T_STRING, '"', [$value]];
     }
 
-    protected static $libPercentage = ['value'];
+    protected static $libPercentage = ['number'];
     protected function libPercentage($args)
     {
         return new Node\Number($this->coercePercent($args[0]) * 100, '%');
     }
 
-    protected static $libRound = ['value'];
+    protected static $libRound = ['number'];
     protected function libRound($args)
     {
         $num = $args[0];
@@ -5678,7 +7120,7 @@ protected function libRound($args)
         return new Node\Number(round($num[1]), $num[2]);
     }
 
-    protected static $libFloor = ['value'];
+    protected static $libFloor = ['number'];
     protected function libFloor($args)
     {
         $num = $args[0];
@@ -5686,7 +7128,7 @@ protected function libFloor($args)
         return new Node\Number(floor($num[1]), $num[2]);
     }
 
-    protected static $libCeil = ['value'];
+    protected static $libCeil = ['number'];
     protected function libCeil($args)
     {
         $num = $args[0];
@@ -5694,7 +7136,7 @@ protected function libCeil($args)
         return new Node\Number(ceil($num[1]), $num[2]);
     }
 
-    protected static $libAbs = ['value'];
+    protected static $libAbs = ['number'];
     protected function libAbs($args)
     {
         $num = $args[0];
@@ -5705,29 +7147,47 @@ protected function libAbs($args)
     protected function libMin($args)
     {
         $numbers = $this->getNormalizedNumbers($args);
-        $min = null;
+        $minOriginal = null;
+        $minNormalized = null;
+
+        foreach ($numbers as $key => $pair) {
+            list($original, $normalized) = $pair;
 
-        foreach ($numbers as $key => $number) {
-            if (null === $min || $number[1] <= $min[1]) {
-                $min = [$key, $number[1]];
+            if (\is_null($normalized) || \is_null($minNormalized)) {
+                if (\is_null($minOriginal) || $original[1] <= $minOriginal[1]) {
+                    $minOriginal = $original;
+                    $minNormalized = $normalized;
+                }
+            } elseif ($normalized[1] <= $minNormalized[1]) {
+                $minOriginal = $original;
+                $minNormalized = $normalized;
             }
         }
 
-        return $args[$min[0]];
+        return $minOriginal;
     }
 
     protected function libMax($args)
     {
         $numbers = $this->getNormalizedNumbers($args);
-        $max = null;
+        $maxOriginal = null;
+        $maxNormalized = null;
+
+        foreach ($numbers as $key => $pair) {
+            list($original, $normalized) = $pair;
 
-        foreach ($numbers as $key => $number) {
-            if (null === $max || $number[1] >= $max[1]) {
-                $max = [$key, $number[1]];
+            if (\is_null($normalized) || \is_null($maxNormalized)) {
+                if (\is_null($maxOriginal) || $original[1] >= $maxOriginal[1]) {
+                    $maxOriginal = $original;
+                    $maxNormalized = $normalized;
+                }
+            } elseif ($normalized[1] >= $maxNormalized[1]) {
+                $maxOriginal = $original;
+                $maxNormalized = $normalized;
             }
         }
 
-        return $args[$max[0]];
+        return $maxOriginal;
     }
 
     /**
@@ -5739,27 +7199,23 @@ protected function libMax($args)
      */
     protected function getNormalizedNumbers($args)
     {
-        $unit = null;
+        $unit         = null;
         $originalUnit = null;
-        $numbers = [];
+        $numbers      = [];
 
         foreach ($args as $key => $item) {
-            if ($item[0] !== Type::T_NUMBER) {
-                $this->throwError('%s is not a number', $item[0]);
-                break;
-            }
+            $this->assertNumber($item);
 
             $number = $item->normalize();
 
-            if (null === $unit) {
+            if (empty($unit)) {
                 $unit = $number[2];
                 $originalUnit = $item->unitStr();
-            } elseif ($number[1] && $unit !== $number[2]) {
-                $this->throwError('Incompatible units: "%s" and "%s".', $originalUnit, $item->unitStr());
-                break;
+            } elseif ($number[1] && $unit !== $number[2] && ! empty($number[2])) {
+                throw $this->error('Incompatible units: "%s" and "%s".', $originalUnit, $item->unitStr());
             }
 
-            $numbers[$key] = $number;
+            $numbers[$key] = [$args[$key], empty($number[2]) ? null : $number];
         }
 
         return $numbers;
@@ -5768,21 +7224,25 @@ protected function getNormalizedNumbers($args)
     protected static $libLength = ['list'];
     protected function libLength($args)
     {
-        $list = $this->coerceList($args[0]);
+        $list = $this->coerceList($args[0], ',', true);
 
-        return count($list[2]);
+        return \count($list[2]);
     }
 
     //protected static $libListSeparator = ['list...'];
     protected function libListSeparator($args)
     {
-        if (count($args) > 1) {
+        if (\count($args) > 1) {
             return 'comma';
         }
 
+        if (! \in_array($args[0][0], [Type::T_LIST, Type::T_MAP])) {
+            return 'space';
+        }
+
         $list = $this->coerceList($args[0]);
 
-        if (count($list[2]) <= 1) {
+        if (\count($list[2]) <= 1 && empty($list['enclosing'])) {
             return 'space';
         }
 
@@ -5796,13 +7256,13 @@ protected function libListSeparator($args)
     protected static $libNth = ['list', 'n'];
     protected function libNth($args)
     {
-        $list = $this->coerceList($args[0]);
+        $list = $this->coerceList($args[0], ',', false);
         $n = $this->assertNumber($args[1]);
 
         if ($n > 0) {
             $n--;
         } elseif ($n < 0) {
-            $n += count($list[2]);
+            $n += \count($list[2]);
         }
 
         return isset($list[2][$n]) ? $list[2][$n] : static::$defaultValue;
@@ -5817,13 +7277,11 @@ protected function libSetNth($args)
         if ($n > 0) {
             $n--;
         } elseif ($n < 0) {
-            $n += count($list[2]);
+            $n += \count($list[2]);
         }
 
         if (! isset($list[2][$n])) {
-            $this->throwError('Invalid argument for "n"');
-
-            return null;
+            throw $this->error('Invalid argument for "n"');
         }
 
         $list[2][$n] = $args[2];
@@ -5837,9 +7295,10 @@ protected function libMapGet($args)
         $map = $this->assertMap($args[0]);
         $key = $args[1];
 
-        if (! is_null($key)) {
+        if (! \is_null($key)) {
             $key = $this->compileStringContent($this->coerceString($key));
-            for ($i = count($map[1]) - 1; $i >= 0; $i--) {
+
+            for ($i = \count($map[1]) - 1; $i >= 0; $i--) {
                 if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) {
                     return $map[2][$i];
                 }
@@ -5867,14 +7326,20 @@ protected function libMapValues($args)
         return [Type::T_LIST, ',', $values];
     }
 
-    protected static $libMapRemove = ['map', 'key'];
+    protected static $libMapRemove = ['map', 'key...'];
     protected function libMapRemove($args)
     {
         $map = $this->assertMap($args[0]);
-        $key = $this->compileStringContent($this->coerceString($args[1]));
+        $keyList = $this->assertList($args[1]);
 
-        for ($i = count($map[1]) - 1; $i >= 0; $i--) {
-            if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) {
+        $keys = [];
+
+        foreach ($keyList[2] as $key) {
+            $keys[] = $this->compileStringContent($this->coerceString($key));
+        }
+
+        for ($i = \count($map[1]) - 1; $i >= 0; $i--) {
+            if (in_array($this->compileStringContent($this->coerceString($map[1][$i])), $keys)) {
                 array_splice($map[1], $i, 1);
                 array_splice($map[2], $i, 1);
             }
@@ -5889,7 +7354,7 @@ protected function libMapHasKey($args)
         $map = $this->assertMap($args[0]);
         $key = $this->compileStringContent($this->coerceString($args[1]));
 
-        for ($i = count($map[1]) - 1; $i >= 0; $i--) {
+        for ($i = \count($map[1]) - 1; $i >= 0; $i--) {
             if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) {
                 return true;
             }
@@ -5898,7 +7363,10 @@ protected function libMapHasKey($args)
         return false;
     }
 
-    protected static $libMapMerge = ['map-1', 'map-2'];
+    protected static $libMapMerge = [
+        ['map1', 'map2'],
+        ['map-1', 'map-2']
+    ];
     protected function libMapMerge($args)
     {
         $map1 = $this->assertMap($args[0]);
@@ -5937,6 +7405,19 @@ protected function libKeywords($args)
         return [Type::T_MAP, $keys, $values];
     }
 
+    protected static $libIsBracketed = ['list'];
+    protected function libIsBracketed($args)
+    {
+        $list = $args[0];
+        $this->coerceList($list, ' ');
+
+        if (! empty($list['enclosing']) && $list['enclosing'] === 'bracket') {
+            return true;
+        }
+
+        return false;
+    }
+
     protected function listSeparatorForJoin($list1, $sep)
     {
         if (! isset($sep)) {
@@ -5948,23 +7429,58 @@ protected function listSeparatorForJoin($list1, $sep)
                 return ',';
 
             case 'space':
-                return '';
+                return ' ';
 
             default:
                 return $list1[1];
         }
     }
 
-    protected static $libJoin = ['list1', 'list2', 'separator:null'];
+    protected static $libJoin = ['list1', 'list2', 'separator:null', 'bracketed:auto'];
     protected function libJoin($args)
     {
-        list($list1, $list2, $sep) = $args;
+        list($list1, $list2, $sep, $bracketed) = $args;
+
+        $list1 = $this->coerceList($list1, ' ', true);
+        $list2 = $this->coerceList($list2, ' ', true);
+        $sep   = $this->listSeparatorForJoin($list1, $sep);
+
+        if ($bracketed === static::$true) {
+            $bracketed = true;
+        } elseif ($bracketed === static::$false) {
+            $bracketed = false;
+        } elseif ($bracketed === [Type::T_KEYWORD, 'auto']) {
+            $bracketed = 'auto';
+        } elseif ($bracketed === static::$null) {
+            $bracketed = false;
+        } else {
+            $bracketed = $this->compileValue($bracketed);
+            $bracketed = ! ! $bracketed;
+
+            if ($bracketed === true) {
+                $bracketed = true;
+            }
+        }
+
+        if ($bracketed === 'auto') {
+            $bracketed = false;
+
+            if (! empty($list1['enclosing']) && $list1['enclosing'] === 'bracket') {
+                $bracketed = true;
+            }
+        }
+
+        $res = [Type::T_LIST, $sep, array_merge($list1[2], $list2[2])];
+
+        if (isset($list1['enclosing'])) {
+            $res['enlcosing'] = $list1['enclosing'];
+        }
 
-        $list1 = $this->coerceList($list1, ' ');
-        $list2 = $this->coerceList($list2, ' ');
-        $sep = $this->listSeparatorForJoin($list1, $sep);
+        if ($bracketed) {
+            $res['enclosing'] = 'bracket';
+        }
 
-        return [Type::T_LIST, $sep, array_merge($list1[2], $list2[2])];
+        return $res;
     }
 
     protected static $libAppend = ['list', 'val', 'separator:null'];
@@ -5972,36 +7488,48 @@ protected function libAppend($args)
     {
         list($list1, $value, $sep) = $args;
 
-        $list1 = $this->coerceList($list1, ' ');
-        $sep = $this->listSeparatorForJoin($list1, $sep);
+        $list1 = $this->coerceList($list1, ' ', true);
+        $sep   = $this->listSeparatorForJoin($list1, $sep);
+        $res   = [Type::T_LIST, $sep, array_merge($list1[2], [$value])];
+
+        if (isset($list1['enclosing'])) {
+            $res['enclosing'] = $list1['enclosing'];
+        }
 
-        return [Type::T_LIST, $sep, array_merge($list1[2], [$value])];
+        return $res;
     }
 
     protected function libZip($args)
     {
-        foreach ($args as $arg) {
-            $this->assertList($arg);
+        foreach ($args as $key => $arg) {
+            $args[$key] = $this->coerceList($arg);
         }
 
         $lists = [];
         $firstList = array_shift($args);
 
-        foreach ($firstList[2] as $key => $item) {
-            $list = [Type::T_LIST, '', [$item]];
+        $result = [Type::T_LIST, ',', $lists];
+        if (! \is_null($firstList)) {
+            foreach ($firstList[2] as $key => $item) {
+                $list = [Type::T_LIST, '', [$item]];
 
-            foreach ($args as $arg) {
-                if (isset($arg[2][$key])) {
-                    $list[2][] = $arg[2][$key];
-                } else {
-                    break 2;
+                foreach ($args as $arg) {
+                    if (isset($arg[2][$key])) {
+                        $list[2][] = $arg[2][$key];
+                    } else {
+                        break 2;
+                    }
                 }
+
+                $lists[] = $list;
             }
 
-            $lists[] = $list;
+            $result[2] = $lists;
+        } else {
+            $result['enclosing'] = 'parent';
         }
 
-        return [Type::T_LIST, ',', $lists];
+        return $result;
     }
 
     protected static $libTypeOf = ['value'];
@@ -6023,6 +7551,9 @@ protected function libTypeOf($args)
             case Type::T_FUNCTION:
                 return 'string';
 
+            case Type::T_FUNCTION_REFERENCE:
+                return 'function';
+
             case Type::T_LIST:
                 if (isset($value[3]) && $value[3]) {
                     return 'arglist';
@@ -6054,17 +7585,19 @@ protected function libUnitless($args)
         return $value[0] === Type::T_NUMBER && $value->unitless();
     }
 
-    protected static $libComparable = ['number-1', 'number-2'];
+    protected static $libComparable = [
+        ['number1', 'number2'],
+        ['number-1', 'number-2']
+    ];
     protected function libComparable($args)
     {
         list($number1, $number2) = $args;
 
-        if (! isset($number1[0]) || $number1[0] !== Type::T_NUMBER ||
+        if (
+            ! isset($number1[0]) || $number1[0] !== Type::T_NUMBER ||
             ! isset($number2[0]) || $number2[0] !== Type::T_NUMBER
         ) {
-            $this->throwError('Invalid argument(s) for "comparable"');
-
-            return null;
+            throw $this->error('Invalid argument(s) for "comparable"');
         }
 
         $number1 = $number1->normalize();
@@ -6076,13 +7609,17 @@ protected function libComparable($args)
     protected static $libStrIndex = ['string', 'substring'];
     protected function libStrIndex($args)
     {
-        $string = $this->coerceString($args[0]);
+        $string = $this->assertString($args[0], 'string');
         $stringContent = $this->compileStringContent($string);
 
-        $substring = $this->coerceString($args[1]);
+        $substring = $this->assertString($args[1], 'substring');
         $substringContent = $this->compileStringContent($substring);
 
-        $result = strpos($stringContent, $substringContent);
+        if (! \strlen($substringContent)) {
+            $result = 0;
+        } else {
+            $result = strpos($stringContent, $substringContent);
+        }
 
         return $result === false ? static::$null : new Node\Number($result + 1, '');
     }
@@ -6090,15 +7627,25 @@ protected function libStrIndex($args)
     protected static $libStrInsert = ['string', 'insert', 'index'];
     protected function libStrInsert($args)
     {
-        $string = $this->coerceString($args[0]);
+        $string = $this->assertString($args[0], 'string');
         $stringContent = $this->compileStringContent($string);
 
-        $insert = $this->coerceString($args[1]);
+        $insert = $this->assertString($args[1], 'insert');
         $insertContent = $this->compileStringContent($insert);
 
-        list(, $index) = $args[2];
+        $index = $this->assertInteger($args[2], 'index');
+        if ($index > 0) {
+            $index = $index - 1;
+        }
+        if ($index < 0) {
+            $index = Util::mbStrlen($stringContent) + 1 + $index;
+        }
 
-        $string[2] = [substr_replace($stringContent, $insertContent, $index - 1, 0)];
+        $string[2] = [
+            Util::mbSubstr($stringContent, 0, $index),
+            $insertContent,
+            Util::mbSubstr($stringContent, $index)
+        ];
 
         return $string;
     }
@@ -6106,16 +7653,16 @@ protected function libStrInsert($args)
     protected static $libStrLength = ['string'];
     protected function libStrLength($args)
     {
-        $string = $this->coerceString($args[0]);
+        $string = $this->assertString($args[0], 'string');
         $stringContent = $this->compileStringContent($string);
 
-        return new Node\Number(strlen($stringContent), '');
+        return new Node\Number(Util::mbStrlen($stringContent), '');
     }
 
-    protected static $libStrSlice = ['string', 'start-at', 'end-at:null'];
+    protected static $libStrSlice = ['string', 'start-at', 'end-at:-1'];
     protected function libStrSlice($args)
     {
-        if (isset($args[2]) && $args[2][1] == 0) {
+        if (isset($args[2]) && ! $args[2][1]) {
             return static::$nullString;
         }
 
@@ -6128,7 +7675,7 @@ protected function libStrSlice($args)
             $start--;
         }
 
-        $end    = (int) $args[2][1];
+        $end    = isset($args[2]) ? (int) $args[2][1] : -1;
         $length = $end < 0 ? $end + 1 : ($end > 0 ? $end - $start : $end);
 
         $string[2] = $length
@@ -6144,7 +7691,7 @@ protected function libToLowerCase($args)
         $string = $this->coerceString($args[0]);
         $stringContent = $this->compileStringContent($string);
 
-        $string[2] = [function_exists('mb_strtolower') ? mb_strtolower($stringContent) : strtolower($stringContent)];
+        $string[2] = [\function_exists('mb_strtolower') ? mb_strtolower($stringContent) : strtolower($stringContent)];
 
         return $string;
     }
@@ -6155,7 +7702,7 @@ protected function libToUpperCase($args)
         $string = $this->coerceString($args[0]);
         $stringContent = $this->compileStringContent($string);
 
-        $string[2] = [function_exists('mb_strtoupper') ? mb_strtoupper($stringContent) : strtoupper($stringContent)];
+        $string[2] = [\function_exists('mb_strtoupper') ? mb_strtoupper($stringContent) : strtoupper($stringContent)];
 
         return $string;
     }
@@ -6167,7 +7714,7 @@ protected function libFeatureExists($args)
         $name = $this->compileStringContent($string);
 
         return $this->toBool(
-            array_key_exists($name, $this->registeredFeatures) ? $this->registeredFeatures[$name] : false
+            \array_key_exists($name, $this->registeredFeatures) ? $this->registeredFeatures[$name] : false
         );
     }
 
@@ -6191,7 +7738,7 @@ protected function libFunctionExists($args)
         // built-in functions
         $f = $this->getBuiltinFunction($name);
 
-        return $this->toBool(is_callable($f));
+        return $this->toBool(\is_callable($f));
     }
 
     protected static $libGlobalVariableExists = ['name'];
@@ -6235,22 +7782,25 @@ protected function libCounter($args)
         return [Type::T_STRING, '', ['counter(' . implode(',', $list) . ')']];
     }
 
-    protected static $libRandom = ['limit'];
+    protected static $libRandom = ['limit:null'];
     protected function libRandom($args)
     {
-        if (isset($args[0])) {
+        if (isset($args[0]) & $args[0] !== static::$null) {
             $n = $this->assertNumber($args[0]);
 
             if ($n < 1) {
-                $this->throwError("limit must be greater than or equal to 1");
+                throw $this->error("\$limit must be greater than or equal to 1");
+            }
 
-                return null;
+            if (round($n - \intval($n), Node\Number::PRECISION) > 0) {
+                throw $this->error("Expected \$limit to be an integer but got $n for `random`");
             }
 
-            return new Node\Number(mt_rand(1, $n), '');
+            return new Node\Number(mt_rand(1, \intval($n)), '');
         }
 
-        return new Node\Number(mt_rand(1, mt_getrandmax()), '');
+        $max = mt_getrandmax();
+        return new Node\Number(mt_rand(0, $max - 1) / $max, '');
     }
 
     protected function libUniqueId()
@@ -6258,7 +7808,9 @@ protected function libUniqueId()
         static $id;
 
         if (! isset($id)) {
-            $id = mt_rand(0, pow(36, 8));
+            $id = PHP_INT_SIZE === 4
+                ? mt_rand(0, pow(36, 5)) . str_pad(mt_rand(0, pow(36, 5)) % 10000000, 7, '0', STR_PAD_LEFT)
+                : mt_rand(0, pow(36, 8));
         }
 
         $id += mt_rand(0, 10) + 1;
@@ -6266,14 +7818,47 @@ protected function libUniqueId()
         return [Type::T_STRING, '', ['u' . str_pad(base_convert($id, 10, 36), 8, '0', STR_PAD_LEFT)]];
     }
 
+    protected function inspectFormatValue($value, $force_enclosing_display = false)
+    {
+        if ($value === static::$null) {
+            $value = [Type::T_KEYWORD, 'null'];
+        }
+
+        $stringValue = [$value];
+
+        if ($value[0] === Type::T_LIST) {
+            if (end($value[2]) === static::$null) {
+                array_pop($value[2]);
+                $value[2][] = [Type::T_STRING, '', ['']];
+                $force_enclosing_display = true;
+            }
+
+            if (
+                ! empty($value['enclosing']) &&
+                ($force_enclosing_display ||
+                    ($value['enclosing'] === 'bracket') ||
+                    ! \count($value[2]))
+            ) {
+                $value['enclosing'] = 'forced_' . $value['enclosing'];
+                $force_enclosing_display = true;
+            }
+
+            foreach ($value[2] as $k => $listelement) {
+                $value[2][$k] = $this->inspectFormatValue($listelement, $force_enclosing_display);
+            }
+
+            $stringValue = [$value];
+        }
+
+        return [Type::T_STRING, '', $stringValue];
+    }
+
     protected static $libInspect = ['value'];
     protected function libInspect($args)
     {
-        if ($args[0] === static::$null) {
-            return [Type::T_KEYWORD, 'null'];
-        }
+        $value = $args[0];
 
-        return $args[0];
+        return $this->inspectFormatValue($value);
     }
 
     /**
@@ -6283,14 +7868,21 @@ protected function libInspect($args)
      *
      * @return array|boolean
      */
-    protected function getSelectorArg($arg)
+    protected function getSelectorArg($arg, $varname = null, $allowParent = false)
     {
         static $parser = null;
 
-        if (is_null($parser)) {
+        if (\is_null($parser)) {
             $parser = $this->parserFactory(__METHOD__);
         }
 
+        if (! $this->checkSelectorArgType($arg)) {
+            $var_display = ($varname ? ' $' . $varname . ':' : '');
+            $var_value = $this->compileValue($arg);
+            throw $this->error("Error:{$var_display} $var_value is not a valid selector: it must be a string,"
+                . " a list of strings, or a list of lists of strings");
+        }
+
         $arg = $this->libUnquote([$arg]);
         $arg = $this->compileValue($arg);
 
@@ -6300,10 +7892,44 @@ protected function getSelectorArg($arg)
             $selector = $this->evalSelectors($parsedSelector);
             $gluedSelector = $this->glueFunctionSelectors($selector);
 
+            if (! $allowParent) {
+                foreach ($gluedSelector as $selector) {
+                    foreach ($selector as $s) {
+                        if (in_array(static::$selfSelector, $s)) {
+                            $var_display = ($varname ? ' $' . $varname . ':' : '');
+                            throw $this->error("Error:{$var_display} Parent selectors aren't allowed here.");
+                        }
+                    }
+                }
+            }
+
             return $gluedSelector;
         }
 
-        return false;
+        $var_display = ($varname ? ' $' . $varname . ':' : '');
+        throw $this->error("Error:{$var_display} expected more input, invalid selector.");
+    }
+
+    /**
+     * Check variable type for getSelectorArg() function
+     * @param array $arg
+     * @param int $maxDepth
+     * @return bool
+     */
+    protected function checkSelectorArgType($arg, $maxDepth = 2)
+    {
+        if ($arg[0] === Type::T_LIST && $maxDepth > 0) {
+            foreach ($arg[2] as $elt) {
+                if (! $this->checkSelectorArgType($elt, $maxDepth - 1)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (!in_array($arg[0], [Type::T_STRING, Type::T_KEYWORD])) {
+            return false;
+        }
+        return true;
     }
 
     /**
@@ -6325,8 +7951,8 @@ protected function libIsSuperselector($args)
     {
         list($super, $sub) = $args;
 
-        $super = $this->getSelectorArg($super);
-        $sub = $this->getSelectorArg($sub);
+        $super = $this->getSelectorArg($super, 'super');
+        $sub = $this->getSelectorArg($sub, 'sub');
 
         return $this->isSuperSelector($super, $sub);
     }
@@ -6342,12 +7968,30 @@ protected function libIsSuperselector($args)
     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 (! $super) {
+            throw $this->error('Invalid super selector for isSuperSelector()');
+        }
+
+        if (! $sub) {
+            throw $this->error('Invalid sub selector for isSuperSelector()');
+        }
+
+        if (count($sub) > 1) {
+            foreach ($sub as $s) {
+                if (! $this->isSuperSelector($super, [$s])) {
+                    return false;
+                }
+            }
+            return true;
         }
 
-        if (! $sub || count($sub) !== 1) {
-            $this->throwError("Invalid sub selector for isSuperSelector()");
+        if (count($super) > 1) {
+            foreach ($super as $s) {
+                if ($this->isSuperSelector([$s], $sub)) {
+                    return true;
+                }
+            }
+            return false;
         }
 
         $super = reset($super);
@@ -6374,7 +8018,7 @@ function ($value, $key) use (&$compound) {
                 $nextMustMatch = true;
                 $i++;
             } else {
-                while ($i < count($sub) && ! $this->isSuperPart($node, $sub[$i])) {
+                while ($i < \count($sub) && ! $this->isSuperPart($node, $sub[$i])) {
                     if ($nextMustMatch) {
                         return false;
                     }
@@ -6382,7 +8026,7 @@ function ($value, $key) use (&$compound) {
                     $i++;
                 }
 
-                if ($i >= count($sub)) {
+                if ($i >= \count($sub)) {
                     return false;
                 }
 
@@ -6407,11 +8051,11 @@ protected function isSuperPart($superParts, $subParts)
         $i = 0;
 
         foreach ($superParts as $superPart) {
-            while ($i < count($subParts) && $subParts[$i] !== $superPart) {
+            while ($i < \count($subParts) && $subParts[$i] !== $superPart) {
                 $i++;
             }
 
-            if ($i >= count($subParts)) {
+            if ($i >= \count($subParts)) {
                 return false;
             }
 
@@ -6427,11 +8071,15 @@ 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");
+
+        if (\count($args) < 1) {
+            throw $this->error('selector-append() needs at least 1 argument');
         }
 
-        $selectors = array_map([$this, 'getSelectorArg'], $args);
+        $selectors = [];
+        foreach ($args as $arg) {
+            $selectors[] = $this->getSelectorArg($arg, 'selector');
+        }
 
         return $this->formatOutputSelector($this->selectorAppend($selectors));
     }
@@ -6450,14 +8098,14 @@ protected function selectorAppend($selectors)
         $lastSelectors = array_pop($selectors);
 
         if (! $lastSelectors) {
-            $this->throwError("Invalid selector list in selector-append()");
+            throw $this->error('Invalid selector list in selector-append()');
         }
 
-        while (count($selectors)) {
+        while (\count($selectors)) {
             $previousSelectors = array_pop($selectors);
 
             if (! $previousSelectors) {
-                $this->throwError("Invalid selector list in selector-append()");
+                throw $this->error('Invalid selector list in selector-append()');
             }
 
             // do the trick, happening $lastSelector to $previousSelector
@@ -6487,17 +8135,20 @@ protected function selectorAppend($selectors)
         return $lastSelectors;
     }
 
-    protected static $libSelectorExtend = ['selectors', 'extendee', 'extender'];
+    protected static $libSelectorExtend = [
+        ['selector', 'extendee', 'extender'],
+        ['selectors', 'extendee', 'extender']
+    ];
     protected function libSelectorExtend($args)
     {
         list($selectors, $extendee, $extender) = $args;
 
-        $selectors = $this->getSelectorArg($selectors);
-        $extendee = $this->getSelectorArg($extendee);
-        $extender = $this->getSelectorArg($extender);
+        $selectors = $this->getSelectorArg($selectors, 'selector');
+        $extendee  = $this->getSelectorArg($extendee, 'extendee');
+        $extender  = $this->getSelectorArg($extender, 'extender');
 
         if (! $selectors || ! $extendee || ! $extender) {
-            $this->throwError("selector-extend() invalid arguments");
+            throw $this->error('selector-extend() invalid arguments');
         }
 
         $extended = $this->extendOrReplaceSelectors($selectors, $extendee, $extender);
@@ -6505,17 +8156,20 @@ protected function libSelectorExtend($args)
         return $this->formatOutputSelector($extended);
     }
 
-    protected static $libSelectorReplace = ['selectors', 'original', 'replacement'];
+    protected static $libSelectorReplace = [
+        ['selector', 'original', 'replacement'],
+        ['selectors', 'original', 'replacement']
+    ];
     protected function libSelectorReplace($args)
     {
         list($selectors, $original, $replacement) = $args;
 
-        $selectors = $this->getSelectorArg($selectors);
-        $original = $this->getSelectorArg($original);
-        $replacement = $this->getSelectorArg($replacement);
+        $selectors   = $this->getSelectorArg($selectors, 'selector');
+        $original    = $this->getSelectorArg($original, 'original');
+        $replacement = $this->getSelectorArg($replacement, 'replacement');
 
         if (! $selectors || ! $original || ! $replacement) {
-            $this->throwError("selector-replace() invalid arguments");
+            throw $this->error('selector-replace() invalid arguments');
         }
 
         $replaced = $this->extendOrReplaceSelectors($selectors, $original, $replacement, true);
@@ -6554,12 +8208,12 @@ protected function extendOrReplaceSelectors($selectors, $extendee, $extender, $r
                 $extended[] = $selector;
             }
 
-            $n = count($extended);
+            $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) {
+            if ($replace && \count($extended) === $n) {
                 $extended[] = $selector;
             }
         }
@@ -6576,13 +8230,18 @@ 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");
+
+        if (\count($args) < 1) {
+            throw $this->error('selector-nest() needs at least 1 argument');
         }
 
-        $selectorsMap = array_map([$this, 'getSelectorArg'], $args);
+        $selectorsMap = [];
+        foreach ($args as $arg) {
+            $selectorsMap[] = $this->getSelectorArg($arg, 'selector', true);
+        }
 
         $envs = [];
+
         foreach ($selectorsMap as $selectors) {
             $env = new Environment();
             $env->selectors = $selectors;
@@ -6590,18 +8249,21 @@ protected function libSelectorNest($args)
             $envs[] = $env;
         }
 
-        $envs = array_reverse($envs);
-        $env = $this->extractEnv($envs);
+        $envs            = array_reverse($envs);
+        $env             = $this->extractEnv($envs);
         $outputSelectors = $this->multiplySelectors($env);
 
         return $this->formatOutputSelector($outputSelectors);
     }
 
-    protected static $libSelectorParse = ['selectors'];
+    protected static $libSelectorParse = [
+        ['selector'],
+        ['selectors']
+    ];
     protected function libSelectorParse($args)
     {
         $selectors = reset($args);
-        $selectors = $this->getSelectorArg($selectors);
+        $selectors = $this->getSelectorArg($selectors, 'selector');
 
         return $this->formatOutputSelector($selectors);
     }
@@ -6611,11 +8273,11 @@ protected function libSelectorUnify($args)
     {
         list($selectors1, $selectors2) = $args;
 
-        $selectors1 = $this->getSelectorArg($selectors1);
-        $selectors2 = $this->getSelectorArg($selectors2);
+        $selectors1 = $this->getSelectorArg($selectors1, 'selectors1');
+        $selectors2 = $this->getSelectorArg($selectors2, 'selectors2');
 
         if (! $selectors1 || ! $selectors2) {
-            $this->throwError("selector-unify() invalid arguments");
+            throw $this->error('selector-unify() invalid arguments');
         }
 
         // only consider the first compound of each
@@ -6634,22 +8296,23 @@ protected function libSelectorUnify($args)
      *
      * @param array $compound1
      * @param array $compound2
+     *
      * @return array|mixed
      */
     protected function unifyCompoundSelectors($compound1, $compound2)
     {
-        if (! count($compound1)) {
+        if (! \count($compound1)) {
             return $compound2;
         }
 
-        if (! count($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);
+        $last      = $this->mergeParts($lastPart1, $lastPart2);
 
         if (! $last) {
             return [[]];
@@ -6659,7 +8322,7 @@ protected function unifyCompoundSelectors($compound1, $compound2)
         $unifiedSelectors = [$unifiedCompound];
 
         // do the rest
-        while (count($compound1) || count($compound2)) {
+        while (\count($compound1) || \count($compound2)) {
             $part1 = end($compound1);
             $part2 = end($compound2);
 
@@ -6672,6 +8335,7 @@ protected function unifyCompoundSelectors($compound1, $compound2)
 
                 $c = $this->mergeParts($part1, $part2);
                 $unifiedSelectors = $this->prependSelectors($unifiedSelectors, [$c]);
+
                 $part1 = $part2 = null;
 
                 array_pop($compound1);
@@ -6686,6 +8350,7 @@ protected function unifyCompoundSelectors($compound1, $compound2)
 
                 $c = $this->mergeParts($part2, $part1);
                 $unifiedSelectors = $this->prependSelectors($unifiedSelectors, [$c]);
+
                 $part1 = $part2 = null;
 
                 array_pop($compound2);
@@ -6697,9 +8362,9 @@ protected function unifyCompoundSelectors($compound1, $compound2)
                 array_pop($compound1);
                 array_pop($compound2);
 
-                $s = $this->prependSelectors($unifiedSelectors, [$part2]);
+                $s   = $this->prependSelectors($unifiedSelectors, [$part2]);
                 $new = array_merge($new, $this->prependSelectors($s, [$part1]));
-                $s = $this->prependSelectors($unifiedSelectors, [$part1]);
+                $s   = $this->prependSelectors($unifiedSelectors, [$part1]);
                 $new = array_merge($new, $this->prependSelectors($s, [$part2]));
             } elseif ($part1) {
                 array_pop($compound1);
@@ -6753,11 +8418,11 @@ protected function prependSelectors($selectors, $parts)
     protected function matchPartInCompound($part, $compound)
     {
         $partTag = $this->findTagName($part);
-        $before = $compound;
-        $after = [];
+        $before  = $compound;
+        $after   = [];
 
         // try to find a match by tag name first
-        while (count($before)) {
+        while (\count($before)) {
             $p = array_pop($before);
 
             if ($partTag && $partTag !== '*' && $partTag == $this->findTagName($p)) {
@@ -6771,11 +8436,11 @@ protected function matchPartInCompound($part, $compound)
         $before = $compound;
         $after = [];
 
-        while (count($before)) {
+        while (\count($before)) {
             $p = array_pop($before);
 
             if ($this->checkCompatibleTags($partTag, $this->findTagName($p))) {
-                if (count(array_intersect($part, $p))) {
+                if (\count(array_intersect($part, $p))) {
                     return [$before, $p, $after];
                 }
             }
@@ -6800,7 +8465,7 @@ protected function mergeParts($parts1, $parts2)
     {
         $tag1 = $this->findTagName($parts1);
         $tag2 = $this->findTagName($parts2);
-        $tag = $this->checkCompatibleTags($tag1, $tag2);
+        $tag  = $this->checkCompatibleTags($tag1, $tag2);
 
         // not compatible tags
         if ($tag === false) {
@@ -6851,12 +8516,12 @@ protected function checkCompatibleTags($tag1, $tag2)
         $tags = array_unique($tags);
         $tags = array_filter($tags);
 
-        if (count($tags)>1) {
+        if (\count($tags) > 1) {
             $tags = array_diff($tags, ['*']);
         }
 
         // not compatible nodes
-        if (count($tags)>1) {
+        if (\count($tags) > 1) {
             return false;
         }
 
@@ -6885,7 +8550,7 @@ protected function findTagName($parts)
     protected function libSimpleSelectors($args)
     {
         $selector = reset($args);
-        $selector = $this->getSelectorArg($selector);
+        $selector = $this->getSelectorArg($selector, 'selector');
 
         // remove selectors list layer, keeping the first one
         $selector = reset($selector);
@@ -6901,4 +8566,23 @@ protected function libSimpleSelectors($args)
 
         return [Type::T_LIST, ',', $listParts];
     }
+
+    protected static $libScssphpGlob = ['pattern'];
+    protected function libScssphpGlob($args)
+    {
+        $string = $this->coerceString($args[0]);
+        $pattern = $this->compileStringContent($string);
+        $matches = glob($pattern);
+        $listParts = [];
+
+        foreach ($matches as $match) {
+            if (! is_file($match)) {
+                continue;
+            }
+
+            $listParts[] = [Type::T_STRING, '"', [$match]];
+        }
+
+        return [Type::T_LIST, ',', $listParts];
+    }
 }
diff --git a/scssphp/src/Compiler/Environment.php b/scssphp/src/Compiler/Environment.php
index 03eb86a..dc2f86c 100644
--- a/scssphp/src/Compiler/Environment.php
+++ b/scssphp/src/Compiler/Environment.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
diff --git a/scssphp/src/Exception/CompilerException.php b/scssphp/src/Exception/CompilerException.php
index a9d134f..343da4c 100644
--- a/scssphp/src/Exception/CompilerException.php
+++ b/scssphp/src/Exception/CompilerException.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -16,6 +17,6 @@
  *
  * @author Oleksandr Savchenko <traveltino@gmail.com>
  */
-class CompilerException extends \Exception
+class CompilerException extends \Exception implements SassException
 {
 }
diff --git a/scssphp/src/Exception/ParserException.php b/scssphp/src/Exception/ParserException.php
index 2fa12dd..5237f30 100644
--- a/scssphp/src/Exception/ParserException.php
+++ b/scssphp/src/Exception/ParserException.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -16,6 +17,32 @@
  *
  * @author Oleksandr Savchenko <traveltino@gmail.com>
  */
-class ParserException extends \Exception
+class ParserException extends \Exception implements SassException
 {
+    /**
+     * @var array
+     */
+    private $sourcePosition;
+
+    /**
+     * Get source position
+     *
+     * @api
+     */
+    public function getSourcePosition()
+    {
+        return $this->sourcePosition;
+    }
+
+    /**
+     * Set source position
+     *
+     * @api
+     *
+     * @param array $sourcePosition
+     */
+    public function setSourcePosition($sourcePosition)
+    {
+        $this->sourcePosition = $sourcePosition;
+    }
 }
diff --git a/scssphp/src/Exception/RangeException.php b/scssphp/src/Exception/RangeException.php
index ee36c97..b18c32d 100644
--- a/scssphp/src/Exception/RangeException.php
+++ b/scssphp/src/Exception/RangeException.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -16,6 +17,6 @@
  *
  * @author Anthon Pang <anthon.pang@gmail.com>
  */
-class RangeException extends \Exception
+class RangeException extends \Exception implements SassException
 {
 }
diff --git a/scssphp/src/Exception/SassException.php b/scssphp/src/Exception/SassException.php
new file mode 100644
index 0000000..9f62b3c
--- /dev/null
+++ b/scssphp/src/Exception/SassException.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace ScssPhp\ScssPhp\Exception;
+
+interface SassException
+{
+}
diff --git a/scssphp/src/Exception/ServerException.php b/scssphp/src/Exception/ServerException.php
index d4a207a..ad5b379 100644
--- a/scssphp/src/Exception/ServerException.php
+++ b/scssphp/src/Exception/ServerException.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -16,6 +17,6 @@
  *
  * @author Anthon Pang <anthon.pang@gmail.com>
  */
-class ServerException extends \Exception
+class ServerException extends \Exception implements SassException
 {
 }
diff --git a/scssphp/src/Formatter.php b/scssphp/src/Formatter.php
index 478aa6a..290f5f3 100644
--- a/scssphp/src/Formatter.php
+++ b/scssphp/src/Formatter.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -81,6 +82,11 @@ abstract class Formatter
      */
     protected $sourceMapGenerator;
 
+    /**
+     * @var string
+     */
+    protected $strippedSemicolon;
+
     /**
      * Initialize formatter
      *
@@ -114,21 +120,19 @@ public function property($name, $value)
     }
 
     /**
-     * Strip semi-colon appended by property(); it's a separator, not a terminator
+     * Return custom property assignment
+     * differs in that you have to keep spaces in the value as is
      *
      * @api
      *
-     * @param array $lines
+     * @param string $name
+     * @param mixed  $value
+     *
+     * @return string
      */
-    public function stripSemicolon(&$lines)
+    public function customProperty($name, $value)
     {
-        if ($this->keepSemicolons) {
-            return;
-        }
-
-        if (($count = count($lines)) && substr($lines[$count - 1], -1) === ';') {
-            $lines[$count - 1] = substr($lines[$count - 1], 0, -1);
-        }
+        return rtrim($name) . trim($this->assignSeparator) . $value . ';';
     }
 
     /**
@@ -139,8 +143,7 @@ public function stripSemicolon(&$lines)
     protected function blockLines(OutputBlock $block)
     {
         $inner = $this->indentStr();
-
-        $glue = $this->break . $inner;
+        $glue  = $this->break . $inner;
 
         $this->write($inner . implode($glue, $block->lines));
 
@@ -207,6 +210,10 @@ protected function block(OutputBlock $block)
         if (! empty($block->selectors)) {
             $this->indentLevel--;
 
+            if (! $this->keepSemicolons) {
+                $this->strippedSemicolon = '';
+            }
+
             if (empty($block->children)) {
                 $this->write($this->break);
             }
@@ -217,8 +224,10 @@ protected function block(OutputBlock $block)
 
     /**
      * Test and clean safely empty children
+     *
      * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
-     * @return bool
+     *
+     * @return boolean
      */
     protected function testEmptyChildren($block)
     {
@@ -228,14 +237,16 @@ protected function testEmptyChildren($block)
             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;
-                    }
+                    continue;
+                }
+
+                if ($child->type === Type::T_MEDIA || $child->type === Type::T_DIRECTIVE) {
+                    $child->children = [];
+                    $child->selectors = null;
                 }
             }
         }
+
         return $isEmpty;
     }
 
@@ -254,8 +265,8 @@ public function format(OutputBlock $block, SourceMapGenerator $sourceMapGenerato
         $this->sourceMapGenerator = null;
 
         if ($sourceMapGenerator) {
-            $this->currentLine = 1;
-            $this->currentColumn = 0;
+            $this->currentLine        = 1;
+            $this->currentColumn      = 0;
             $this->sourceMapGenerator = $sourceMapGenerator;
         }
 
@@ -271,10 +282,33 @@ public function format(OutputBlock $block, SourceMapGenerator $sourceMapGenerato
     }
 
     /**
+     * Output content
+     *
      * @param string $str
      */
     protected function write($str)
     {
+        if (! empty($this->strippedSemicolon)) {
+            echo $this->strippedSemicolon;
+
+            $this->strippedSemicolon = '';
+        }
+
+        /*
+         * Maybe Strip semi-colon appended by property(); it's a separator, not a terminator
+         * will be striped for real before a closing, otherwise displayed unchanged starting the next write
+         */
+        if (
+            ! $this->keepSemicolons &&
+            $str &&
+            (strpos($str, ';') !== false) &&
+            (substr($str, -1) === ';')
+        ) {
+            $str = substr($str, 0, -1);
+
+            $this->strippedSemicolon = ';';
+        }
+
         if ($this->sourceMapGenerator) {
             $this->sourceMapGenerator->addMapping(
                 $this->currentLine,
@@ -286,12 +320,12 @@ protected function write($str)
             );
 
             $lines = explode("\n", $str);
-            $lineCount = count($lines);
-            $this->currentLine += $lineCount-1;
+            $lineCount = \count($lines);
+            $this->currentLine += $lineCount - 1;
 
             $lastLine = array_pop($lines);
 
-            $this->currentColumn = ($lineCount === 1 ? $this->currentColumn : 0) + strlen($lastLine);
+            $this->currentColumn = ($lineCount === 1 ? $this->currentColumn : 0) + \strlen($lastLine);
         }
 
         echo $str;
diff --git a/scssphp/src/Formatter/Compact.php b/scssphp/src/Formatter/Compact.php
index 591f0c9..98009b4 100644
--- a/scssphp/src/Formatter/Compact.php
+++ b/scssphp/src/Formatter/Compact.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
diff --git a/scssphp/src/Formatter/Compressed.php b/scssphp/src/Formatter/Compressed.php
index ec4722e..3fdb97a 100644
--- a/scssphp/src/Formatter/Compressed.php
+++ b/scssphp/src/Formatter/Compressed.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
diff --git a/scssphp/src/Formatter/Crunched.php b/scssphp/src/Formatter/Crunched.php
index 51ccb51..137cdff 100644
--- a/scssphp/src/Formatter/Crunched.php
+++ b/scssphp/src/Formatter/Crunched.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
diff --git a/scssphp/src/Formatter/Debug.php b/scssphp/src/Formatter/Debug.php
index 94e70c8..5c539a2 100644
--- a/scssphp/src/Formatter/Debug.php
+++ b/scssphp/src/Formatter/Debug.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
diff --git a/scssphp/src/Formatter/Expanded.php b/scssphp/src/Formatter/Expanded.php
index 8eec475..3d5344c 100644
--- a/scssphp/src/Formatter/Expanded.php
+++ b/scssphp/src/Formatter/Expanded.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -55,7 +56,7 @@ protected function blockLines(OutputBlock $block)
 
         foreach ($block->lines as $index => $line) {
             if (substr($line, 0, 2) === '/*') {
-                $block->lines[$index] = preg_replace('/(\r|\n)+/', $glue, $line);
+                $block->lines[$index] = preg_replace('/\r\n?|\n|\f/', $this->break, $line);
             }
         }
 
diff --git a/scssphp/src/Formatter/Nested.php b/scssphp/src/Formatter/Nested.php
index 50a70ce..046ecc8 100644
--- a/scssphp/src/Formatter/Nested.php
+++ b/scssphp/src/Formatter/Nested.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -58,29 +59,17 @@ protected function indentStr()
     protected function blockLines(OutputBlock $block)
     {
         $inner = $this->indentStr();
-
-        $glue = $this->break . $inner;
+        $glue  = $this->break . $inner;
 
         foreach ($block->lines as $index => $line) {
             if (substr($line, 0, 2) === '/*') {
-                $block->lines[$index] = preg_replace('/(\r|\n)+/', $glue, $line);
+                $block->lines[$index] = preg_replace('/\r\n?|\n|\f/', $this->break, $line);
             }
         }
 
         $this->write($inner . implode($glue, $block->lines));
     }
 
-    protected function hasFlatChild($block)
-    {
-        foreach ($block->children as $child) {
-            if (empty($child->selectors)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
     /**
      * {@inheritdoc}
      */
@@ -101,7 +90,7 @@ protected function block(OutputBlock $block)
             $previousHasSelector = false;
         }
 
-        $isMediaOrDirective = in_array($block->type, [Type::T_DIRECTIVE, Type::T_MEDIA]);
+        $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);
 
@@ -109,7 +98,8 @@ protected function block(OutputBlock $block)
             array_pop($depths);
             $this->depth--;
 
-            if (!$this->depth && ($block->depth <= 1 || (!$this->indentLevel && $block->type === Type::T_COMMENT)) &&
+            if (
+                ! $this->depth && ($block->depth <= 1 || (! $this->indentLevel && $block->type === Type::T_COMMENT)) &&
                 (($block->selectors && ! $isMediaOrDirective) || $previousHasSelector)
             ) {
                 $downLevel = $this->break;
@@ -130,10 +120,12 @@ protected function block(OutputBlock $block)
             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;
                 }
             }
@@ -170,15 +162,18 @@ protected function block(OutputBlock $block)
             }
 
             $this->blockLines($block);
+
             $closeBlock = $this->break;
         }
 
         if (! empty($block->children)) {
-            if ($this->depth>0 && ($isMediaOrDirective || ! $this->hasFlatChild($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);
@@ -193,13 +188,19 @@ protected function block(OutputBlock $block)
         if (! empty($block->selectors)) {
             $this->indentLevel--;
 
+            if (! $this->keepSemicolons) {
+                $this->strippedSemicolon = '';
+            }
+
             $this->write($this->close);
+
             $closeBlock = $this->break;
 
             if ($this->depth > 1 && ! empty($block->children)) {
                 array_pop($depths);
                 $this->depth--;
             }
+
             if (! $isMediaOrDirective) {
                 $previousHasSelector = true;
             }
@@ -209,4 +210,22 @@ protected function block(OutputBlock $block)
             $this->write($this->break);
         }
     }
+
+    /**
+     * Block has flat child
+     *
+     * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
+     *
+     * @return boolean
+     */
+    private function hasFlatChild($block)
+    {
+        foreach ($block->children as $child) {
+            if (empty($child->selectors)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
 }
diff --git a/scssphp/src/Formatter/OutputBlock.php b/scssphp/src/Formatter/OutputBlock.php
index 3e6fd92..8dcba7c 100644
--- a/scssphp/src/Formatter/OutputBlock.php
+++ b/scssphp/src/Formatter/OutputBlock.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
diff --git a/scssphp/src/Node.php b/scssphp/src/Node.php
index dab565a..60d357e 100644
--- a/scssphp/src/Node.php
+++ b/scssphp/src/Node.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
diff --git a/scssphp/src/Node/Number.php b/scssphp/src/Node/Number.php
index 1e83bf8..0f2099f 100644
--- a/scssphp/src/Node/Number.php
+++ b/scssphp/src/Node/Number.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -28,17 +29,20 @@
  */
 class Number extends Node implements \ArrayAccess
 {
+    const PRECISION = 10;
+
     /**
      * @var integer
+     * @deprecated use {Number::PRECISION} instead to read the precision. Configuring it is not supported anymore.
      */
-    static public $precision = 10;
+    public static $precision = self::PRECISION;
 
     /**
      * @see http://www.w3.org/TR/2012/WD-css3-values-20120308/
      *
      * @var array
      */
-    static protected $unitTable = [
+    protected static $unitTable = [
         'in' => [
             'in' => 1,
             'pc' => 6,
@@ -64,8 +68,8 @@ class Number extends Node implements \ArrayAccess
         ],
         'dpi' => [
             'dpi'  => 1,
-            'dpcm' => 2.54,
-            'dppx' => 96,
+            'dpcm' => 1 / 2.54,
+            'dppx' => 1 / 96,
         ],
     ];
 
@@ -89,7 +93,7 @@ public function __construct($dimension, $initialUnit)
     {
         $this->type      = Type::T_NUMBER;
         $this->dimension = $dimension;
-        $this->units     = is_array($initialUnit)
+        $this->units     = \is_array($initialUnit)
             ? $initialUnit
             : ($initialUnit ? [$initialUnit => 1]
                             : []);
@@ -110,11 +114,18 @@ public function coerce($units)
 
         $dimension = $this->dimension;
 
-        foreach (static::$unitTable['in'] as $unit => $conv) {
-            $from       = isset($this->units[$unit]) ? $this->units[$unit] : 0;
-            $to         = isset($units[$unit]) ? $units[$unit] : 0;
-            $factor     = pow($conv, $from - $to);
-            $dimension /= $factor;
+        if (\count($units)) {
+            $baseUnit = array_keys($units);
+            $baseUnit = reset($baseUnit);
+            $baseUnit = $this->findBaseUnit($baseUnit);
+            if ($baseUnit && isset(static::$unitTable[$baseUnit])) {
+                foreach (static::$unitTable[$baseUnit] as $unit => $conv) {
+                    $from       = isset($this->units[$unit]) ? $this->units[$unit] : 0;
+                    $to         = isset($units[$unit]) ? $units[$unit] : 0;
+                    $factor     = pow($conv, $from - $to);
+                    $dimension /= $factor;
+                }
+            }
         }
 
         return new Number($dimension, $units);
@@ -130,7 +141,7 @@ public function normalize()
         $dimension = $this->dimension;
         $units     = [];
 
-        $this->normalizeUnits($dimension, $units, 'in');
+        $this->normalizeUnits($dimension, $units);
 
         return new Number($dimension, $units);
     }
@@ -141,14 +152,15 @@ public function normalize()
     public function offsetExists($offset)
     {
         if ($offset === -3) {
-            return $this->sourceColumn !== null;
+            return ! \is_null($this->sourceColumn);
         }
 
         if ($offset === -2) {
-            return $this->sourceLine !== null;
+            return ! \is_null($this->sourceLine);
         }
 
-        if ($offset === -1 ||
+        if (
+            $offset === -1 ||
             $offset === 0 ||
             $offset === 1 ||
             $offset === 2
@@ -231,6 +243,35 @@ public function unitless()
         return ! array_sum($this->units);
     }
 
+    /**
+     * Test if a number can be normalized in a base unit
+     * ie if its units are homogeneous
+     *
+     * @return boolean
+     */
+    public function isNormalizable()
+    {
+        if ($this->unitless()) {
+            return false;
+        }
+
+        $baseUnit = null;
+
+        foreach ($this->units as $unit => $exp) {
+            $b = $this->findBaseUnit($unit);
+
+            if (\is_null($baseUnit)) {
+                $baseUnit = $b;
+            }
+
+            if (\is_null($b) or $b !== $baseUnit) {
+                return false;
+            }
+        }
+
+        return $baseUnit;
+    }
+
     /**
      * Returns unit(s) as the product of numerator units divided by the product of denominator units
      *
@@ -243,17 +284,17 @@ public function unitStr()
 
         foreach ($this->units as $unit => $unitSize) {
             if ($unitSize > 0) {
-                $numerators = array_pad($numerators, count($numerators) + $unitSize, $unit);
+                $numerators = array_pad($numerators, \count($numerators) + $unitSize, $unit);
                 continue;
             }
 
             if ($unitSize < 0) {
-                $denominators = array_pad($denominators, count($denominators) + $unitSize, $unit);
+                $denominators = array_pad($denominators, \count($denominators) - $unitSize, $unit);
                 continue;
             }
         }
 
-        return implode('*', $numerators) . (count($denominators) ? '/' . implode('*', $denominators) : '');
+        return implode('*', $numerators) . (\count($denominators) ? '/' . implode('*', $denominators) : '');
     }
 
     /**
@@ -265,19 +306,19 @@ public function unitStr()
      */
     public function output(Compiler $compiler = null)
     {
-        $dimension = round($this->dimension, static::$precision);
+        $dimension = round($this->dimension, self::PRECISION);
 
         $units = array_filter($this->units, function ($unitSize) {
             return $unitSize;
         });
 
-        if (count($units) > 1 && array_sum($units) === 0) {
+        if (\count($units) > 1 && array_sum($units) === 0) {
             $dimension = $this->dimension;
             $units     = [];
 
-            $this->normalizeUnits($dimension, $units, 'in');
+            $this->normalizeUnits($dimension, $units);
 
-            $dimension = round($dimension, static::$precision);
+            $dimension = round($dimension, self::PRECISION);
             $units     = array_filter($units, function ($unitSize) {
                 return $unitSize;
             });
@@ -285,15 +326,17 @@ public function output(Compiler $compiler = null)
 
         $unitSize = array_sum($units);
 
-        if ($compiler && ($unitSize > 1 || $unitSize < 0 || count($units) > 1)) {
-            $compiler->throwError((string) $dimension . $this->unitStr() . " isn't a valid CSS value.");
+        if ($compiler && ($unitSize > 1 || $unitSize < 0 || \count($units) > 1)) {
+            $this->units = $units;
+            $unit = $this->unitStr();
+        } else {
+            reset($units);
+            $unit = key($units);
         }
 
-        reset($units);
-        $unit = key($units);
-        $dimension = number_format($dimension, static::$precision, '.', '');
+        $dimension = number_format($dimension, self::PRECISION, '.', '');
 
-        return (static::$precision ? rtrim(rtrim($dimension, '0'), '.') : $dimension) . $unit;
+        return (self::PRECISION ? rtrim(rtrim($dimension, '0'), '.') : $dimension) . $unit;
     }
 
     /**
@@ -311,13 +354,17 @@ public function __toString()
      * @param array         $units
      * @param string        $baseUnit
      */
-    private function normalizeUnits(&$dimension, &$units, $baseUnit = 'in')
+    private function normalizeUnits(&$dimension, &$units, $baseUnit = null)
     {
         $dimension = $this->dimension;
         $units     = [];
 
         foreach ($this->units as $unit => $exp) {
-            if (isset(static::$unitTable[$baseUnit][$unit])) {
+            if (! $baseUnit) {
+                $baseUnit = $this->findBaseUnit($unit);
+            }
+
+            if ($baseUnit && isset(static::$unitTable[$baseUnit][$unit])) {
                 $factor = pow(static::$unitTable[$baseUnit][$unit], $exp);
 
                 $unit = $baseUnit;
@@ -327,4 +374,22 @@ private function normalizeUnits(&$dimension, &$units, $baseUnit = 'in')
             $units[$unit] = $exp + (isset($units[$unit]) ? $units[$unit] : 0);
         }
     }
+
+    /**
+     * Find the base unit family for a given unit
+     *
+     * @param string $unit
+     *
+     * @return string|null
+     */
+    private function findBaseUnit($unit)
+    {
+        foreach (static::$unitTable as $baseUnit => $unitVariants) {
+            if (isset($unitVariants[$unit])) {
+                return $baseUnit;
+            }
+        }
+
+        return null;
+    }
 }
diff --git a/scssphp/src/Parser.php b/scssphp/src/Parser.php
index ed9b28f..7b47f15 100644
--- a/scssphp/src/Parser.php
+++ b/scssphp/src/Parser.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -65,12 +66,15 @@ class Parser
     private $inParens;
     private $eatWhiteDefault;
     private $discardComments;
+    private $allowVars;
     private $buffer;
     private $utf8;
     private $encoding;
     private $patternModifiers;
     private $commentsSeen;
 
+    private $cssOnly;
+
     /**
      * Constructor
      *
@@ -81,7 +85,7 @@ class Parser
      * @param string                 $encoding
      * @param \ScssPhp\ScssPhp\Cache $cache
      */
-    public function __construct($sourceName, $sourceIndex = 0, $encoding = 'utf-8', $cache = null)
+    public function __construct($sourceName, $sourceIndex = 0, $encoding = 'utf-8', $cache = null, $cssOnly = false)
     {
         $this->sourceName       = $sourceName ?: '(stdin)';
         $this->sourceIndex      = $sourceIndex;
@@ -89,7 +93,9 @@ public function __construct($sourceName, $sourceIndex = 0, $encoding = 'utf-8',
         $this->utf8             = ! $encoding || strtolower($encoding) === 'utf-8';
         $this->patternModifiers = $this->utf8 ? 'Aisu' : 'Ais';
         $this->commentsSeen     = [];
-        $this->discardComments  = false;
+        $this->commentsSeen     = [];
+        $this->allowVars        = true;
+        $this->cssOnly          = $cssOnly;
 
         if (empty(static::$operatorPattern)) {
             static::$operatorPattern = '([*\/%+-]|[!=]\=|\>\=?|\<\=\>|\<\=?|and|or)';
@@ -138,11 +144,21 @@ public function throwParseError($msg = 'parse error')
              ? "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");
+        if ($this->peek('(.*?)(\n|$)', $m, $this->count)) {
+            $this->restoreEncoding();
+
+            $e = new ParserException("$msg: failed at `$m[1]` $loc");
+            $e->setSourcePosition([$this->sourceName, $line, $column]);
+
+            throw $e;
         }
 
-        throw new ParserException("$msg: $loc");
+        $this->restoreEncoding();
+
+        $e = new ParserException("$msg: $loc");
+        $e->setSourcePosition([$this->sourceName, $line, $column]);
+
+        throw $e;
     }
 
     /**
@@ -157,14 +173,14 @@ public function throwParseError($msg = 'parse error')
     public function parse($buffer)
     {
         if ($this->cache) {
-            $cacheKey = $this->sourceName . ":" . md5($buffer);
+            $cacheKey = $this->sourceName . ':' . md5($buffer);
             $parseOptions = [
                 'charset' => $this->charset,
                 'utf8' => $this->utf8,
             ];
-            $v = $this->cache->getCache("parse", $cacheKey, $parseOptions);
+            $v = $this->cache->getCache('parse', $cacheKey, $parseOptions);
 
-            if (! is_null($v)) {
+            if (! \is_null($v)) {
                 return $v;
             }
         }
@@ -192,7 +208,7 @@ public function parse($buffer)
             ;
         }
 
-        if ($this->count !== strlen($this->buffer)) {
+        if ($this->count !== \strlen($this->buffer)) {
             $this->throwParseError();
         }
 
@@ -207,7 +223,7 @@ public function parse($buffer)
         $this->restoreEncoding();
 
         if ($this->cache) {
-            $this->cache->setCache("parse", $cacheKey, $this->env, $parseOptions);
+            $this->cache->setCache('parse', $cacheKey, $this->env, $parseOptions);
         }
 
         return $this->env;
@@ -218,8 +234,8 @@ public function parse($buffer)
      *
      * @api
      *
-     * @param string $buffer
-     * @param string $out
+     * @param string       $buffer
+     * @param string|array $out
      *
      * @return boolean
      */
@@ -245,8 +261,8 @@ public function parseValue($buffer, &$out)
      *
      * @api
      *
-     * @param string $buffer
-     * @param string $out
+     * @param string       $buffer
+     * @param string|array $out
      *
      * @return boolean
      */
@@ -272,10 +288,10 @@ public function parseSelector($buffer, &$out)
      *
      * @api
      *
-     * @param string $buffer
-     * @param string $out
+     * @param string       $buffer
+     * @param string|array $out
      *
-     * @return array
+     * @return boolean
      */
     public function parseMediaQueryList($buffer, &$out)
     {
@@ -287,7 +303,6 @@ public function parseMediaQueryList($buffer, &$out)
 
         $this->saveEncoding();
 
-
         $isMediaQuery = $this->mediaQueryList($out);
 
         $this->restoreEncoding();
@@ -340,21 +355,31 @@ protected function parseChunk()
 
         // the directives
         if (isset($this->buffer[$this->count]) && $this->buffer[$this->count] === '@') {
-            if ($this->literal('@at-root', 8) &&
+            if (
+                $this->literal('@at-root', 8) &&
                 ($this->selectors($selector) || true) &&
                 ($this->map($with) || true) &&
+                (($this->matchChar('(') &&
+                    $this->interpolation($with) &&
+                    $this->matchChar(')')) || true) &&
                 $this->matchChar('{', false)
             ) {
+                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
                 $atRoot = $this->pushSpecialBlock(Type::T_AT_ROOT, $s);
                 $atRoot->selector = $selector;
-                $atRoot->with = $with;
+                $atRoot->with     = $with;
 
                 return true;
             }
 
             $this->seek($s);
 
-            if ($this->literal('@media', 6) && $this->mediaQueryList($mediaQueryList) && $this->matchChar('{', false)) {
+            if (
+                $this->literal('@media', 6) &&
+                $this->mediaQueryList($mediaQueryList) &&
+                $this->matchChar('{', false)
+            ) {
                 $media = $this->pushSpecialBlock(Type::T_MEDIA, $s);
                 $media->queryList = $mediaQueryList[2];
 
@@ -363,11 +388,14 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@mixin', 6) &&
+            if (
+                $this->literal('@mixin', 6) &&
                 $this->keyword($mixinName) &&
                 ($this->argumentDef($args) || true) &&
                 $this->matchChar('{', false)
             ) {
+                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
                 $mixin = $this->pushSpecialBlock(Type::T_MIXIN, $s);
                 $mixin->name = $mixinName;
                 $mixin->args = $args;
@@ -377,15 +405,27 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@include', 8) &&
-                $this->keyword($mixinName) &&
-                ($this->matchChar('(') &&
+            if (
+                ($this->literal('@include', 8) &&
+                    $this->keyword($mixinName) &&
+                    ($this->matchChar('(') &&
                     ($this->argValues($argValues) || true) &&
                     $this->matchChar(')') || true) &&
-                ($this->end() ||
-                    $this->matchChar('{') && $hasBlock = true)
+                    ($this->end()) ||
+                ($this->literal('using', 5) &&
+                    $this->argumentDef($argUsing) &&
+                    ($this->end() || $this->matchChar('{') && $hasBlock = true)) ||
+                $this->matchChar('{') && $hasBlock = true)
             ) {
-                $child = [Type::T_INCLUDE, $mixinName, isset($argValues) ? $argValues : null, null];
+                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
+                $child = [
+                    Type::T_INCLUDE,
+                    $mixinName,
+                    isset($argValues) ? $argValues : null,
+                    null,
+                    isset($argUsing) ? $argUsing : null
+                ];
 
                 if (! empty($hasBlock)) {
                     $include = $this->pushSpecialBlock(Type::T_INCLUDE, $s);
@@ -399,10 +439,13 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@scssphp-import-once', 20) &&
+            if (
+                $this->literal('@scssphp-import-once', 20) &&
                 $this->valueList($importPath) &&
                 $this->end()
             ) {
+                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
                 $this->append([Type::T_SCSSPHP_IMPORT_ONCE, $importPath], $s);
 
                 return true;
@@ -410,10 +453,18 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@import', 7) &&
+            if (
+                $this->literal('@import', 7) &&
                 $this->valueList($importPath) &&
+                $importPath[0] !== Type::T_FUNCTION_CALL &&
                 $this->end()
             ) {
+                if ($this->cssOnly) {
+                    $this->assertPlainCssValid($importPath, $s);
+                    $this->append([Type::T_COMMENT, rtrim(substr($this->buffer, $s, $this->count - $s))]);
+                    return true;
+                }
+
                 $this->append([Type::T_IMPORT, $importPath], $s);
 
                 return true;
@@ -421,10 +472,17 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@import', 7) &&
+            if (
+                $this->literal('@import', 7) &&
                 $this->url($importPath) &&
                 $this->end()
             ) {
+                if ($this->cssOnly) {
+                    $this->assertPlainCssValid($importPath, $s);
+                    $this->append([Type::T_COMMENT, rtrim(substr($this->buffer, $s, $this->count - $s))]);
+                    return true;
+                }
+
                 $this->append([Type::T_IMPORT, $importPath], $s);
 
                 return true;
@@ -432,10 +490,13 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@extend', 7) &&
+            if (
+                $this->literal('@extend', 7) &&
                 $this->selectors($selectors) &&
                 $this->end()
             ) {
+                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
                 // check for '!flag'
                 $optional = $this->stripOptionalFlag($selectors);
                 $this->append([Type::T_EXTEND, $selectors, $optional], $s);
@@ -445,11 +506,14 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@function', 9) &&
+            if (
+                $this->literal('@function', 9) &&
                 $this->keyword($fnName) &&
                 $this->argumentDef($args) &&
                 $this->matchChar('{', false)
             ) {
+                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
                 $func = $this->pushSpecialBlock(Type::T_FUNCTION, $s);
                 $func->name = $fnName;
                 $func->args = $args;
@@ -459,7 +523,12 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@break', 6) && $this->end()) {
+            if (
+                $this->literal('@break', 6) &&
+                $this->end()
+            ) {
+                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
                 $this->append([Type::T_BREAK], $s);
 
                 return true;
@@ -467,7 +536,12 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@continue', 9) && $this->end()) {
+            if (
+                $this->literal('@continue', 9) &&
+                $this->end()
+            ) {
+                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
                 $this->append([Type::T_CONTINUE], $s);
 
                 return true;
@@ -475,7 +549,13 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@return', 7) && ($this->valueList($retVal) || true) && $this->end()) {
+            if (
+                $this->literal('@return', 7) &&
+                ($this->valueList($retVal) || true) &&
+                $this->end()
+            ) {
+                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
                 $this->append([Type::T_RETURN, isset($retVal) ? $retVal : [Type::T_NULL]], $s);
 
                 return true;
@@ -483,12 +563,15 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@each', 5) &&
+            if (
+                $this->literal('@each', 5) &&
                 $this->genericList($varNames, 'variable', ',', false) &&
                 $this->literal('in', 2) &&
                 $this->valueList($list) &&
                 $this->matchChar('{', false)
             ) {
+                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
                 $each = $this->pushSpecialBlock(Type::T_EACH, $s);
 
                 foreach ($varNames[2] as $varName) {
@@ -502,10 +585,22 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@while', 6) &&
+            if (
+                $this->literal('@while', 6) &&
                 $this->expression($cond) &&
                 $this->matchChar('{', false)
             ) {
+                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
+                while (
+                    $cond[0] === Type::T_LIST &&
+                    ! empty($cond['enclosing']) &&
+                    $cond['enclosing'] === 'parent' &&
+                    \count($cond[2]) == 1
+                ) {
+                    $cond = reset($cond[2]);
+                }
+
                 $while = $this->pushSpecialBlock(Type::T_WHILE, $s);
                 $while->cond = $cond;
 
@@ -514,7 +609,8 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@for', 4) &&
+            if (
+                $this->literal('@for', 4) &&
                 $this->variable($varName) &&
                 $this->literal('from', 4) &&
                 $this->expression($start) &&
@@ -523,10 +619,12 @@ protected function parseChunk()
                 $this->expression($end) &&
                 $this->matchChar('{', false)
             ) {
+                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
                 $for = $this->pushSpecialBlock(Type::T_FOR, $s);
-                $for->var = $varName[1];
+                $for->var   = $varName[1];
                 $for->start = $start;
-                $for->end = $end;
+                $for->end   = $end;
                 $for->until = isset($forUntil);
 
                 return true;
@@ -534,9 +632,24 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@if', 3) && $this->valueList($cond) && $this->matchChar('{', false)) {
+            if (
+                $this->literal('@if', 3) &&
+                $this->functionCallArgumentsList($cond, false, '{', false)
+            ) {
+                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
                 $if = $this->pushSpecialBlock(Type::T_IF, $s);
-                $if->cond = $cond;
+
+                while (
+                    $cond[0] === Type::T_LIST &&
+                    ! empty($cond['enclosing']) &&
+                    $cond['enclosing'] === 'parent' &&
+                    \count($cond[2]) == 1
+                ) {
+                    $cond = reset($cond[2]);
+                }
+
+                $if->cond  = $cond;
                 $if->cases = [];
 
                 return true;
@@ -544,10 +657,12 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@debug', 6) &&
-                $this->valueList($value) &&
-                $this->end()
+            if (
+                $this->literal('@debug', 6) &&
+                $this->functionCallArgumentsList($value, false)
             ) {
+                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
                 $this->append([Type::T_DEBUG, $value], $s);
 
                 return true;
@@ -555,10 +670,12 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@warn', 5) &&
-                $this->valueList($value) &&
-                $this->end()
+            if (
+                $this->literal('@warn', 5) &&
+                $this->functionCallArgumentsList($value, false)
             ) {
+                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
                 $this->append([Type::T_WARN, $value], $s);
 
                 return true;
@@ -566,10 +683,12 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@error', 6) &&
-                $this->valueList($value) &&
-                $this->end()
+            if (
+                $this->literal('@error', 6) &&
+                $this->functionCallArgumentsList($value, false)
             ) {
+                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
                 $this->append([Type::T_ERROR, $value], $s);
 
                 return true;
@@ -577,8 +696,17 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@content', 8) && $this->end()) {
-                $this->append([Type::T_MIXIN_CONTENT], $s);
+            if (
+                $this->literal('@content', 8) &&
+                ($this->end() ||
+                    $this->matchChar('(') &&
+                    $this->argValues($argContent) &&
+                    $this->matchChar(')') &&
+                    $this->end())
+            ) {
+                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
+                $this->append([Type::T_MIXIN_CONTENT, isset($argContent) ? $argContent : null], $s);
 
                 return true;
             }
@@ -593,7 +721,11 @@ protected function parseChunk()
                 if ($this->literal('@else', 5)) {
                     if ($this->matchChar('{', false)) {
                         $else = $this->pushSpecialBlock(Type::T_ELSE, $s);
-                    } elseif ($this->literal('if', 2) && $this->valueList($cond) && $this->matchChar('{', false)) {
+                    } elseif (
+                        $this->literal('if', 2) &&
+                        $this->valueList($cond) &&
+                        $this->matchChar('{', false)
+                    ) {
                         $else = $this->pushSpecialBlock(Type::T_ELSEIF, $s);
                         $else->cond = $cond;
                     }
@@ -610,7 +742,8 @@ protected function parseChunk()
             }
 
             // only retain the first @charset directive encountered
-            if ($this->literal('@charset', 8) &&
+            if (
+                $this->literal('@charset', 8) &&
                 $this->valueList($charset) &&
                 $this->end()
             ) {
@@ -631,11 +764,13 @@ protected function parseChunk()
 
             $this->seek($s);
 
-            if ($this->literal('@supports', 9) &&
-                ($t1=$this->supportsQuery($supportQuery)) &&
-                ($t2=$this->matchChar('{', false)) ) {
+            if (
+                $this->literal('@supports', 9) &&
+                ($t1 = $this->supportsQuery($supportQuery)) &&
+                ($t2 = $this->matchChar('{', false))
+            ) {
                 $directive = $this->pushSpecialBlock(Type::T_DIRECTIVE, $s);
-                $directive->name = 'supports';
+                $directive->name  = 'supports';
                 $directive->value = $supportQuery;
 
                 return true;
@@ -644,11 +779,16 @@ protected function parseChunk()
             $this->seek($s);
 
             // doesn't match built in directive, do generic one
-            if ($this->matchChar('@', false) &&
-                $this->keyword($dirName) &&
-                ($this->variable($dirValue) || $this->openString('{', $dirValue) || true) &&
-                $this->matchChar('{', false)
+            if (
+                $this->matchChar('@', false) &&
+                $this->mixedKeyword($dirName) &&
+                $this->directiveValue($dirValue, '{')
             ) {
+                if (count($dirName) === 1 && is_string(reset($dirName))) {
+                    $dirName = reset($dirName);
+                } else {
+                    $dirName = [Type::T_STRING, '', $dirName];
+                }
                 if ($dirName === 'media') {
                     $directive = $this->pushSpecialBlock(Type::T_MEDIA, $s);
                 } else {
@@ -657,6 +797,7 @@ protected function parseChunk()
                 }
 
                 if (isset($dirValue)) {
+                    ! $this->cssOnly || ($dirValue = $this->assertPlainCssValid($dirValue));
                     $directive->value = $dirValue;
                 }
 
@@ -665,12 +806,102 @@ protected function parseChunk()
 
             $this->seek($s);
 
+            // maybe it's a generic blockless directive
+            if (
+                $this->matchChar('@', false) &&
+                $this->mixedKeyword($dirName) &&
+                ! $this->isKnownGenericDirective($dirName) &&
+                ($this->end(false) || ($this->directiveValue($dirValue, '') && $this->end(false)))
+            ) {
+                if (\count($dirName) === 1 && \is_string(\reset($dirName))) {
+                    $dirName = \reset($dirName);
+                } else {
+                    $dirName = [Type::T_STRING, '', $dirName];
+                }
+                if (
+                    ! empty($this->env->parent) &&
+                    $this->env->type &&
+                    ! \in_array($this->env->type, [Type::T_DIRECTIVE, Type::T_MEDIA])
+                ) {
+                    $plain = \trim(\substr($this->buffer, $s, $this->count - $s));
+                    $this->throwParseError(
+                        "Unknown directive `{$plain}` not allowed in `" . $this->env->type . "` block"
+                    );
+                }
+                // blockless directives with a blank line after keeps their blank lines after
+                // sass-spec compliance purpose
+                $s = $this->count;
+                $hasBlankLine = false;
+                if ($this->match('\s*?\n\s*\n', $out, false)) {
+                    $hasBlankLine = true;
+                    $this->seek($s);
+                }
+                $isNotRoot = ! empty($this->env->parent);
+                $this->append([Type::T_DIRECTIVE, [$dirName, $dirValue, $hasBlankLine, $isNotRoot]], $s);
+                $this->whitespace();
+
+                return true;
+            }
+
+            $this->seek($s);
+
             return false;
         }
 
+        $inCssSelector = null;
+        if ($this->cssOnly) {
+            $inCssSelector = (! empty($this->env->parent) &&
+                ! in_array($this->env->type, [Type::T_DIRECTIVE, Type::T_MEDIA]));
+        }
+        // custom properties : right part is static
+        if (($this->customProperty($name) ) && $this->matchChar(':', false)) {
+            $start = $this->count;
+
+            // but can be complex and finish with ; or }
+            foreach ([';','}'] as $ending) {
+                if (
+                    $this->openString($ending, $stringValue, '(', ')', false) &&
+                    $this->end()
+                ) {
+                    $end = $this->count;
+                    $value = $stringValue;
+
+                    // check if we have only a partial value due to nested [] or { } to take in account
+                    $nestingPairs = [['[', ']'], ['{', '}']];
+
+                    foreach ($nestingPairs as $nestingPair) {
+                        $p = strpos($this->buffer, $nestingPair[0], $start);
+
+                        if ($p && $p < $end) {
+                            $this->seek($start);
+
+                            if (
+                                $this->openString($ending, $stringValue, $nestingPair[0], $nestingPair[1], false) &&
+                                $this->end() &&
+                                $this->count > $end
+                            ) {
+                                $end = $this->count;
+                                $value = $stringValue;
+                            }
+                        }
+                    }
+
+                    $this->seek($end);
+                    $this->append([Type::T_CUSTOM_PROPERTY, $name, $value], $s);
+
+                    return true;
+                }
+            }
+
+            // TODO: output an error here if nothing found according to sass spec
+        }
+
+        $this->seek($s);
+
         // property shortcut
         // captures most properties before having to parse a selector
-        if ($this->keyword($name, false) &&
+        if (
+            $this->keyword($name, false) &&
             $this->literal(': ', 2) &&
             $this->valueList($value) &&
             $this->end()
@@ -684,11 +915,14 @@ protected function parseChunk()
         $this->seek($s);
 
         // variable assigns
-        if ($this->variable($name) &&
+        if (
+            $this->variable($name) &&
             $this->matchChar(':') &&
             $this->valueList($value) &&
             $this->end()
         ) {
+            ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
+
             // check for '!flag'
             $assignmentFlags = $this->stripAssignmentFlags($value);
             $this->append([Type::T_ASSIGN, $name, $value, $assignmentFlags], $s);
@@ -704,12 +938,17 @@ protected function parseChunk()
         }
 
         // opening css block
-        if ($this->selectors($selectors) && $this->matchChar('{', false)) {
+        if (
+            $this->selectors($selectors) &&
+            $this->matchChar('{', false)
+        ) {
+            ! $this->cssOnly || ! $inCssSelector || $this->assertPlainCssValid(false);
+
             $this->pushBlock($selectors, $s);
 
             if ($this->eatWhiteDefault) {
                 $this->whitespace();
-                $this->append(null); // collect comments at the begining if needed
+                $this->append(null); // collect comments at the beginning if needed
             }
 
             return true;
@@ -718,7 +957,10 @@ protected function parseChunk()
         $this->seek($s);
 
         // property assign, or nested assign
-        if ($this->propertyName($name) && $this->matchChar(':')) {
+        if (
+            $this->propertyName($name) &&
+            $this->matchChar(':')
+        ) {
             $foundSomething = false;
 
             if ($this->valueList($value)) {
@@ -731,6 +973,8 @@ protected function parseChunk()
             }
 
             if ($this->matchChar('{', false)) {
+                ! $this->cssOnly || $this->assertPlainCssValid(false);
+
                 $propBlock = $this->pushSpecialBlock(Type::T_NESTED_PROPERTY, $s);
                 $propBlock->prefix = $name;
                 $propBlock->hasValue = $foundSomething;
@@ -751,7 +995,7 @@ protected function parseChunk()
         if ($this->matchChar('}', false)) {
             $block = $this->popBlock();
 
-            if (!isset($block->type) || $block->type !== Type::T_IF) {
+            if (! isset($block->type) || $block->type !== Type::T_IF) {
                 if ($this->env->parent) {
                     $this->append(null); // collect comments before next statement if needed
                 }
@@ -780,7 +1024,8 @@ protected function parseChunk()
         }
 
         // extra stuff
-        if ($this->matchChar(';') ||
+        if (
+            $this->matchChar(';') ||
             $this->literal('<!--', 4)
         ) {
             return true;
@@ -801,7 +1046,7 @@ protected function pushBlock($selectors, $pos = 0)
     {
         list($line, $column) = $this->getSourcePosition($pos);
 
-        $b = new Block;
+        $b = new Block();
         $b->sourceName   = $this->sourceName;
         $b->sourceLine   = $line;
         $b->sourceColumn = $column;
@@ -823,7 +1068,7 @@ protected function pushBlock($selectors, $pos = 0)
 
         $this->env = $b;
 
-        // collect comments at the begining of a block if needed
+        // collect comments at the beginning of a block if needed
         if ($this->eatWhiteDefault) {
             $this->whitespace();
 
@@ -916,13 +1161,187 @@ protected function seek($where)
         $this->count = $where;
     }
 
+    /**
+     * Assert a parsed part is plain CSS Valid
+     *
+     * @param array $parsed
+     * @param int $startPos
+     * @throws ParserException
+     */
+    protected function assertPlainCssValid($parsed, $startPos = null)
+    {
+        $type = '';
+        if ($parsed) {
+            $type = $parsed[0];
+            $parsed = $this->isPlainCssValidElement($parsed);
+        }
+        if (! $parsed) {
+            if (! \is_null($startPos)) {
+                $plain = rtrim(substr($this->buffer, $startPos, $this->count - $startPos));
+                $message = "Error : `{$plain}` isn't allowed in plain CSS";
+            } else {
+                $message = 'Error: SCSS syntax not allowed in CSS file';
+            }
+            if ($type) {
+                $message .= " ($type)";
+            }
+            $this->throwParseError($message);
+        }
+
+        return $parsed;
+    }
+
+    /**
+     * Check a parsed element is plain CSS Valid
+     * @param array $parsed
+     * @return bool|array
+     */
+    protected function isPlainCssValidElement($parsed, $allowExpression = false)
+    {
+        if (
+            \in_array($parsed[0], [Type::T_FUNCTION, Type::T_FUNCTION_CALL]) &&
+            !\in_array($parsed[1], [
+                'alpha',
+                'attr',
+                'calc',
+                'cubic-bezier',
+                'env',
+                'grayscale',
+                'hsl',
+                'hsla',
+                'invert',
+                'linear-gradient',
+                'min',
+                'max',
+                'radial-gradient',
+                'repeating-linear-gradient',
+                'repeating-radial-gradient',
+                'rgb',
+                'rgba',
+                'rotate',
+                'saturate',
+                'var',
+            ]) &&
+            Compiler::isNativeFunction($parsed[1])
+        ) {
+            return false;
+        }
+
+        switch ($parsed[0]) {
+            case Type::T_BLOCK:
+            case Type::T_KEYWORD:
+            case Type::T_NULL:
+            case Type::T_NUMBER:
+                return $parsed;
+
+            case Type::T_COMMENT:
+                if (isset($parsed[2])) {
+                    return false;
+                }
+                return $parsed;
+
+            case Type::T_DIRECTIVE:
+                if (\is_array($parsed[1])) {
+                    $parsed[1][1] = $this->isPlainCssValidElement($parsed[1][1]);
+                    if (! $parsed[1][1]) {
+                        return false;
+                    }
+                }
+
+                return $parsed;
+
+            case Type::T_STRING:
+                foreach ($parsed[2] as $k => $substr) {
+                    if (\is_array($substr)) {
+                        $parsed[2][$k] = $this->isPlainCssValidElement($substr);
+                        if (! $parsed[2][$k]) {
+                            return false;
+                        }
+                    }
+                }
+                return $parsed;
+
+            case Type::T_ASSIGN:
+                foreach ([1, 2, 3] as $k) {
+                    if (! empty($parsed[$k])) {
+                        $parsed[$k] = $this->isPlainCssValidElement($parsed[$k]);
+                        if (! $parsed[$k]) {
+                            return false;
+                        }
+                    }
+                }
+                return $parsed;
+
+            case Type::T_EXPRESSION:
+                list( ,$op, $lhs, $rhs, $inParens, $whiteBefore, $whiteAfter) = $parsed;
+                if (! $allowExpression &&  ! \in_array($op, ['and', 'or', '/'])) {
+                    return false;
+                }
+                $lhs = $this->isPlainCssValidElement($lhs, true);
+                if (! $lhs) {
+                    return false;
+                }
+                $rhs = $this->isPlainCssValidElement($rhs, true);
+                if (! $rhs) {
+                    return false;
+                }
+
+                return [
+                    Type::T_STRING,
+                    '', [
+                        $this->inParens ? '(' : '',
+                        $lhs,
+                        ($whiteBefore ? ' ' : '') . $op . ($whiteAfter ? ' ' : ''),
+                        $rhs,
+                        $this->inParens ? ')' : ''
+                    ]
+                ];
+
+            case Type::T_UNARY:
+                $parsed[2] = $this->isPlainCssValidElement($parsed[2]);
+                if (! $parsed[2]) {
+                    return false;
+                }
+                return $parsed;
+
+            case Type::T_FUNCTION:
+                $argsList = $parsed[2];
+                foreach ($argsList[2] as $argElement) {
+                    if (! $this->isPlainCssValidElement($argElement)) {
+                        return false;
+                    }
+                }
+                return $parsed;
+
+            case Type::T_FUNCTION_CALL:
+                $parsed[0] = Type::T_FUNCTION;
+                $argsList = [Type::T_LIST, ',', []];
+                foreach ($parsed[2] as $arg) {
+                    if ($arg[0] || ! empty($arg[2])) {
+                        // no named arguments possible in a css function call
+                        // nor ... argument
+                        return false;
+                    }
+                    $arg = $this->isPlainCssValidElement($arg[1], $parsed[1] === 'calc');
+                    if (! $arg) {
+                        return false;
+                    }
+                    $argsList[2][] = $arg;
+                }
+                $parsed[2] = $argsList;
+                return $parsed;
+        }
+
+        return false;
+    }
+
     /**
      * Match string looking for either ending delim, escape, or string interpolation
      *
      * {@internal This is a workaround for preg_match's 250K string match limit. }}
      *
      * @param array  $m     Matches (passed by reference)
-     * @param string $delim Delimeter
+     * @param string $delim Delimiter
      *
      * @return boolean True if match; false otherwise
      */
@@ -930,10 +1349,10 @@ protected function matchString(&$m, $delim)
     {
         $token = null;
 
-        $end = strlen($this->buffer);
+        $end = \strlen($this->buffer);
 
         // look for either ending delim, escape, or string interpolation
-        foreach (['#{', '\\', $delim] as $lookahead) {
+        foreach (['#{', '\\', "\r", $delim] as $lookahead) {
             $pos = strpos($this->buffer, $lookahead, $this->count);
 
             if ($pos !== false && $pos < $end) {
@@ -952,7 +1371,7 @@ protected function matchString(&$m, $delim)
             $match,
             $token
         ];
-        $this->count = $end + strlen($token);
+        $this->count = $end + \strlen($token);
 
         return true;
     }
@@ -974,7 +1393,7 @@ protected function match($regex, &$out, $eatWhitespace = null)
             return false;
         }
 
-        $this->count += strlen($out[0]);
+        $this->count += \strlen($out[0]);
 
         if (! isset($eatWhitespace)) {
             $eatWhitespace = $this->eatWhiteDefault;
@@ -1055,28 +1474,29 @@ protected function whitespace()
             if (isset($m[1]) && empty($this->commentsSeen[$this->count])) {
                 // comment that are kept in the output CSS
                 $comment = [];
-                $endCommentCount = $this->count + strlen($m[1]);
+                $startCommentCount = $this->count;
+                $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;
+                    $c           = substr($this->buffer, $this->count, $p - $this->count);
+                    $comment[]   = $c;
                     $this->count = $p;
-                    $out = null;
+                    $out         = null;
 
                     if ($this->interpolation($out)) {
                         // keep right spaces in the following string part
                         if ($out[3]) {
-                            while ($this->buffer[$this->count-1] !== '}') {
+                            while ($this->buffer[$this->count - 1] !== '}') {
                                 $this->count--;
                             }
 
                             $out[3] = '';
                         }
 
-                        $comment[] = $out;
+                        $comment[] = [Type::T_COMMENT, substr($this->buffer, $p, $this->count - $p), $out];
                     } else {
                         $comment[] = substr($this->buffer, $this->count, 2);
 
@@ -1094,14 +1514,19 @@ protected function whitespace()
                     $this->appendComment([Type::T_COMMENT, $c]);
                 } else {
                     $comment[] = $c;
-                    $this->appendComment([Type::T_COMMENT, [Type::T_STRING, '', $comment]]);
+                    $staticComment = substr($this->buffer, $startCommentCount, $endCommentCount - $startCommentCount);
+                    $this->appendComment([Type::T_COMMENT, $staticComment, [Type::T_STRING, '', $comment]]);
                 }
 
-                $this->commentsSeen[$this->count] = true;
+                $this->commentsSeen[$startCommentCount] = 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]);
+                // silent comments are not allowed in plain CSS files
+                ! $this->cssOnly
+                  || ! \strlen(trim($m[0]))
+                  || $this->assertPlainCssValid(false, $this->count - \strlen($m[0]));
             }
 
             $gotWhite = true;
@@ -1118,10 +1543,6 @@ protected function whitespace()
     protected function appendComment($comment)
     {
         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;
         }
     }
@@ -1134,8 +1555,10 @@ protected function appendComment($comment)
      */
     protected function append($statement, $pos = null)
     {
-        if (! is_null($statement)) {
-            if ($pos !== null) {
+        if (! \is_null($statement)) {
+            ! $this->cssOnly || ($statement = $this->assertPlainCssValid($statement, $pos));
+
+            if (! \is_null($pos)) {
                 list($line, $column) = $this->getSourcePosition($pos);
 
                 $statement[static::SOURCE_LINE]   = $line;
@@ -1161,7 +1584,7 @@ protected function append($statement, $pos = null)
      */
     protected function last()
     {
-        $i = count($this->env->children) - 1;
+        $i = \count($this->env->children) - 1;
 
         if (isset($this->env->children[$i])) {
             return $this->env->children[$i];
@@ -1192,7 +1615,9 @@ protected function mediaQuery(&$out)
         $expressions = null;
         $parts = [];
 
-        if (($this->literal('only', 4) && ($only = true) || $this->literal('not', 3) && ($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];
@@ -1208,7 +1633,7 @@ protected function mediaQuery(&$out)
             $media = [Type::T_LIST, '', []];
 
             foreach ((array) $mediaType as $type) {
-                if (is_array($type)) {
+                if (\is_array($type)) {
                     $media[2][] = $type;
                 } else {
                     $media[2][] = [Type::T_KEYWORD, $type];
@@ -1222,7 +1647,7 @@ protected function mediaQuery(&$out)
         if (empty($parts) || $this->literal('and', 3)) {
             $this->genericList($expressions, 'mediaExpression', 'and', false);
 
-            if (is_array($expressions)) {
+            if (\is_array($expressions)) {
                 $parts = array_merge($parts, $expressions[2]);
             }
         }
@@ -1247,12 +1672,15 @@ protected function supportsQuery(&$out)
         $s = $this->count;
 
         $not = false;
-        if (($this->literal('not', 3) && ($not = true) || true) &&
+
+        if (
+            ($this->literal('not', 3) && ($not = true) || true) &&
             $this->matchChar('(') &&
             ($this->expression($property)) &&
             $this->literal(': ', 2) &&
             $this->valueList($value) &&
-            $this->matchChar(')')) {
+            $this->matchChar(')')
+        ) {
             $support = [Type::T_STRING, '', [[Type::T_KEYWORD, ($not ? 'not ' : '') . '(']]];
             $support[2][] = $property;
             $support[2][] = [Type::T_KEYWORD, ': '];
@@ -1265,40 +1693,50 @@ protected function supportsQuery(&$out)
             $this->seek($s);
         }
 
-        if ($this->matchChar('(') &&
+        if (
+            $this->matchChar('(') &&
             $this->supportsQuery($subQuery) &&
-            $this->matchChar(')')) {
+            $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)) {
+        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) &&
+        if (
+            $this->literal('selector(', 9) &&
             $this->selector($selector) &&
-            $this->matchChar(')')) {
+            $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)) {
+                    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;
@@ -1314,29 +1752,37 @@ protected function supportsQuery(&$out)
             $this->seek($s);
         }
 
-        if ($this->literal('and', 3) &&
-            $this->genericList($expressions, 'supportsQuery', ' and', false)) {
+        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)) {
+        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 (\count($parts)) {
             if ($this->eatWhiteDefault) {
                 $this->whitespace();
             }
+
             $out = [Type::T_STRING, '', $parts];
+
             return true;
         }
 
@@ -1356,9 +1802,11 @@ protected function mediaExpression(&$out)
         $s = $this->count;
         $value = null;
 
-        if ($this->matchChar('(') &&
+        if (
+            $this->matchChar('(') &&
             $this->expression($feature) &&
-            ($this->matchChar(':') && $this->expression($value) || true) &&
+            ($this->matchChar(':') &&
+                $this->expression($value) || true) &&
             $this->matchChar(')')
         ) {
             $out = [Type::T_MEDIA_EXPRESSION, $feature];
@@ -1384,12 +1832,19 @@ protected function mediaExpression(&$out)
      */
     protected function argValues(&$out)
     {
+        $discardComments = $this->discardComments;
+        $this->discardComments = true;
+
         if ($this->genericList($list, 'argValue', ',', false)) {
             $out = $list[2];
 
+            $this->discardComments = $discardComments;
+
             return true;
         }
 
+        $this->discardComments = $discardComments;
+
         return false;
     }
 
@@ -1408,10 +1863,11 @@ protected function argValue(&$out)
 
         if (! $this->variable($keyword) || ! $this->matchChar(':')) {
             $this->seek($s);
+
             $keyword = null;
         }
 
-        if ($this->genericList($value, 'expression')) {
+        if ($this->genericList($value, 'expression', '', true)) {
             $out = [$keyword, $value, false];
             $s = $this->count;
 
@@ -1428,113 +1884,345 @@ protected function argValue(&$out)
     }
 
     /**
-     * Parse comma separated value list
-     *
-     * @param array $out
-     *
-     * @return boolean
-     */
-    protected function valueList(&$out)
-    {
-        return $this->genericList($out, 'spaceList', ',');
-    }
-
-    /**
-     * Parse space separated value list
-     *
-     * @param array $out
-     *
-     * @return boolean
+     * Check if a generic directive is known to be able to allow almost any syntax or not
+     * @param $directiveName
+     * @return bool
      */
-    protected function spaceList(&$out)
+    protected function isKnownGenericDirective($directiveName)
     {
-        return $this->genericList($out, 'expression');
+        if (\is_array($directiveName) && \is_string(reset($directiveName))) {
+            $directiveName = reset($directiveName);
+        }
+        if (! \is_string($directiveName)) {
+            return false;
+        }
+        if (
+            \in_array($directiveName, [
+            'at-root',
+            'media',
+            'mixin',
+            'include',
+            'scssphp-import-once',
+            'import',
+            'extend',
+            'function',
+            'break',
+            'continue',
+            'return',
+            'each',
+            'while',
+            'for',
+            'if',
+            'debug',
+            'warn',
+            'error',
+            'content',
+            'else',
+            'charset',
+            'supports',
+            // Todo
+            'use',
+            'forward',
+            ])
+        ) {
+            return true;
+        }
+        return false;
     }
 
     /**
-     * Parse generic list
+     * Parse directive value list that considers $vars as keyword
      *
-     * @param array    $out
-     * @param callable $parseItem
-     * @param string   $delim
-     * @param boolean  $flatten
+     * @param array          $out
+     * @param boolean|string $endChar
      *
      * @return boolean
      */
-    protected function genericList(&$out, $parseItem, $delim = '', $flatten = true)
+    protected function directiveValue(&$out, $endChar = false)
     {
         $s = $this->count;
-        $items = [];
-        $value = null;
 
-        while ($this->$parseItem($value)) {
-            $items[] = $value;
+        if ($this->variable($out)) {
+            if ($endChar && $this->matchChar($endChar, false)) {
+                return true;
+            }
 
-            if ($delim) {
-                if (! $this->literal($delim, strlen($delim))) {
-                    break;
-                }
+            if (! $endChar && $this->end()) {
+                return true;
             }
         }
 
-        if (! $items) {
-            $this->seek($s);
+        $this->seek($s);
 
-            return false;
+        if (\is_string($endChar) && $this->openString($endChar ? $endChar : ';', $out, null, null, true, ";}{")) {
+            if ($endChar && $this->matchChar($endChar, false)) {
+                return true;
+            }
+            $ss = $this->count;
+            if (!$endChar && $this->end()) {
+                $this->seek($ss);
+                return true;
+            }
         }
 
-        if ($flatten && count($items) === 1) {
-            $out = $items[0];
-        } else {
-            $out = [Type::T_LIST, $delim, $items];
+        $this->seek($s);
+
+        $allowVars = $this->allowVars;
+        $this->allowVars = false;
+
+        $res = $this->genericList($out, 'spaceList', ',');
+        $this->allowVars = $allowVars;
+
+        if ($res) {
+            if ($endChar && $this->matchChar($endChar, false)) {
+                return true;
+            }
+
+            if (! $endChar && $this->end()) {
+                return true;
+            }
         }
 
-        return true;
+        $this->seek($s);
+
+        if ($endChar && $this->matchChar($endChar, false)) {
+            return true;
+        }
+
+        return false;
     }
 
     /**
-     * Parse expression
+     * Parse comma separated value list
      *
      * @param array $out
      *
      * @return boolean
      */
-    protected function expression(&$out)
+    protected function valueList(&$out)
     {
-        $s = $this->count;
-        $discard = $this->discardComments;
+        $discardComments = $this->discardComments;
         $this->discardComments = true;
+        $res = $this->genericList($out, 'spaceList', ',');
+        $this->discardComments = $discardComments;
 
-        if ($this->matchChar('(')) {
-            if ($this->parenExpression($out, $s, ")")) {
-                $this->discardComments = $discard;
-                return true;
+        return $res;
+    }
+
+    /**
+     * Parse a function call, where externals () are part of the call
+     * and not of the value list
+     *
+     * @param $out
+     * @param bool $mandatoryEnclos
+     * @param null|string $charAfter
+     * @param null|bool $eatWhiteSp
+     * @return bool
+     */
+    protected function functionCallArgumentsList(&$out, $mandatoryEnclos = true, $charAfter = null, $eatWhiteSp = null)
+    {
+        $s = $this->count;
+
+        if (
+            $this->matchChar('(') &&
+            $this->valueList($out) &&
+            $this->matchChar(')') &&
+            ($charAfter ? $this->matchChar($charAfter, $eatWhiteSp) : $this->end())
+        ) {
+            return true;
+        }
+
+        if (! $mandatoryEnclos) {
+            $this->seek($s);
+
+            if (
+                $this->valueList($out) &&
+                ($charAfter ? $this->matchChar($charAfter, $eatWhiteSp) : $this->end())
+            ) {
+                return true;
+            }
+        }
+
+        $this->seek($s);
+
+        return false;
+    }
+
+    /**
+     * Parse space separated value list
+     *
+     * @param array $out
+     *
+     * @return boolean
+     */
+    protected function spaceList(&$out)
+    {
+        return $this->genericList($out, 'expression');
+    }
+
+    /**
+     * Parse generic list
+     *
+     * @param array    $out
+     * @param callable $parseItem
+     * @param string   $delim
+     * @param boolean  $flatten
+     *
+     * @return boolean
+     */
+    protected function genericList(&$out, $parseItem, $delim = '', $flatten = true)
+    {
+        $s     = $this->count;
+        $items = [];
+        $value = null;
+
+        while ($this->$parseItem($value)) {
+            $trailing_delim = false;
+            $items[] = $value;
+
+            if ($delim) {
+                if (! $this->literal($delim, \strlen($delim))) {
+                    break;
+                }
+
+                $trailing_delim = true;
+            } else {
+                // if no delim watch that a keyword didn't eat the single/double quote
+                // from the following starting string
+                if ($value[0] === Type::T_KEYWORD) {
+                    $word = $value[1];
+
+                    $last_char = substr($word, -1);
+
+                    if (
+                        strlen($word) > 1 &&
+                        in_array($last_char, [ "'", '"']) &&
+                        substr($word, -2, 1) !== '\\'
+                    ) {
+                        // if there is a non escaped opening quote in the keyword, this seems unlikely a mistake
+                        $word = str_replace('\\' . $last_char, '\\\\', $word);
+                        if (strpos($word, $last_char) < strlen($word) - 1) {
+                            continue;
+                        }
+
+                        $currentCount = $this->count;
+
+                        // let's try to rewind to previous char and try a parse
+                        $this->count--;
+                        // in case the keyword also eat spaces
+                        while (substr($this->buffer, $this->count, 1) !== $last_char) {
+                            $this->count--;
+                        }
+
+                        $nextValue = null;
+                        if ($this->$parseItem($nextValue)) {
+                            if ($nextValue[0] === Type::T_KEYWORD && $nextValue[1] === $last_char) {
+                                // bad try, forget it
+                                $this->seek($currentCount);
+                                continue;
+                            }
+                            if ($nextValue[0] !== Type::T_STRING) {
+                                // bad try, forget it
+                                $this->seek($currentCount);
+                                continue;
+                            }
+
+                            // OK it was a good idea
+                            $value[1] = substr($value[1], 0, -1);
+                            array_pop($items);
+                            $items[] = $value;
+                            $items[] = $nextValue;
+                        } else {
+                            // bad try, forget it
+                            $this->seek($currentCount);
+                            continue;
+                        }
+                    }
+                }
             }
+        }
 
+        if (! $items) {
             $this->seek($s);
+
+            return false;
         }
 
-        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, ']' ]];
+        if ($trailing_delim) {
+            $items[] = [Type::T_NULL];
+        }
+
+        if ($flatten && \count($items) === 1) {
+            $out = $items[0];
+        } else {
+            $out = [Type::T_LIST, $delim, $items];
+        }
+
+        return true;
+    }
+
+    /**
+     * Parse expression
+     *
+     * @param array   $out
+     * @param boolean $listOnly
+     * @param boolean $lookForExp
+     *
+     * @return boolean
+     */
+    protected function expression(&$out, $listOnly = false, $lookForExp = true)
+    {
+        $s = $this->count;
+        $discard = $this->discardComments;
+        $this->discardComments = true;
+        $allowedTypes = ($listOnly ? [Type::T_LIST] : [Type::T_LIST, Type::T_MAP]);
+
+        if ($this->matchChar('(')) {
+            if ($this->enclosedExpression($lhs, $s, ')', $allowedTypes)) {
+                if ($lookForExp) {
+                    $out = $this->expHelper($lhs, 0);
+                } else {
+                    $out = $lhs;
+                }
+
+                $this->discardComments = $discard;
+
+                return true;
+            }
+
+            $this->seek($s);
+        }
+
+        if (\in_array(Type::T_LIST, $allowedTypes) && $this->matchChar('[')) {
+            if ($this->enclosedExpression($lhs, $s, ']', [Type::T_LIST])) {
+                if ($lookForExp) {
+                    $out = $this->expHelper($lhs, 0);
+                } else {
+                    $out = $lhs;
                 }
 
                 $this->discardComments = $discard;
+
                 return true;
             }
 
             $this->seek($s);
         }
 
-        if ($this->value($lhs)) {
-            $out = $this->expHelper($lhs, 0);
+        if (! $listOnly && $this->value($lhs)) {
+            if ($lookForExp) {
+                $out = $this->expHelper($lhs, 0);
+            } else {
+                $out = $lhs;
+            }
 
             $this->discardComments = $discard;
+
             return true;
         }
 
         $this->discardComments = $discard;
+
         return false;
     }
 
@@ -1548,21 +2236,50 @@ protected function expression(&$out)
      *
      * @return boolean
      */
-    protected function parenExpression(&$out, $s, $closingParen = ")", $allowedTypes = [Type::T_LIST, Type::T_MAP])
+    protected function enclosedExpression(&$out, $s, $closingParen = ')', $allowedTypes = [Type::T_LIST, Type::T_MAP])
     {
-        if ($this->matchChar($closingParen)) {
+        if ($this->matchChar($closingParen) && \in_array(Type::T_LIST, $allowedTypes)) {
             $out = [Type::T_LIST, '', []];
 
+            switch ($closingParen) {
+                case ')':
+                    $out['enclosing'] = 'parent'; // parenthesis list
+                    break;
+
+                case ']':
+                    $out['enclosing'] = 'bracket'; // bracketed list
+                    break;
+            }
+
             return true;
         }
 
-        if ($this->valueList($out) && $this->matchChar($closingParen) && in_array($out[0], $allowedTypes)) {
+        if (
+            $this->valueList($out) &&
+            $this->matchChar($closingParen) && ! ($closingParen === ')' &&
+            \in_array($out[0], [Type::T_EXPRESSION, Type::T_UNARY])) &&
+            \in_array(Type::T_LIST, $allowedTypes)
+        ) {
+            if ($out[0] !== Type::T_LIST || ! empty($out['enclosing'])) {
+                $out = [Type::T_LIST, '', [$out]];
+            }
+
+            switch ($closingParen) {
+                case ')':
+                    $out['enclosing'] = 'parent'; // parenthesis list
+                    break;
+
+                case ']':
+                    $out['enclosing'] = 'bracket'; // bracketed list
+                    break;
+            }
+
             return true;
         }
 
         $this->seek($s);
 
-        if (in_array(Type::T_MAP, $allowedTypes) && $this->map($out)) {
+        if (\in_array(Type::T_MAP, $allowedTypes) && $this->map($out)) {
             return true;
         }
 
@@ -1600,7 +2317,11 @@ protected function expHelper($lhs, $minP)
                 break;
             }
 
-            if (! $this->value($rhs)) {
+            if (! $this->value($rhs) && ! $this->expression($rhs, true, false)) {
+                break;
+            }
+
+            if ($op === '-' && ! $whiteAfter && $rhs[0] === Type::T_KEYWORD) {
                 break;
             }
 
@@ -1610,6 +2331,7 @@ protected function expHelper($lhs, $minP)
             }
 
             $lhs = [Type::T_EXPRESSION, $op, $lhs, $rhs, $this->inParens, $whiteBefore, $whiteAfter];
+
             $ss = $this->count;
             $whiteBefore = isset($this->buffer[$this->count - 1]) &&
                 ctype_space($this->buffer[$this->count - 1]);
@@ -1636,7 +2358,10 @@ protected function value(&$out)
         $s = $this->count;
         $char = $this->buffer[$this->count];
 
-        if ($this->literal('url(', 4) && $this->match('data:([a-z]+)\/([a-z0-9.+-]+);base64,', $m, false)) {
+        if (
+            $this->literal('url(', 4) &&
+            $this->match('data:([a-z]+)\/([a-z0-9.+-]+);base64,', $m, false)
+        ) {
             $len = strspn(
                 $this->buffer,
                 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwyxz0123456789+/=',
@@ -1655,7 +2380,10 @@ protected function value(&$out)
 
         $this->seek($s);
 
-        if ($this->literal('url(', 4, false) && $this->match('\s*(\/\/\S+)\s*', $m)) {
+        if (
+            $this->literal('url(', 4, false) &&
+            $this->match('\s*(\/\/[^\s\)]+)\s*', $m)
+        ) {
             $content = 'url(' . $m[1];
 
             if ($this->matchChar(')')) {
@@ -1670,7 +2398,10 @@ protected function value(&$out)
 
         // not
         if ($char === 'n' && $this->literal('not', 3, false)) {
-            if ($this->whitespace() && $this->value($inner)) {
+            if (
+                $this->whitespace() &&
+                $this->value($inner)
+            ) {
                 $out = [Type::T_UNARY, 'not', $inner, $this->inParens];
 
                 return true;
@@ -1691,28 +2422,56 @@ protected function value(&$out)
         if ($char === '+') {
             $this->count++;
 
+            $follow_white = $this->whitespace();
+
             if ($this->value($inner)) {
                 $out = [Type::T_UNARY, '+', $inner, $this->inParens];
 
                 return true;
             }
 
-            $this->count--;
+            if ($follow_white) {
+                $out = [Type::T_KEYWORD, $char];
+                return  true;
+            }
+
+            $this->seek($s);
 
             return false;
         }
 
         // negation
         if ($char === '-') {
+            if ($this->customProperty($out)) {
+                return true;
+            }
+
             $this->count++;
 
+            $follow_white = $this->whitespace();
+
             if ($this->variable($inner) || $this->unit($inner) || $this->parenValue($inner)) {
                 $out = [Type::T_UNARY, '-', $inner, $this->inParens];
 
                 return true;
             }
 
-            $this->count--;
+            if (
+                $this->keyword($inner) &&
+                ! $this->func($inner, $out)
+            ) {
+                $out = [Type::T_UNARY, '-', $inner, $this->inParens];
+
+                return true;
+            }
+
+            if ($follow_white) {
+                $out = [Type::T_KEYWORD, $char];
+
+                return  true;
+            }
+
+            $this->seek($s);
         }
 
         // paren
@@ -1724,6 +2483,16 @@ protected function value(&$out)
             if ($this->interpolation($out) || $this->color($out)) {
                 return true;
             }
+
+            $this->count++;
+
+            if ($this->keyword($keyword)) {
+                $out = [Type::T_KEYWORD, '#' . $keyword];
+
+                return true;
+            }
+
+            $this->count--;
         }
 
         if ($this->matchChar('&', true)) {
@@ -1749,9 +2518,17 @@ protected function value(&$out)
         }
 
         // 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->literal('U+', 2) &&
+            $this->match('\?+|([0-9A-F]+(\?+|(-[0-9A-F]+))?)', $m, false)
+        ) {
+            $unicode = explode('-', $m[0]);
+            if (strlen(reset($unicode)) <= 6 && strlen(end($unicode)) <= 6) {
+                $out = [Type::T_KEYWORD, 'U+' . $m[0]];
+
+                return true;
+            }
+            $this->count -= strlen($m[0]) + 2;
         }
 
         if ($this->keyword($keyword, false)) {
@@ -1795,7 +2572,10 @@ protected function parenValue(&$out)
 
             $this->inParens = true;
 
-            if ($this->expression($exp) && $this->matchChar(')')) {
+            if (
+                $this->expression($exp) &&
+                $this->matchChar(')')
+            ) {
                 $out = $exp;
                 $this->inParens = $inParens;
 
@@ -1820,7 +2600,8 @@ protected function progid(&$out)
     {
         $s = $this->count;
 
-        if ($this->literal('progid:', 7, false) &&
+        if (
+            $this->literal('progid:', 7, false) &&
             $this->openString('(', $fn) &&
             $this->matchChar('(')
         ) {
@@ -1862,7 +2643,10 @@ protected function func($name, &$func)
             if ($name !== 'expression' && ! preg_match('/^(-[a-z]+-)?calc$/', $name)) {
                 $ss = $this->count;
 
-                if ($this->argValues($args) && $this->matchChar(')')) {
+                if (
+                    $this->argValues($args) &&
+                    $this->matchChar(')')
+                ) {
                     $func = [Type::T_FUNCTION_CALL, $name, $args];
 
                     return true;
@@ -1871,7 +2655,8 @@ protected function func($name, &$func)
                 $this->seek($ss);
             }
 
-            if (($this->openString(')', $str, '(') || true) &&
+            if (
+                ($this->openString(')', $str, '(') || true) &&
                 $this->matchChar(')')
             ) {
                 $args = [];
@@ -1906,7 +2691,10 @@ protected function argumentList(&$out)
         $args = [];
 
         while ($this->keyword($var)) {
-            if ($this->matchChar('=') && $this->expression($exp)) {
+            if (
+                $this->matchChar('=') &&
+                $this->expression($exp)
+            ) {
                 $args[] = [Type::T_STRING, '', [$var . '=']];
                 $arg = $exp;
             } else {
@@ -1952,7 +2740,10 @@ protected function argumentDef(&$out)
 
             $ss = $this->count;
 
-            if ($this->matchChar(':') && $this->genericList($defaultVal, 'expression')) {
+            if (
+                $this->matchChar(':') &&
+                $this->genericList($defaultVal, 'expression', '', true)
+            ) {
                 $arg[1] = $defaultVal;
             } else {
                 $this->seek($ss);
@@ -1968,6 +2759,7 @@ protected function argumentDef(&$out)
                 }
 
                 $arg[2] = true;
+
                 $this->seek($sss);
             } else {
                 $this->seek($ss);
@@ -2009,8 +2801,10 @@ protected function map(&$out)
         $keys = [];
         $values = [];
 
-        while ($this->genericList($key, 'expression') && $this->matchChar(':') &&
-            $this->genericList($value, 'expression')
+        while (
+            $this->genericList($key, 'expression', '', true) &&
+            $this->matchChar(':') &&
+            $this->genericList($value, 'expression', '', true)
         ) {
             $keys[] = $key;
             $values[] = $value;
@@ -2040,55 +2834,18 @@ protected function map(&$out)
      */
     protected function color(&$out)
     {
-        $color = [Type::T_COLOR];
-        $s     = $this->count;
-
-        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];
-
-            switch ($nofValues) {
-                case 3:
-                case 4:
-                    $num = hexdec($m[2]);
-
-                    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);
+        $s = $this->count;
 
-                    return false;
-            }
+        if ($this->match('(#([0-9a-f]+)\b)', $m)) {
+            if (\in_array(\strlen($m[2]), [3,4,6,8])) {
+                $out = [Type::T_KEYWORD, $m[0]];
 
-            if ($hasAlpha) {
-                if ($color[4] === 255) {
-                    $color[4] = 1; // fully opaque
-                } else {
-                    $color[4] = round($color[4] / 255, 3);
-                }
+                return true;
             }
 
-            $out = $color;
+            $this->seek($s);
 
-            return true;
+            return false;
         }
 
         return false;
@@ -2106,7 +2863,7 @@ protected function unit(&$unit)
         $s = $this->count;
 
         if ($this->match('([0-9]*(\.)?[0-9]+)([%a-zA-Z]+)?', $m, false)) {
-            if (strlen($this->buffer) === $this->count || ! ctype_digit($this->buffer[$this->count])) {
+            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]);
@@ -2127,7 +2884,7 @@ protected function unit(&$unit)
      *
      * @return boolean
      */
-    protected function string(&$out)
+    protected function string(&$out, $keepDelimWithInterpolation = false)
     {
         $s = $this->count;
 
@@ -2150,52 +2907,48 @@ protected function string(&$out)
             }
 
             if ($m[2] === '#{') {
-                $this->count -= strlen($m[2]);
+                $this->count -= \strlen($m[2]);
 
                 if ($this->interpolation($inter, false)) {
                     $content[] = $inter;
                     $hasInterpolation = true;
                 } else {
-                    $this->count += strlen($m[2]);
+                    $this->count += \strlen($m[2]);
                     $content[] = '#{'; // ignore it
                 }
+            } elseif ($m[2] === "\r") {
+                $content[] = '\\a';
+                // TODO : warning
+                # DEPRECATION WARNING on line x, column y of zzz:
+                # Unescaped multiline strings are deprecated and will be removed in a future version of Sass.
+                # To include a newline in a string, use "\a" or "\a " as in CSS.
+                if ($this->matchChar("\n", false)) {
+                    $content[] = ' ';
+                }
             } elseif ($m[2] === '\\') {
-                if ($this->matchChar('"', false)) {
-                    $content[] = $m[2] . '"';
-                } 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)
+                if (
+                    $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
+                } elseif ($this->matchEscapeCharacter($c)) {
+                    $content[] = $c;
                 } else {
-                    $content[] = $m[2];
+                    $this->throwParseError('Unterminated escape sequence');
                 }
             } else {
-                $this->count -= strlen($delim);
+                $this->count -= \strlen($delim);
                 break; // delim
             }
         }
 
         $this->eatWhiteDefault = $oldWhite;
 
-        if ($this->literal($delim, strlen($delim))) {
-            if ($hasInterpolation) {
+        if ($this->literal($delim, \strlen($delim))) {
+            if ($hasInterpolation && ! $keepDelimWithInterpolation) {
                 $delim = '"';
-
-                foreach ($content as &$string) {
-                    if ($string === "\\\\") {
-                        $string = "\\";
-                    } elseif ($string === "\\'") {
-                        $string = "'";
-                    } elseif ($string === '\\"') {
-                        $string = '"';
-                    }
-                }
             }
 
             $out = [Type::T_STRING, $delim, $content];
@@ -2208,6 +2961,39 @@ protected function string(&$out)
         return false;
     }
 
+    protected function matchEscapeCharacter(&$out)
+    {
+        if ($this->match('[a-f0-9]', $m, false)) {
+            $hex = $m[0];
+
+            for ($i = 5; $i--;) {
+                if ($this->match('[a-f0-9]', $m, false)) {
+                    $hex .= $m[0];
+                } else {
+                    break;
+                }
+            }
+
+            $value = hexdec($hex);
+
+            if ($value == 0 || ($value >= 0xD800 && $value <= 0xDFFF) || $value >= 0x10FFFF) {
+                $out = "\u{FFFD}";
+            } else {
+                $out = Util::mbChr($value);
+            }
+
+            return true;
+        }
+
+        if ($this->match('.', $m, false)) {
+            $out = $m[0];
+
+            return true;
+        }
+
+        return false;
+    }
+
     /**
      * Parse keyword or interpolation
      *
@@ -2255,18 +3041,29 @@ protected function mixedKeyword(&$out, $restricted = false)
     /**
      * Parse an unbounded string stopped by $end
      *
-     * @param string $end
-     * @param array  $out
-     * @param string $nestingOpen
+     * @param string  $end
+     * @param array   $out
+     * @param string  $nestOpen
+     * @param string  $nestClose
+     * @param boolean $rtrim
+     * @param string $disallow
      *
      * @return boolean
      */
-    protected function openString($end, &$out, $nestingOpen = null)
+    protected function openString($end, &$out, $nestOpen = null, $nestClose = null, $rtrim = true, $disallow = null)
     {
         $oldWhite = $this->eatWhiteDefault;
         $this->eatWhiteDefault = false;
 
-        $patt = '(.*?)([\'"]|#\{|' . $this->pregQuote($end) . '|' . static::$commentPattern . ')';
+        if ($nestOpen && ! $nestClose) {
+            $nestClose = $end;
+        }
+
+        $patt = ($disallow ? '[^' . $this->pregQuote($disallow) . ']' : '.');
+        $patt = '(' . $patt . '*?)([\'"]|#\{|'
+            . $this->pregQuote($end) . '|'
+            . (($nestClose && $nestClose !== $end) ? $this->pregQuote($nestClose) . '|' : '')
+            . static::$commentPattern . ')';
 
         $nestingLevel = 0;
 
@@ -2276,20 +3073,24 @@ protected function openString($end, &$out, $nestingOpen = null)
             if (isset($m[1]) && $m[1] !== '') {
                 $content[] = $m[1];
 
-                if ($nestingOpen) {
-                    $nestingLevel += substr_count($m[1], $nestingOpen);
+                if ($nestOpen) {
+                    $nestingLevel += substr_count($m[1], $nestOpen);
                 }
             }
 
             $tok = $m[2];
 
-            $this->count-= strlen($tok);
+            $this->count -= \strlen($tok);
 
-            if ($tok === $end && ! $nestingLevel--) {
+            if ($tok === $end && ! $nestingLevel) {
                 break;
             }
 
-            if (($tok === "'" || $tok === '"') && $this->string($str)) {
+            if ($tok === $nestClose) {
+                $nestingLevel--;
+            }
+
+            if (($tok === "'" || $tok === '"') && $this->string($str, true)) {
                 $content[] = $str;
                 continue;
             }
@@ -2300,18 +3101,18 @@ protected function openString($end, &$out, $nestingOpen = null)
             }
 
             $content[] = $tok;
-            $this->count+= strlen($tok);
+            $this->count += \strlen($tok);
         }
 
         $this->eatWhiteDefault = $oldWhite;
 
-        if (! $content) {
+        if (! $content || $tok !== $end) {
             return false;
         }
 
         // trim the end
-        if (is_string(end($content))) {
-            $content[count($content) - 1] = rtrim(end($content));
+        if ($rtrim && \is_string(end($content))) {
+            $content[\count($content) - 1] = rtrim(end($content));
         }
 
         $out = [Type::T_STRING, '', $content];
@@ -2322,25 +3123,34 @@ protected function openString($end, &$out, $nestingOpen = null)
     /**
      * Parser interpolation
      *
-     * @param array   $out
-     * @param boolean $lookWhite save information about whitespace before and after
+     * @param string|array $out
+     * @param boolean      $lookWhite save information about whitespace before and after
      *
      * @return boolean
      */
     protected function interpolation(&$out, $lookWhite = true)
     {
         $oldWhite = $this->eatWhiteDefault;
+        $allowVars = $this->allowVars;
+        $this->allowVars = true;
         $this->eatWhiteDefault = true;
 
         $s = $this->count;
 
-        if ($this->literal('#{', 2) && $this->valueList($value) && $this->matchChar('}', false)) {
+        if (
+            $this->literal('#{', 2) &&
+            $this->valueList($value) &&
+            $this->matchChar('}', false)
+        ) {
             if ($value === [Type::T_SELF]) {
                 $out = $value;
             } else {
                 if ($lookWhite) {
                     $left = ($s > 0 && preg_match('/\s/', $this->buffer[$s - 1])) ? ' ' : '';
-                    $right = preg_match('/\s/', $this->buffer[$this->count]) ? ' ': '';
+                    $right = (
+                        ! empty($this->buffer[$this->count]) &&
+                        preg_match('/\s/', $this->buffer[$this->count])
+                    ) ? ' ' : '';
                 } else {
                     $left = $right = false;
                 }
@@ -2349,6 +3159,7 @@ protected function interpolation(&$out, $lookWhite = true)
             }
 
             $this->eatWhiteDefault = $oldWhite;
+            $this->allowVars = $allowVars;
 
             if ($this->eatWhiteDefault) {
                 $this->whitespace();
@@ -2360,6 +3171,7 @@ protected function interpolation(&$out, $lookWhite = true)
         $this->seek($s);
 
         $this->eatWhiteDefault = $oldWhite;
+        $this->allowVars = $allowVars;
 
         return false;
     }
@@ -2405,16 +3217,10 @@ protected function propertyName(&$out)
         }
 
         // match comment hack
-        if (preg_match(
-            static::$whitePattern,
-            $this->buffer,
-            $m,
-            null,
-            $this->count
-        )) {
+        if (preg_match(static::$whitePattern, $this->buffer, $m, null, $this->count)) {
             if (! empty($m[0])) {
                 $parts[] = $m[0];
-                $this->count += strlen($m[0]);
+                $this->count += \strlen($m[0]);
             }
         }
 
@@ -2426,12 +3232,72 @@ protected function propertyName(&$out)
     }
 
     /**
-     * Parse comma separated selector list
+     * Parse custom property name (as an array of parts or a string)
      *
      * @param array $out
      *
      * @return boolean
      */
+    protected function customProperty(&$out)
+    {
+        $s = $this->count;
+
+        if (! $this->literal('--', 2, false)) {
+            return false;
+        }
+
+        $parts = ['--'];
+
+        $oldWhite = $this->eatWhiteDefault;
+        $this->eatWhiteDefault = false;
+
+        for (;;) {
+            if ($this->interpolation($inter)) {
+                $parts[] = $inter;
+                continue;
+            }
+
+            if ($this->matchChar('&', false)) {
+                $parts[] = [Type::T_SELF];
+                continue;
+            }
+
+            if ($this->variable($var)) {
+                $parts[] = $var;
+                continue;
+            }
+
+            if ($this->keyword($text)) {
+                $parts[] = $text;
+                continue;
+            }
+
+            break;
+        }
+
+        $this->eatWhiteDefault = $oldWhite;
+
+        if (\count($parts) == 1) {
+            $this->seek($s);
+
+            return false;
+        }
+
+        $this->whitespace(); // get any extra whitespace
+
+        $out = [Type::T_STRING, '', $parts];
+
+        return true;
+    }
+
+    /**
+     * Parse comma separated selector list
+     *
+     * @param array   $out
+     * @param boolean $subSelector
+     *
+     * @return boolean
+     */
     protected function selectors(&$out, $subSelector = false)
     {
         $s = $this->count;
@@ -2463,7 +3329,8 @@ protected function selectors(&$out, $subSelector = false)
     /**
      * Parse whitespace separated selector list
      *
-     * @param array $out
+     * @param array   $out
+     * @param boolean $subSelector
      *
      * @return boolean
      */
@@ -2472,9 +3339,18 @@ protected function selector(&$out, $subSelector = false)
         $selector = [];
 
         for (;;) {
+            $s = $this->count;
+
             if ($this->match('[>+~]+', $m, true)) {
-                $selector[] = [$m[0]];
-                continue;
+                if (
+                    $subSelector && \is_string($subSelector) && strpos($subSelector, 'nth-') === 0 &&
+                    $m[0] === '+' && $this->match("(\d+|n\b)", $counter)
+                ) {
+                    $this->seek($s);
+                } else {
+                    $selector[] = [$m[0]];
+                    continue;
+                }
             }
 
             if ($this->selectorSingle($part, $subSelector)) {
@@ -2507,7 +3383,8 @@ protected function selector(&$out, $subSelector = false)
      *     div[yes=no]#something.hello.world:nth-child(-2n+1)%placeholder
      * }}
      *
-     * @param array $out
+     * @param array   $out
+     * @param boolean $subSelector
      *
      * @return boolean
      */
@@ -2545,6 +3422,7 @@ protected function selectorSingle(&$out, $subSelector = false)
                 case '&':
                     $parts[] = Compiler::$selfSelector;
                     $this->count++;
+                    ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
                     continue 2;
 
                 case '.':
@@ -2569,6 +3447,7 @@ protected function selectorSingle(&$out, $subSelector = false)
                 if ($this->placeholder($placeholder)) {
                     $parts[] = '%';
                     $parts[] = $placeholder;
+                    ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
                     continue;
                 }
 
@@ -2578,6 +3457,7 @@ protected function selectorSingle(&$out, $subSelector = false)
             if ($char === '#') {
                 if ($this->interpolation($inter)) {
                     $parts[] = $inter;
+                    ! $this->cssOnly || $this->assertPlainCssValid(false, $s);
                     continue;
                 }
 
@@ -2605,12 +3485,21 @@ protected function selectorSingle(&$out, $subSelector = false)
 
                     $ss = $this->count;
 
-                    if ($nameParts === ['not'] || $nameParts === ['is'] ||
-                        $nameParts === ['has'] || $nameParts === ['where']
+                    if (
+                        $nameParts === ['not'] ||
+                        $nameParts === ['is'] ||
+                        $nameParts === ['has'] ||
+                        $nameParts === ['where'] ||
+                        $nameParts === ['slotted'] ||
+                        $nameParts === ['nth-child'] ||
+                        $nameParts === ['nth-last-child'] ||
+                        $nameParts === ['nth-of-type'] ||
+                        $nameParts === ['nth-last-of-type']
                     ) {
-                        if ($this->matchChar('(') &&
-                          ($this->selectors($subs, true) || true) &&
-                          $this->matchChar(')')
+                        if (
+                            $this->matchChar('(', true) &&
+                            ($this->selectors($subs, reset($nameParts)) || true) &&
+                            $this->matchChar(')')
                         ) {
                             $parts[] = '(';
 
@@ -2619,11 +3508,13 @@ protected function selectorSingle(&$out, $subSelector = false)
                                     foreach ($ps as &$p) {
                                         $parts[] = $p;
                                     }
-                                    if (count($sub) && reset($sub)) {
+
+                                    if (\count($sub) && reset($sub)) {
                                         $parts[] = ' ';
                                     }
                                 }
-                                if (count($subs) && reset($subs)) {
+
+                                if (\count($subs) && reset($subs)) {
                                     $parts[] = ', ';
                                 }
                             }
@@ -2632,21 +3523,20 @@ protected function selectorSingle(&$out, $subSelector = false)
                         } else {
                             $this->seek($ss);
                         }
-                    } else {
-                        if ($this->matchChar('(') &&
-                          ($this->openString(')', $str, '(') || true) &&
-                          $this->matchChar(')')
-                        ) {
-                            $parts[] = '(';
-
-                            if (! empty($str)) {
-                                $parts[] = $str;
-                            }
+                    } elseif (
+                        $this->matchChar('(') &&
+                        ($this->openString(')', $str, '(') || true) &&
+                        $this->matchChar(')')
+                    ) {
+                        $parts[] = '(';
 
-                            $parts[] = ')';
-                        } else {
-                            $this->seek($ss);
+                        if (! empty($str)) {
+                            $parts[] = $str;
                         }
+
+                        $parts[] = ')';
+                    } else {
+                        $this->seek($ss);
                     }
 
                     continue;
@@ -2655,8 +3545,20 @@ protected function selectorSingle(&$out, $subSelector = false)
 
             $this->seek($s);
 
+            // 2n+1
+            if ($subSelector && \is_string($subSelector) && strpos($subSelector, 'nth-') === 0) {
+                if ($this->match("(\s*(\+\s*|\-\s*)?(\d+|n|\d+n))+", $counter)) {
+                    $parts[] = $counter[0];
+                    //$parts[] = str_replace(' ', '', $counter[0]);
+                    continue;
+                }
+            }
+
+            $this->seek($s);
+
             // attribute selector
-            if ($char === '[' &&
+            if (
+                $char === '[' &&
                 $this->matchChar('[') &&
                 ($this->openString(']', $str, '[') || true) &&
                 $this->matchChar(']')
@@ -2709,8 +3611,15 @@ protected function variable(&$out)
     {
         $s = $this->count;
 
-        if ($this->matchChar('$', false) && $this->keyword($name)) {
-            $out = [Type::T_VARIABLE, $name];
+        if (
+            $this->matchChar('$', false) &&
+            $this->keyword($name)
+        ) {
+            if ($this->allowVars) {
+                $out = [Type::T_VARIABLE, $name];
+            } else {
+                $out = [Type::T_KEYWORD, '$' . $name];
+            }
 
             return true;
         }
@@ -2730,13 +3639,15 @@ protected function variable(&$out)
      */
     protected function keyword(&$word, $eatWhitespace = null)
     {
-        if ($this->match(
+        $match = $this->match(
             $this->utf8
                 ? '(([\pL\w\x{00A0}-\x{10FFFF}_\-\*!"\']|[\\\\].)([\pL\w\x{00A0}-\x{10FFFF}\-_"\']|[\\\\].)*)'
                 : '(([\w_\-\*!"\']|[\\\\].)([\w\-_"\']|[\\\\].)*)',
             $m,
             $eatWhitespace
-        )) {
+        );
+
+        if ($match) {
             $word = $m[1];
 
             return true;
@@ -2757,7 +3668,7 @@ protected function restrictedKeyword(&$word, $eatWhitespace = null)
     {
         $s = $this->count;
 
-        if ($this->keyword($word, $eatWhitespace) && (ord($word[0]) > 57 || ord($word[0]) < 48)) {
+        if ($this->keyword($word, $eatWhitespace) && (\ord($word[0]) > 57 || \ord($word[0]) < 48)) {
             return true;
         }
 
@@ -2769,22 +3680,25 @@ protected function restrictedKeyword(&$word, $eatWhitespace = null)
     /**
      * Parse a placeholder
      *
-     * @param string $placeholder
+     * @param string|array $placeholder
      *
      * @return boolean
      */
     protected function placeholder(&$placeholder)
     {
-        if ($this->match(
+        $match = $this->match(
             $this->utf8
                 ? '([\pL\w\-_]+)'
                 : '([\w\-_]+)',
             $m
-        )) {
+        );
+
+        if ($match) {
             $placeholder = $m[1];
 
             return true;
         }
+
         if ($this->interpolation($placeholder)) {
             return true;
         }
@@ -2801,10 +3715,28 @@ protected function placeholder(&$placeholder)
      */
     protected function url(&$out)
     {
-        if ($this->match('(url\(\s*(["\']?)([^)]+)\2\s*\))', $m)) {
-            $out = [Type::T_STRING, '', ['url(' . $m[2] . $m[3] . $m[2] . ')']];
+        if ($this->literal('url(', 4)) {
+            $s = $this->count;
 
-            return true;
+            if (
+                ($this->string($out) || $this->spaceList($out)) &&
+                $this->matchChar(')')
+            ) {
+                $out = [Type::T_STRING, '', ['url(', $out, ')']];
+
+                return true;
+            }
+
+            $this->seek($s);
+
+            if (
+                $this->openString(')', $out) &&
+                $this->matchChar(')')
+            ) {
+                $out = [Type::T_STRING, '', ['url(', $out, ')']];
+
+                return true;
+            }
         }
 
         return false;
@@ -2812,16 +3744,17 @@ protected function url(&$out)
 
     /**
      * Consume an end of statement delimiter
+     * @param bool $eatWhitespace
      *
      * @return boolean
      */
-    protected function end()
+    protected function end($eatWhitespace = null)
     {
-        if ($this->matchChar(';')) {
+        if ($this->matchChar(';', $eatWhitespace)) {
             return true;
         }
 
-        if ($this->count === strlen($this->buffer) || $this->buffer[$this->count] === '}') {
+        if ($this->count === \strlen($this->buffer) || $this->buffer[$this->count] === '}') {
             // if there is end of file or a closing block next then we don't need a ;
             return true;
         }
@@ -2840,18 +3773,15 @@ protected function stripAssignmentFlags(&$value)
     {
         $flags = [];
 
-        for ($token = &$value; $token[0] === Type::T_LIST && ($s = count($token[2])); $token = &$lastNode) {
+        for ($token = &$value; $token[0] === Type::T_LIST && ($s = \count($token[2])); $token = &$lastNode) {
             $lastNode = &$token[2][$s - 1];
 
-            while ($lastNode[0] === Type::T_KEYWORD && in_array($lastNode[1], ['!default', '!global'])) {
+            while ($lastNode[0] === Type::T_KEYWORD && \in_array($lastNode[1], ['!default', '!global'])) {
                 array_pop($token[2]);
 
-                $node = end($token[2]);
-
-                $token = $this->flattenList($token);
-
-                $flags[] = $lastNode[1];
-
+                $node     = end($token[2]);
+                $token    = $this->flattenList($token);
+                $flags[]  = $lastNode[1];
                 $lastNode = $node;
             }
         }
@@ -2869,12 +3799,11 @@ protected function stripAssignmentFlags(&$value)
     protected function stripOptionalFlag(&$selectors)
     {
         $optional = false;
-
         $selector = end($selectors);
-        $part = end($selector);
+        $part     = end($selector);
 
         if ($part === ['!optional']) {
-            array_pop($selectors[count($selectors) - 1]);
+            array_pop($selectors[\count($selectors) - 1]);
 
             $optional = true;
         }
@@ -2891,55 +3820,13 @@ protected function stripOptionalFlag(&$selectors)
      */
     protected function flattenList($value)
     {
-        if ($value[0] === Type::T_LIST && count($value[2]) === 1) {
+        if ($value[0] === Type::T_LIST && \count($value[2]) === 1) {
             return $this->flattenList($value[2][0]);
         }
 
         return $value;
     }
 
-    /**
-     * @deprecated
-     *
-     * {@internal
-     *     advance counter to next occurrence of $what
-     *     $until - don't include $what in advance
-     *     $allowNewline, if string, will be used as valid char set
-     * }}
-     */
-    protected function to($what, &$out, $until = false, $allowNewline = false)
-    {
-        if (is_string($allowNewline)) {
-            $validChars = $allowNewline;
-        } else {
-            $validChars = $allowNewline ? '.' : "[^\n]";
-        }
-
-        if (! $this->match('(' . $validChars . '*?)' . $this->pregQuote($what), $m, ! $until)) {
-            return false;
-        }
-
-        if ($until) {
-            $this->count -= strlen($what); // give back $what
-        }
-
-        $out = $m[1];
-
-        return true;
-    }
-
-    /**
-     * @deprecated
-     */
-    protected function show()
-    {
-        if ($this->peek("(.*?)(\n|$)", $m, $this->count)) {
-            return $m[1];
-        }
-
-        return '';
-    }
-
     /**
      * Quote regular expression
      *
@@ -2967,10 +3854,10 @@ private function extractLineNumbers($buffer)
             $prev = $pos + 1;
         }
 
-        $this->sourcePositions[] = strlen($buffer);
+        $this->sourcePositions[] = \strlen($buffer);
 
         if (substr($buffer, -1) !== "\n") {
-            $this->sourcePositions[] = strlen($buffer) + 1;
+            $this->sourcePositions[] = \strlen($buffer) + 1;
         }
     }
 
@@ -2984,7 +3871,7 @@ private function extractLineNumbers($buffer)
     private function getSourcePosition($pos)
     {
         $low = 0;
-        $high = count($this->sourcePositions);
+        $high = \count($this->sourcePositions);
 
         while ($low < $high) {
             $mid = (int) (($high + $low) / 2);
@@ -3010,13 +3897,7 @@ private function getSourcePosition($pos)
      */
     private function saveEncoding()
     {
-        if (version_compare(PHP_VERSION, '7.2.0') >= 0) {
-            return;
-        }
-
-        $iniDirective = 'mbstring' . '.func_overload'; // deprecated in PHP 7.2
-
-        if (ini_get($iniDirective) & 2) {
+        if (\extension_loaded('mbstring')) {
             $this->encoding = mb_internal_encoding();
 
             mb_internal_encoding('iso-8859-1');
@@ -3028,7 +3909,7 @@ private function saveEncoding()
      */
     private function restoreEncoding()
     {
-        if ($this->encoding) {
+        if (\extension_loaded('mbstring') && $this->encoding) {
             mb_internal_encoding($this->encoding);
         }
     }
diff --git a/scssphp/src/SourceMap/Base64.php b/scssphp/src/SourceMap/Base64.php
index 93c6c1b..5fc56b2 100644
--- a/scssphp/src/SourceMap/Base64.php
+++ b/scssphp/src/SourceMap/Base64.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
diff --git a/scssphp/src/SourceMap/Base64VLQ.php b/scssphp/src/SourceMap/Base64VLQ.php
index d6f6452..9083d78 100644
--- a/scssphp/src/SourceMap/Base64VLQ.php
+++ b/scssphp/src/SourceMap/Base64VLQ.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -61,7 +62,9 @@ public static function encode($value)
 
         do {
             $digit = $vlq & self::VLQ_BASE_MASK;
-            $vlq >>= self::VLQ_BASE_SHIFT;
+
+            //$vlq >>>= self::VLQ_BASE_SHIFT; // unsigned right shift
+            $vlq = (($vlq >> 1) & PHP_INT_MAX) >> (self::VLQ_BASE_SHIFT - 1);
 
             if ($vlq > 0) {
                 $digit |= self::VLQ_CONTINUATION_BIT;
@@ -130,8 +133,19 @@ private static function toVLQSigned($value)
     private static function fromVLQSigned($value)
     {
         $negate = ($value & 1) === 1;
-        $value = $value >> 1;
 
-        return $negate ? -$value : $value;
+        //$value >>>= 1; // unsigned right shift
+        $value = ($value >> 1) & PHP_INT_MAX;
+
+        if (! $negate) {
+            return $value;
+        }
+
+        // We need to OR 0x80000000 here to ensure the 32nd bit (the sign bit) is
+        // always set for negative numbers. If `value` were 1, (meaning `negate` is
+        // true and all other bits were zeros), `value` would now be 0. -0 is just
+        // 0, and doesn't flip the 32nd bit as intended. All positive numbers will
+        // successfully flip the 32nd bit without issue, so it's a noop for them.
+        return -$value | 0x80000000;
     }
 }
diff --git a/scssphp/src/SourceMap/Base64VLQEncoder.php b/scssphp/src/SourceMap/Base64VLQEncoder.php
deleted file mode 100644
index 365b4d9..0000000
--- a/scssphp/src/SourceMap/Base64VLQEncoder.php
+++ /dev/null
@@ -1,217 +0,0 @@
-<?php
-/**
- * SCSSPHP
- *
- * @copyright 2012-2019 Leaf Corcoran
- *
- * @license http://opensource.org/licenses/MIT MIT
- *
- * @link http://scssphp.github.io/scssphp
- */
-
-namespace ScssPhp\ScssPhp\SourceMap;
-
-/**
- * Base64 VLQ Encoder
- *
- * {@internal Derivative of oyejorge/less.php's lib/SourceMap/Base64VLQ.php, relicensed with permission. }}
- *
- * @author Josh Schmidt <oyejorge@gmail.com>
- * @author Nicolas FRANÇOIS <nicolas.francois@frog-labs.com>
- */
-class Base64VLQEncoder
-{
-    /**
-     * Shift
-     *
-     * @var integer
-     */
-    private $shift = 5;
-
-    /**
-     * Mask
-     *
-     * @var integer
-     */
-    private $mask = 0x1F; // == (1 << shift) == 0b00011111
-
-    /**
-     * Continuation bit
-     *
-     * @var integer
-     */
-    private $continuationBit = 0x20; // == (mask - 1 ) == 0b00100000
-
-    /**
-     * Char to integer map
-     *
-     * @var 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,
-        '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,
-    ];
-
-    /**
-     * Integer to char map
-     *
-     * @var 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',
-        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 => '/',
-    ];
-
-    /**
-     * Constructor
-     */
-    public function __construct()
-    {
-        // I leave it here for future reference
-        // foreach (str_split('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/') as $i => $char)
-        // {
-        //     $this->charToIntMap[$char] = $i;
-        //     $this->intToCharMap[$i] = $char;
-        // }
-    }
-
-    /**
-     * Convert 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)
-     * We generate the value for 32 bit machines, hence -2147483648 becomes 1, not 4294967297,
-     * even on a 64 bit machine.
-     *
-     * @param string $aValue
-     */
-    public function toVLQSigned($aValue)
-    {
-        return 0xffffffff & ($aValue < 0 ? ((-$aValue) << 1) + 1 : ($aValue << 1) + 0);
-    }
-
-    /**
-     * Convert 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
-     * We assume that the value was generated with a 32 bit machine in mind.
-     * Hence
-     *   1 becomes -2147483648
-     * even on a 64 bit machine.
-     *
-     * @param integer $aValue
-     */
-    public function fromVLQSigned($aValue)
-    {
-        return $aValue & 1 ? $this->zeroFill(~$aValue + 2, 1) | (-1 - 0x7fffffff) : $this->zeroFill($aValue, 1);
-    }
-
-    /**
-     * Return the base 64 VLQ encoded value.
-     *
-     * @param string $aValue The value to encode
-     *
-     * @return string The encoded value
-     */
-    public function encode($aValue)
-    {
-        $encoded = '';
-        $vlq = $this->toVLQSigned($aValue);
-
-        do {
-            $digit = $vlq & $this->mask;
-            $vlq = $this->zeroFill($vlq, $this->shift);
-
-            if ($vlq > 0) {
-                $digit |= $this->continuationBit;
-            }
-
-            $encoded .= $this->base64Encode($digit);
-        } while ($vlq > 0);
-
-        return $encoded;
-    }
-
-    /**
-     * Return the value decoded from base 64 VLQ.
-     *
-     * @param string $encoded The encoded value to decode
-     *
-     * @return integer The decoded value
-     */
-    public function decode($encoded)
-    {
-        $vlq = 0;
-        $i = 0;
-
-        do {
-            $digit = $this->base64Decode($encoded[$i]);
-            $vlq |= ($digit & $this->mask) << ($i * $this->shift);
-            $i++;
-        } while ($digit & $this->continuationBit);
-
-        return $this->fromVLQSigned($vlq);
-    }
-
-    /**
-     * Right shift with zero fill.
-     *
-     * @param integer $a number to shift
-     * @param integer $b number of bits to shift
-     *
-     * @return integer
-     */
-    public function zeroFill($a, $b)
-    {
-        return ($a >= 0) ? ($a >> $b) : ($a >> $b) & (PHP_INT_MAX >> ($b - 1));
-    }
-
-    /**
-     * Encode single 6-bit digit as base64.
-     *
-     * @param integer $number
-     *
-     * @return string
-     *
-     * @throws \Exception If the number is invalid
-     */
-    public function base64Encode($number)
-    {
-        if ($number < 0 || $number > 63) {
-            throw new \Exception(sprintf('Invalid number "%s" given. Must be between 0 and 63.', $number));
-        }
-
-        return $this->intToCharMap[$number];
-    }
-
-    /**
-     * Decode single 6-bit digit from base64
-     *
-     * @param string $char
-     *
-     * @return integer
-     *
-     * @throws \Exception If the number is invalid
-     */
-    public function base64Decode($char)
-    {
-        if (! array_key_exists($char, $this->charToIntMap)) {
-            throw new \Exception(sprintf('Invalid base 64 digit "%s" given.', $char));
-        }
-
-        return $this->charToIntMap[$char];
-    }
-}
diff --git a/scssphp/src/SourceMap/SourceMapGenerator.php b/scssphp/src/SourceMap/SourceMapGenerator.php
index d0231b4..d01f7cc 100644
--- a/scssphp/src/SourceMap/SourceMapGenerator.php
+++ b/scssphp/src/SourceMap/SourceMapGenerator.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -132,7 +133,7 @@ public function addMapping($generatedLine, $generatedColumn, $originalLine, $ori
     public function saveMap($content)
     {
         $file = $this->options['sourceMapWriteTo'];
-        $dir  = dirname($file);
+        $dir  = \dirname($file);
 
         // directory does not exist
         if (! is_dir($dir)) {
@@ -201,7 +202,7 @@ public function generateJson()
         }
 
         // less.js compat fixes
-        if (count($sourceMap['sources']) && empty($sourceMap['sourceRoot'])) {
+        if (\count($sourceMap['sources']) && empty($sourceMap['sourceRoot'])) {
             unset($sourceMap['sourceRoot']);
         }
 
@@ -235,7 +236,7 @@ protected function getSourcesContent()
      */
     public function generateMappings()
     {
-        if (! count($this->mappings)) {
+        if (! \count($this->mappings)) {
             return '';
         }
 
@@ -249,6 +250,7 @@ public function generateMappings()
         }
 
         ksort($groupedMap);
+
         $lastGeneratedLine = $lastOriginalIndex = $lastOriginalLine = $lastOriginalColumn = 0;
 
         foreach ($groupedMap as $lineNumber => $lineMap) {
@@ -313,8 +315,8 @@ protected function normalizeFilename($filename)
         $basePath = $this->options['sourceMapBasepath'];
 
         // "Trim" the 'sourceMapBasepath' from the output filename.
-        if (strlen($basePath) && strpos($filename, $basePath) === 0) {
-            $filename = substr($filename, strlen($basePath));
+        if (\strlen($basePath) && strpos($filename, $basePath) === 0) {
+            $filename = substr($filename, \strlen($basePath));
         }
 
         // Remove extra leading path separators.
diff --git a/scssphp/src/Type.php b/scssphp/src/Type.php
index a12da72..97ebb0d 100644
--- a/scssphp/src/Type.php
+++ b/scssphp/src/Type.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -27,6 +28,7 @@ class Type
     const T_COMMENT = 'comment';
     const T_CONTINUE = 'continue';
     const T_CONTROL = 'control';
+    const T_CUSTOM_PROPERTY = 'custom';
     const T_DEBUG = 'debug';
     const T_DIRECTIVE = 'directive';
     const T_EACH = 'each';
@@ -37,6 +39,7 @@ class Type
     const T_EXTEND = 'extend';
     const T_FOR = 'for';
     const T_FUNCTION = 'function';
+    const T_FUNCTION_REFERENCE = 'function-reference';
     const T_FUNCTION_CALL = 'fncall';
     const T_HSL = 'hsl';
     const T_IF = 'if';
diff --git a/scssphp/src/Util.php b/scssphp/src/Util.php
index b0b76fd..124aa82 100644
--- a/scssphp/src/Util.php
+++ b/scssphp/src/Util.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -39,6 +40,10 @@ public static function checkRange($name, Range $range, $value, $unit = '')
         $val = $value[1];
         $grace = new Range(-0.00001, 0.00001);
 
+        if (! \is_numeric($val)) {
+            throw new RangeException("$name {$val} is not a number.");
+        }
+
         if ($range->includes($val)) {
             return $val;
         }
@@ -67,4 +72,89 @@ public static function encodeURIComponent($string)
 
         return strtr(rawurlencode($string), $revert);
     }
+
+    /**
+     * mb_chr() wrapper
+     *
+     * @param integer $code
+     *
+     * @return string
+     */
+    public static function mbChr($code)
+    {
+        // Use the native implementation if available.
+        if (\function_exists('mb_chr')) {
+            return mb_chr($code, 'UTF-8');
+        }
+
+        if (0x80 > $code %= 0x200000) {
+            $s = \chr($code);
+        } elseif (0x800 > $code) {
+            $s = \chr(0xC0 | $code >> 6) . \chr(0x80 | $code & 0x3F);
+        } elseif (0x10000 > $code) {
+            $s = \chr(0xE0 | $code >> 12) . \chr(0x80 | $code >> 6 & 0x3F) . \chr(0x80 | $code & 0x3F);
+        } else {
+            $s = \chr(0xF0 | $code >> 18) . \chr(0x80 | $code >> 12 & 0x3F)
+                . \chr(0x80 | $code >> 6 & 0x3F) . \chr(0x80 | $code & 0x3F);
+        }
+
+        return $s;
+    }
+
+    /**
+     * mb_strlen() wrapper
+     *
+     * @param string $string
+     * @return false|int
+     */
+    public static function mbStrlen($string)
+    {
+        // Use the native implementation if available.
+        if (\function_exists('mb_strlen')) {
+            return mb_strlen($string, 'UTF-8');
+        }
+
+        if (\function_exists('iconv_strlen')) {
+            return @iconv_strlen($string, 'UTF-8');
+        }
+
+        return strlen($string);
+    }
+
+    /**
+     * mb_substr() wrapper
+     * @param string $string
+     * @param int $start
+     * @param null|int $length
+     * @return string
+     */
+    public static function mbSubstr($string, $start, $length = null)
+    {
+        // Use the native implementation if available.
+        if (\function_exists('mb_substr')) {
+            return mb_substr($string, $start, $length, 'UTF-8');
+        }
+
+        if (\function_exists('iconv_substr')) {
+            if ($start < 0) {
+                $start = static::mbStrlen($string) + $start;
+                if ($start < 0) {
+                    $start = 0;
+                }
+            }
+
+            if (null === $length) {
+                $length = 2147483647;
+            } elseif ($length < 0) {
+                $length = static::mbStrlen($string) + $length - $start;
+                if ($length < 0) {
+                    return '';
+                }
+            }
+
+            return (string)iconv_substr($string, $start, $length, 'UTF-8');
+        }
+
+        return substr($string, $start, $length);
+    }
 }
diff --git a/scssphp/src/Version.php b/scssphp/src/Version.php
index d5e6dc0..8445434 100644
--- a/scssphp/src/Version.php
+++ b/scssphp/src/Version.php
@@ -1,8 +1,9 @@
 <?php
+
 /**
  * SCSSPHP
  *
- * @copyright 2012-2019 Leaf Corcoran
+ * @copyright 2012-2020 Leaf Corcoran
  *
  * @license http://opensource.org/licenses/MIT MIT
  *
@@ -18,5 +19,5 @@
  */
 class Version
 {
-    const VERSION = 'v1.0.2';
+    const VERSION = '1.2.1';
 }