WordPress Button Plugin MaxButtons

Version Description

Updated ScssPhp to 1.0.7
Updated SimpleHTMLDom to 1.9.1
Fixed Buttons menu tab

Release Info

Developer	basszje
Plugin	WordPress Button Plugin MaxButtons
Version	7.13.4
Comparing to
See all releases

Code changes from version 7.13.3 to 7.13.4

Files changed (62) hide show

assets/libraries/{scssphp_legacy → scssphp}/LICENSE.md +1 -1
assets/libraries/{scssphp_legacy → scssphp}/README.md +4 -5
assets/libraries/scssphp/scss.inc.php +6 -4
assets/libraries/scssphp/src/Base/Range.php +3 -3
assets/libraries/scssphp/src/Block.php +9 -4
assets/libraries/scssphp/src/Cache.php +239 -0
assets/libraries/scssphp/src/Colors.php +71 -4
assets/libraries/scssphp/src/Compiler.php +2979 -677
assets/libraries/scssphp/src/Compiler/Environment.php +10 -5
assets/libraries/scssphp/src/Exception/CompilerException.php +3 -3
assets/libraries/scssphp/src/Exception/ParserException.php +3 -3
assets/libraries/scssphp/src/Exception/RangeException.php +3 -3
assets/libraries/scssphp/src/Exception/ServerException.php +3 -3
assets/libraries/scssphp/src/Formatter.php +78 -36
assets/libraries/scssphp/src/Formatter/Compact.php +4 -4
assets/libraries/scssphp/src/Formatter/Compressed.php +24 -5
assets/libraries/scssphp/src/Formatter/Crunched.php +24 -5
assets/libraries/scssphp/src/Formatter/Debug.php +5 -5
assets/libraries/scssphp/src/Formatter/Expanded.php +6 -6
assets/libraries/scssphp/src/Formatter/Nested.php +110 -83
assets/libraries/scssphp/src/Formatter/OutputBlock.php +4 -4
assets/libraries/scssphp/src/Node.php +3 -3
assets/libraries/scssphp/src/Node/Number.php +15 -15
assets/libraries/scssphp/src/Parser.php +994 -366
assets/libraries/scssphp/src/SourceMap/Base64.php +184 -0
assets/libraries/scssphp/src/SourceMap/Base64VLQ.php +146 -0
assets/libraries/scssphp/src/SourceMap/Base64VLQEncoder.php +0 -218
assets/libraries/scssphp/src/SourceMap/SourceMapGenerator.php +45 -35
assets/libraries/scssphp/src/Type.php +3 -3
assets/libraries/scssphp/src/Util.php +8 -8
assets/libraries/scssphp/src/Version.php +4 -4
assets/libraries/scssphp_legacy/scss.inc.php +0 -29
assets/libraries/scssphp_legacy/src/Base/Range.php +0 -47
assets/libraries/scssphp_legacy/src/Block.php +0 -55
assets/libraries/scssphp_legacy/src/Colors.php +0 -178
assets/libraries/scssphp_legacy/src/Compiler.php +0 -4924
assets/libraries/scssphp_legacy/src/Compiler/Environment.php +0 -42
assets/libraries/scssphp_legacy/src/Formatter.php +0 -202
assets/libraries/scssphp_legacy/src/Formatter/Compact.php +0 -44
assets/libraries/scssphp_legacy/src/Formatter/Compressed.php +0 -84
assets/libraries/scssphp_legacy/src/Formatter/Crunched.php +0 -71
assets/libraries/scssphp_legacy/src/Formatter/Debug.php +0 -118
assets/libraries/scssphp_legacy/src/Formatter/Expanded.php +0 -67
assets/libraries/scssphp_legacy/src/Formatter/Nested.php +0 -197
assets/libraries/scssphp_legacy/src/Formatter/OutputBlock.php +0 -50
assets/libraries/scssphp_legacy/src/Node.php +0 -35
assets/libraries/scssphp_legacy/src/Node/Number.php +0 -236
assets/libraries/scssphp_legacy/src/Parser.php +0 -2377
assets/libraries/scssphp_legacy/src/Server.php +0 -459
assets/libraries/scssphp_legacy/src/Type.php +0 -68
assets/libraries/scssphp_legacy/src/Util.php +0 -55
assets/libraries/scssphp_legacy/src/Version.php +0 -22
assets/libraries/simplehtmldom/CHANGELOG.md +265 -0
assets/libraries/simplehtmldom/LICENSE +21 -0
assets/libraries/simplehtmldom/phpcompatibility.xml +11 -0
assets/libraries/simplehtmldom/phpcs.xml +48 -0
assets/libraries/simplehtmldom/simple_html_dom.php +2354 -1749
classes/maxCSSParser.php +32 -13
classes/maxbuttons-admin-helper.php +2 -2
classes/maxbuttons-class.php +0 -8
maxbuttons.php +3 -20
readme.txt +7 -1

assets/libraries/{scssphp_legacy → scssphp}/LICENSE.md RENAMED Viewed

	@@ -1,4 +1,4 @@
1	- Copyright (c) 2015 Leaf Corcoran, http://~~leafo~~.github.io/scssphp
2
3	Permission is hereby granted, free of charge, to any person obtaining
4	a copy of this software and associated documentation files (the


1	+ Copyright (c) 2015 Leaf Corcoran, http://scssphp.github.io/scssphp
2
3	Permission is hereby granted, free of charge, to any person obtaining
4	a copy of this software and associated documentation files (the

assets/libraries/{scssphp_legacy → scssphp}/README.md RENAMED Viewed

	@@ -1,12 +1,12 @@
1	# scssphp
2	- ### <http://~~leafo~~.github.io/scssphp>
3
4	- [![Build](https://travis-ci.org/~~leafo~~/scssphp.svg?branch=master)](http://travis-ci.org/~~leafo~~/scssphp)
5	- [![License](https://poser.pugx.org/~~leafo~~/scssphp/license~~.svg~~)](https://packagist.org/packages/~~leafo~~/scssphp)
6
7	`scssphp` is a compiler for SCSS written in PHP.
8
9	- Checkout the homepage, <http://~~leafo~~.github.io/scssphp>, for directions on how to use.
10
11	## Running Tests
12
	@@ -24,7 +24,6 @@ There are several tests in the `tests/` directory:
24	* `InputTest.php` compiles every `.scss` file in the `tests/inputs` directory
25	then compares to the respective `.css` file in the `tests/outputs` directory.
26	* `ScssTest.php` extracts (ruby) `scss` tests from the `tests/scss_test.rb` file.
27	- * `ServerTest.php` contains functional tests for the `Server` class.
28
29	When changing any of the tests in `tests/inputs`, the tests will most likely
30	fail because the output has changed. Once you verify that the output is correct


1	# scssphp
2	+ ### <http://scssphp.github.io/scssphp>
3
4	+ [![Build](https://travis-ci.org/scssphp/scssphp.svg?branch=master)](http://travis-ci.org/scssphp/scssphp)
5	+ [![License](https://poser.pugx.org/scssphp/scssphp/license)](https://packagist.org/packages/scssphp/scssphp)
6
7	`scssphp` is a compiler for SCSS written in PHP.
8
9	+ Checkout the homepage, <http://scssphp.github.io/scssphp>, for directions on how to use.
10
11	## Running Tests
12

24	* `InputTest.php` compiles every `.scss` file in the `tests/inputs` directory
25	then compares to the respective `.css` file in the `tests/outputs` directory.
26	* `ScssTest.php` extracts (ruby) `scss` tests from the `tests/scss_test.rb` file.

27
28	When changing any of the tests in `tests/inputs`, the tests will most likely
29	fail because the output has changed. Once you verify that the output is correct

assets/libraries/scssphp/scss.inc.php CHANGED Viewed

	@@ -1,11 +1,12 @@
1	<?php
2	- if (version_compare(PHP_VERSION, '5.4') < 0) {
3	- throw new \Exception('scssphp requires PHP 5.4 or above');
4	}
5
6	- if (! class_exists('~~Leafo~~\ScssPhp\Version', false)) {
7	include_once __DIR__ . '/src/Base/Range.php';
8	include_once __DIR__ . '/src/Block.php';

9	include_once __DIR__ . '/src/Colors.php';
10	include_once __DIR__ . '/src/Compiler.php';
11	include_once __DIR__ . '/src/Compiler/Environment.php';
	@@ -24,7 +25,8 @@ if (! class_exists('Leafo\ScssPhp\Version', false)) {
24	include_once __DIR__ . '/src/Node.php';
25	include_once __DIR__ . '/src/Node/Number.php';
26	include_once __DIR__ . '/src/Parser.php';
27	- include_once __DIR__ . '/src/SourceMap/~~Base64VLQEncoder~~.php';

28	include_once __DIR__ . '/src/SourceMap/SourceMapGenerator.php';
29	include_once __DIR__ . '/src/Type.php';
30	include_once __DIR__ . '/src/Util.php';


1	<?php
2	+ if (version_compare(PHP_VERSION, '5.6') < 0) {
3	+ throw new \Exception('scssphp requires PHP 5.6 or above');
4	}
5
6	+ if (! class_exists('ScssPhp\ScssPhp\Version', false)) {
7	include_once __DIR__ . '/src/Base/Range.php';
8	include_once __DIR__ . '/src/Block.php';
9	+ include_once __DIR__ . '/src/Cache.php';
10	include_once __DIR__ . '/src/Colors.php';
11	include_once __DIR__ . '/src/Compiler.php';
12	include_once __DIR__ . '/src/Compiler/Environment.php';

25	include_once __DIR__ . '/src/Node.php';
26	include_once __DIR__ . '/src/Node/Number.php';
27	include_once __DIR__ . '/src/Parser.php';
28	+ include_once __DIR__ . '/src/SourceMap/Base64.php';
29	+ include_once __DIR__ . '/src/SourceMap/Base64VLQ.php';
30	include_once __DIR__ . '/src/SourceMap/SourceMapGenerator.php';
31	include_once __DIR__ . '/src/Type.php';
32	include_once __DIR__ . '/src/Util.php';

assets/libraries/scssphp/src/Base/Range.php CHANGED Viewed

	@@ -2,14 +2,14 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2015-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp\Base;
13
14	/**
15	* Range


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2015-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp\Base;
13
14	/**
15	* Range

assets/libraries/scssphp/src/Block.php CHANGED Viewed

	@@ -2,14 +2,14 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp;
13
14	/**
15	* Block
	@@ -24,7 +24,7 @@ class Block
24	public $type;
25
26	/**
27	- * @var \~~Leafo~~\ScssPhp\Block
28	*/
29	public $parent;
30
	@@ -62,4 +62,9 @@ class Block
62	* @var array
63	*/
64	public $children;





65	}


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp;
13
14	/**
15	* Block

24	public $type;
25
26	/**
27	+ * @var \ScssPhp\ScssPhp\Block
28	*/
29	public $parent;
30

62	* @var array
63	*/
64	public $children;
65	+
66	+ /**
67	+ * @var \ScssPhp\ScssPhp\Block
68	+ */
69	+ public $selfParent;
70	}

assets/libraries/scssphp/src/Cache.php ADDED Viewed

	@@ -0,0 +1,239 @@


1	+ <?php
2	+ /**
3	+ * SCSSPHP
4	+ *
5	+ * @copyright 2012-2020 Leaf Corcoran
6	+ *
7	+ * @license http://opensource.org/licenses/MIT MIT
8	+ *
9	+ * @link http://scssphp.github.io/scssphp
10	+ */
11	+
12	+ namespace ScssPhp\ScssPhp;
13	+
14	+ use Exception;
15	+
16	+ /**
17	+ * The scss cache manager.
18	+ *
19	+ * In short:
20	+ *
21	+ * allow to put in cache/get from cache a generic result from a known operation on a generic dataset,
22	+ * taking in account options that affects the result
23	+ *
24	+ * The cache manager is agnostic about data format and only the operation is expected to be described by string
25	+ *
26	+ */
27	+
28	+ /**
29	+ * SCSS cache
30	+ *
31	+ * @author Cedric Morin
32	+ */
33	+ class Cache
34	+ {
35	+ const CACHE_VERSION = 1;
36	+
37	+ // directory used for storing data
38	+ public static $cacheDir = false;
39	+
40	+ // prefix for the storing data
41	+ public static $prefix = 'scssphp_';
42	+
43	+ // force a refresh : 'once' for refreshing the first hit on a cache only, true to never use the cache in this hit
44	+ public static $forceRefresh = false;
45	+
46	+ // specifies the number of seconds after which data cached will be seen as 'garbage' and potentially cleaned up
47	+ public static $gcLifetime = 604800;
48	+
49	+ // array of already refreshed cache if $forceRefresh==='once'
50	+ protected static $refreshed = [];
51	+
52	+ /**
53	+ * Constructor
54	+ *
55	+ * @param array $options
56	+ */
57	+ public function __construct($options)
58	+ {
59	+ // check $cacheDir
60	+ if (isset($options['cacheDir'])) {
61	+ self::$cacheDir = $options['cacheDir'];
62	+ }
63	+
64	+ if (empty(self::$cacheDir)) {
65	+ throw new Exception('cacheDir not set');
66	+ }
67	+
68	+ if (isset($options['prefix'])) {
69	+ self::$prefix = $options['prefix'];
70	+ }
71	+
72	+ if (empty(self::$prefix)) {
73	+ throw new Exception('prefix not set');
74	+ }
75	+
76	+ if (isset($options['forceRefresh'])) {
77	+ self::$forceRefresh = $options['forceRefresh'];
78	+ }
79	+
80	+ self::checkCacheDir();
81	+ }
82	+
83	+ /**
84	+ * Get the cached result of $operation on $what,
85	+ * which is known as dependant from the content of $options
86	+ *
87	+ * @param string $operation parse, compile...
88	+ * @param mixed $what content key (e.g., filename to be treated)
89	+ * @param array $options any option that affect the operation result on the content
90	+ * @param integer $lastModified last modified timestamp
91	+ *
92	+ * @return mixed
93	+ *
94	+ * @throws \Exception
95	+ */
96	+ public function getCache($operation, $what, $options = [], $lastModified = null)
97	+ {
98	+ $fileCache = self::$cacheDir . self::cacheName($operation, $what, $options);
99	+
100	+ if (((self::$forceRefresh === false) \|\| (self::$forceRefresh === 'once' &&
101	+ isset(self::$refreshed[$fileCache]))) && file_exists($fileCache)
102	+ ) {
103	+ $cacheTime = filemtime($fileCache);
104	+
105	+ if ((is_null($lastModified) \|\| $cacheTime > $lastModified) &&
106	+ $cacheTime + self::$gcLifetime > time()
107	+ ) {
108	+ $c = file_get_contents($fileCache);
109	+ $c = unserialize($c);
110	+
111	+ if (is_array($c) && isset($c['value'])) {
112	+ return $c['value'];
113	+ }
114	+ }
115	+ }
116	+
117	+ return null;
118	+ }
119	+
120	+ /**
121	+ * Put in cache the result of $operation on $what,
122	+ * which is known as dependant from the content of $options
123	+ *
124	+ * @param string $operation
125	+ * @param mixed $what
126	+ * @param mixed $value
127	+ * @param array $options
128	+ */
129	+ public function setCache($operation, $what, $value, $options = [])
130	+ {
131	+ $fileCache = self::$cacheDir . self::cacheName($operation, $what, $options);
132	+
133	+ $c = ['value' => $value];
134	+ $c = serialize($c);
135	+ file_put_contents($fileCache, $c);
136	+
137	+ if (self::$forceRefresh === 'once') {
138	+ self::$refreshed[$fileCache] = true;
139	+ }
140	+ }
141	+
142	+ /**
143	+ * Get the cache name for the caching of $operation on $what,
144	+ * which is known as dependant from the content of $options
145	+ *
146	+ * @param string $operation
147	+ * @param mixed $what
148	+ * @param array $options
149	+ *
150	+ * @return string
151	+ */
152	+ private static function cacheName($operation, $what, $options = [])
153	+ {
154	+ $t = [
155	+ 'version' => self::CACHE_VERSION,
156	+ 'operation' => $operation,
157	+ 'what' => $what,
158	+ 'options' => $options
159	+ ];
160	+
161	+ $t = self::$prefix
162	+ . sha1(json_encode($t))
163	+ . ".$operation"
164	+ . ".scsscache";
165	+
166	+ return $t;
167	+ }
168	+
169	+ /**
170	+ * Check that the cache dir exists and is writeable
171	+ *
172	+ * @throws \Exception
173	+ */
174	+ public static function checkCacheDir()
175	+ {
176	+ self::$cacheDir = str_replace('\\', '/', self::$cacheDir);
177	+ self::$cacheDir = rtrim(self::$cacheDir, '/') . '/';
178	+
179	+ if (! is_dir(self::$cacheDir)) {
180	+ if (! mkdir(self::$cacheDir)) {
181	+ throw new Exception('Cache directory couldn\'t be created: ' . self::$cacheDir);
182	+ }
183	+ }
184	+
185	+ if (! is_writable(self::$cacheDir)) {
186	+ throw new Exception('Cache directory isn\'t writable: ' . self::$cacheDir);
187	+ }
188	+ }
189	+
190	+ /**
191	+ * Delete unused cached files
192	+ */
193	+ public static function cleanCache()
194	+ {
195	+ static $clean = false;
196	+
197	+ if ($clean \|\| empty(self::$cacheDir)) {
198	+ return;
199	+ }
200	+
201	+ $clean = true;
202	+
203	+ // only remove files with extensions created by SCSSPHP Cache
204	+ // css files removed based on the list files
205	+ $removeTypes = ['scsscache' => 1];
206	+
207	+ $files = scandir(self::$cacheDir);
208	+
209	+ if (! $files) {
210	+ return;
211	+ }
212	+
213	+ $checkTime = time() - self::$gcLifetime;
214	+
215	+ foreach ($files as $file) {
216	+ // don't delete if the file wasn't created with SCSSPHP Cache
217	+ if (strpos($file, self::$prefix) !== 0) {
218	+ continue;
219	+ }
220	+
221	+ $parts = explode('.', $file);
222	+ $type = array_pop($parts);
223	+
224	+ if (! isset($removeTypes[$type])) {
225	+ continue;
226	+ }
227	+
228	+ $fullPath = self::$cacheDir . $file;
229	+ $mtime = filemtime($fullPath);
230	+
231	+ // don't delete if it's a relatively new file
232	+ if ($mtime > $checkTime) {
233	+ continue;
234	+ }
235	+
236	+ unlink($fullPath);
237	+ }
238	+ }
239	+ }

assets/libraries/scssphp/src/Colors.php CHANGED Viewed

@@ -2,14 +2,14 @@
             /**
              * SCSSPHP
+             *
-            -
             * @copyright 2012-2018 Leaf Corcoran
+             *
              * @license http://opensource.org/licenses/MIT MIT
+             *
-            -
             * @link http://leafo.github.io/scssphp
              */
-            -
            namespace Leafo\ScssPhp;
             /**
              * CSS Colors
@@ -25,7 +25,7 @@ class Colors
+                 *
                  * @var array
                  */
-            -
                public static $cssColors = [
                     'aliceblue' => '240,248,255',
                     'antiquewhite' => '250,235,215',
                     'aqua' => '0,255,255',
@@ -176,4 +176,71 @@ class Colors
                     'yellow' => '255,255,0',
                     'yellowgreen' => '154,205,50',
                 ];
+            }


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp;
13
14	/**
15	* CSS Colors

25	*
26	* @var array
27	*/
28	+ protected static $cssColors = [
29	'aliceblue' => '240,248,255',
30	'antiquewhite' => '250,235,215',
31	'aqua' => '0,255,255',

176	'yellow' => '255,255,0',
177	'yellowgreen' => '154,205,50',
178	];
179	+
180	+ /**
181	+ * Convert named color in a [r,g,b[,a]] array
182	+ *
183	+ * @param string $colorName
184	+ *
185	+ * @return array\|null
186	+ */
187	+ public static function colorNameToRGBa($colorName)
188	+ {
189	+ if (is_string($colorName) && isset(static::$cssColors[$colorName])) {
190	+ $rgba = explode(',', static::$cssColors[$colorName]);
191	+
192	+ // only case with opacity is transparent, with opacity=0, so we can intval on opacity also
193	+ $rgba = array_map('intval', $rgba);
194	+
195	+ return $rgba;
196	+ }
197	+
198	+ return null;
199	+ }
200	+
201	+ /**
202	+ * Reverse conversion : from RGBA to a color name if possible
203	+ *
204	+ * @param integer $r
205	+ * @param integer $g
206	+ * @param integer $b
207	+ * @param integer $a
208	+ *
209	+ * @return string\|null
210	+ */
211	+ public static function RGBaToColorName($r, $g, $b, $a = 1)
212	+ {
213	+ static $reverseColorTable = null;
214	+
215	+ if (! is_numeric($r) \|\| ! is_numeric($g) \|\| ! is_numeric($b) \|\| ! is_numeric($a)) {
216	+ return null;
217	+ }
218	+
219	+ if ($a < 1) {
220	+ # specific case we dont' revert according to spec
221	+ #if (! $a && ! $r && ! $g && ! $b) {
222	+ # return 'transparent';
223	+ #}
224	+
225	+ return null;
226	+ }
227	+
228	+ if (is_null($reverseColorTable)) {
229	+ $reverseColorTable = [];
230	+
231	+ foreach (static::$cssColors as $name => $rgb_str) {
232	+ $rgb_str = explode(',', $rgb_str);
233	+
234	+ if (count($rgb_str) == 3) {
235	+ $reverseColorTable[intval($rgb_str[0])][intval($rgb_str[1])][intval($rgb_str[2])] = $name;
236	+ }
237	+ }
238	+ }
239	+
240	+ if (isset($reverseColorTable[intval($r)][intval($g)][intval($b)])) {
241	+ return $reverseColorTable[intval($r)][intval($g)][intval($b)];
242	+ }
243	+
244	+ return null;
245	+ }
246	}

assets/libraries/scssphp/src/Compiler.php CHANGED Viewed

@@ -2,26 +2,27 @@
             /**
              * SCSSPHP
+             *
-            -
             * @copyright 2012-2018 Leaf Corcoran
+             *
              * @license http://opensource.org/licenses/MIT MIT
+             *
-            -
             * @link http://leafo.github.io/scssphp
              */
-            -
            namespace Leafo\ScssPhp;
-            -
-            -
            use Leafo\ScssPhp\Base\Range;
-            -
            use Leafo\ScssPhp\Block;
-            -
            use Leafo\ScssPhp\Colors;
-            -
            use Leafo\ScssPhp\Compiler\Environment;
-            -
            use Leafo\ScssPhp\Exception\CompilerException;
-            -
            use Leafo\ScssPhp\Formatter\OutputBlock;
-            -
            use Leafo\ScssPhp\Node;
-            -
            use Leafo\ScssPhp\SourceMap\SourceMapGenerator;
-            -
            use Leafo\ScssPhp\Type;
-            -
            use Leafo\ScssPhp\Parser;
-            -
            use Leafo\ScssPhp\Util;
             /**
              * The scss compiler and parser.
@@ -98,17 +99,17 @@ class Compiler
                     'function' => '^',
                 ];
-            -
                static public $true = [Type::T_KEYWORD, 'true'];
-            -
                static public $false = [Type::T_KEYWORD, 'false'];
-            -
                static public $null = [Type::T_NULL];
-            -
                static public $nullString = [Type::T_STRING, '', []];
                 static public $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'];
                 protected $importPaths = [''];
                 protected $importCache = [];
@@ -129,15 +130,15 @@ class Compiler
                 protected $sourceMapOptions = [];
                 /**
-            -
                 * @var string|\Leafo\ScssPhp\Formatter
                  */
-            -
                protected $formatter = 'Leafo\ScssPhp\Formatter\Nested';
                 protected $rootEnv;
                 protected $rootBlock;
                 /**
-            -
                 * @var \Leafo\ScssPhp\Compiler\Environment
                  */
                 protected $env;
                 protected $scope;
@@ -145,26 +146,67 @@ class Compiler
                 protected $charsetSeen;
                 protected $sourceNames;
-            -
                private $indentLevel;
-            -
                private $commentsSeen;
-            -
                private $extends;
-            -
                private $extendsMap;
-            -
                private $parsedFiles;
-            -
                private $parser;
-            -
                private $sourceIndex;
-            -
                private $sourceLine;
-            -
                private $sourceColumn;
-            -
                private $stderr;
-            -
                private $shouldEvaluate;
-            -
                private $ignoreErrors;
                 /**
                  * Constructor
                  */
-            -
                public function __construct()
+                {
                     $this->parsedFiles = [];
                     $this->sourceNames = [];
+                }
                 /**
@@ -179,8 +221,28 @@ class Compiler
                  */
                 public function compile($code, $path = null)
+                {
                     $this->indentLevel    = -1;
-            -
                    $this->commentsSeen   = [];
                     $this->extends        = [];
                     $this->extendsMap     = [];
                     $this->sourceIndex    = null;
@@ -191,11 +253,9 @@ class Compiler
                     $this->storeEnv       = null;
                     $this->charsetSeen    = null;
                     $this->shouldEvaluate = null;
-            -
                    $this->stderr         = fopen('php://stderr', 'w');
                     $this->parser = $this->parserFactory($path);
-            -
                    $tree = $this->parser->parse($code);
-            -
                     $this->parser = null;
                     $this->formatter = new $this->formatter();
@@ -236,6 +296,15 @@ class Compiler
                         $out .= sprintf('/*# sourceMappingURL=%s */', $sourceMapUrl);
+                    }
                     return $out;
+                }
@@ -244,14 +313,13 @@ class Compiler
+                 *
                  * @param string $path
+                 *
-            -
                 * @return \Leafo\ScssPhp\Parser
                  */
                 protected function parserFactory($path)
+                {
-            -
                    $parser = new Parser($path, count($this->sourceNames), $this->encoding);
                     $this->sourceNames[] = $path;
-            -
                     $this->addParsedFile($path);
                     return $parser;
@@ -279,9 +347,9 @@ class Compiler
                 /**
                  * Push extends
+                 *
-            -
                 * @param array     $target
-            -
                 * @param array     $origin
-            -
                 * @param \stdClass $block
                  */
                 protected function pushExtends($target, $origin, $block)
+                {
@@ -307,17 +375,17 @@ class Compiler
                  * @param string $type
                  * @param array  $selectors
+                 *
-            -
                 * @return \Leafo\ScssPhp\Formatter\OutputBlock
                  */
                 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;
                     if ($this->env->block instanceof Block) {
                         $out->sourceName   = $this->env->block->sourceName;
@@ -335,7 +403,7 @@ class Compiler
                 /**
                  * Compile root
+                 *
-            -
                 * @param \Leafo\ScssPhp\Block $rootBlock
                  */
                 protected function compileRoot(Block $rootBlock)
+                {
@@ -374,8 +442,8 @@ class Compiler
                 /**
                  * Flatten selectors
+                 *
-            -
                 * @param \Leafo\ScssPhp\Formatter\OutputBlock $block
-            -
                 * @param string                               $parentKey
                  */
                 protected function flattenSelectors(OutputBlock $block, $parentKey = null)
+                {
@@ -430,6 +498,40 @@ class Compiler
+                    }
+                }
                 /**
                  * Match extends
+                 *
@@ -440,32 +542,60 @@ class Compiler
                  */
                 protected function matchExtends($selector, &$out, $from = 0, $initial = true)
+                {
                     foreach ($selector as $i => $part) {
                         if ($i < $from) {
                             continue;
+                        }
-            -
                        if ($this->matchExtendsSingle($part, $origin)) {
-            -
                            $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 ($initial) {
                                     while ($k < $i && isset($new[$k]) && $selector[$k] === $new[$k]) {
                                         $k++;
+                                    }
+                                }
                                 $replacement = [];
                                 $tempReplacement = $k > 0 ? array_slice($new, $k) : $new;
                                 for ($l = count($tempReplacement) - 1; $l >= 0; $l--) {
-            -
                                    $slice = $tempReplacement[$l];
                                     array_unshift($replacement, $slice);
                                     if (! $this->isImmediateRelationshipCombinator(end($slice))) {
@@ -489,33 +619,93 @@ class Compiler
                                     continue;
+                                }
-            -
                                $out[] = $result;
                                 // recursively check for more matches
-            -
                                $this->matchExtends($result, $out, count($before) + count($mergedBefore), false);
                                 // selector sequence merging
                                 if (! empty($before) && count($new) > 1) {
-            -
                                    $sharedParts = $k > 0 ? array_slice($before, 0, $k) : [];
                                     $postSharedParts = $k > 0 ? array_slice($before, $k) : $before;
-            -
                                    list($injectBetweenSharedParts, $nonBreakable2) = $this->extractRelationshipFromFragment($afterBefore);
                                     $result2 = array_merge(
-            -
                                        $sharedParts,
-            -
                                        $injectBetweenSharedParts,
                                         $postSharedParts,
-            -
                                        $nonBreakable2,
                                         $nonBreakableBefore,
                                         $replacement,
                                         $after
                                     );
-            -
                                    $out[] = $result2;
+                                }
+                            }
+                        }
+                    }
+                }
                 /**
@@ -523,14 +713,20 @@ class Compiler
+                 *
                  * @param array $rawSingle
                  * @param array $outOrigin
+                 *
                  * @return boolean
                  */
-            -
                protected function matchExtendsSingle($rawSingle, &$outOrigin)
+                {
                     $counts = [];
                     $single = [];
                     foreach ($rawSingle as $part) {
                         // matches Number
                         if (! is_string($part)) {
@@ -551,20 +747,46 @@ class Compiler
                         $extendingDecoratedTag = preg_match('/^[a-z0-9]+$/i', $single[0], $matches) ? $matches[0] : false;
+                    }
-            -
                    foreach ($single as $part) {
                         if (isset($this->extendsMap[$part])) {
                             foreach ($this->extendsMap[$part] as $idx) {
                                 $counts[$idx] = isset($counts[$idx]) ? $counts[$idx] + 1 : 1;
+                            }
+                        }
+                    }
-            -
                    $outOrigin = [];
-            -
                    $found = false;
-            -
                     foreach ($counts as $idx => $count) {
                         list($target, $origin, /* $block */) = $this->extends[$idx];
                         // check count
                         if ($count !== count($target)) {
                             continue;
@@ -605,7 +827,6 @@ class Compiler
                     return $found;
+                }
-            -
                 /**
                  * Extract a relationship from the fragment.
+                 *
@@ -615,18 +836,20 @@ class Compiler
                  * the rest.
+                 *
                  * @param array $fragment The selector fragment maybe ending with a direction relationship combinator.
                  * @return array The selector without the relationship fragment if any, the relationship fragment.
                  */
                 protected function extractRelationshipFromFragment(array $fragment)
+                {
                     $parents = [];
                     $children = [];
                     $j = $i = count($fragment);
                     for (;;) {
                         $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;
@@ -648,22 +871,30 @@ class Compiler
                  */
                 protected function combineSelectorSingle($base, $other)
+                {
-            -
                    $tag = [];
-            -
                    $out = [];
-            -
                    $wasTag = true;
-            -
                    foreach ([$base, $other] as $single) {
                         foreach ($single as $part) {
-            -
                            if (preg_match('/^[\[.:#]/', $part)) {
                                 $out[] = $part;
                                 $wasTag = false;
                             } elseif (preg_match('/^[^_-]/', $part)) {
                                 $tag[] = $part;
                                 $wasTag = true;
                             } elseif ($wasTag) {
                                 $tag[count($tag) - 1] .= $part;
                             } else {
-            -
                                $out[count($out) - 1] .= $part;
+                            }
+                        }
+                    }
@@ -671,6 +902,9 @@ class Compiler
                     if (count($tag)) {
                         array_unshift($out, $tag[0]);
+                    }
                     return $out;
+                }
@@ -678,19 +912,24 @@ class Compiler
                 /**
                  * Compile media
+                 *
-            -
                 * @param \Leafo\ScssPhp\Block $media
                  */
                 protected function compileMedia(Block $media)
+                {
                     $this->pushEnv($media);
-            -
                    $mediaQuery = $this->compileMediaQuery($this->multiplyMedia($this->env));
-            -
-            -
                    if (! empty($mediaQuery)) {
-            -
                        $this->scope = $this->makeOutputBlock(Type::T_MEDIA, [$mediaQuery]);
                         $parentScope = $this->mediaParent($this->scope);
-            -
                        $parentScope->children[] = $this->scope;
                         // top level properties in a media cause it to be wrapped
                         $needsWrap = false;
@@ -720,11 +959,35 @@ class Compiler
                             $wrapped->children     = $media->children;
                             $media->children = [[Type::T_BLOCK, $wrapped]];
+                        }
                         $this->compileChildrenNoReturn($media->children, $this->scope);
-            -
                        $this->scope = $this->scope->parent;
+                    }
                     $this->popEnv();
@@ -733,9 +996,9 @@ class Compiler
                 /**
                  * Media parent
+                 *
-            -
                 * @param \Leafo\ScssPhp\Formatter\OutputBlock $scope
+                 *
-            -
                 * @return \Leafo\ScssPhp\Formatter\OutputBlock
                  */
                 protected function mediaParent(OutputBlock $scope)
+                {
@@ -753,33 +1016,42 @@ class Compiler
                 /**
                  * Compile directive
+                 *
-            -
                 * @param \Leafo\ScssPhp\Block $block
                  */
-            -
                protected function compileDirective(Block $block)
+                {
-            -
                    $s = '@' . $block->name;
-            -
                    if (! empty($block->value)) {
-            -
                        $s .= ' ' . $this->compileValue($block->value);
-            -
                    }
-            -
                    if ($block->name === 'keyframes' || substr($block->name, -10) === '-keyframes') {
-            -
                        $this->compileKeyframeBlock($block, [$s]);
-            -
                    } else {
-            -
                        $this->compileNestedBlock($block, [$s]);
+                    }
+                }
                 /**
                  * Compile at-root
+                 *
-            -
                 * @param \Leafo\ScssPhp\Block $block
                  */
                 protected function compileAtRoot(Block $block)
+                {
                     $env     = $this->pushEnv($block);
                     $envs    = $this->compactEnv($env);
-            -
                    $without = isset($block->with) ? $this->compileWith($block->with) : static::WITH_RULE;
                     // wrap inline selector
                     if ($block->selector) {
@@ -792,18 +1064,29 @@ class Compiler
                         $wrapped->comments     = [];
                         $wrapped->parent       = $block;
                         $wrapped->children     = $block->children;
                         $block->children = [[Type::T_BLOCK, $wrapped]];
+                    }
-            -
                    $this->env = $this->filterWithout($envs, $without);
-            -
                    $newBlock  = $this->spliceTree($envs, $block, $without);
                     $saveScope   = $this->scope;
-            -
                    $this->scope = $this->rootBlock;
-            -
                    $this->compileChild($newBlock, $this->scope);
                     $this->scope = $saveScope;
                     $this->env   = $this->extractEnv($envs);
@@ -811,152 +1094,190 @@ class Compiler
+                }
                 /**
-            -
                 * Splice parse tree
+                 *
-            -
                 * @param array                $envs
-            -
                 * @param \Leafo\ScssPhp\Block $block
-            -
                 * @param integer              $without
+                 *
-            -
                 * @return array
                  */
-            -
                private function spliceTree($envs, Block $block, $without)
+                {
-            -
                    $newBlock = null;
-            -
                    foreach ($envs as $e) {
-            -
                        if (! isset($e->block)) {
-            -
                            continue;
-            -
                        }
-            -
                        if ($e->block === $block) {
-            -
                            continue;
+                        }
-            -
                        if (isset($e->block->type) && $e->block->type === Type::T_AT_ROOT) {
-            -
                            continue;
+                        }
-            -
                        if ($e->block && $this->isWithout($without, $e->block)) {
-            -
                            continue;
+                        }
-            -
                        $b = new Block;
-            -
                        $b->sourceName   = $e->block->sourceName;
-            -
                        $b->sourceIndex  = $e->block->sourceIndex;
-            -
                        $b->sourceLine   = $e->block->sourceLine;
-            -
                        $b->sourceColumn = $e->block->sourceColumn;
-            -
                        $b->selectors    = [];
-            -
                        $b->comments     = $e->block->comments;
-            -
                        $b->parent       = null;
-            -
                        if ($newBlock) {
-            -
                            $type = isset($newBlock->type) ? $newBlock->type : Type::T_BLOCK;
-            -
                            $b->children = [[$type, $newBlock]];
-            -
                            $newBlock->parent = $b;
-            -
                        } elseif (count($block->children)) {
-            -
                            foreach ($block->children as $child) {
-            -
                                if ($child[0] === Type::T_BLOCK) {
-            -
                                    $child[1]->parent = $b;
-            -
                                }
-            -
                            }
-            -
                            $b->children = $block->children;
-            -
                        }
-            -
                        if (isset($e->block->type)) {
-            -
                            $b->type = $e->block->type;
-            -
                        }
-            -
                        if (isset($e->block->name)) {
-            -
                            $b->name = $e->block->name;
-            -
                        }
-            -
                        if (isset($e->block->queryList)) {
-            -
                            $b->queryList = $e->block->queryList;
+                        }
-            -
                        if (isset($e->block->value)) {
-            -
                            $b->value = $e->block->value;
-            -
                        }
-            -
                        $newBlock = $b;
+                    }
-            -
                    $type = isset($newBlock->type) ? $newBlock->type : Type::T_BLOCK;
-            -
                    return [$type, $newBlock];
+                }
                 /**
-            -
                 * Compile @at-root's with: inclusion / without: exclusion into filter flags
+                 *
-            -
                 * @param array $with
+                 *
-            -
                 * @return integer
                  */
-            -
                private function compileWith($with)
+                {
-            -
                    static $mapping = [
-            -
                        'rule'     => self::WITH_RULE,
-            -
                        'media'    => self::WITH_MEDIA,
-            -
                        'supports' => self::WITH_SUPPORTS,
-            -
                        'all'      => self::WITH_ALL,
-            -
                    ];
-            -
                    // exclude selectors by default
-            -
                    $without = static::WITH_RULE;
-            -
                    if ($this->libMapHasKey([$with, static::$with])) {
-            -
                        $without = static::WITH_ALL;
-            -
-            -
                        $list = $this->coerceList($this->libMapGet([$with, static::$with]));
-            -
-            -
                        foreach ($list[2] as $item) {
-            -
                            $keyword = $this->compileStringContent($this->coerceString($item));
-            -
                            if (array_key_exists($keyword, $mapping)) {
-            -
                                $without &= ~($mapping[$keyword]);
+                            }
+                        }
-            -
                    }
-            -
                    if ($this->libMapHasKey([$with, static::$without])) {
-            -
                        $without = 0;
-            -
                        $list = $this->coerceList($this->libMapGet([$with, static::$without]));
-            -
-            -
                        foreach ($list[2] as $item) {
-            -
                            $keyword = $this->compileStringContent($this->coerceString($item));
-            -
                            if (array_key_exists($keyword, $mapping)) {
-            -
                                $without |= $mapping[$keyword];
+                            }
+                        }
+                    }
-            -
                    return $without;
+                }
                 /**
                  * Filter env stack
+                 *
                  * @param array   $envs
-            -
                 * @param integer $without
+                 *
-            -
                 * @return \Leafo\ScssPhp\Compiler\Environment
                  */
-            -
                private function filterWithout($envs, $without)
+                {
                     $filtered = [];
                     foreach ($envs as $e) {
-            -
                        if ($e->block && $this->isWithout($without, $e->block)) {
-            -
                            continue;
-            -
                        }
-            -
                        $filtered[] = $e;
+                    }
                     return $this->extractEnv($filtered);
@@ -965,31 +1286,76 @@ class Compiler
                 /**
                  * Filter WITH rules
+                 *
-            -
                 * @param integer              $without
-            -
                 * @param \Leafo\ScssPhp\Block $block
+                 *
                  * @return boolean
                  */
-            -
                private function isWithout($without, Block $block)
+                {
-            -
                    if ((($without & static::WITH_RULE) && isset($block->selectors)) ||
-            -
                        (($without & static::WITH_MEDIA) &&
-            -
                            isset($block->type) && $block->type === Type::T_MEDIA) ||
-            -
                        (($without & static::WITH_SUPPORTS) &&
-            -
                            isset($block->type) && $block->type === Type::T_DIRECTIVE &&
-            -
                            isset($block->name) && $block->name === 'supports')
-            -
                    ) {
-            -
                        return true;
+                    }
-            -
                    return false;
+                }
                 /**
                  * Compile keyframe block
+                 *
-            -
                 * @param \Leafo\ScssPhp\Block $block
-            -
                 * @param array                $selectors
                  */
                 protected function compileKeyframeBlock(Block $block, $selectors)
+                {
@@ -1013,11 +1379,45 @@ class Compiler
                     $this->popEnv();
+                }
                 /**
                  * Compile nested block
+                 *
-            -
                 * @param \Leafo\ScssPhp\Block $block
-            -
                 * @param array                $selectors
                  */
                 protected function compileNestedBlock(Block $block, $selectors)
+                {
@@ -1026,6 +1426,35 @@ class Compiler
                     $this->scope = $this->makeOutputBlock($block->type, $selectors);
                     $this->scope->parent->children[] = $this->scope;
                     $this->compileChildrenNoReturn($block->children, $this->scope);
                     $this->scope = $this->scope->parent;
@@ -1049,7 +1478,7 @@ class Compiler
+                 *
                  * @see Compiler::compileChild()
+                 *
-            -
                 * @param \Leafo\ScssPhp\Block $block
                  */
                 protected function compileBlock(Block $block)
+                {
@@ -1085,17 +1514,63 @@ class Compiler
                     $this->scope->children[] = $out;
                     if (count($block->children)) {
-            -
                        $out->selectors = $this->multiplySelectors($env);
-            -
                        $this->compileChildrenNoReturn($block->children, $out);
-            -
                    }
-            -
                    $this->formatter->stripSemicolon($out->lines);
-            -
                    $this->popEnv();
-            -
                }
-            -
                /**
                  * Compile root level comment
+                 *
                  * @param array $block
@@ -1103,7 +1578,8 @@ class Compiler
                 protected function compileComment($block)
+                {
                     $out = $this->makeOutputBlock(Type::T_COMMENT);
-            -
                    $out->lines[] = $block[1];
                     $this->scope->children[] = $out;
+                }
@@ -1122,8 +1598,9 @@ class Compiler
                     // after evaluating interpolates, we might need a second pass
                     if ($this->shouldEvaluate) {
-            -
                        $buffer = $this->collapseSelectors($selectors);
-            -
                        $parser = $this->parserFactory(__METHOD__);
                         if ($parser->parseSelector($buffer, $newSelectors)) {
                             $selectors = array_map([$this, 'evalSelector'], $newSelectors);
@@ -1176,28 +1653,89 @@ class Compiler
                 /**
                  * Collapse selectors
+                 *
-            -
                 * @param array $selectors
+                 *
                  * @return string
                  */
-            -
                protected function collapseSelectors($selectors)
+                {
                     $parts = [];
                     foreach ($selectors as $selector) {
-            -
                        $output = '';
-            -
                        array_walk_recursive(
-            -
                            $selector,
-            -
                            function ($value, $key) use (&$output) {
-            -
                                $output .= $value;
+                            }
-            -
                        );
                         $parts[] = $output;
+                    }
-            -
                    return implode(', ', $parts);
+                }
                 /**
@@ -1304,16 +1842,43 @@ class Compiler
                     return false;
+                }
                 /**
                  * Compile children and return result
+                 *
-            -
                 * @param array                                $stms
-            -
                 * @param \Leafo\ScssPhp\Formatter\OutputBlock $out
+                 *
-            -
                 * @return array
                  */
-            -
                protected function compileChildren($stms, OutputBlock $out)
+                {
                     foreach ($stms as $stm) {
                         $ret = $this->compileChild($stm, $out);
@@ -1321,20 +1886,38 @@ class Compiler
                             return $ret;
+                        }
+                    }
+                }
                 /**
                  * Compile children and throw exception if unexpected @return
+                 *
-            -
                 * @param array                                $stms
-            -
                 * @param \Leafo\ScssPhp\Formatter\OutputBlock $out
+                 *
                  * @throws \Exception
                  */
-            -
                protected function compileChildrenNoReturn($stms, OutputBlock $out)
+                {
                     foreach ($stms as $stm) {
-            -
                        $ret = $this->compileChild($stm, $out);
                         if (isset($ret)) {
                             $this->throwError('@return may only be used within a function');
@@ -1342,6 +1925,74 @@ class Compiler
                             return;
+                        }
+                    }
+                }
                 /**
@@ -1349,31 +2000,76 @@ class Compiler
+                 *
                  * @param array $queryList
+                 *
-            -
                 * @return string
                  */
                 protected function compileMediaQuery($queryList)
+                {
-            -
                    $out = '@media';
-            -
                    $first = true;
                     foreach ($queryList as $query) {
                         $type = null;
                         $parts = [];
                         foreach ($query as $q) {
                             switch ($q[0]) {
                                 case Type::T_MEDIA_TYPE:
-            -
                                    if ($type) {
-            -
                                        $type = $this->mergeMediaTypes(
-            -
                                            $type,
-            -
                                            array_map([$this, 'compileValue'], array_slice($q, 1))
-            -
                                        );
-            -
                                        if (empty($type)) { // merge failed
-            -
                                            return null;
+                                        }
-            -
                                    } else {
-            -
                                        $type = array_map([$this, 'compileValue'], array_slice($q, 1));
+                                    }
                                     break;
@@ -1402,20 +2098,34 @@ class Compiler
+                        }
                         if (! empty($parts)) {
-            -
                            if ($first) {
-            -
                                $first = false;
-            -
                                $out .= ' ';
-            -
                            } else {
-            -
                                $out .= $this->formatter->tagSeparator;
+                            }
-            -
                            $out .= implode(' and ', $parts);
+                        }
+                    }
                     return $out;
+                }
                 protected function mergeDirectRelationships($selectors1, $selectors2)
+                {
                     if (empty($selectors1) || empty($selectors2)) {
@@ -1425,7 +2135,7 @@ class Compiler
                     $part1 = end($selectors1);
                     $part2 = end($selectors2);
-            -
                    if (! $this->isImmediateRelationshipCombinator($part1[0]) || $part1 !== $part2) {
                         return array_merge($selectors1, $selectors2);
+                    }
@@ -1435,13 +2145,18 @@ class Compiler
                         $part1 = array_pop($selectors1);
                         $part2 = array_pop($selectors2);
-            -
                        if ($this->isImmediateRelationshipCombinator($part1[0]) && $part1 !== $part2) {
-            -
                            $merged = array_merge($selectors1, [$part1], $selectors2, [$part2], $merged);
                             break;
+                        }
                         array_unshift($merged, $part1);
-            -
                        array_unshift($merged, [array_pop($selectors1)[0] . array_pop($selectors2)[0]]);
                     } while (! empty($selectors1) && ! empty($selectors2));
                     return $merged;
@@ -1465,23 +2180,19 @@ class Compiler
                         return $type1;
+                    }
-            -
                    $m1 = '';
-            -
                    $t1 = '';
-            -
                     if (count($type1) > 1) {
-            -
                        $m1= strtolower($type1[0]);
-            -
                        $t1= strtolower($type1[1]);
                     } else {
                         $t1 = strtolower($type1[0]);
+                    }
-            -
                    $m2 = '';
-            -
                    $t2 = '';
-            -
                     if (count($type2) > 1) {
                         $m2 = strtolower($type2[0]);
                         $t2 = strtolower($type2[1]);
                     } else {
                         $t2 = strtolower($type2[0]);
+                    }
@@ -1516,13 +2227,13 @@ class Compiler
                 /**
                  * Compile import; returns true if the value was something that could be imported
+                 *
-            -
                 * @param array   $rawPath
-            -
                 * @param array   $out
-            -
                 * @param boolean $once
+                 *
                  * @return boolean
                  */
-            -
                protected function compileImport($rawPath, $out, $once = false)
+                {
                     if ($rawPath[0] === Type::T_STRING) {
                         $path = $this->compileStringContent($rawPath);
@@ -1536,6 +2247,8 @@ class Compiler
                             return true;
+                        }
                         return false;
+                    }
@@ -1547,57 +2260,155 @@ class Compiler
                         foreach ($rawPath[2] as $path) {
                             if ($path[0] !== Type::T_STRING) {
                                 return false;
+                            }
+                        }
                         foreach ($rawPath[2] as $path) {
-            -
                            $this->compileImport($path, $out);
+                        }
                         return true;
+                    }
                     return false;
+                }
                 /**
                  * Compile child; returns a value to halt execution
+                 *
-            -
                 * @param array                                $child
-            -
                 * @param \Leafo\ScssPhp\Formatter\OutputBlock $out
+                 *
                  * @return array
                  */
                 protected function compileChild($child, OutputBlock $out)
+                {
-            -
                    $this->sourceIndex  = isset($child[Parser::SOURCE_INDEX]) ? $child[Parser::SOURCE_INDEX] : null;
-            -
                    $this->sourceLine   = isset($child[Parser::SOURCE_LINE]) ? $child[Parser::SOURCE_LINE] : -1;
-            -
                    $this->sourceColumn = isset($child[Parser::SOURCE_COLUMN]) ? $child[Parser::SOURCE_COLUMN] : -1;
                     switch ($child[0]) {
                         case Type::T_SCSSPHP_IMPORT_ONCE:
-            -
                            list(, $rawPath) = $child;
-            -
-            -
                            $rawPath = $this->reduce($rawPath);
-            -
                            if (! $this->compileImport($rawPath, $out, true)) {
-            -
                                $out->lines[] = '@import ' . $this->compileValue($rawPath) . ';';
-            -
                            }
                             break;
                         case Type::T_IMPORT:
-            -
                            list(, $rawPath) = $child;
-            -
-            -
                            $rawPath = $this->reduce($rawPath);
-            -
                            if (! $this->compileImport($rawPath, $out)) {
-            -
                                $out->lines[] = '@import ' . $this->compileValue($rawPath) . ';';
-            -
                            }
                             break;
                         case Type::T_DIRECTIVE:
-            -
                            $this->compileDirective($child[1]);
                             break;
                         case Type::T_AT_ROOT:
@@ -1615,8 +2426,7 @@ class Compiler
                         case Type::T_CHARSET:
                             if (! $this->charsetSeen) {
                                 $this->charsetSeen = true;
-            -
-            -
                                $out->lines[] = '@charset ' . $this->compileValue($child[1]) . ';';
+                            }
                             break;
@@ -1624,35 +2434,98 @@ class Compiler
                             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);
                                 if ($isGlobal) {
-            -
                                    $this->set($name[1], $this->reduce($value), false, $this->rootEnv);
                                     break;
+                                }
                                 $shouldSet = $isDefault &&
-            -
                                    (($result = $this->get($name[1], false)) === null
-            -
                                    || $result === static::$null);
                                 if (! $isDefault || $shouldSet) {
-            -
                                    $this->set($name[1], $this->reduce($value));
+                                }
                                 break;
+                            }
                             $compiledName = $this->compileValue($name);
-            -
                            // handle shorthand syntax: size / line-height
-            -
                            if ($compiledName === 'font') {
-            -
                                if ($value[0] === Type::T_EXPRESSION && $value[1] === '/') {
-            -
                                    $value = $this->expToString($value);
-            -
                                } elseif ($value[0] === Type::T_LIST) {
-            -
                                    foreach ($value[2] as &$item) {
                                         if ($item[0] === Type::T_EXPRESSION && $item[1] === '/') {
-            -
                                            $item = $this->expToString($item);
+                                        }
+                                    }
+                                }
@@ -1670,10 +2543,11 @@ class Compiler
                             $compiledValue = $this->compileValue($value);
-            -
                            $out->lines[] = $this->formatter->property(
                                 $compiledName,
                                 $compiledValue
                             );
                             break;
                         case Type::T_COMMENT:
@@ -1682,27 +2556,32 @@ class Compiler
                                 break;
+                            }
-            -
                            $out->lines[] = $child[1];
                             break;
                         case Type::T_MIXIN:
                         case Type::T_FUNCTION:
                             list(, $block) = $child;
-            -
-            -
                            $this->set(static::$namespaces[$block->type] . $block->name, $block);
                             break;
                         case Type::T_EXTEND:
-            -
                            list(, $selectors) = $child;
-            -
-            -
                            foreach ($selectors as $sel) {
                                 $results = $this->evalSelectors([$sel]);
                                 foreach ($results as $result) {
                                     // only use the first one
                                     $result = current($result);
-            -
                                    $this->pushExtends($result, $out->selectors, $child);
+                                }
+                            }
                             break;
@@ -1729,6 +2608,8 @@ class Compiler
                             $list = $this->coerceList($this->reduce($each->list));
                             $this->pushEnv();
                             foreach ($list[2] as $item) {
                                 if (count($each->vars) === 1) {
@@ -1745,7 +2626,14 @@ class Compiler
                                 if ($ret) {
                                     if ($ret[0] !== Type::T_CONTROL) {
                                         $this->popEnv();
                                         return $ret;
+                                    }
@@ -1755,8 +2643,15 @@ class Compiler
+                                    }
+                                }
+                            }
-            -
                             $this->popEnv();
                             break;
                         case Type::T_WHILE:
@@ -1829,31 +2724,12 @@ class Compiler
                             return $this->reduce($child[1], true);
                         case Type::T_NESTED_PROPERTY:
-            -
                            list(, $prop) = $child;
-            -
-            -
                            $prefixed = [];
-            -
                            $prefix = $this->compileValue($prop->prefix) . '-';
-            -
-            -
                            foreach ($prop->children as $child) {
-            -
                                switch ($child[0]) {
-            -
                                    case Type::T_ASSIGN:
-            -
                                        array_unshift($child[1][2], $prefix);
-            -
                                        break;
-            -
-            -
                                    case Type::T_NESTED_PROPERTY:
-            -
                                        array_unshift($child[1]->prefix[2], $prefix);
-            -
                                        break;
-            -
                                }
-            -
-            -
                                $prefixed[] = $child;
-            -
                            }
-            -
-            -
                            $this->compileChildrenNoReturn($prefixed, $out);
                             break;
                         case Type::T_INCLUDE:
                             // including a mixin
-            -
                            list(, $name, $argValues, $content) = $child;
                             $mixin = $this->get(static::$namespaces['mixin'] . $name, false);
@@ -1871,19 +2747,58 @@ class Compiler
                             $storeEnv = $this->storeEnv;
                             $this->storeEnv = $this->env;
-            -
                            if (isset($content)) {
-            -
                                $content->scope = $callingScope;
-            -
                                $this->setRaw(static::$namespaces['special'] . 'content', $content, $this->env);
-            -
                            }
-            -
                            if (isset($mixin->args)) {
                                 $this->applyArguments($mixin->args, $argValues);
+                            }
                             $this->env->marker = 'mixin';
-            -
                            $this->compileChildrenNoReturn($mixin->children, $out);
                             $this->storeEnv = $storeEnv;
@@ -1891,19 +2806,35 @@ class Compiler
                             break;
                         case Type::T_MIXIN_CONTENT:
-            -
                            $content = $this->get(static::$namespaces['special'] . 'content', false, $this->getStoreEnv())
-            -
                                     ?: $this->get(static::$namespaces['special'] . 'content', false, $this->env);
                             if (! $content) {
                                 $content = new \stdClass();
-            -
                                $content->scope = new \stdClass();
-            -
                                $content->children = $this->storeEnv->parent->block->children;
                                 break;
+                            }
                             $storeEnv = $this->storeEnv;
                             $this->storeEnv = $content->scope;
                             $this->compileChildrenNoReturn($content->children, $out);
                             $this->storeEnv = $storeEnv;
@@ -1912,25 +2843,31 @@ class Compiler
                         case Type::T_DEBUG:
                             list(, $value) = $child;
-            -
                            $line = $this->sourceLine;
                             $value = $this->compileValue($this->reduce($value, true));
-            -
                            fwrite($this->stderr, "Line $line DEBUG: $value\n");
                             break;
                         case Type::T_WARN:
                             list(, $value) = $child;
-            -
                            $line = $this->sourceLine;
                             $value = $this->compileValue($this->reduce($value, true));
-            -
                            fwrite($this->stderr, "Line $line WARN: $value\n");
                             break;
                         case Type::T_ERROR:
                             list(, $value) = $child;
-            -
                            $line = $this->sourceLine;
                             $value = $this->compileValue($this->reduce($value, true));
-            -
                            $this->throwError("Line $line ERROR: $value\n");
                             break;
                         case Type::T_CONTROL:
@@ -1975,7 +2912,7 @@ class Compiler
+                 *
                  * @param array $value
+                 *
-            -
                 * @return array
                  */
                 protected function isTruthy($value)
+                {
@@ -2006,7 +2943,7 @@ class Compiler
                     switch ($value[0]) {
                         case Type::T_EXPRESSION:
                             if ($value[1] === '/') {
-            -
                                return $this->shouldEval($value[2], $value[3]);
+                            }
                             // fall-thru
@@ -2024,13 +2961,15 @@ class Compiler
                  * @param array   $value
                  * @param boolean $inExp
+                 *
-            -
                 * @return array|\Leafo\ScssPhp\Node\Number
                  */
                 protected function reduce($value, $inExp = false)
+                {
-            -
                    list($type) = $value;
-            -
                    switch ($type) {
                         case Type::T_EXPRESSION:
                             list(, $op, $left, $right, $inParens) = $value;
@@ -2044,16 +2983,15 @@ class Compiler
+                            }
                             // special case: looks like css shorthand
-            -
                            if ($opName == 'div' && ! $inParens && ! $inExp && isset($right[2])
-            -
                                && (($right[0] !== Type::T_NUMBER && $right[2] != '')
-            -
                                || ($right[0] === Type::T_NUMBER && ! $right->unitless()))
                             ) {
                                 return $this->expToString($value);
+                            }
-            -
                            $left = $this->coerceForExpression($left);
                             $right = $this->coerceForExpression($right);
-            -
                             $ltype = $left[0];
                             $rtype = $right[0];
@@ -2163,9 +3101,7 @@ class Compiler
                             return [Type::T_STRING, '', [$op, $exp]];
                         case Type::T_VARIABLE:
-            -
                            list(, $name) = $value;
-            -
-            -
                            return $this->reduce($this->get($name));
                         case Type::T_LIST:
                             foreach ($value[2] as &$item) {
@@ -2197,12 +3133,20 @@ class Compiler
                         case Type::T_INTERPOLATE:
                             $value[1] = $this->reduce($value[1]);
                             return $value;
                         case Type::T_FUNCTION_CALL:
-            -
                            list(, $name, $argValues) = $value;
-            -
                            return $this->fncall($name, $argValues);
                         default:
                             return $value;
@@ -2217,7 +3161,7 @@ class Compiler
+                 *
                  * @return array|null
                  */
-            -
                private function fncall($name, $argValues)
+                {
                     // SCSS @function
                     if ($this->callScssFunction($name, $argValues, $returnValue)) {
@@ -2263,9 +3207,8 @@ class Compiler
                 public function normalizeValue($value)
+                {
                     $value = $this->coerceForExpression($this->reduce($value));
-            -
                    list($type) = $value;
-            -
                    switch ($type) {
                         case Type::T_LIST:
                             $value = $this->extractInterpolation($value);
@@ -2277,10 +3220,14 @@ class Compiler
                                 $value[2][$key] = $this->normalizeValue($item);
+                            }
                             return $value;
                         case Type::T_STRING:
-            -
                            return [$type, '"', [$this->compileStringContent($value)]];
                         case Type::T_NUMBER:
                             return $value->normalize();
@@ -2299,7 +3246,7 @@ class Compiler
                  * @param array $left
                  * @param array $right
+                 *
-            -
                 * @return \Leafo\ScssPhp\Node\Number
                  */
                 protected function opAddNumberNumber($left, $right)
+                {
@@ -2312,7 +3259,7 @@ class Compiler
                  * @param array $left
                  * @param array $right
+                 *
-            -
                 * @return \Leafo\ScssPhp\Node\Number
                  */
                 protected function opMulNumberNumber($left, $right)
+                {
@@ -2325,7 +3272,7 @@ class Compiler
                  * @param array $left
                  * @param array $right
+                 *
-            -
                 * @return \Leafo\ScssPhp\Node\Number
                  */
                 protected function opSubNumberNumber($left, $right)
+                {
@@ -2338,7 +3285,7 @@ class Compiler
                  * @param array $left
                  * @param array $right
+                 *
-            -
                 * @return array|\Leafo\ScssPhp\Node\Number
                  */
                 protected function opDivNumberNumber($left, $right)
+                {
@@ -2355,7 +3302,7 @@ class Compiler
                  * @param array $left
                  * @param array $right
+                 *
-            -
                 * @return \Leafo\ScssPhp\Node\Number
                  */
                 protected function opModNumberNumber($left, $right)
+                {
@@ -2368,7 +3315,7 @@ class Compiler
                  * @param array $left
                  * @param array $right
+                 *
-            -
                 * @return array
                  */
                 protected function opAdd($left, $right)
+                {
@@ -2391,6 +3338,8 @@ class Compiler
                         return $strRight;
+                    }
+                }
                 /**
@@ -2400,15 +3349,21 @@ class Compiler
                  * @param array   $right
                  * @param boolean $shouldEval
+                 *
-            -
                 * @return array
                  */
                 protected function opAnd($left, $right, $shouldEval)
+                {
                     if (! $shouldEval) {
-            -
                        return;
+                    }
-            -
                    if ($left !== static::$false and $left !== static::$null) {
                         return $this->reduce($right, true);
+                    }
@@ -2422,15 +3377,21 @@ class Compiler
                  * @param array   $right
                  * @param boolean $shouldEval
+                 *
-            -
                 * @return array
                  */
                 protected function opOr($left, $right, $shouldEval)
+                {
                     if (! $shouldEval) {
-            -
                        return;
+                    }
-            -
                    if ($left !== static::$false and $left !== static::$null) {
                         return $left;
+                    }
@@ -2641,7 +3602,7 @@ class Compiler
                  * @param array $left
                  * @param array $right
+                 *
-            -
                 * @return \Leafo\ScssPhp\Node\Number
                  */
                 protected function opCmpNumberNumber($left, $right)
+                {
@@ -2679,15 +3640,13 @@ class Compiler
+                 *
                  * @param array $value
+                 *
-            -
                 * @return string
                  */
                 public function compileValue($value)
+                {
                     $value = $this->reduce($value);
-            -
                    list($type) = $value;
-            -
-            -
                    switch ($type) {
                         case Type::T_KEYWORD:
                             return $value[1];
@@ -2698,14 +3657,38 @@ class Compiler
                             // [4] - optional alpha component
                             list(, $r, $g, $b) = $value;
-            -
                            $r = round($r);
-            -
                            $g = round($g);
-            -
                            $b = round($b);
-            -
                            if (count($value) === 5 && $value[4] !== 1) { // rgba
-            -
                                $a = new Node\Number($value[4], '');
-            -
                                return 'rgba(' . $r . ', ' . $g . ', ' . $b . ', ' . $a . ')';
+                            }
                             $h = sprintf('#%02x%02x%02x', $r, $g, $b);
@@ -2736,9 +3719,28 @@ class Compiler
+                            }
                             list(, $delim, $items) = $value;
                             if ($delim !== ' ') {
-            -
                                $delim .= ' ';
+                            }
                             $filtered = [];
@@ -2748,14 +3750,18 @@ class Compiler
                                     continue;
+                                }
-            -
                                $filtered[] = $this->compileValue($item);
+                            }
-            -
                            return implode("$delim", $filtered);
                         case Type::T_MAP:
-            -
                            $keys = $value[1];
-            -
                            $values = $value[2];
                             $filtered = [];
                             for ($i = 0, $s = count($keys); $i < $s; $i++) {
@@ -2773,20 +3779,29 @@ class Compiler
                             list(, $interpolate, $left, $right) = $value;
                             list(,, $whiteLeft, $whiteRight) = $interpolate;
                             $left = count($left[2]) > 0 ?
-            -
                                $this->compileValue($left) . $whiteLeft : '';
                             $right = count($right[2]) > 0 ?
-            -
                                $whiteRight . $this->compileValue($right) : '';
                             return $left . $this->compileValue($interpolate) . $right;
                         case Type::T_INTERPOLATE:
-            -
                            // raw parse node
-            -
                            list(, $exp) = $value;
-            -
                             // strip quotes if it's a string
-            -
                            $reduced = $this->reduce($exp);
                             switch ($reduced[0]) {
                                 case Type::T_LIST:
@@ -2810,6 +3825,7 @@ class Compiler
+                                        }
                                         $temp = $this->compileValue([Type::T_KEYWORD, $item]);
                                         if ($temp[0] === Type::T_STRING) {
                                             $filtered[] = $this->compileStringContent($temp);
                                         } elseif ($temp[0] === Type::T_KEYWORD) {
@@ -2835,8 +3851,11 @@ class Compiler
                         case Type::T_NULL:
                             return 'null';
                         default:
-            -
                            $this->throwError("unknown value type: $type");
+                    }
+                }
@@ -2900,44 +3919,70 @@ class Compiler
                 /**
                  * Find the final set of selectors
+                 *
-            -
                 * @param \Leafo\ScssPhp\Compiler\Environment $env
+                 *
                  * @return array
                  */
-            -
                protected function multiplySelectors(Environment $env)
+                {
                     $envs            = $this->compactEnv($env);
                     $selectors       = [];
                     $parentSelectors = [[]];
                     while ($env = array_pop($envs)) {
                         if (empty($env->selectors)) {
                             continue;
+                        }
-            -
                        $selectors = [];
-            -
                        foreach ($env->selectors as $selector) {
-            -
                            foreach ($parentSelectors as $parent) {
-            -
                                $selectors[] = $this->joinSelectors($parent, $selector);
+                            }
-            -
                        }
                         $parentSelectors = $selectors;
+                    }
                     return $selectors;
+                }
                 /**
                  * Join selectors; looks for & to replace, or append parent before child
+                 *
-            -
                 * @param array $parent
-            -
                 * @param array $child
-            -
                 *
                  * @return array
                  */
-            -
                protected function joinSelectors($parent, $child)
+                {
                     $setSelf = false;
                     $out = [];
@@ -2946,16 +3991,35 @@ class Compiler
                         $newPart = [];
                         foreach ($part as $p) {
-            -
                            if ($p === static::$selfSelector) {
                                 $setSelf = true;
-            -
                                foreach ($parent as $i => $parentPart) {
                                     if ($i > 0) {
                                         $out[] = $newPart;
                                         $newPart = [];
+                                    }
                                     foreach ($parentPart as $pp) {
                                         $newPart[] = $pp;
+                                    }
+                                }
@@ -2973,8 +4037,8 @@ class Compiler
                 /**
                  * Multiply media
+                 *
-            -
                 * @param \Leafo\ScssPhp\Compiler\Environment $env
-            -
                 * @param array                               $childQueries
+                 *
                  * @return array
                  */
@@ -2995,7 +4059,15 @@ class Compiler
                         ? $env->block->queryList
                         : [[[Type::T_MEDIA_VALUE, $env->block->value]]];
-            -
                    if ($childQueries === null) {
                         $childQueries = $parentQueries;
                     } else {
                         $originalQueries = $childQueries;
@@ -3003,7 +4075,11 @@ class Compiler
                         foreach ($parentQueries as $parentQuery) {
                             foreach ($originalQueries as $childQuery) {
-            -
                                $childQueries []= array_merge($parentQuery, $childQuery);
+                            }
+                        }
+                    }
@@ -3014,11 +4090,11 @@ class Compiler
                 /**
                  * Convert env linked list to stack
+                 *
-            -
                 * @param \Leafo\ScssPhp\Compiler\Environment $env
+                 *
                  * @return array
                  */
-            -
                private function compactEnv(Environment $env)
+                {
                     for ($envs = []; $env; $env = $env->parent) {
                         $envs[] = $env;
@@ -3032,9 +4108,9 @@ class Compiler
+                 *
                  * @param array $envs
+                 *
-            -
                 * @return \Leafo\ScssPhp\Compiler\Environment
                  */
-            -
                private function extractEnv($envs)
+                {
                     for ($env = null; $e = array_pop($envs);) {
                         $e->parent = $env;
@@ -3047,9 +4123,9 @@ class Compiler
                 /**
                  * Push environment
+                 *
-            -
                 * @param \Leafo\ScssPhp\Block $block
+                 *
-            -
                 * @return \Leafo\ScssPhp\Compiler\Environment
                  */
                 protected function pushEnv(Block $block = null)
+                {
@@ -3075,7 +4151,7 @@ class Compiler
                 /**
                  * Get store environment
+                 *
-            -
                 * @return \Leafo\ScssPhp\Compiler\Environment
                  */
                 protected function getStoreEnv()
+                {
@@ -3085,12 +4161,13 @@ class Compiler
                 /**
                  * Set variable
+                 *
-            -
                 * @param string                              $name
-            -
                 * @param mixed                               $value
-            -
                 * @param boolean                             $shadow
-            -
                 * @param \Leafo\ScssPhp\Compiler\Environment $env
                  */
-            -
                protected function set($name, $value, $shadow = false, Environment $env = null)
+                {
                     $name = $this->normalizeName($name);
@@ -3099,22 +4176,24 @@ class Compiler
+                    }
                     if ($shadow) {
-            -
                        $this->setRaw($name, $value, $env);
                     } else {
-            -
                        $this->setExisting($name, $value, $env);
+                    }
+                }
                 /**
                  * Set existing variable
+                 *
-            -
                 * @param string                              $name
-            -
                 * @param mixed                               $value
-            -
                 * @param \Leafo\ScssPhp\Compiler\Environment $env
                  */
-            -
                protected function setExisting($name, $value, Environment $env)
+                {
                     $storeEnv = $env;
                     $hasNamespace = $name[0] === '^' || $name[0] === '@' || $name[0] === '%';
@@ -3124,8 +4203,18 @@ class Compiler
+                        }
                         if (! $hasNamespace && isset($env->marker)) {
-            -
                            $env = $storeEnv;
-            -
                            break;
+                        }
                         if (! isset($env->parent)) {
@@ -3137,18 +4226,27 @@ class Compiler
+                    }
                     $env->store[$name] = $value;
+                }
                 /**
                  * Set raw variable
+                 *
-            -
                 * @param string                              $name
-            -
                 * @param mixed                               $value
-            -
                 * @param \Leafo\ScssPhp\Compiler\Environment $env
                  */
-            -
                protected function setRaw($name, $value, Environment $env)
+                {
                     $env->store[$name] = $value;
+                }
                 /**
@@ -3156,13 +4254,14 @@ class Compiler
+                 *
                  * @api
+                 *
-            -
                 * @param string                              $name
-            -
                 * @param boolean                             $shouldThrow
-            -
                 * @param \Leafo\ScssPhp\Compiler\Environment $env
+                 *
-            -
                 * @return mixed
                  */
-            -
                public function get($name, $shouldThrow = true, Environment $env = null)
+                {
                     $normalizedName = $this->normalizeName($name);
                     $specialContentKey = static::$namespaces['special'] . 'content';
@@ -3171,22 +4270,34 @@ class Compiler
                         $env = $this->getStoreEnv();
+                    }
-            -
                    $nextIsRoot = false;
                     $hasNamespace = $normalizedName[0] === '^' || $normalizedName[0] === '@' || $normalizedName[0] === '%';
                     for (;;) {
                         if (array_key_exists($normalizedName, $env->store)) {
                             return $env->store[$normalizedName];
+                        }
                         if (! $hasNamespace && isset($env->marker)) {
-            -
                            if (! $nextIsRoot && ! empty($env->store[$specialContentKey])) {
                                 $env = $env->store[$specialContentKey]->scope;
-            -
                                $nextIsRoot = true;
                                 continue;
+                            }
-            -
                            $env = $this->rootEnv;
                             continue;
+                        }
@@ -3198,23 +4309,24 @@ class Compiler
+                    }
                     if ($shouldThrow) {
-            -
                        $this->throwError("Undefined variable \$$name");
+                    }
                     // found nothing
+                }
                 /**
                  * Has variable?
+                 *
-            -
                 * @param string                              $name
-            -
                 * @param \Leafo\ScssPhp\Compiler\Environment $env
+                 *
                  * @return boolean
                  */
                 protected function has($name, Environment $env = null)
+                {
-            -
                    return $this->get($name, false, $env) !== null;
+                }
                 /**
@@ -3288,7 +4400,7 @@ class Compiler
                  */
                 public function addParsedFile($path)
+                {
-            -
                    if (isset($path) && file_exists($path)) {
                         $this->parsedFiles[realpath($path)] = filemtime($path);
+                    }
+                }
@@ -3310,7 +4422,7 @@ class Compiler
+                 *
                  * @api
+                 *
-            -
                 * @param string $path
                  */
                 public function addImportPath($path)
+                {
@@ -3432,10 +4544,10 @@ class Compiler
                 /**
                  * Import file
+                 *
-            -
                 * @param string $path
-            -
                 * @param array  $out
                  */
-            -
                protected function importFile($path, $out)
+                {
                     // see if tree is cached
                     $realPath = realpath($path);
@@ -3453,6 +4565,7 @@ class Compiler
+                    }
                     $pi = pathinfo($path);
                     array_unshift($this->importPaths, $pi['dirname']);
                     $this->compileChildrenNoReturn($tree->children, $out);
                     array_shift($this->importPaths);
@@ -3472,9 +4585,9 @@ class Compiler
                     $urls = [];
                     // for "normal" scss imports (ignore vanilla css and external requests)
-            -
                    if (! preg_match('/\.css$|^https?:\/\//', $url)) {
                         // try both normal and the _partial filename
-            -
                        $urls = [$url, preg_replace('/[^\/]+$/', '_\0', $url)];
+                    }
                     $hasExtension = preg_match('/[.]s?css$/', $url);
@@ -3483,12 +4596,15 @@ class Compiler
                         if (is_string($dir)) {
                             // check urls for normal import paths
                             foreach ($urls as $full) {
-            -
                                $full = $dir
-            -
                                    . (! empty($dir) && substr($dir, -1) !== '/' ? '/' : '')
-            -
                                    . $full;
-            -
-            -
                                if ($this->fileExists($file = $full . '.scss') ||
-            -
                                    ($hasExtension && $this->fileExists($file = $full))
                                 ) {
                                     return $file;
+                                }
@@ -3497,7 +4613,7 @@ class Compiler
                             // check custom callback for import path
                             $file = call_user_func($dir, $url);
-            -
                            if ($file !== null) {
                                 return $file;
+                            }
+                        }
@@ -3525,11 +4641,13 @@ class Compiler
+                 *
                  * @param boolean $ignoreErrors
+                 *
-            -
                 * @return \Leafo\ScssPhp\Compiler
                  */
                 public function setIgnoreErrors($ignoreErrors)
+                {
                     $this->ignoreErrors = $ignoreErrors;
+                }
                 /**
@@ -3539,7 +4657,7 @@ class Compiler
+                 *
                  * @param string $msg Message with optional sprintf()-style vararg parameters
+                 *
-            -
                 * @throws \Leafo\ScssPhp\Exception\CompilerException
                  */
                 public function throwError($msg)
+                {
@@ -3547,16 +4665,62 @@ class Compiler
                         return;
+                    }
                     if (func_num_args() > 1) {
                         $msg = call_user_func_array('sprintf', func_get_args());
+                    }
-            -
                    $line = $this->sourceLine;
-            -
                    $msg = "$msg: line: $line";
                     throw new CompilerException($msg);
+                }
                 /**
                  * Handle import loop
+                 *
@@ -3567,6 +4731,10 @@ class Compiler
                 protected function handleImportLoop($name)
+                {
                     for ($env = $this->env; $env; $env = $env->parent) {
                         $file = $this->sourceNames[$env->block->sourceIndex];
                         if (realpath($file) === $name) {
@@ -3576,18 +4744,6 @@ class Compiler
+                    }
+                }
-            -
                /**
-            -
                 * Does file exist?
-            -
                 *
-            -
                 * @param string $name
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function fileExists($name)
-            -
                {
-            -
                    return file_exists($name) && is_file($name);
-            -
                }
-            -
                 /**
                  * Call SCSS @function
+                 *
@@ -3621,8 +4777,13 @@ class Compiler
                     $tmp->children = [];
                     $this->env->marker = 'function';
-            -
                    $ret = $this->compileChildren($func->children, $tmp);
                     $this->storeEnv = $storeEnv;
@@ -3657,11 +4818,17 @@ class Compiler
                         return false;
+                    }
-            -
                    list($sorted, $kwargs) = $this->sortArgs($prototype, $args);
                     if ($name !== 'if' && $name !== 'call') {
                         foreach ($sorted as &$val) {
-            -
                            $val = $this->reduce($val, true);
+                        }
+                    }
@@ -3699,62 +4866,170 @@ class Compiler
                 /**
                  * Sorts keyword arguments
+                 *
-            -
                 * @param array $prototype
-            -
                 * @param array $args
+                 *
                  * @return array
                  */
-            -
                protected function sortArgs($prototype, $args)
+                {
-            -
                    $keyArgs = [];
-            -
                    $posArgs = [];
-            -
                    // separate positional and keyword arguments
-            -
                    foreach ($args as $arg) {
-            -
                        list($key, $value) = $arg;
-            -
                        $key = $key[1];
-            -
                        if (empty($key)) {
-            -
                            $posArgs[] = $value;
-            -
                        } else {
-            -
                            $keyArgs[$key] = $value;
+                        }
-            -
                    }
-            -
                    if (! isset($prototype)) {
                         return [$posArgs, $keyArgs];
+                    }
-            -
                    // copy positional args
-            -
                    $finalArgs = array_pad($posArgs, count($prototype), null);
-            -
                    // overwrite positional args with keyword args
-            -
                    foreach ($prototype as $i => $names) {
-            -
                        foreach ((array) $names as $name) {
-            -
                            if (isset($keyArgs[$name])) {
-            -
                                $finalArgs[$i] = $keyArgs[$name];
+                            }
+                        }
+                    }
                     return [$finalArgs, $keyArgs];
+                }
                 /**
                  * Apply argument values per definition
+                 *
-            -
                 * @param array $argDef
-            -
                 * @param array $argValues
+                 *
                  * @throws \Exception
                  */
-            -
                protected function applyArguments($argDef, $argValues)
+                {
-            -
                    $storeEnv = $this->getStoreEnv();
-            -
                    $env = new Environment;
-            -
                    $env->store = $storeEnv->store;
                     $hasVariable = false;
                     $args = [];
@@ -3766,37 +5041,64 @@ class Compiler
                         $hasVariable |= $isVariable;
+                    }
-            -
                    $keywordArgs = [];
                     $deferredKeywordArgs = [];
-            -
                    $remaining = [];
                     // assign the keyword args
                     foreach ((array) $argValues as $arg) {
                         if (! empty($arg[0])) {
-            -
                            if (! isset($args[$arg[0][1]])) {
                                 if ($hasVariable) {
-            -
                                    $deferredKeywordArgs[$arg[0][1]] = $arg[1];
                                 } else {
                                     $this->throwError("Mixin or function doesn't have an argument named $%s.", $arg[0][1]);
                                     break;
+                                }
-            -
                            } 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;
                             } else {
-            -
                                $keywordArgs[$arg[0][1]] = $arg[1];
+                            }
-            -
                        } elseif (count($keywordArgs)) {
-            -
                            $this->throwError('Positional arguments must come before keyword arguments.');
-            -
                            break;
                         } elseif ($arg[2] === true) {
                             $val = $this->reduce($arg[1], true);
                             if ($val[0] === Type::T_LIST) {
                                 foreach ($val[2] as $name => $item) {
                                     if (! is_numeric($name)) {
-            -
                                        $keywordArgs[$name] = $item;
                                     } else {
                                         $remaining[] = $item;
+                                    }
+                                }
@@ -3806,14 +5108,34 @@ class Compiler
                                     $item = $val[2][$i];
                                     if (! is_numeric($name)) {
-            -
                                        $keywordArgs[$name] = $item;
-            -
                                    } else {
-            -
                                        $remaining[] = $item;
-            -
                                    }
-            -
                                }
                             } else {
                                 $remaining[] = $val;
+                            }
                         } else {
                             $remaining[] = $arg[1];
+                        }
@@ -3823,7 +5145,7 @@ class Compiler
                         list($i, $name, $default, $isVariable) = $arg;
                         if ($isVariable) {
-            -
                            $val = [Type::T_LIST, ',', [], $isVariable];
                             for ($count = count($remaining); $i < $count; $i++) {
                                 $val[2][] = $remaining[$i];
@@ -3843,10 +5165,16 @@ class Compiler
                             break;
+                        }
-            -
                        $this->set($name, $this->reduce($val, true), true, $env);
+                    }
-            -
                    $storeEnv->store = $env->store;
                     foreach ($args as $arg) {
                         list($i, $name, $default, $isVariable) = $arg;
@@ -3855,8 +5183,14 @@ class Compiler
                             continue;
+                        }
-            -
                        $this->set($name, $this->reduce($default, true), true);
+                    }
+                }
                 /**
@@ -3864,9 +5198,9 @@ class Compiler
+                 *
                  * @param mixed $value
+                 *
-            -
                 * @return array|\Leafo\ScssPhp\Node\Number
                  */
-            -
                private function coerceValue($value)
+                {
                     if (is_array($value) || $value instanceof \ArrayAccess) {
                         return $value;
@@ -3876,7 +5210,7 @@ class Compiler
                         return $this->toBool($value);
+                    }
-            -
                    if ($value === null) {
                         return static::$null;
+                    }
@@ -3888,30 +5222,14 @@ class Compiler
                         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;
-            -
                            }
-            -
                        }
                         return $color;
+                    }
-            -
                    return [Type::T_KEYWORD, $value];
+                }
                 /**
@@ -3927,7 +5245,9 @@ class Compiler
                         return $item;
+                    }
-            -
                    if ($item === static::$emptyList) {
                         return static::$emptyMap;
+                    }
@@ -3957,10 +5277,21 @@ class Compiler
                             $key = $keys[$i];
                             $value = $values[$i];
                             $list[] = [
                                 Type::T_LIST,
                                 '',
-            -
                                [[Type::T_KEYWORD, $this->compileStringContent($this->coerceString($key))], $value]
                             ];
+                        }
@@ -3993,21 +5324,106 @@ class Compiler
+                 *
                  * @return array|null
                  */
-            -
                protected function coerceColor($value)
+                {
                     switch ($value[0]) {
                         case Type::T_COLOR:
                             return $value;
                         case Type::T_KEYWORD:
                             $name = strtolower($value[1]);
-            -
                            if (isset(Colors::$cssColors[$name])) {
-            -
                                $rgba = explode(',', Colors::$cssColors[$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]];
+                            }
                             return null;
@@ -4016,6 +5432,88 @@ class Compiler
                     return null;
+                }
                 /**
                  * Coerce value to string
+                 *
@@ -4068,7 +5566,7 @@ class Compiler
                     $value = $this->coerceMap($value);
                     if ($value[0] !== Type::T_MAP) {
-            -
                        $this->throwError('expecting map');
+                    }
                     return $value;
@@ -4088,7 +5586,7 @@ class Compiler
                 public function assertList($value)
+                {
                     if ($value[0] !== Type::T_LIST) {
-            -
                        $this->throwError('expecting list');
+                    }
                     return $value;
@@ -4111,7 +5609,7 @@ class Compiler
                         return $color;
+                    }
-            -
                    $this->throwError('expecting color');
+                }
                 /**
@@ -4128,7 +5626,7 @@ class Compiler
                 public function assertNumber($value)
+                {
                     if ($value[0] !== Type::T_NUMBER) {
-            -
                        $this->throwError('expecting number');
+                    }
                     return $value[1];
@@ -4205,7 +5703,7 @@ class Compiler
+                 *
                  * @return float
                  */
-            -
                private function hueToRGB($m1, $m2, $h)
+                {
                     if ($h < 0) {
                         $h += 1;
@@ -4263,28 +5761,27 @@ class Compiler
                 // Built in functions
-            -
                //protected static $libCall = ['name', 'args...'];
                 protected function libCall($args, $kwargs)
+                {
                     $name = $this->compileStringContent($this->coerceString($this->reduce(array_shift($args), true)));
-            -
                    $args = array_map(
-            -
                        function ($a) {
-            -
                            return [null, $a, false];
-            -
                        },
-            -
                        $args
-            -
                    );
-            -
-            -
                    if (count($kwargs)) {
-            -
                        foreach ($kwargs as $key => $value) {
-            -
                            $args[] = [[Type::T_VARIABLE, $key], $value, false];
+                        }
+                    }
-            -
                    return $this->reduce([Type::T_FUNCTION_CALL, $name, $args]);
+                }
-            -
                protected static $libIf = ['condition', 'if-true', 'if-false'];
                 protected function libIf($args)
+                {
                     list($cond, $t, $f) = $args;
@@ -4328,30 +5825,68 @@ class Compiler
                     return false === $key ? static::$null : $key + 1;
+                }
-            -
                protected static $libRgb = ['red', 'green', 'blue'];
-            -
                protected function libRgb($args)
+                {
-            -
                    list($r, $g, $b) = $args;
-            -
                    return [Type::T_COLOR, $r[1], $g[1], $b[1]];
-            -
                }
-            -
                protected static $libRgba = [
-            -
                    ['red', 'color'],
-            -
                    'green', 'blue', 'alpha'];
-            -
                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;
-            -
                        return $color;
+                    }
-            -
                    list($r, $g, $b, $a) = $args;
-            -
                    return [Type::T_COLOR, $r[1], $g[1], $b[1], $a[1]];
+                }
                 // helper function for adjust_color, change_color, and scale_color
@@ -4359,21 +5894,25 @@ class Compiler
+                {
                     $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);
+                        }
+                    }
-            -
                    if (isset($args[4]) || isset($args[5]) || isset($args[6])) {
                         $hsl = $this->toHSL($color[1], $color[2], $color[3]);
-            -
                        foreach ([4, 5, 6] as $i) {
-            -
                            if (isset($args[$i])) {
-            -
                                $val = $this->assertNumber($args[$i]);
-            -
                                $hsl[$i - 3] = call_user_func($fn, $hsl[$i - 3], $val, $i);
+                            }
+                        }
@@ -4390,8 +5929,8 @@ class Compiler
+                }
                 protected static $libAdjustColor = [
-            -
                    'color', 'red', 'green', 'blue',
-            -
                    'hue', 'saturation', 'lightness', 'alpha'
                 ];
                 protected function libAdjustColor($args)
+                {
@@ -4401,8 +5940,8 @@ class Compiler
+                }
                 protected static $libChangeColor = [
-            -
                    'color', 'red', 'green', 'blue',
-            -
                    'hue', 'saturation', 'lightness', 'alpha'
                 ];
                 protected function libChangeColor($args)
+                {
@@ -4412,8 +5951,8 @@ class Compiler
+                }
                 protected static $libScaleColor = [
-            -
                    'color', 'red', 'green', 'blue',
-            -
                    'hue', 'saturation', 'lightness', 'alpha'
                 ];
                 protected function libScaleColor($args)
+                {
@@ -4456,7 +5995,7 @@ class Compiler
                     $color = $this->coerceColor($args[0]);
                     $color[4] = isset($color[4]) ? round(255 * $color[4]) : 255;
-            -
                    return sprintf('#%02X%02X%02X%02X', $color[4], $color[1], $color[2], $color[3]);
+                }
                 protected static $libRed = ['color'];
@@ -4507,7 +6046,7 @@ class Compiler
+                }
                 // mix two colors
-            -
                protected static $libMix = ['color-1', 'color-2', 'weight'];
                 protected function libMix($args)
+                {
                     list($first, $second, $weight) = $args;
@@ -4543,25 +6082,56 @@ class Compiler
                     return $this->fixColor($new);
+                }
-            -
                protected static $libHsl = ['hue', 'saturation', 'lightness'];
-            -
                protected function libHsl($args)
+                {
-            -
                    list($h, $s, $l) = $args;
-            -
                    return $this->toRGB($h[1], $s[1], $l[1]);
-            -
                }
-            -
                protected static $libHsla = ['hue', 'saturation', 'lightness', 'alpha'];
-            -
                protected function libHsla($args)
-            -
                {
-            -
                    list($h, $s, $l, $a) = $args;
-            -
                    $color = $this->toRGB($h[1], $s[1], $l[1]);
-            -
                    $color[4] = $a[1];
                     return $color;
+                }
                 protected static $libHue = ['color'];
                 protected function libHue($args)
+                {
@@ -4629,7 +6199,7 @@ class Compiler
                     return $this->adjustHsl($color, 3, -$amount);
+                }
-            -
                protected static $libSaturate = ['color', 'amount'];
                 protected function libSaturate($args)
+                {
                     $value = $args[0];
@@ -4671,21 +6241,32 @@ class Compiler
                     return $this->adjustHsl($this->assertColor($args[0]), 1, 180);
+                }
-            -
                protected static $libInvert = ['color'];
                 protected function libInvert($args)
+                {
-            -
                    $value = $args[0];
                     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];
-            -
                    return $color;
+                }
                 // increases opacity by amount
@@ -4794,7 +6375,7 @@ class Compiler
                     $min = null;
                     foreach ($numbers as $key => $number) {
-            -
                        if (null === $min || $number[1] <= $min[1]) {
                             $min = [$key, $number[1]];
+                        }
+                    }
@@ -4808,7 +6389,7 @@ class Compiler
                     $max = null;
                     foreach ($numbers as $key => $number) {
-            -
                        if (null === $max || $number[1] >= $max[1]) {
                             $max = [$key, $number[1]];
+                        }
+                    }
@@ -4825,9 +6406,9 @@ class Compiler
                  */
                 protected function getNormalizedNumbers($args)
+                {
-            -
                    $unit = null;
                     $originalUnit = null;
-            -
                    $numbers = [];
                     foreach ($args as $key => $item) {
                         if ($item[0] !== Type::T_NUMBER) {
@@ -4837,10 +6418,10 @@ class Compiler
                         $number = $item->normalize();
-            -
                        if (null === $unit) {
                             $unit = $number[2];
                             $originalUnit = $item->unitStr();
-            -
                        } elseif ($unit !== $number[2]) {
                             $this->throwError('Incompatible units: "%s" and "%s".', $originalUnit, $item->unitStr());
                             break;
+                        }
@@ -4909,7 +6490,7 @@ class Compiler
                     if (! isset($list[2][$n])) {
                         $this->throwError('Invalid argument for "n"');
-            -
                        return;
+                    }
                     $list[2][$n] = $args[2];
@@ -4921,11 +6502,15 @@ class Compiler
                 protected function libMapGet($args)
+                {
                     $map = $this->assertMap($args[0]);
-            -
                    $key = $this->compileStringContent($this->coerceString($args[1]));
-            -
                    for ($i = count($map[1]) - 1; $i >= 0; $i--) {
-            -
                        if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) {
-            -
                            return $map[2][$i];
+                        }
+                    }
@@ -4987,7 +6572,21 @@ class Compiler
                     $map1 = $this->assertMap($args[0]);
                     $map2 = $this->assertMap($args[1]);
-            -
                    return [Type::T_MAP, array_merge($map1[1], $map2[1]), array_merge($map1[2], $map2[2])];
+                }
                 protected static $libKeywords = ['args'];
@@ -5006,6 +6605,18 @@ class Compiler
                     return [Type::T_MAP, $keys, $values];
+                }
                 protected function listSeparatorForJoin($list1, $sep)
+                {
                     if (! isset($sep)) {
@@ -5017,26 +6628,56 @@ class Compiler
                             return ',';
                         case 'space':
-            -
                            return '';
                         default:
                             return $list1[1];
+                    }
+                }
-            -
                protected static $libJoin = ['list1', 'list2', 'separator'];
                 protected function libJoin($args)
+                {
-            -
                    list($list1, $list2, $sep) = $args;
                     $list1 = $this->coerceList($list1, ' ');
                     $list2 = $this->coerceList($list2, ' ');
-            -
                    $sep = $this->listSeparatorForJoin($list1, $sep);
-            -
                    return [Type::T_LIST, $sep, array_merge($list1[2], $list2[2])];
+                }
-            -
                protected static $libAppend = ['list', 'val', 'separator'];
                 protected function libAppend($args)
+                {
                     list($list1, $value, $sep) = $args;
@@ -5044,13 +6685,17 @@ class Compiler
                     $list1 = $this->coerceList($list1, ' ');
                     $sep = $this->listSeparatorForJoin($list1, $sep);
-            -
                    return [Type::T_LIST, $sep, array_merge($list1[2], [$value])];
+                }
                 protected function libZip($args)
+                {
-            -
                    foreach ($args as $arg) {
-            -
                        $this->assertList($arg);
+                    }
                     $lists = [];
@@ -5133,7 +6778,7 @@ class Compiler
                     ) {
                         $this->throwError('Invalid argument(s) for "comparable"');
-            -
                        return;
+                    }
                     $number1 = $number1->normalize();
@@ -5181,10 +6826,10 @@ class Compiler
                     return new Node\Number(strlen($stringContent), '');
+                }
-            -
                protected static $libStrSlice = ['string', 'start-at', 'end-at'];
                 protected function libStrSlice($args)
+                {
-            -
                    if (isset($args[2]) && $args[2][1] == 0) {
                         return static::$nullString;
+                    }
@@ -5197,7 +6842,7 @@ class Compiler
                         $start--;
+                    }
-            -
                    $end    = (int) $args[2][1];
                     $length = $end < 0 ? $end + 1 : ($end > 0 ? $end - $start : $end);
                     $string[2] = $length
@@ -5313,7 +6958,7 @@ class Compiler
                         if ($n < 1) {
                             $this->throwError("limit must be greater than or equal to 1");
-            -
                            return;
+                        }
                         return new Node\Number(mt_rand(1, $n), '');
@@ -5335,13 +6980,670 @@ class Compiler
                     return [Type::T_STRING, '', ['u' . str_pad(base_convert($id, 10, 36), 8, '0', STR_PAD_LEFT)]];
+                }
                 protected static $libInspect = ['value'];
                 protected function libInspect($args)
+                {
-            -
                    if ($args[0] === static::$null) {
-            -
                        return [Type::T_KEYWORD, 'null'];
+                    }
-            -
                    return $args[0];
+                }
+            }


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp;
13	+
14	+ use ScssPhp\ScssPhp\Base\Range;
15	+ use ScssPhp\ScssPhp\Block;
16	+ use ScssPhp\ScssPhp\Cache;
17	+ use ScssPhp\ScssPhp\Colors;
18	+ use ScssPhp\ScssPhp\Compiler\Environment;
19	+ use ScssPhp\ScssPhp\Exception\CompilerException;
20	+ use ScssPhp\ScssPhp\Formatter\OutputBlock;
21	+ use ScssPhp\ScssPhp\Node;
22	+ use ScssPhp\ScssPhp\SourceMap\SourceMapGenerator;
23	+ use ScssPhp\ScssPhp\Type;
24	+ use ScssPhp\ScssPhp\Parser;
25	+ use ScssPhp\ScssPhp\Util;
26
27	/**
28	* The scss compiler and parser.

99	'function' => '^',
100	];
101
102	+ static public $true = [Type::T_KEYWORD, 'true'];
103	+ static public $false = [Type::T_KEYWORD, 'false'];
104	+ static public $null = [Type::T_NULL];
105	+ static public $nullString = [Type::T_STRING, '', []];
106	static public $defaultValue = [Type::T_KEYWORD, ''];
107	static public $selfSelector = [Type::T_SELF];
108	+ static public $emptyList = [Type::T_LIST, '', []];
109	+ static public $emptyMap = [Type::T_MAP, [], []];
110	+ static public $emptyString = [Type::T_STRING, '"', []];
111	+ static public $with = [Type::T_KEYWORD, 'with'];
112	+ static public $without = [Type::T_KEYWORD, 'without'];
113
114	protected $importPaths = [''];
115	protected $importCache = [];

130	protected $sourceMapOptions = [];
131
132	/**
133	+ * @var string\|\ScssPhp\ScssPhp\Formatter
134	*/
135	+ protected $formatter = 'ScssPhp\ScssPhp\Formatter\Nested';
136
137	protected $rootEnv;
138	protected $rootBlock;
139
140	/**
141	+ * @var \ScssPhp\ScssPhp\Compiler\Environment
142	*/
143	protected $env;
144	protected $scope;

146	protected $charsetSeen;
147	protected $sourceNames;
148
149	+ protected $cache;
150	+
151	+ protected $indentLevel;
152	+ protected $extends;
153	+ protected $extendsMap;
154	+ protected $parsedFiles;
155	+ protected $parser;
156	+ protected $sourceIndex;
157	+ protected $sourceLine;
158	+ protected $sourceColumn;
159	+ protected $stderr;
160	+ protected $shouldEvaluate;
161	+ protected $ignoreErrors;
162	+
163	+ protected $callStack = [];
164
165	/**
166	* Constructor
167	+ *
168	+ * @param array\|null $cacheOptions
169	*/
170	+ public function __construct($cacheOptions = null)
171	{
172	$this->parsedFiles = [];
173	$this->sourceNames = [];
174	+
175	+ if ($cacheOptions) {
176	+ $this->cache = new Cache($cacheOptions);
177	+ }
178	+
179	+ $this->stderr = fopen('php://stderr', 'w');
180	+ }
181	+
182	+ /**
183	+ * Get compiler options
184	+ *
185	+ * @return array
186	+ */
187	+ public function getCompileOptions()
188	+ {
189	+ $options = [
190	+ 'importPaths' => $this->importPaths,
191	+ 'registeredVars' => $this->registeredVars,
192	+ 'registeredFeatures' => $this->registeredFeatures,
193	+ 'encoding' => $this->encoding,
194	+ 'sourceMap' => serialize($this->sourceMap),
195	+ 'sourceMapOptions' => $this->sourceMapOptions,
196	+ 'formatter' => $this->formatter,
197	+ ];
198	+
199	+ return $options;
200	+ }
201	+
202	+ /**
203	+ * Set an alternative error output stream, for testing purpose only
204	+ *
205	+ * @param resource $handle
206	+ */
207	+ public function setErrorOuput($handle)
208	+ {
209	+ $this->stderr = $handle;
210	}
211
212	/**

221	*/
222	public function compile($code, $path = null)
223	{
224	+ if ($this->cache) {
225	+ $cacheKey = ($path ? $path : "(stdin)") . ":" . md5($code);
226	+ $compileOptions = $this->getCompileOptions();
227	+ $cache = $this->cache->getCache("compile", $cacheKey, $compileOptions);
228	+
229	+ if (is_array($cache) && isset($cache['dependencies']) && isset($cache['out'])) {
230	+ // check if any dependency file changed before accepting the cache
231	+ foreach ($cache['dependencies'] as $file => $mtime) {
232	+ if (! is_file($file) \|\| filemtime($file) !== $mtime) {
233	+ unset($cache);
234	+ break;
235	+ }
236	+ }
237	+
238	+ if (isset($cache)) {
239	+ return $cache['out'];
240	+ }
241	+ }
242	+ }
243	+
244	+
245	$this->indentLevel = -1;

246	$this->extends = [];
247	$this->extendsMap = [];
248	$this->sourceIndex = null;

253	$this->storeEnv = null;
254	$this->charsetSeen = null;
255	$this->shouldEvaluate = null;

256
257	$this->parser = $this->parserFactory($path);
258	+ $tree = $this->parser->parse($code);

259	$this->parser = null;
260
261	$this->formatter = new $this->formatter();

296	$out .= sprintf('/# sourceMappingURL=%s /', $sourceMapUrl);
297	}
298
299	+ if ($this->cache && isset($cacheKey) && isset($compileOptions)) {
300	+ $v = [
301	+ 'dependencies' => $this->getParsedFiles(),
302	+ 'out' => &$out,
303	+ ];
304	+
305	+ $this->cache->setCache("compile", $cacheKey, $v, $compileOptions);
306	+ }
307	+
308	return $out;
309	}
310

313	*
314	* @param string $path
315	*
316	+ * @return \ScssPhp\ScssPhp\Parser
317	*/
318	protected function parserFactory($path)
319	{
320	+ $parser = new Parser($path, count($this->sourceNames), $this->encoding, $this->cache);
321
322	$this->sourceNames[] = $path;

323	$this->addParsedFile($path);
324
325	return $parser;

347	/**
348	* Push extends
349	*
350	+ * @param array $target
351	+ * @param array $origin
352	+ * @param array\|null $block
353	*/
354	protected function pushExtends($target, $origin, $block)
355	{

375	* @param string $type
376	* @param array $selectors
377	*
378	+ * @return \ScssPhp\ScssPhp\Formatter\OutputBlock
379	*/
380	protected function makeOutputBlock($type, $selectors = null)
381	{
382	$out = new OutputBlock;
383	+ $out->type = $type;
384	+ $out->lines = [];
385	+ $out->children = [];
386	+ $out->parent = $this->scope;
387	+ $out->selectors = $selectors;
388	+ $out->depth = $this->env->depth;
389
390	if ($this->env->block instanceof Block) {
391	$out->sourceName = $this->env->block->sourceName;

403	/**
404	* Compile root
405	*
406	+ * @param \ScssPhp\ScssPhp\Block $rootBlock
407	*/
408	protected function compileRoot(Block $rootBlock)
409	{

442	/**
443	* Flatten selectors
444	*
445	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
446	+ * @param string $parentKey
447	*/
448	protected function flattenSelectors(OutputBlock $block, $parentKey = null)
449	{

498	}
499	}
500
501	+ /**
502	+ * Glue parts of :not( or :nth-child( ... that are in general splitted in selectors parts
503	+ *
504	+ * @param array $parts
505	+ *
506	+ * @return array
507	+ */
508	+ protected function glueFunctionSelectors($parts)
509	+ {
510	+ $new = [];
511	+
512	+ foreach ($parts as $part) {
513	+ if (is_array($part)) {
514	+ $part = $this->glueFunctionSelectors($part);
515	+ $new[] = $part;
516	+ } else {
517	+ // a selector part finishing with a ) is the last part of a :not( or :nth-child(
518	+ // and need to be joined to this
519	+ if (count($new) && is_string($new[count($new) - 1]) &&
520	+ strlen($part) && substr($part, -1) === ')' && strpos($part, '(') === false
521	+ ) {
522	+ while (count($new)>1 && substr($new[count($new) - 1], -1) !== '(') {
523	+ $part = array_pop($new) . $part;
524	+ }
525	+ $new[count($new) - 1] .= $part;
526	+ } else {
527	+ $new[] = $part;
528	+ }
529	+ }
530	+ }
531	+
532	+ return $new;
533	+ }
534	+
535	/**
536	* Match extends
537	*

542	*/
543	protected function matchExtends($selector, &$out, $from = 0, $initial = true)
544	{
545	+ static $partsPile = [];
546	+ $selector = $this->glueFunctionSelectors($selector);
547	+
548	+ if (count($selector) == 1 && in_array(reset($selector), $partsPile)) {
549	+ return;
550	+ }
551	+
552	+ $outRecurs = [];
553	foreach ($selector as $i => $part) {
554	if ($i < $from) {
555	continue;
556	}
557
558	+ // check that we are not building an infinite loop of extensions
559	+ // if the new part is just including a previous part don't try to extend anymore
560	+ if (count($part) > 1) {
561	+ foreach ($partsPile as $previousPart) {
562	+ if (! count(array_diff($previousPart, $part))) {
563	+ continue 2;
564	+ }
565	+ }
566	+ }
567
568	+ $partsPile[] = $part;
569	+ if ($this->matchExtendsSingle($part, $origin, $initial)) {
570	+ $after = array_slice($selector, $i + 1);
571	+ $before = array_slice($selector, 0, $i);
572	list($before, $nonBreakableBefore) = $this->extractRelationshipFromFragment($before);
573
574	foreach ($origin as $new) {
575	$k = 0;
576
577	// remove shared parts
578	+ if (count($new) > 1) {
579	while ($k < $i && isset($new[$k]) && $selector[$k] === $new[$k]) {
580	$k++;
581	}
582	}
583	+ if (count($nonBreakableBefore) and $k == count($new)) {
584	+ $k--;
585	+ }
586
587	$replacement = [];
588	$tempReplacement = $k > 0 ? array_slice($new, $k) : $new;
589
590	for ($l = count($tempReplacement) - 1; $l >= 0; $l--) {
591	+ $slice = [];
592	+
593	+ foreach ($tempReplacement[$l] as $chunk) {
594	+ if (! in_array($chunk, $slice)) {
595	+ $slice[] = $chunk;
596	+ }
597	+ }
598	+
599	array_unshift($replacement, $slice);
600
601	if (! $this->isImmediateRelationshipCombinator(end($slice))) {

619	continue;
620	}
621
622	+ $this->pushOrMergeExtentedSelector($out, $result);
623
624	// recursively check for more matches
625	+ $startRecurseFrom = count($before) + min(count($nonBreakableBefore), count($mergedBefore));
626	+ if (count($origin) > 1) {
627	+ $this->matchExtends($result, $out, $startRecurseFrom, false);
628	+ } else {
629	+ $this->matchExtends($result, $outRecurs, $startRecurseFrom, false);
630	+ }
631
632	// selector sequence merging
633	if (! empty($before) && count($new) > 1) {
634	+ $preSharedParts = $k > 0 ? array_slice($before, 0, $k) : [];
635	$postSharedParts = $k > 0 ? array_slice($before, $k) : $before;
636
637	+ list($betweenSharedParts, $nonBreakabl2) = $this->extractRelationshipFromFragment($afterBefore);
638
639	$result2 = array_merge(
640	+ $preSharedParts,
641	+ $betweenSharedParts,
642	$postSharedParts,
643	+ $nonBreakabl2,
644	$nonBreakableBefore,
645	$replacement,
646	$after
647	);
648
649	+ $this->pushOrMergeExtentedSelector($out, $result2);
650	+ }
651	+ }
652	+ }
653	+ array_pop($partsPile);
654	+ }
655	+ while (count($outRecurs)) {
656	+ $result = array_shift($outRecurs);
657	+ $this->pushOrMergeExtentedSelector($out, $result);
658	+ }
659	+ }
660	+
661	+ /**
662	+ * Test a part for being a pseudo selector
663	+ * @param string $part
664	+ * @param array $matches
665	+ * @return bool
666	+ */
667	+ protected function isPseudoSelector($part, &$matches)
668	+ {
669	+ if (strpos($part, ":") === 0
670	+ && preg_match(",^::?([\w-]+)$(.+)$$,", $part, $matches)) {
671	+ return true;
672	+ }
673	+ return false;
674	+ }
675	+
676	+ /**
677	+ * Push extended selector except if
678	+ * - this is a pseudo selector
679	+ * - same as previous
680	+ * - in a white list
681	+ * in this case we merge the pseudo selector content
682	+ * @param array $out
683	+ * @param array $extended
684	+ */
685	+ protected function pushOrMergeExtentedSelector(&$out, $extended)
686	+ {
687	+ if (count($out) && count($extended) === 1 && count(reset($extended)) === 1) {
688	+ $single = reset($extended);
689	+ $part = reset($single);
690	+ if ($this->isPseudoSelector($part, $matchesExtended)
691	+ && in_array($matchesExtended[1], [ 'slotted' ])) {
692	+ $prev = end($out);
693	+ $prev = $this->glueFunctionSelectors($prev);
694	+ if (count($prev) === 1 && count(reset($prev)) === 1) {
695	+ $single = reset($prev);
696	+ $part = reset($single);
697	+ if ($this->isPseudoSelector($part, $matchesPrev)
698	+ && $matchesPrev[1] === $matchesExtended[1]) {
699	+ $extended = explode($matchesExtended[1] . '(', $matchesExtended[0], 2);
700	+ $extended[1] = $matchesPrev[2] . ", " . $extended[1];
701	+ $extended = implode($matchesExtended[1] . '(', $extended);
702	+ $extended = [ [ $extended ]];
703	+ array_pop($out);
704	}
705	}
706	}
707	}
708	+ $out[] = $extended;
709	}
710
711	/**

713	*
714	* @param array $rawSingle
715	* @param array $outOrigin
716	+ * @param bool $initial
717	*
718	* @return boolean
719	*/
720	+ protected function matchExtendsSingle($rawSingle, &$outOrigin, $initial = true)
721	{
722	$counts = [];
723	$single = [];
724
725	+ // simple usual cases, no need to do the whole trick
726	+ if (in_array($rawSingle, [['>'],['+'],['~']])) {
727	+ return false;
728	+ }
729	+
730	foreach ($rawSingle as $part) {
731	// matches Number
732	if (! is_string($part)) {

747	$extendingDecoratedTag = preg_match('/^[a-z0-9]+$/i', $single[0], $matches) ? $matches[0] : false;
748	}
749
750	+ $outOrigin = [];
751	+ $found = false;
752	+
753	+ foreach ($single as $k => $part) {
754	if (isset($this->extendsMap[$part])) {
755	foreach ($this->extendsMap[$part] as $idx) {
756	$counts[$idx] = isset($counts[$idx]) ? $counts[$idx] + 1 : 1;
757	}
758	}
759	+ if ($initial
760	+ && $this->isPseudoSelector($part, $matches)
761	+ && ! in_array($matches[1], [ 'not' ])) {
762	+ $buffer = $matches[2];
763	+ $parser = $this->parserFactory(__METHOD__);
764	+ if ($parser->parseSelector($buffer, $subSelectors)) {
765	+ foreach ($subSelectors as $ksub => $subSelector) {
766	+ $subExtended = [];
767	+ $this->matchExtends($subSelector, $subExtended, 0, false);
768	+ if ($subExtended) {
769	+ $subSelectorsExtended = $subSelectors;
770	+ $subSelectorsExtended[$ksub] = $subExtended;
771	+ foreach ($subSelectorsExtended as $ksse => $sse) {
772	+ $subSelectorsExtended[$ksse] = $this->collapseSelectors($sse);
773	+ }
774	+ $subSelectorsExtended = implode(', ', $subSelectorsExtended);
775	+ $singleExtended = $single;
776	+ $singleExtended[$k] = str_replace("(".$buffer.")", "($subSelectorsExtended)", $part);
777	+ $outOrigin[] = [ $singleExtended ];
778	+ $found = true;
779	+ }
780	+ }
781	+ }
782	+ }
783	}
784



785	foreach ($counts as $idx => $count) {
786	list($target, $origin, /* $block */) = $this->extends[$idx];
787
788	+ $origin = $this->glueFunctionSelectors($origin);
789	+
790	// check count
791	if ($count !== count($target)) {
792	continue;

827	return $found;
828	}
829

830	/**
831	* Extract a relationship from the fragment.
832	*

836	* the rest.
837	*
838	* @param array $fragment The selector fragment maybe ending with a direction relationship combinator.
839	+ *
840	* @return array The selector without the relationship fragment if any, the relationship fragment.
841	*/
842	protected function extractRelationshipFromFragment(array $fragment)
843	{
844	$parents = [];
845	$children = [];
846	+
847	$j = $i = count($fragment);
848
849	for (;;) {
850	$children = $j != $i ? array_slice($fragment, $j, $i - $j) : [];
851	+ $parents = array_slice($fragment, 0, $j);
852	+ $slice = end($parents);
853
854	if (empty($slice) \|\| ! $this->isImmediateRelationshipCombinator($slice[0])) {
855	break;

871	*/
872	protected function combineSelectorSingle($base, $other)
873	{
874	+ $tag = [];
875	+ $out = [];
876	+ $wasTag = false;
877	+ $pseudo = [];
878	+
879	+ while (count($other) && strpos(end($other), ':')===0) {
880	+ array_unshift($pseudo, array_pop($other));
881	+ }
882
883	+ foreach ([array_reverse($base), array_reverse($other)] as $single) {
884	foreach ($single as $part) {
885	+ if (preg_match('/^[\[:]/', $part)) {
886	$out[] = $part;
887	$wasTag = false;
888	+ } elseif (preg_match('/^[\.#]/', $part)) {
889	+ array_unshift($out, $part);
890	+ $wasTag = false;
891	} elseif (preg_match('/^[^_-]/', $part)) {
892	$tag[] = $part;
893	$wasTag = true;
894	} elseif ($wasTag) {
895	$tag[count($tag) - 1] .= $part;
896	} else {
897	+ $out[] = $part;
898	}
899	}
900	}

902	if (count($tag)) {
903	array_unshift($out, $tag[0]);
904	}
905	+ while (count($pseudo)) {
906	+ $out[] = array_shift($pseudo);
907	+ }
908
909	return $out;
910	}

912	/**
913	* Compile media
914	*
915	+ * @param \ScssPhp\ScssPhp\Block $media
916	*/
917	protected function compileMedia(Block $media)
918	{
919	$this->pushEnv($media);
920
921	+ $mediaQueries = $this->compileMediaQuery($this->multiplyMedia($this->env));



922
923	+ if (! empty($mediaQueries) && $mediaQueries) {
924	+ $previousScope = $this->scope;
925	$parentScope = $this->mediaParent($this->scope);
926	+
927	+ foreach ($mediaQueries as $mediaQuery) {
928	+ $this->scope = $this->makeOutputBlock(Type::T_MEDIA, [$mediaQuery]);
929	+
930	+ $parentScope->children[] = $this->scope;
931	+ $parentScope = $this->scope;
932	+ }
933
934	// top level properties in a media cause it to be wrapped
935	$needsWrap = false;

959	$wrapped->children = $media->children;
960
961	$media->children = [[Type::T_BLOCK, $wrapped]];
962	+
963	+ if (isset($this->lineNumberStyle)) {
964	+ $annotation = $this->makeOutputBlock(Type::T_COMMENT);
965	+ $annotation->depth = 0;
966	+
967	+ $file = $this->sourceNames[$media->sourceIndex];
968	+ $line = $media->sourceLine;
969	+
970	+ switch ($this->lineNumberStyle) {
971	+ case static::LINE_COMMENTS:
972	+ $annotation->lines[] = '/* line ' . $line
973	+ . ($file ? ', ' . $file : '')
974	+ . ' */';
975	+ break;
976	+
977	+ case static::DEBUG_INFO:
978	+ $annotation->lines[] = '@media -sass-debug-info{'
979	+ . ($file ? 'filename{font-family:"' . $file . '"}' : '')
980	+ . 'line{font-family:' . $line . '}}';
981	+ break;
982	+ }
983	+
984	+ $this->scope->children[] = $annotation;
985	+ }
986	}
987
988	$this->compileChildrenNoReturn($media->children, $this->scope);
989
990	+ $this->scope = $previousScope;
991	}
992
993	$this->popEnv();

996	/**
997	* Media parent
998	*
999	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $scope
1000	*
1001	+ * @return \ScssPhp\ScssPhp\Formatter\OutputBlock
1002	*/
1003	protected function mediaParent(OutputBlock $scope)
1004	{

1016	/**
1017	* Compile directive
1018	*
1019	+ * @param \ScssPhp\ScssPhp\Block\|array $block
1020	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
1021	*/
1022	+ protected function compileDirective($directive, OutputBlock $out)
1023	{
1024	+ if (is_array($directive)) {
1025	+ $s = '@' . $directive[0];
1026	+ if (! empty($directive[1])) {
1027	+ $s .= ' ' . $this->compileValue($directive[1]);
1028	+ }
1029	+ $this->appendRootDirective($s . ';', $out);
1030	+ } else {
1031	+ $s = '@' . $directive->name;
1032
1033	+ if (! empty($directive->value)) {
1034	+ $s .= ' ' . $this->compileValue($directive->value);
1035	+ }
1036
1037	+ if ($directive->name === 'keyframes' \|\| substr($directive->name, -10) === '-keyframes') {
1038	+ $this->compileKeyframeBlock($directive, [$s]);
1039	+ } else {
1040	+ $this->compileNestedBlock($directive, [$s]);
1041	+ }
1042	}
1043	}
1044
1045	/**
1046	* Compile at-root
1047	*
1048	+ * @param \ScssPhp\ScssPhp\Block $block
1049	*/
1050	protected function compileAtRoot(Block $block)
1051	{
1052	$env = $this->pushEnv($block);
1053	$envs = $this->compactEnv($env);
1054	+ list($with, $without) = $this->compileWith(isset($block->with) ? $block->with : null);
1055
1056	// wrap inline selector
1057	if ($block->selector) {

1064	$wrapped->comments = [];
1065	$wrapped->parent = $block;
1066	$wrapped->children = $block->children;
1067	+ $wrapped->selfParent = $block->selfParent;
1068
1069	$block->children = [[Type::T_BLOCK, $wrapped]];
1070	+ $block->selector = null;
1071	+ }
1072	+
1073	+ $selfParent = $block->selfParent;
1074	+
1075	+ if (! $block->selfParent->selectors && isset($block->parent) && $block->parent &&
1076	+ isset($block->parent->selectors) && $block->parent->selectors
1077	+ ) {
1078	+ $selfParent = $block->parent;
1079	}
1080
1081	+ $this->env = $this->filterWithWithout($envs, $with, $without);

1082
1083	$saveScope = $this->scope;
1084	+ $this->scope = $this->filterScopeWithWithout($saveScope, $with, $without);
1085
1086	+ // propagate selfParent to the children where they still can be useful
1087	+ $this->compileChildrenNoReturn($block->children, $this->scope, $selfParent);
1088
1089	+ $this->scope = $this->completeScope($this->scope, $saveScope);
1090	$this->scope = $saveScope;
1091	$this->env = $this->extractEnv($envs);
1092

1094	}
1095
1096	/**
1097	+ * Filter at-root scope depending of with/without option
1098	*
1099	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $scope
1100	+ * @param array $with
1101	+ * @param array $without
1102	*
1103	+ * @return mixed
1104	*/
1105	+ protected function filterScopeWithWithout($scope, $with, $without)
1106	{
1107	+ $filteredScopes = [];
1108	+ $childStash = [];
1109
1110	+ if ($scope->type === TYPE::T_ROOT) {
1111	+ return $scope;
1112	+ }

1113
1114	+ // start from the root
1115	+ while ($scope->parent && $scope->parent->type !== TYPE::T_ROOT) {
1116	+ array_unshift($childStash, $scope);
1117	+ $scope = $scope->parent;
1118	+ }
1119	+
1120	+ for (;;) {
1121	+ if (! $scope) {
1122	+ break;
1123	}
1124
1125	+ if ($this->isWith($scope, $with, $without)) {
1126	+ $s = clone $scope;
1127	+ $s->children = [];
1128	+ $s->lines = [];
1129	+ $s->parent = null;
1130	+
1131	+ if ($s->type !== Type::T_MEDIA && $s->type !== Type::T_DIRECTIVE) {
1132	+ $s->selectors = [];
1133	+ }
1134	+
1135	+ $filteredScopes[] = $s;
1136	}
1137
1138	+ if (count($childStash)) {
1139	+ $scope = array_shift($childStash);
1140	+ } elseif ($scope->children) {
1141	+ $scope = end($scope->children);
1142	+ } else {
1143	+ $scope = null;
1144	}
1145	+ }
1146
1147	+ if (! count($filteredScopes)) {
1148	+ return $this->rootBlock;
1149	+ }





1150
1151	+ $newScope = array_shift($filteredScopes);
1152	+ $newScope->parent = $this->rootBlock;
1153
1154	+ $this->rootBlock->children[] = $newScope;
1155
1156	+ $p = &$newScope;






1157
1158	+ while (count($filteredScopes)) {
1159	+ $s = array_shift($filteredScopes);
1160	+ $s->parent = $p;
1161	+ $p->children[] = $s;
1162	+ $newScope = &$p->children[0];
1163	+ $p = &$p->children[0];
1164	+ }
1165
1166	+ return $newScope;
1167	+ }

1168
1169	+ /**
1170	+ * found missing selector from a at-root compilation in the previous scope
1171	+ * (if at-root is just enclosing a property, the selector is in the parent tree)
1172	+ *
1173	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $scope
1174	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $previousScope
1175	+ *
1176	+ * @return mixed
1177	+ */
1178	+ protected function completeScope($scope, $previousScope)
1179	+ {
1180	+ if (! $scope->type && (! $scope->selectors \|\| ! count($scope->selectors)) && count($scope->lines)) {
1181	+ $scope->selectors = $this->findScopeSelectors($previousScope, $scope->depth);
1182	+ }
1183
1184	+ if ($scope->children) {
1185	+ foreach ($scope->children as $k => $c) {
1186	+ $scope->children[$k] = $this->completeScope($c, $previousScope);
1187	}
1188	+ }
1189
1190	+ return $scope;
1191	+ }

1192
1193	+ /**
1194	+ * Find a selector by the depth node in the scope
1195	+ *
1196	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $scope
1197	+ * @param integer $depth
1198	+ *
1199	+ * @return array
1200	+ */
1201	+ protected function findScopeSelectors($scope, $depth)
1202	+ {
1203	+ if ($scope->depth === $depth && $scope->selectors) {
1204	+ return $scope->selectors;
1205	}
1206
1207	+ if ($scope->children) {
1208	+ foreach (array_reverse($scope->children) as $c) {
1209	+ if ($s = $this->findScopeSelectors($c, $depth)) {
1210	+ return $s;
1211	+ }
1212	+ }
1213	+ }
1214
1215	+ return [];
1216	}
1217
1218	/**
1219	+ * Compile @at-root's with: inclusion / without: exclusion into 2 lists uses to filter scope/env later
1220	*
1221	+ * @param array $withCondition
1222	*
1223	+ * @return array
1224	*/
1225	+ protected function compileWith($withCondition)
1226	{
1227	+ // just compile what we have in 2 lists
1228	+ $with = [];
1229	+ $without = ['rule' => true];



1230
1231	+ if ($withCondition) {
1232	+ if ($this->libMapHasKey([$withCondition, static::$with])) {
1233	+ $without = []; // cancel the default
1234	+ $list = $this->coerceList($this->libMapGet([$withCondition, static::$with]));
1235
1236	+ foreach ($list[2] as $item) {
1237	+ $keyword = $this->compileStringContent($this->coerceString($item));





1238
1239	+ $with[$keyword] = true;

1240	}
1241	}

1242
1243	+ if ($this->libMapHasKey([$withCondition, static::$without])) {
1244	+ $without = []; // cancel the default
1245	+ $list = $this->coerceList($this->libMapGet([$withCondition, static::$without]));
1246
1247	+ foreach ($list[2] as $item) {
1248	+ $keyword = $this->compileStringContent($this->coerceString($item));


1249
1250	+ $without[$keyword] = true;

1251	}
1252	}
1253	}
1254
1255	+ return [$with, $without];
1256	}
1257
1258	/**
1259	* Filter env stack
1260	*
1261	* @param array $envs
1262	+ * @param array $with
1263	+ * @param array $without
1264	*
1265	+ * @return \ScssPhp\ScssPhp\Compiler\Environment
1266	*/
1267	+ protected function filterWithWithout($envs, $with, $without)
1268	{
1269	$filtered = [];
1270
1271	foreach ($envs as $e) {
1272	+ if ($e->block && ! $this->isWith($e->block, $with, $without)) {
1273	+ $ec = clone $e;
1274	+ $ec->block = null;
1275	+ $ec->selectors = [];
1276
1277	+ $filtered[] = $ec;
1278	+ } else {
1279	+ $filtered[] = $e;
1280	+ }
1281	}
1282
1283	return $this->extractEnv($filtered);

1286	/**
1287	* Filter WITH rules
1288	*
1289	+ * @param \ScssPhp\ScssPhp\Block\|\ScssPhp\ScssPhp\Formatter\OutputBlock $block
1290	+ * @param array $with
1291	+ * @param array $without
1292	*
1293	* @return boolean
1294	*/
1295	+ protected function isWith($block, $with, $without)
1296	{
1297	+ if (isset($block->type)) {
1298	+ if ($block->type === Type::T_MEDIA) {
1299	+ return $this->testWithWithout('media', $with, $without);
1300	+ }
1301	+
1302	+ if ($block->type === Type::T_DIRECTIVE) {
1303	+ if (isset($block->name)) {
1304	+ return $this->testWithWithout($block->name, $with, $without);
1305	+ } elseif (isset($block->selectors) && preg_match(',@(\w+),ims', json_encode($block->selectors), $m)) {
1306	+ return $this->testWithWithout($m[1], $with, $without);
1307	+ } else {
1308	+ return $this->testWithWithout('???', $with, $without);
1309	+ }
1310	+ }
1311	+ } elseif (isset($block->selectors)) {
1312	+ // a selector starting with number is a keyframe rule
1313	+ if (count($block->selectors)) {
1314	+ $s = reset($block->selectors);
1315	+
1316	+ while (is_array($s)) {
1317	+ $s = reset($s);
1318	+ }
1319	+
1320	+ if (is_object($s) && $s instanceof Node\Number) {
1321	+ return $this->testWithWithout('keyframes', $with, $without);
1322	+ }
1323	+ }
1324	+
1325	+ return $this->testWithWithout('rule', $with, $without);
1326	}
1327
1328	+ return true;
1329	+ }
1330	+
1331	+ /**
1332	+ * Test a single type of block against with/without lists
1333	+ *
1334	+ * @param string $what
1335	+ * @param array $with
1336	+ * @param array $without
1337	+ *
1338	+ * @return boolean
1339	+ * true if the block should be kept, false to reject
1340	+ */
1341	+ protected function testWithWithout($what, $with, $without)
1342	+ {
1343	+
1344	+ // if without, reject only if in the list (or 'all' is in the list)
1345	+ if (count($without)) {
1346	+ return (isset($without[$what]) \|\| isset($without['all'])) ? false : true;
1347	+ }
1348	+
1349	+ // otherwise reject all what is not in the with list
1350	+ return (isset($with[$what]) \|\| isset($with['all'])) ? true : false;
1351	}
1352
1353	+
1354	/**
1355	* Compile keyframe block
1356	*
1357	+ * @param \ScssPhp\ScssPhp\Block $block
1358	+ * @param array $selectors
1359	*/
1360	protected function compileKeyframeBlock(Block $block, $selectors)
1361	{

1379	$this->popEnv();
1380	}
1381
1382	+ /**
1383	+ * Compile nested properties lines
1384	+ *
1385	+ * @param \ScssPhp\ScssPhp\Block $block
1386	+ * @param OutputBlock $out
1387	+ */
1388	+ protected function compileNestedPropertiesBlock(Block $block, OutputBlock $out)
1389	+ {
1390	+ $prefix = $this->compileValue($block->prefix) . '-';
1391	+
1392	+ $nested = $this->makeOutputBlock($block->type);
1393	+ $nested->parent = $out;
1394	+
1395	+ if ($block->hasValue) {
1396	+ $nested->depth = $out->depth + 1;
1397	+ }
1398	+
1399	+ $out->children[] = $nested;
1400	+
1401	+ foreach ($block->children as $child) {
1402	+ switch ($child[0]) {
1403	+ case Type::T_ASSIGN:
1404	+ array_unshift($child[1][2], $prefix);
1405	+ break;
1406	+
1407	+ case Type::T_NESTED_PROPERTY:
1408	+ array_unshift($child[1]->prefix[2], $prefix);
1409	+ break;
1410	+ }
1411	+
1412	+ $this->compileChild($child, $nested);
1413	+ }
1414	+ }
1415	+
1416	/**
1417	* Compile nested block
1418	*
1419	+ * @param \ScssPhp\ScssPhp\Block $block
1420	+ * @param array $selectors
1421	*/
1422	protected function compileNestedBlock(Block $block, $selectors)
1423	{

1426	$this->scope = $this->makeOutputBlock($block->type, $selectors);
1427	$this->scope->parent->children[] = $this->scope;
1428
1429	+ // wrap assign children in a block
1430	+ // except for @font-face
1431	+ if ($block->type !== Type::T_DIRECTIVE \|\| $block->name !== "font-face") {
1432	+ // need wrapping?
1433	+ $needWrapping = false;
1434	+
1435	+ foreach ($block->children as $child) {
1436	+ if ($child[0] === Type::T_ASSIGN) {
1437	+ $needWrapping = true;
1438	+ break;
1439	+ }
1440	+ }
1441	+
1442	+ if ($needWrapping) {
1443	+ $wrapped = new Block;
1444	+ $wrapped->sourceName = $block->sourceName;
1445	+ $wrapped->sourceIndex = $block->sourceIndex;
1446	+ $wrapped->sourceLine = $block->sourceLine;
1447	+ $wrapped->sourceColumn = $block->sourceColumn;
1448	+ $wrapped->selectors = [];
1449	+ $wrapped->comments = [];
1450	+ $wrapped->parent = $block;
1451	+ $wrapped->children = $block->children;
1452	+ $wrapped->selfParent = $block->selfParent;
1453	+
1454	+ $block->children = [[Type::T_BLOCK, $wrapped]];
1455	+ }
1456	+ }
1457	+
1458	$this->compileChildrenNoReturn($block->children, $this->scope);
1459
1460	$this->scope = $this->scope->parent;

1478	*
1479	* @see Compiler::compileChild()
1480	*
1481	+ * @param \ScssPhp\ScssPhp\Block $block
1482	*/
1483	protected function compileBlock(Block $block)
1484	{

1514	$this->scope->children[] = $out;
1515
1516	if (count($block->children)) {
1517	+ $out->selectors = $this->multiplySelectors($env, $block->selfParent);
1518
1519	+ // propagate selfParent to the children where they still can be useful
1520	+ $selfParentSelectors = null;
1521
1522	+ if (isset($block->selfParent->selectors)) {
1523	+ $selfParentSelectors = $block->selfParent->selectors;
1524	+ $block->selfParent->selectors = $out->selectors;
1525	+ }
1526
1527	+ $this->compileChildrenNoReturn($block->children, $out, $block->selfParent);

1528
1529	+ // and revert for the following children of the same block
1530	+ if ($selfParentSelectors) {
1531	+ $block->selfParent->selectors = $selfParentSelectors;
1532	+ }
1533	+ }
1534	+
1535	+ $this->popEnv();
1536	+ }
1537	+
1538	+
1539	+ /**
1540	+ * Compile the value of a comment that can have interpolation
1541	+ *
1542	+ * @param array $value
1543	+ * @param boolean $pushEnv
1544	+ *
1545	+ * @return array\|mixed\|string
1546	+ */
1547	+ protected function compileCommentValue($value, $pushEnv = false)
1548	+ {
1549	+ $c = $value[1];
1550	+
1551	+ if (isset($value[2])) {
1552	+ if ($pushEnv) {
1553	+ $this->pushEnv();
1554	+ $storeEnv = $this->storeEnv;
1555	+ $this->storeEnv = $this->env;
1556	+ }
1557	+
1558	+ try {
1559	+ $c = $this->compileValue($value[2]);
1560	+ } catch (\Exception $e) {
1561	+ // ignore error in comment compilation which are only interpolation
1562	+ }
1563	+
1564	+ if ($pushEnv) {
1565	+ $this->storeEnv = $storeEnv;
1566	+ $this->popEnv();
1567	+ }
1568	+ }
1569	+
1570	+ return $c;
1571	+ }
1572	+
1573	+ /**
1574	* Compile root level comment
1575	*
1576	* @param array $block

1578	protected function compileComment($block)
1579	{
1580	$out = $this->makeOutputBlock(Type::T_COMMENT);
1581	+ $out->lines[] = $this->compileCommentValue($block, true);
1582	+
1583	$this->scope->children[] = $out;
1584	}
1585

1598
1599	// after evaluating interpolates, we might need a second pass
1600	if ($this->shouldEvaluate) {
1601	+ $selectors = $this->revertSelfSelector($selectors);
1602	+ $buffer = $this->collapseSelectors($selectors);
1603	+ $parser = $this->parserFactory(__METHOD__);
1604
1605	if ($parser->parseSelector($buffer, $newSelectors)) {
1606	$selectors = array_map([$this, 'evalSelector'], $newSelectors);

1653	/**
1654	* Collapse selectors
1655	*
1656	+ * @param array $selectors
1657	+ * @param boolean $selectorFormat
1658	+ * if false return a collapsed string
1659	+ * if true return an array description of a structured selector
1660	*
1661	* @return string
1662	*/
1663	+ protected function collapseSelectors($selectors, $selectorFormat = false)
1664	{
1665	$parts = [];
1666
1667	foreach ($selectors as $selector) {
1668	+ $output = [];
1669	+ $glueNext = false;
1670
1671	+ foreach ($selector as $node) {
1672	+ $compound = '';
1673	+
1674	+ array_walk_recursive(
1675	+ $node,
1676	+ function ($value, $key) use (&$compound) {
1677	+ $compound .= $value;
1678	+ }
1679	+ );
1680	+
1681	+ if ($selectorFormat && $this->isImmediateRelationshipCombinator($compound)) {
1682	+ if (count($output)) {
1683	+ $output[count($output) - 1] .= ' ' . $compound;
1684	+ } else {
1685	+ $output[] = $compound;
1686	+ }
1687	+
1688	+ $glueNext = true;
1689	+ } elseif ($glueNext) {
1690	+ $output[count($output) - 1] .= ' ' . $compound;
1691	+ $glueNext = false;
1692	+ } else {
1693	+ $output[] = $compound;
1694	}
1695	+ }
1696	+
1697	+ if ($selectorFormat) {
1698	+ foreach ($output as &$o) {
1699	+ $o = [Type::T_STRING, '', [$o]];
1700	+ }
1701	+
1702	+ $output = [Type::T_LIST, ' ', $output];
1703	+ } else {
1704	+ $output = implode(' ', $output);
1705	+ }
1706
1707	$parts[] = $output;
1708	}
1709
1710	+ if ($selectorFormat) {
1711	+ $parts = [Type::T_LIST, ',', $parts];
1712	+ } else {
1713	+ $parts = implode(', ', $parts);
1714	+ }
1715	+
1716	+ return $parts;
1717	+ }
1718	+
1719	+ /**
1720	+ * Parse down the selector and revert [self] to "&" before a reparsing
1721	+ *
1722	+ * @param array $selectors
1723	+ *
1724	+ * @return array
1725	+ */
1726	+ protected function revertSelfSelector($selectors)
1727	+ {
1728	+ foreach ($selectors as &$part) {
1729	+ if (is_array($part)) {
1730	+ if ($part === [Type::T_SELF]) {
1731	+ $part = '&';
1732	+ } else {
1733	+ $part = $this->revertSelfSelector($part);
1734	+ }
1735	+ }
1736	+ }
1737	+
1738	+ return $selectors;
1739	}
1740
1741	/**

1842	return false;
1843	}
1844
1845	+ protected function pushCallStack($name = '')
1846	+ {
1847	+ $this->callStack[] = [
1848	+ 'n' => $name,
1849	+ Parser::SOURCE_INDEX => $this->sourceIndex,
1850	+ Parser::SOURCE_LINE => $this->sourceLine,
1851	+ Parser::SOURCE_COLUMN => $this->sourceColumn
1852	+ ];
1853	+
1854	+ // infinite calling loop
1855	+ if (count($this->callStack) > 25000) {
1856	+ // not displayed but you can var_dump it to deep debug
1857	+ $msg = $this->callStackMessage(true, 100);
1858	+ $msg = "Infinite calling loop";
1859	+
1860	+ $this->throwError($msg);
1861	+ }
1862	+ }
1863	+
1864	+ protected function popCallStack()
1865	+ {
1866	+ array_pop($this->callStack);
1867	+ }
1868	+
1869	/**
1870	* Compile children and return result
1871	*
1872	+ * @param array $stms
1873	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
1874	+ * @param string $traceName
1875	*
1876	+ * @return array\|null
1877	*/
1878	+ protected function compileChildren($stms, OutputBlock $out, $traceName = '')
1879	{
1880	+ $this->pushCallStack($traceName);
1881	+
1882	foreach ($stms as $stm) {
1883	$ret = $this->compileChild($stm, $out);
1884

1886	return $ret;
1887	}
1888	}
1889	+
1890	+ $this->popCallStack();
1891	+
1892	+ return null;
1893	}
1894
1895	/**
1896	* Compile children and throw exception if unexpected @return
1897	*
1898	+ * @param array $stms
1899	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
1900	+ * @param \ScssPhp\ScssPhp\Block $selfParent
1901	+ * @param string $traceName
1902	*
1903	* @throws \Exception
1904	*/
1905	+ protected function compileChildrenNoReturn($stms, OutputBlock $out, $selfParent = null, $traceName = '')
1906	{
1907	+ $this->pushCallStack($traceName);
1908	+
1909	foreach ($stms as $stm) {
1910	+ if ($selfParent && isset($stm[1]) && is_object($stm[1]) && $stm[1] instanceof Block) {
1911	+ $stm[1]->selfParent = $selfParent;
1912	+ $ret = $this->compileChild($stm, $out);
1913	+ $stm[1]->selfParent = null;
1914	+ } elseif ($selfParent && in_array($stm[0], [TYPE::T_INCLUDE, TYPE::T_EXTEND])) {
1915	+ $stm['selfParent'] = $selfParent;
1916	+ $ret = $this->compileChild($stm, $out);
1917	+ unset($stm['selfParent']);
1918	+ } else {
1919	+ $ret = $this->compileChild($stm, $out);
1920	+ }
1921
1922	if (isset($ret)) {
1923	$this->throwError('@return may only be used within a function');

1925	return;
1926	}
1927	}
1928	+
1929	+ $this->popCallStack();
1930	+ }
1931	+
1932	+
1933	+ /**
1934	+ * evaluate media query : compile internal value keeping the structure inchanged
1935	+ *
1936	+ * @param array $queryList
1937	+ *
1938	+ * @return array
1939	+ */
1940	+ protected function evaluateMediaQuery($queryList)
1941	+ {
1942	+ static $parser = null;
1943	+
1944	+ $outQueryList = [];
1945	+
1946	+ foreach ($queryList as $kql => $query) {
1947	+ $shouldReparse = false;
1948	+
1949	+ foreach ($query as $kq => $q) {
1950	+ for ($i = 1; $i < count($q); $i++) {
1951	+ $value = $this->compileValue($q[$i]);
1952	+
1953	+ // the parser had no mean to know if media type or expression if it was an interpolation
1954	+ // so you need to reparse if the T_MEDIA_TYPE looks like anything else a media type
1955	+ if ($q[0] == Type::T_MEDIA_TYPE &&
1956	+ (strpos($value, '(') !== false \|\|
1957	+ strpos($value, ')') !== false \|\|
1958	+ strpos($value, ':') !== false \|\|
1959	+ strpos($value, ',') !== false)
1960	+ ) {
1961	+ $shouldReparse = true;
1962	+ }
1963	+
1964	+ $queryList[$kql][$kq][$i] = [Type::T_KEYWORD, $value];
1965	+ }
1966	+ }
1967	+
1968	+ if ($shouldReparse) {
1969	+ if (is_null($parser)) {
1970	+ $parser = $this->parserFactory(__METHOD__);
1971	+ }
1972	+
1973	+ $queryString = $this->compileMediaQuery([$queryList[$kql]]);
1974	+ $queryString = reset($queryString);
1975	+
1976	+ if (strpos($queryString, '@media ') === 0) {
1977	+ $queryString = substr($queryString, 7);
1978	+ $queries = [];
1979	+
1980	+ if ($parser->parseMediaQueryList($queryString, $queries)) {
1981	+ $queries = $this->evaluateMediaQuery($queries[2]);
1982	+
1983	+ while (count($queries)) {
1984	+ $outQueryList[] = array_shift($queries);
1985	+ }
1986	+
1987	+ continue;
1988	+ }
1989	+ }
1990	+ }
1991	+
1992	+ $outQueryList[] = $queryList[$kql];
1993	+ }
1994	+
1995	+ return $outQueryList;
1996	}
1997
1998	/**

2000	*
2001	* @param array $queryList
2002	*
2003	+ * @return array
2004	*/
2005	protected function compileMediaQuery($queryList)
2006	{
2007	+ $start = '@media ';
2008	+ $default = trim($start);
2009	+ $out = [];
2010	+ $current = "";
2011
2012	foreach ($queryList as $query) {
2013	$type = null;
2014	$parts = [];
2015
2016	+ $mediaTypeOnly = true;
2017	+
2018	+ foreach ($query as $q) {
2019	+ if ($q[0] !== Type::T_MEDIA_TYPE) {
2020	+ $mediaTypeOnly = false;
2021	+ break;
2022	+ }
2023	+ }
2024	+
2025	foreach ($query as $q) {
2026	switch ($q[0]) {
2027	case Type::T_MEDIA_TYPE:
2028	+ $newType = array_map([$this, 'compileValue'], array_slice($q, 1));




2029
2030	+ // combining not and anything else than media type is too risky and should be avoided
2031	+ if (! $mediaTypeOnly) {
2032	+ if (in_array(Type::T_NOT, $newType) \|\| ($type && in_array(Type::T_NOT, $type) )) {
2033	+ if ($type) {
2034	+ array_unshift($parts, implode(' ', array_filter($type)));
2035	+ }
2036	+
2037	+ if (! empty($parts)) {
2038	+ if (strlen($current)) {
2039	+ $current .= $this->formatter->tagSeparator;
2040	+ }
2041	+
2042	+ $current .= implode(' and ', $parts);
2043	+ }
2044	+
2045	+ if ($current) {
2046	+ $out[] = $start . $current;
2047	+ }
2048	+
2049	+ $current = "";
2050	+ $type = null;
2051	+ $parts = [];
2052	+ }
2053	+ }
2054	+
2055	+ if ($newType === ['all'] && $default) {
2056	+ $default = $start . 'all';
2057	+ }
2058	+
2059	+ // all can be safely ignored and mixed with whatever else
2060	+ if ($newType !== ['all']) {
2061	+ if ($type) {
2062	+ $type = $this->mergeMediaTypes($type, $newType);
2063	+
2064	+ if (empty($type)) {
2065	+ // merge failed : ignore this query that is not valid, skip to the next one
2066	+ $parts = [];
2067	+ $default = ''; // if everything fail, no @media at all
2068	+ continue 3;
2069	+ }
2070	+ } else {
2071	+ $type = $newType;
2072	}


2073	}
2074	break;
2075

2098	}
2099
2100	if (! empty($parts)) {
2101	+ if (strlen($current)) {
2102	+ $current .= $this->formatter->tagSeparator;



2103	}
2104
2105	+ $current .= implode(' and ', $parts);
2106	}
2107	}
2108
2109	+ if ($current) {
2110	+ $out[] = $start . $current;
2111	+ }
2112	+
2113	+ // no @media type except all, and no conflict?
2114	+ if (! $out && $default) {
2115	+ $out[] = $default;
2116	+ }
2117	+
2118	return $out;
2119	}
2120
2121	+ /**
2122	+ * Merge direct relationships between selectors
2123	+ *
2124	+ * @param array $selectors1
2125	+ * @param array $selectors2
2126	+ *
2127	+ * @return array
2128	+ */
2129	protected function mergeDirectRelationships($selectors1, $selectors2)
2130	{
2131	if (empty($selectors1) \|\| empty($selectors2)) {

2135	$part1 = end($selectors1);
2136	$part2 = end($selectors2);
2137
2138	+ if (! $this->isImmediateRelationshipCombinator($part1[0]) && $part1 !== $part2) {
2139	return array_merge($selectors1, $selectors2);
2140	}
2141

2145	$part1 = array_pop($selectors1);
2146	$part2 = array_pop($selectors2);
2147
2148	+ if (! $this->isImmediateRelationshipCombinator($part1[0]) && $part1 !== $part2) {
2149	+ if ($this->isImmediateRelationshipCombinator(reset($merged)[0])) {
2150	+ array_unshift($merged, [$part1[0] . $part2[0]]);
2151	+ $merged = array_merge($selectors1, $selectors2, $merged);
2152	+ } else {
2153	+ $merged = array_merge($selectors1, [$part1], $selectors2, [$part2], $merged);
2154	+ }
2155	+
2156	break;
2157	}
2158
2159	array_unshift($merged, $part1);

2160	} while (! empty($selectors1) && ! empty($selectors2));
2161
2162	return $merged;

2180	return $type1;
2181	}
2182



2183	if (count($type1) > 1) {
2184	+ $m1 = strtolower($type1[0]);
2185	+ $t1 = strtolower($type1[1]);
2186	} else {
2187	+ $m1 = '';
2188	$t1 = strtolower($type1[0]);
2189	}
2190



2191	if (count($type2) > 1) {
2192	$m2 = strtolower($type2[0]);
2193	$t2 = strtolower($type2[1]);
2194	} else {
2195	+ $m2 = '';
2196	$t2 = strtolower($type2[0]);
2197	}
2198

2227	/**
2228	* Compile import; returns true if the value was something that could be imported
2229	*
2230	+ * @param array $rawPath
2231	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
2232	+ * @param boolean $once
2233	*
2234	* @return boolean
2235	*/
2236	+ protected function compileImport($rawPath, OutputBlock $out, $once = false)
2237	{
2238	if ($rawPath[0] === Type::T_STRING) {
2239	$path = $this->compileStringContent($rawPath);

2247	return true;
2248	}
2249
2250	+ $this->appendRootDirective('@import ' . $this->compileValue($rawPath). ';', $out);
2251	+
2252	return false;
2253	}
2254

2260
2261	foreach ($rawPath[2] as $path) {
2262	if ($path[0] !== Type::T_STRING) {
2263	+ $this->appendRootDirective('@import ' . $this->compileValue($rawPath) . ';', $out);
2264	+
2265	return false;
2266	}
2267	}
2268
2269	foreach ($rawPath[2] as $path) {
2270	+ $this->compileImport($path, $out, $once);
2271	}
2272
2273	return true;
2274	}
2275
2276	+ $this->appendRootDirective('@import ' . $this->compileValue($rawPath) . ';', $out);
2277	+
2278	return false;
2279	}
2280
2281	+
2282	+ /**
2283	+ * Append a root directive like @import or @charset as near as the possible from the source code
2284	+ * (keeping before comments, @import and @charset coming before in the source code)
2285	+ *
2286	+ * @param string $line
2287	+ * @param @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
2288	+ * @param array $allowed
2289	+ */
2290	+ protected function appendRootDirective($line, $out, $allowed = [Type::T_COMMENT])
2291	+ {
2292	+ $root = $out;
2293	+
2294	+ while ($root->parent) {
2295	+ $root = $root->parent;
2296	+ }
2297	+
2298	+ $i = 0;
2299	+
2300	+ while ($i < count($root->children)) {
2301	+ if (! isset($root->children[$i]->type) \|\| ! in_array($root->children[$i]->type, $allowed)) {
2302	+ break;
2303	+ }
2304	+
2305	+ $i++;
2306	+ }
2307	+
2308	+ // remove incompatible children from the bottom of the list
2309	+ $saveChildren = [];
2310	+
2311	+ while ($i < count($root->children)) {
2312	+ $saveChildren[] = array_pop($root->children);
2313	+ }
2314	+
2315	+ // insert the directive as a comment
2316	+ $child = $this->makeOutputBlock(Type::T_COMMENT);
2317	+ $child->lines[] = $line;
2318	+ $child->sourceName = $this->sourceNames[$this->sourceIndex];
2319	+ $child->sourceLine = $this->sourceLine;
2320	+ $child->sourceColumn = $this->sourceColumn;
2321	+
2322	+ $root->children[] = $child;
2323	+
2324	+ // repush children
2325	+ while (count($saveChildren)) {
2326	+ $root->children[] = array_pop($saveChildren);
2327	+ }
2328	+ }
2329	+
2330	+ /**
2331	+ * Append lines to the current output block:
2332	+ * directly to the block or through a child if necessary
2333	+ *
2334	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
2335	+ * @param string $type
2336	+ * @param string\|mixed $line
2337	+ */
2338	+ protected function appendOutputLine(OutputBlock $out, $type, $line)
2339	+ {
2340	+ $outWrite = &$out;
2341	+
2342	+ if ($type === Type::T_COMMENT) {
2343	+ $parent = $out->parent;
2344	+
2345	+ if (end($parent->children) !== $out) {
2346	+ $outWrite = &$parent->children[count($parent->children) - 1];
2347	+ }
2348	+ }
2349	+
2350	+ // check if it's a flat output or not
2351	+ if (count($out->children)) {
2352	+ $lastChild = &$out->children[count($out->children) - 1];
2353	+
2354	+ if ($lastChild->depth === $out->depth && is_null($lastChild->selectors) && ! count($lastChild->children)) {
2355	+ $outWrite = $lastChild;
2356	+ } else {
2357	+ $nextLines = $this->makeOutputBlock($type);
2358	+ $nextLines->parent = $out;
2359	+ $nextLines->depth = $out->depth;
2360	+
2361	+ $out->children[] = $nextLines;
2362	+ $outWrite = &$nextLines;
2363	+ }
2364	+ }
2365	+
2366	+ $outWrite->lines[] = $line;
2367	+ }
2368	+
2369	/**
2370	* Compile child; returns a value to halt execution
2371	*
2372	+ * @param array $child
2373	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
2374	*
2375	* @return array
2376	*/
2377	protected function compileChild($child, OutputBlock $out)
2378	{
2379	+ if (isset($child[Parser::SOURCE_LINE])) {
2380	+ $this->sourceIndex = isset($child[Parser::SOURCE_INDEX]) ? $child[Parser::SOURCE_INDEX] : null;
2381	+ $this->sourceLine = isset($child[Parser::SOURCE_LINE]) ? $child[Parser::SOURCE_LINE] : -1;
2382	+ $this->sourceColumn = isset($child[Parser::SOURCE_COLUMN]) ? $child[Parser::SOURCE_COLUMN] : -1;
2383	+ } elseif (is_array($child) && isset($child[1]->sourceLine)) {
2384	+ $this->sourceIndex = $child[1]->sourceIndex;
2385	+ $this->sourceLine = $child[1]->sourceLine;
2386	+ $this->sourceColumn = $child[1]->sourceColumn;
2387	+ } elseif (! empty($out->sourceLine) && ! empty($out->sourceName)) {
2388	+ $this->sourceLine = $out->sourceLine;
2389	+ $this->sourceIndex = array_search($out->sourceName, $this->sourceNames);
2390	+ $this->sourceColumn = $out->sourceColumn;
2391	+
2392	+ if ($this->sourceIndex === false) {
2393	+ $this->sourceIndex = null;
2394	+ }
2395	+ }
2396
2397	switch ($child[0]) {
2398	case Type::T_SCSSPHP_IMPORT_ONCE:
2399	+ $rawPath = $this->reduce($child[1]);


2400
2401	+ $this->compileImport($rawPath, $out, true);


2402	break;
2403
2404	case Type::T_IMPORT:
2405	+ $rawPath = $this->reduce($child[1]);


2406
2407	+ $this->compileImport($rawPath, $out);


2408	break;
2409
2410	case Type::T_DIRECTIVE:
2411	+ $this->compileDirective($child[1], $out);
2412	break;
2413
2414	case Type::T_AT_ROOT:

2426	case Type::T_CHARSET:
2427	if (! $this->charsetSeen) {
2428	$this->charsetSeen = true;
2429	+ $this->appendRootDirective('@charset ' . $this->compileValue($child[1]) . ';', $out);

2430	}
2431	break;
2432

2434	list(, $name, $value) = $child;
2435
2436	if ($name[0] === Type::T_VARIABLE) {
2437	+ $flags = isset($child[3]) ? $child[3] : [];
2438	$isDefault = in_array('!default', $flags);
2439	+ $isGlobal = in_array('!global', $flags);
2440
2441	if ($isGlobal) {
2442	+ $this->set($name[1], $this->reduce($value), false, $this->rootEnv, $value);
2443	break;
2444	}
2445
2446	$shouldSet = $isDefault &&
2447	+ (is_null($result = $this->get($name[1], false)) \|\|
2448	+ $result === static::$null);
2449
2450	if (! $isDefault \|\| $shouldSet) {
2451	+ $this->set($name[1], $this->reduce($value), true, null, $value);
2452	}
2453	break;
2454	}
2455
2456	$compiledName = $this->compileValue($name);
2457
2458	+ // handle shorthand syntaxes : size / line-height...
2459	+ if (in_array($compiledName, ['font', 'grid-row', 'grid-column', 'border-radius'])) {
2460	+ if ($value[0] === Type::T_VARIABLE) {
2461	+ // if the font value comes from variable, the content is already reduced
2462	+ // (i.e., formulas were already calculated), so we need the original unreduced value
2463	+ $value = $this->get($value[1], true, null, true);
2464	+ }
2465	+
2466	+ $shorthandValue=&$value;
2467	+
2468	+ $shorthandDividerNeedsUnit = false;
2469	+ $maxListElements = null;
2470	+ $maxShorthandDividers = 1;
2471	+
2472	+ switch ($compiledName) {
2473	+ case 'border-radius':
2474	+ $maxListElements = 4;
2475	+ $shorthandDividerNeedsUnit = true;
2476	+ break;
2477	+ }
2478	+
2479	+ if ($compiledName === 'font' and $value[0] === Type::T_LIST && $value[1]==',') {
2480	+ // this is the case if more than one font is given: example: "font: 400 1em/1.3 arial,helvetica"
2481	+ // we need to handle the first list element
2482	+ $shorthandValue=&$value[2][0];
2483	+ }
2484	+
2485	+ if ($shorthandValue[0] === Type::T_EXPRESSION && $shorthandValue[1] === '/') {
2486	+ $revert = true;
2487	+
2488	+ if ($shorthandDividerNeedsUnit) {
2489	+ $divider = $shorthandValue[3];
2490	+
2491	+ if (is_array($divider)) {
2492	+ $divider = $this->reduce($divider, true);
2493	+ }
2494	+
2495	+ if (intval($divider->dimension) and !count($divider->units)) {
2496	+ $revert = false;
2497	+ }
2498	+ }
2499	+
2500	+ if ($revert) {
2501	+ $shorthandValue = $this->expToString($shorthandValue);
2502	+ }
2503	+ } elseif ($shorthandValue[0] === Type::T_LIST) {
2504	+ foreach ($shorthandValue[2] as &$item) {
2505	if ($item[0] === Type::T_EXPRESSION && $item[1] === '/') {
2506	+ if ($maxShorthandDividers > 0) {
2507	+ $revert = true;
2508	+ // if the list of values is too long, this has to be a shorthand,
2509	+ // otherwise it could be a real division
2510	+ if (is_null($maxListElements) or count($shorthandValue[2]) <= $maxListElements) {
2511	+ if ($shorthandDividerNeedsUnit) {
2512	+ $divider = $item[3];
2513	+
2514	+ if (is_array($divider)) {
2515	+ $divider = $this->reduce($divider, true);
2516	+ }
2517	+
2518	+ if (intval($divider->dimension) and !count($divider->units)) {
2519	+ $revert = false;
2520	+ }
2521	+ }
2522	+ }
2523	+
2524	+ if ($revert) {
2525	+ $item = $this->expToString($item);
2526	+ $maxShorthandDividers--;
2527	+ }
2528	+ }
2529	}
2530	}
2531	}

2543
2544	$compiledValue = $this->compileValue($value);
2545
2546	+ $line = $this->formatter->property(
2547	$compiledName,
2548	$compiledValue
2549	);
2550	+ $this->appendOutputLine($out, Type::T_ASSIGN, $line);
2551	break;
2552
2553	case Type::T_COMMENT:

2556	break;
2557	}
2558
2559	+ $line = $this->compileCommentValue($child, true);
2560	+ $this->appendOutputLine($out, Type::T_COMMENT, $line);
2561	break;
2562
2563	case Type::T_MIXIN:
2564	case Type::T_FUNCTION:
2565	list(, $block) = $child;
2566	+ // the block need to be able to go up to it's parent env to resolve vars
2567	+ $block->parentEnv = $this->getStoreEnv();
2568	+ $this->set(static::$namespaces[$block->type] . $block->name, $block, true);
2569	break;
2570
2571	case Type::T_EXTEND:
2572	+ foreach ($child[1] as $sel) {


2573	$results = $this->evalSelectors([$sel]);
2574
2575	foreach ($results as $result) {
2576	// only use the first one
2577	$result = current($result);
2578	+ $selectors = $out->selectors;
2579
2580	+ if (! $selectors && isset($child['selfParent'])) {
2581	+ $selectors = $this->multiplySelectors($this->env, $child['selfParent']);
2582	+ }
2583	+
2584	+ $this->pushExtends($result, $selectors, $child);
2585	}
2586	}
2587	break;

2608	$list = $this->coerceList($this->reduce($each->list));
2609
2610	$this->pushEnv();
2611	+ $storeEnv = $this->storeEnv;
2612	+ $this->storeEnv = $this->env;
2613
2614	foreach ($list[2] as $item) {
2615	if (count($each->vars) === 1) {

2626
2627	if ($ret) {
2628	if ($ret[0] !== Type::T_CONTROL) {
2629	+ $store = $this->env->store;
2630	+ $this->storeEnv = $storeEnv;
2631	$this->popEnv();
2632	+ foreach ($store as $key => $value) {
2633	+ if (!in_array($key, $each->vars)) {
2634	+ $this->set($key, $value, true);
2635	+ }
2636	+ }
2637
2638	return $ret;
2639	}

2643	}
2644	}
2645	}
2646	+ $store = $this->env->store;
2647	+ $this->storeEnv = $storeEnv;
2648	$this->popEnv();
2649	+ foreach ($store as $key => $value) {
2650	+ if (!in_array($key, $each->vars)) {
2651	+ $this->set($key, $value, true);
2652	+ }
2653	+ }
2654	+
2655	break;
2656
2657	case Type::T_WHILE:

2724	return $this->reduce($child[1], true);
2725
2726	case Type::T_NESTED_PROPERTY:
2727	+ $this->compileNestedPropertiesBlock($child[1], $out);



















2728	break;
2729
2730	case Type::T_INCLUDE:
2731	// including a mixin
2732	+ list(, $name, $argValues, $content, $argUsing) = $child;
2733
2734	$mixin = $this->get(static::$namespaces['mixin'] . $name, false);
2735

2747	$storeEnv = $this->storeEnv;
2748	$this->storeEnv = $this->env;
2749
2750	+ // Find the parent selectors in the env to be able to know what '&' refers to in the mixin
2751	+ // and assign this fake parent to childs
2752	+ $selfParent = null;
2753
2754	+ if (isset($child['selfParent']) && isset($child['selfParent']->selectors)) {
2755	+ $selfParent = $child['selfParent'];
2756	+ } else {
2757	+ $parentSelectors = $this->multiplySelectors($this->env);
2758
2759	+ if ($parentSelectors) {
2760	+ $parent = new Block();
2761	+ $parent->selectors = $parentSelectors;
2762	+
2763	+ foreach ($mixin->children as $k => $child) {
2764	+ if (isset($child[1]) && is_object($child[1]) && $child[1] instanceof Block) {
2765	+ $mixin->children[$k][1]->parent = $parent;
2766	+ }
2767	+ }
2768	+ }
2769	+ }
2770	+
2771	+ // clone the stored content to not have its scope spoiled by a further call to the same mixin
2772	+ // i.e., recursive @include of the same mixin
2773	+ if (isset($content)) {
2774	+ $copyContent = clone $content;
2775	+ $copyContent->scope = clone $callingScope;
2776	+
2777	+ $this->setRaw(static::$namespaces['special'] . 'content', $copyContent, $this->env);
2778	+ } else {
2779	+ $this->setRaw(static::$namespaces['special'] . 'content', null, $this->env);
2780	+ }
2781	+
2782	+ // save the "using" argument list for applying it to when "@content" is invoked
2783	+ if (isset($argUsing)) {
2784	+ $this->setRaw(static::$namespaces['special'] . 'using', $argUsing, $this->env);
2785	+ } else {
2786	+ $this->setRaw(static::$namespaces['special'] . 'using', null, $this->env);
2787	+ }
2788	+
2789	+ if (isset($mixin->args)) {
2790	$this->applyArguments($mixin->args, $argValues);
2791	}
2792
2793	$this->env->marker = 'mixin';
2794
2795	+ if (! empty($mixin->parentEnv)) {
2796	+ $this->env->declarationScopeParent = $mixin->parentEnv;
2797	+ } else {
2798	+ $this->throwError("@mixin $name() without parentEnv");
2799	+ }
2800	+
2801	+ $this->compileChildrenNoReturn($mixin->children, $out, $selfParent, $this->env->marker . " " . $name);
2802
2803	$this->storeEnv = $storeEnv;
2804

2806	break;
2807
2808	case Type::T_MIXIN_CONTENT:
2809	+ $env = isset($this->storeEnv) ? $this->storeEnv : $this->env;
2810	+ $content = $this->get(static::$namespaces['special'] . 'content', false, $env);
2811	+ $argUsing = $this->get(static::$namespaces['special'] . 'using', false, $env);
2812	+ $argContent = $child[1];
2813
2814	if (! $content) {
2815	$content = new \stdClass();
2816	+ $content->scope = new \stdClass();
2817	+ $content->children = $env->parent->block->children;
2818	break;
2819	}
2820
2821	$storeEnv = $this->storeEnv;
2822	+ $varsUsing = [];
2823	+
2824	+ if (isset($argUsing) && isset($argContent)) {
2825	+ // Get the arguments provided for the content with the names provided in the "using" argument list
2826	+ $this->storeEnv = $this->env;
2827	+ $varsUsing = $this->applyArguments($argUsing, $argContent, false);
2828	+ }
2829	+
2830	+ // restore the scope from the @content
2831	$this->storeEnv = $content->scope;
2832
2833	+ // append the vars from using if any
2834	+ foreach ($varsUsing as $name => $val) {
2835	+ $this->set($name, $val, true, $this->storeEnv);
2836	+ }
2837	+
2838	$this->compileChildrenNoReturn($content->children, $out);
2839
2840	$this->storeEnv = $storeEnv;

2843	case Type::T_DEBUG:
2844	list(, $value) = $child;
2845
2846	+ $fname = $this->sourceNames[$this->sourceIndex];
2847	+ $line = $this->sourceLine;
2848	$value = $this->compileValue($this->reduce($value, true));
2849	+
2850	+ fwrite($this->stderr, "File $fname on line $line DEBUG: $value\n");
2851	break;
2852
2853	case Type::T_WARN:
2854	list(, $value) = $child;
2855
2856	+ $fname = $this->sourceNames[$this->sourceIndex];
2857	+ $line = $this->sourceLine;
2858	$value = $this->compileValue($this->reduce($value, true));
2859	+
2860	+ fwrite($this->stderr, "File $fname on line $line WARN: $value\n");
2861	break;
2862
2863	case Type::T_ERROR:
2864	list(, $value) = $child;
2865
2866	+ $fname = $this->sourceNames[$this->sourceIndex];
2867	+ $line = $this->sourceLine;
2868	$value = $this->compileValue($this->reduce($value, true));
2869	+
2870	+ $this->throwError("File $fname on line $line ERROR: $value\n");
2871	break;
2872
2873	case Type::T_CONTROL:

2912	*
2913	* @param array $value
2914	*
2915	+ * @return boolean
2916	*/
2917	protected function isTruthy($value)
2918	{

2943	switch ($value[0]) {
2944	case Type::T_EXPRESSION:
2945	if ($value[1] === '/') {
2946	+ return $this->shouldEval($value[2]) \|\| $this->shouldEval($value[3]);
2947	}
2948
2949	// fall-thru

2961	* @param array $value
2962	* @param boolean $inExp
2963	*
2964	+ * @return null\|string\|array\|\ScssPhp\ScssPhp\Node\Number
2965	*/
2966	protected function reduce($value, $inExp = false)
2967	{
2968	+ if (is_null($value)) {
2969	+ return null;
2970	+ }
2971
2972	+ switch ($value[0]) {
2973	case Type::T_EXPRESSION:
2974	list(, $op, $left, $right, $inParens) = $value;
2975

2983	}
2984
2985	// special case: looks like css shorthand
2986	+ if ($opName == 'div' && ! $inParens && ! $inExp && isset($right[2]) &&
2987	+ (($right[0] !== Type::T_NUMBER && $right[2] != '') \|\|
2988	+ ($right[0] === Type::T_NUMBER && ! $right->unitless()))
2989	) {
2990	return $this->expToString($value);
2991	}
2992
2993	+ $left = $this->coerceForExpression($left);
2994	$right = $this->coerceForExpression($right);

2995	$ltype = $left[0];
2996	$rtype = $right[0];
2997

3101	return [Type::T_STRING, '', [$op, $exp]];
3102
3103	case Type::T_VARIABLE:
3104	+ return $this->reduce($this->get($value[1]));


3105
3106	case Type::T_LIST:
3107	foreach ($value[2] as &$item) {

3133	case Type::T_INTERPOLATE:
3134	$value[1] = $this->reduce($value[1]);
3135
3136	+ if ($inExp) {
3137	+ return $value[1];
3138	+ }
3139	+
3140	return $value;
3141
3142	case Type::T_FUNCTION_CALL:
3143	+ return $this->fncall($value[1], $value[2]);
3144	+
3145	+ case Type::T_SELF:
3146	+ $selfSelector = $this->multiplySelectors($this->env);
3147	+ $selfSelector = $this->collapseSelectors($selfSelector, true);
3148
3149	+ return $selfSelector;
3150
3151	default:
3152	return $value;

3161	*
3162	* @return array\|null
3163	*/
3164	+ protected function fncall($name, $argValues)
3165	{
3166	// SCSS @function
3167	if ($this->callScssFunction($name, $argValues, $returnValue)) {

3207	public function normalizeValue($value)
3208	{
3209	$value = $this->coerceForExpression($this->reduce($value));

3210
3211	+ switch ($value[0]) {
3212	case Type::T_LIST:
3213	$value = $this->extractInterpolation($value);
3214

3220	$value[2][$key] = $this->normalizeValue($item);
3221	}
3222
3223	+ if (! empty($value['enclosing'])) {
3224	+ unset($value['enclosing']);
3225	+ }
3226	+
3227	return $value;
3228
3229	case Type::T_STRING:
3230	+ return [$value[0], '"', [$this->compileStringContent($value)]];
3231
3232	case Type::T_NUMBER:
3233	return $value->normalize();

3246	* @param array $left
3247	* @param array $right
3248	*
3249	+ * @return \ScssPhp\ScssPhp\Node\Number
3250	*/
3251	protected function opAddNumberNumber($left, $right)
3252	{

3259	* @param array $left
3260	* @param array $right
3261	*
3262	+ * @return \ScssPhp\ScssPhp\Node\Number
3263	*/
3264	protected function opMulNumberNumber($left, $right)
3265	{

3272	* @param array $left
3273	* @param array $right
3274	*
3275	+ * @return \ScssPhp\ScssPhp\Node\Number
3276	*/
3277	protected function opSubNumberNumber($left, $right)
3278	{

3285	* @param array $left
3286	* @param array $right
3287	*
3288	+ * @return array\|\ScssPhp\ScssPhp\Node\Number
3289	*/
3290	protected function opDivNumberNumber($left, $right)
3291	{

3302	* @param array $left
3303	* @param array $right
3304	*
3305	+ * @return \ScssPhp\ScssPhp\Node\Number
3306	*/
3307	protected function opModNumberNumber($left, $right)
3308	{

3315	* @param array $left
3316	* @param array $right
3317	*
3318	+ * @return array\|null
3319	*/
3320	protected function opAdd($left, $right)
3321	{

3338
3339	return $strRight;
3340	}
3341	+
3342	+ return null;
3343	}
3344
3345	/**

3349	* @param array $right
3350	* @param boolean $shouldEval
3351	*
3352	+ * @return array\|null
3353	*/
3354	protected function opAnd($left, $right, $shouldEval)
3355	{
3356	+ $truthy = ($left === static::$null \|\| $right === static::$null) \|\|
3357	+ ($left === static::$false \|\| $left === static::$true) &&
3358	+ ($right === static::$false \|\| $right === static::$true);
3359	+
3360	if (! $shouldEval) {
3361	+ if (! $truthy) {
3362	+ return null;
3363	+ }
3364	}
3365
3366	+ if ($left !== static::$false && $left !== static::$null) {
3367	return $this->reduce($right, true);
3368	}
3369

3377	* @param array $right
3378	* @param boolean $shouldEval
3379	*
3380	+ * @return array\|null
3381	*/
3382	protected function opOr($left, $right, $shouldEval)
3383	{
3384	+ $truthy = ($left === static::$null \|\| $right === static::$null) \|\|
3385	+ ($left === static::$false \|\| $left === static::$true) &&
3386	+ ($right === static::$false \|\| $right === static::$true);
3387	+
3388	if (! $shouldEval) {
3389	+ if (! $truthy) {
3390	+ return null;
3391	+ }
3392	}
3393
3394	+ if ($left !== static::$false && $left !== static::$null) {
3395	return $left;
3396	}
3397

3602	* @param array $left
3603	* @param array $right
3604	*
3605	+ * @return \ScssPhp\ScssPhp\Node\Number
3606	*/
3607	protected function opCmpNumberNumber($left, $right)
3608	{

3640	*
3641	* @param array $value
3642	*
3643	+ * @return string\|array
3644	*/
3645	public function compileValue($value)
3646	{
3647	$value = $this->reduce($value);
3648
3649	+ switch ($value[0]) {


3650	case Type::T_KEYWORD:
3651	return $value[1];
3652

3657	// [4] - optional alpha component
3658	list(, $r, $g, $b) = $value;
3659
3660	+ $r = $this->compileRGBAValue($r);
3661	+ $g = $this->compileRGBAValue($g);
3662	+ $b = $this->compileRGBAValue($b);
3663	+
3664	+ if (count($value) === 5) {
3665	+ $alpha = $this->compileRGBAValue($value[4], true);
3666	+
3667	+ if (! is_numeric($alpha) \|\| $alpha < 1) {
3668	+ $colorName = Colors::RGBaToColorName($r, $g, $b, $alpha);
3669	+
3670	+ if (! is_null($colorName)) {
3671	+ return $colorName;
3672	+ }
3673	+
3674	+ if (is_numeric($alpha)) {
3675	+ $a = new Node\Number($alpha, '');
3676	+ } else {
3677	+ $a = $alpha;
3678	+ }
3679	+
3680	+ return 'rgba(' . $r . ', ' . $g . ', ' . $b . ', ' . $a . ')';
3681	+ }
3682	+ }
3683	+
3684	+ if (! is_numeric($r) \|\| ! is_numeric($g) \|\| ! is_numeric($b)) {
3685	+ return 'rgb(' . $r . ', ' . $g . ', ' . $b . ')';
3686	+ }
3687
3688	+ $colorName = Colors::RGBaToColorName($r, $g, $b);

3689
3690	+ if (! is_null($colorName)) {
3691	+ return $colorName;
3692	}
3693
3694	$h = sprintf('#%02x%02x%02x', $r, $g, $b);

3719	}
3720
3721	list(, $delim, $items) = $value;
3722	+ $pre = $post = "";
3723	+ if (! empty($value['enclosing'])) {
3724	+ switch ($value['enclosing']) {
3725	+ case 'parent':
3726	+ //$pre = "(";
3727	+ //$post = ")";
3728	+ break;
3729	+ case 'forced_parent':
3730	+ $pre = "(";
3731	+ $post = ")";
3732	+ break;
3733	+ case 'bracket':
3734	+ case 'forced_bracket':
3735	+ $pre = "[";
3736	+ $post = "]";
3737	+ break;
3738	+ }
3739	+ }
3740
3741	+ $prefix_value = '';
3742	if ($delim !== ' ') {
3743	+ $prefix_value = ' ';
3744	}
3745
3746	$filtered = [];

3750	continue;
3751	}
3752
3753	+ $compiled = $this->compileValue($item);
3754	+ if ($prefix_value && strlen($compiled)) {
3755	+ $compiled = $prefix_value . $compiled;
3756	+ }
3757	+ $filtered[] = $compiled;
3758	}
3759
3760	+ return $pre . substr(implode("$delim", $filtered), strlen($prefix_value)) . $post;
3761
3762	case Type::T_MAP:
3763	+ $keys = $value[1];
3764	+ $values = $value[2];
3765	$filtered = [];
3766
3767	for ($i = 0, $s = count($keys); $i < $s; $i++) {

3779	list(, $interpolate, $left, $right) = $value;
3780	list(,, $whiteLeft, $whiteRight) = $interpolate;
3781
3782	+ $delim = $left[1];
3783	+
3784	+ if ($delim && $delim !== ' ' && ! $whiteLeft) {
3785	+ $delim .= ' ';
3786	+ }
3787	+
3788	$left = count($left[2]) > 0 ?
3789	+ $this->compileValue($left) . $delim . $whiteLeft: '';
3790	+
3791	+ $delim = $right[1];
3792	+
3793	+ if ($delim && $delim !== ' ') {
3794	+ $delim .= ' ';
3795	+ }
3796
3797	$right = count($right[2]) > 0 ?
3798	+ $whiteRight . $delim . $this->compileValue($right) : '';
3799
3800	return $left . $this->compileValue($interpolate) . $right;
3801
3802	case Type::T_INTERPOLATE:



3803	// strip quotes if it's a string
3804	+ $reduced = $this->reduce($value[1]);
3805
3806	switch ($reduced[0]) {
3807	case Type::T_LIST:

3825	}
3826
3827	$temp = $this->compileValue([Type::T_KEYWORD, $item]);
3828	+
3829	if ($temp[0] === Type::T_STRING) {
3830	$filtered[] = $this->compileStringContent($temp);
3831	} elseif ($temp[0] === Type::T_KEYWORD) {

3851	case Type::T_NULL:
3852	return 'null';
3853
3854	+ case Type::T_COMMENT:
3855	+ return $this->compileCommentValue($value);
3856	+
3857	default:
3858	+ $this->throwError("unknown value type: ".json_encode($value));
3859	}
3860	}
3861

3919	/**
3920	* Find the final set of selectors
3921	*
3922	+ * @param \ScssPhp\ScssPhp\Compiler\Environment $env
3923	+ * @param \ScssPhp\ScssPhp\Block $selfParent
3924	*
3925	* @return array
3926	*/
3927	+ protected function multiplySelectors(Environment $env, $selfParent = null)
3928	{
3929	$envs = $this->compactEnv($env);
3930	$selectors = [];
3931	$parentSelectors = [[]];
3932
3933	+ $selfParentSelectors = null;
3934	+
3935	+ if (! is_null($selfParent) && $selfParent->selectors) {
3936	+ $selfParentSelectors = $this->evalSelectors($selfParent->selectors);
3937	+ }
3938	+
3939	while ($env = array_pop($envs)) {
3940	if (empty($env->selectors)) {
3941	continue;
3942	}
3943
3944	+ $selectors = $env->selectors;
3945	+
3946	+ do {
3947	+ $stillHasSelf = false;
3948	+ $prevSelectors = $selectors;
3949	+ $selectors = [];
3950
3951	+ foreach ($prevSelectors as $selector) {
3952	+ foreach ($parentSelectors as $parent) {
3953	+ if ($selfParentSelectors) {
3954	+ foreach ($selfParentSelectors as $selfParent) {
3955	+ // if no '&' in the selector, each call will give same result, only add once
3956	+ $s = $this->joinSelectors($parent, $selector, $stillHasSelf, $selfParent);
3957	+ $selectors[serialize($s)] = $s;
3958	+ }
3959	+ } else {
3960	+ $s = $this->joinSelectors($parent, $selector, $stillHasSelf);
3961	+ $selectors[serialize($s)] = $s;
3962	+ }
3963	+ }
3964	}
3965	+ } while ($stillHasSelf);
3966
3967	$parentSelectors = $selectors;
3968	}
3969
3970	+ $selectors = array_values($selectors);
3971	+
3972	return $selectors;
3973	}
3974
3975	/**
3976	* Join selectors; looks for & to replace, or append parent before child
3977	*
3978	+ * @param array $parent
3979	+ * @param array $child
3980	+ * @param boolean &$stillHasSelf
3981	+ * @param array $selfParentSelectors
3982	+
3983	* @return array
3984	*/
3985	+ protected function joinSelectors($parent, $child, &$stillHasSelf, $selfParentSelectors = null)
3986	{
3987	$setSelf = false;
3988	$out = [];

3991	$newPart = [];
3992
3993	foreach ($part as $p) {
3994	+ // only replace & once and should be recalled to be able to make combinations
3995	+ if ($p === static::$selfSelector && $setSelf) {
3996	+ $stillHasSelf = true;
3997	+ }
3998	+
3999	+ if ($p === static::$selfSelector && ! $setSelf) {
4000	$setSelf = true;
4001
4002	+ if (is_null($selfParentSelectors)) {
4003	+ $selfParentSelectors = $parent;
4004	+ }
4005	+
4006	+ foreach ($selfParentSelectors as $i => $parentPart) {
4007	if ($i > 0) {
4008	$out[] = $newPart;
4009	$newPart = [];
4010	}
4011
4012	foreach ($parentPart as $pp) {
4013	+ if (is_array($pp)) {
4014	+ $flatten = [];
4015	+
4016	+ array_walk_recursive($pp, function ($a) use (&$flatten) {
4017	+ $flatten[] = $a;
4018	+ });
4019	+
4020	+ $pp = implode($flatten);
4021	+ }
4022	+
4023	$newPart[] = $pp;
4024	}
4025	}

4037	/**
4038	* Multiply media
4039	*
4040	+ * @param \ScssPhp\ScssPhp\Compiler\Environment $env
4041	+ * @param array $childQueries
4042	*
4043	* @return array
4044	*/

4059	? $env->block->queryList
4060	: [[[Type::T_MEDIA_VALUE, $env->block->value]]];
4061
4062	+ $store = [$this->env, $this->storeEnv];
4063	+
4064	+ $this->env = $env;
4065	+ $this->storeEnv = null;
4066	+ $parentQueries = $this->evaluateMediaQuery($parentQueries);
4067	+
4068	+ list($this->env, $this->storeEnv) = $store;
4069	+
4070	+ if (is_null($childQueries)) {
4071	$childQueries = $parentQueries;
4072	} else {
4073	$originalQueries = $childQueries;

4075
4076	foreach ($parentQueries as $parentQuery) {
4077	foreach ($originalQueries as $childQuery) {
4078	+ $childQueries[] = array_merge(
4079	+ $parentQuery,
4080	+ [[Type::T_MEDIA_TYPE, [Type::T_KEYWORD, 'all']]],
4081	+ $childQuery
4082	+ );
4083	}
4084	}
4085	}

4090	/**
4091	* Convert env linked list to stack
4092	*
4093	+ * @param \ScssPhp\ScssPhp\Compiler\Environment $env
4094	*
4095	* @return array
4096	*/
4097	+ protected function compactEnv(Environment $env)
4098	{
4099	for ($envs = []; $env; $env = $env->parent) {
4100	$envs[] = $env;

4108	*
4109	* @param array $envs
4110	*
4111	+ * @return \ScssPhp\ScssPhp\Compiler\Environment
4112	*/
4113	+ protected function extractEnv($envs)
4114	{
4115	for ($env = null; $e = array_pop($envs);) {
4116	$e->parent = $env;

4123	/**
4124	* Push environment
4125	*
4126	+ * @param \ScssPhp\ScssPhp\Block $block
4127	*
4128	+ * @return \ScssPhp\ScssPhp\Compiler\Environment
4129	*/
4130	protected function pushEnv(Block $block = null)
4131	{

4151	/**
4152	* Get store environment
4153	*
4154	+ * @return \ScssPhp\ScssPhp\Compiler\Environment
4155	*/
4156	protected function getStoreEnv()
4157	{

4161	/**
4162	* Set variable
4163	*
4164	+ * @param string $name
4165	+ * @param mixed $value
4166	+ * @param boolean $shadow
4167	+ * @param \ScssPhp\ScssPhp\Compiler\Environment $env
4168	+ * @param mixed $valueUnreduced
4169	*/
4170	+ protected function set($name, $value, $shadow = false, Environment $env = null, $valueUnreduced = null)
4171	{
4172	$name = $this->normalizeName($name);
4173

4176	}
4177
4178	if ($shadow) {
4179	+ $this->setRaw($name, $value, $env, $valueUnreduced);
4180	} else {
4181	+ $this->setExisting($name, $value, $env, $valueUnreduced);
4182	}
4183	}
4184
4185	/**
4186	* Set existing variable
4187	*
4188	+ * @param string $name
4189	+ * @param mixed $value
4190	+ * @param \ScssPhp\ScssPhp\Compiler\Environment $env
4191	+ * @param mixed $valueUnreduced
4192	*/
4193	+ protected function setExisting($name, $value, Environment $env, $valueUnreduced = null)
4194	{
4195	$storeEnv = $env;
4196	+ $specialContentKey = static::$namespaces['special'] . 'content';
4197
4198	$hasNamespace = $name[0] === '^' \|\| $name[0] === '@' \|\| $name[0] === '%';
4199

4203	}
4204
4205	if (! $hasNamespace && isset($env->marker)) {
4206	+ if (! empty($env->store[$specialContentKey])) {
4207	+ $env = $env->store[$specialContentKey]->scope;
4208	+ continue;
4209	+ }
4210	+
4211	+ if (! empty($env->declarationScopeParent)) {
4212	+ $env = $env->declarationScopeParent;
4213	+ continue;
4214	+ } else {
4215	+ $env = $storeEnv;
4216	+ break;
4217	+ }
4218	}
4219
4220	if (! isset($env->parent)) {

4226	}
4227
4228	$env->store[$name] = $value;
4229	+
4230	+ if ($valueUnreduced) {
4231	+ $env->storeUnreduced[$name] = $valueUnreduced;
4232	+ }
4233	}
4234
4235	/**
4236	* Set raw variable
4237	*
4238	+ * @param string $name
4239	+ * @param mixed $value
4240	+ * @param \ScssPhp\ScssPhp\Compiler\Environment $env
4241	+ * @param mixed $valueUnreduced
4242	*/
4243	+ protected function setRaw($name, $value, Environment $env, $valueUnreduced = null)
4244	{
4245	$env->store[$name] = $value;
4246	+
4247	+ if ($valueUnreduced) {
4248	+ $env->storeUnreduced[$name] = $valueUnreduced;
4249	+ }
4250	}
4251
4252	/**

4254	*
4255	* @api
4256	*
4257	+ * @param string $name
4258	+ * @param boolean $shouldThrow
4259	+ * @param \ScssPhp\ScssPhp\Compiler\Environment $env
4260	+ * @param boolean $unreduced
4261	*
4262	+ * @return mixed\|null
4263	*/
4264	+ public function get($name, $shouldThrow = true, Environment $env = null, $unreduced = false)
4265	{
4266	$normalizedName = $this->normalizeName($name);
4267	$specialContentKey = static::$namespaces['special'] . 'content';

4270	$env = $this->getStoreEnv();
4271	}
4272

4273	$hasNamespace = $normalizedName[0] === '^' \|\| $normalizedName[0] === '@' \|\| $normalizedName[0] === '%';
4274
4275	+ $maxDepth = 10000;
4276	+
4277	for (;;) {
4278	+ if ($maxDepth-- <= 0) {
4279	+ break;
4280	+ }
4281	+
4282	if (array_key_exists($normalizedName, $env->store)) {
4283	+ if ($unreduced && isset($env->storeUnreduced[$normalizedName])) {
4284	+ return $env->storeUnreduced[$normalizedName];
4285	+ }
4286	+
4287	return $env->store[$normalizedName];
4288	}
4289
4290	if (! $hasNamespace && isset($env->marker)) {
4291	+ if (! empty($env->store[$specialContentKey])) {
4292	$env = $env->store[$specialContentKey]->scope;

4293	continue;
4294	}
4295
4296	+ if (! empty($env->declarationScopeParent)) {
4297	+ $env = $env->declarationScopeParent;
4298	+ } else {
4299	+ $env = $this->rootEnv;
4300	+ }
4301	continue;
4302	}
4303

4309	}
4310
4311	if ($shouldThrow) {
4312	+ $this->throwError("Undefined variable \$$name" . ($maxDepth <= 0 ? " (infinite recursion)" : ""));
4313	}
4314
4315	// found nothing
4316	+ return null;
4317	}
4318
4319	/**
4320	* Has variable?
4321	*
4322	+ * @param string $name
4323	+ * @param \ScssPhp\ScssPhp\Compiler\Environment $env
4324	*
4325	* @return boolean
4326	*/
4327	protected function has($name, Environment $env = null)
4328	{
4329	+ return ! is_null($this->get($name, false, $env));
4330	}
4331
4332	/**

4400	*/
4401	public function addParsedFile($path)
4402	{
4403	+ if (isset($path) && is_file($path)) {
4404	$this->parsedFiles[realpath($path)] = filemtime($path);
4405	}
4406	}

4422	*
4423	* @api
4424	*
4425	+ * @param string\|callable $path
4426	*/
4427	public function addImportPath($path)
4428	{

4544	/**
4545	* Import file
4546	*
4547	+ * @param string $path
4548	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $out
4549	*/
4550	+ protected function importFile($path, OutputBlock $out)
4551	{
4552	// see if tree is cached
4553	$realPath = realpath($path);

4565	}
4566
4567	$pi = pathinfo($path);
4568	+
4569	array_unshift($this->importPaths, $pi['dirname']);
4570	$this->compileChildrenNoReturn($tree->children, $out);
4571	array_shift($this->importPaths);

4585	$urls = [];
4586
4587	// for "normal" scss imports (ignore vanilla css and external requests)
4588	+ if (! preg_match('~\.css$\|^https?://~', $url)) {
4589	// try both normal and the _partial filename
4590	+ $urls = [$url, preg_replace('~[^/]+$~', '_\0', $url)];
4591	}
4592
4593	$hasExtension = preg_match('/[.]s?css$/', $url);

4596	if (is_string($dir)) {
4597	// check urls for normal import paths
4598	foreach ($urls as $full) {
4599	+ $separator = (
4600	+ ! empty($dir) &&
4601	+ substr($dir, -1) !== '/' &&
4602	+ substr($full, 0, 1) !== '/'
4603	+ ) ? '/' : '';
4604	+ $full = $dir . $separator . $full;
4605	+
4606	+ if (is_file($file = $full . '.scss') \|\|
4607	+ ($hasExtension && is_file($file = $full))
4608	) {
4609	return $file;
4610	}

4613	// check custom callback for import path
4614	$file = call_user_func($dir, $url);
4615
4616	+ if (! is_null($file)) {
4617	return $file;
4618	}
4619	}

4641	*
4642	* @param boolean $ignoreErrors
4643	*
4644	+ * @return \ScssPhp\ScssPhp\Compiler
4645	*/
4646	public function setIgnoreErrors($ignoreErrors)
4647	{
4648	$this->ignoreErrors = $ignoreErrors;
4649	+
4650	+ return $this;
4651	}
4652
4653	/**

4657	*
4658	* @param string $msg Message with optional sprintf()-style vararg parameters
4659	*
4660	+ * @throws \ScssPhp\ScssPhp\Exception\CompilerException
4661	*/
4662	public function throwError($msg)
4663	{

4665	return;
4666	}
4667
4668	+ $line = $this->sourceLine;
4669	+ $column = $this->sourceColumn;
4670	+
4671	+ $loc = isset($this->sourceNames[$this->sourceIndex])
4672	+ ? $this->sourceNames[$this->sourceIndex] . " on line $line, at column $column"
4673	+ : "line: $line, column: $column";
4674	+
4675	if (func_num_args() > 1) {
4676	$msg = call_user_func_array('sprintf', func_get_args());
4677	}
4678
4679	+ $msg = "$msg: $loc";
4680	+
4681	+ $callStackMsg = $this->callStackMessage();
4682	+
4683	+ if ($callStackMsg) {
4684	+ $msg .= "\nCall Stack:\n" . $callStackMsg;
4685	+ }
4686
4687	throw new CompilerException($msg);
4688	}
4689
4690	+ /**
4691	+ * Beautify call stack for output
4692	+ *
4693	+ * @param boolean $all
4694	+ * @param null $limit
4695	+ *
4696	+ * @return string
4697	+ */
4698	+ protected function callStackMessage($all = false, $limit = null)
4699	+ {
4700	+ $callStackMsg = [];
4701	+ $ncall = 0;
4702	+
4703	+ if ($this->callStack) {
4704	+ foreach (array_reverse($this->callStack) as $call) {
4705	+ if ($all \|\| (isset($call['n']) && $call['n'])) {
4706	+ $msg = "#" . $ncall++ . " " . $call['n'] . " ";
4707	+ $msg .= (isset($this->sourceNames[$call[Parser::SOURCE_INDEX]])
4708	+ ? $this->sourceNames[$call[Parser::SOURCE_INDEX]]
4709	+ : '(unknown file)');
4710	+ $msg .= " on line " . $call[Parser::SOURCE_LINE];
4711	+
4712	+ $callStackMsg[] = $msg;
4713	+
4714	+ if (! is_null($limit) && $ncall > $limit) {
4715	+ break;
4716	+ }
4717	+ }
4718	+ }
4719	+ }
4720	+
4721	+ return implode("\n", $callStackMsg);
4722	+ }
4723	+
4724	/**
4725	* Handle import loop
4726	*

4731	protected function handleImportLoop($name)
4732	{
4733	for ($env = $this->env; $env; $env = $env->parent) {
4734	+ if (! $env->block) {
4735	+ continue;
4736	+ }
4737	+
4738	$file = $this->sourceNames[$env->block->sourceIndex];
4739
4740	if (realpath($file) === $name) {

4744	}
4745	}
4746












4747	/**
4748	* Call SCSS @function
4749	*

4777	$tmp->children = [];
4778
4779	$this->env->marker = 'function';
4780	+ if (! empty($func->parentEnv)) {
4781	+ $this->env->declarationScopeParent = $func->parentEnv;
4782	+ } else {
4783	+ $this->throwError("@function $name() without parentEnv");
4784	+ }
4785
4786	+ $ret = $this->compileChildren($func->children, $tmp, $this->env->marker . " " . $name);
4787
4788	$this->storeEnv = $storeEnv;
4789

4818	return false;
4819	}
4820
4821	+ @list($sorted, $kwargs) = $this->sortNativeFunctionArgs($libName, $prototype, $args);
4822
4823	if ($name !== 'if' && $name !== 'call') {
4824	+ $inExp = true;
4825	+
4826	+ if ($name === 'join') {
4827	+ $inExp = false;
4828	+ }
4829	+
4830	foreach ($sorted as &$val) {
4831	+ $val = $this->reduce($val, $inExp);
4832	}
4833	}
4834

4866	/**
4867	* Sorts keyword arguments
4868	*
4869	+ * @param string $functionName
4870	+ * @param array $prototypes
4871	+ * @param array $args
4872	*
4873	* @return array
4874	*/
4875	+ protected function sortNativeFunctionArgs($functionName, $prototypes, $args)
4876	{
4877	+ static $parser = null;

4878
4879	+ if (! isset($prototypes)) {
4880	+ $keyArgs = [];
4881	+ $posArgs = [];
4882	+
4883	+ // separate positional and keyword arguments
4884	+ foreach ($args as $arg) {
4885	+ list($key, $value) = $arg;
4886
4887	+ $key = $key[1];
4888
4889	+ if (empty($key)) {
4890	+ $posArgs[] = empty($arg[2]) ? $value : $arg;
4891	+ } else {
4892	+ $keyArgs[$key] = $value;
4893	+ }
4894	}

4895

4896	return [$posArgs, $keyArgs];
4897	}
4898
4899	+ // specific cases ?
4900	+ if (in_array($functionName, ['libRgb', 'libRgba', 'libHsl', 'libHsla'])) {
4901	+ // notation 100 127 255 / 0 is in fact a simple list of 4 values
4902	+ foreach ($args as $k => $arg) {
4903	+ if ($arg[1][0] === Type::T_LIST && count($arg[1][2]) === 3) {
4904	+ $last = end($arg[1][2]);
4905	+
4906	+ if ($last[0] === Type::T_EXPRESSION && $last[1] === '/') {
4907	+ array_pop($arg[1][2]);
4908	+ $arg[1][2][] = $last[2];
4909	+ $arg[1][2][] = $last[3];
4910	+ $args[$k] = $arg;
4911	+ }
4912	+ }
4913	+ }
4914	+ }
4915	+
4916	+ $finalArgs = [];
4917	+
4918	+ if (! is_array(reset($prototypes))) {
4919	+ $prototypes = [$prototypes];
4920	+ }
4921	+
4922	+ $keyArgs = [];
4923	+
4924	+ // trying each prototypes
4925	+ $prototypeHasMatch = false;
4926	+ $exceptionMessage = '';
4927	+
4928	+ foreach ($prototypes as $prototype) {
4929	+ $argDef = [];
4930	+
4931	+ foreach ($prototype as $i => $p) {
4932	+ $default = null;
4933	+ $p = explode(':', $p, 2);
4934	+ $name = array_shift($p);
4935	+
4936	+ if (count($p)) {
4937	+ $p = trim(reset($p));
4938	+
4939	+ if ($p === 'null') {
4940	+ // differentiate this null from the static::$null
4941	+ $default = [Type::T_KEYWORD, 'null'];
4942	+ } else {
4943	+ if (is_null($parser)) {
4944	+ $parser = $this->parserFactory(__METHOD__);
4945	+ }
4946	+
4947	+ $parser->parseValue($p, $default);
4948	+ }
4949	+ }
4950	+
4951	+ $isVariable = false;
4952	+
4953	+ if (substr($name, -3) === '...') {
4954	+ $isVariable = true;
4955	+ $name = substr($name, 0, -3);
4956	+ }
4957	+
4958	+ $argDef[] = [$name, $default, $isVariable];
4959	+ }
4960	+
4961	+ try {
4962	+ $vars = $this->applyArguments($argDef, $args, false, false);
4963	+
4964	+ // ensure all args are populated
4965	+ foreach ($prototype as $i => $p) {
4966	+ $name = explode(':', $p)[0];
4967	+
4968	+ if (! isset($finalArgs[$i])) {
4969	+ $finalArgs[$i] = null;
4970	+ }
4971	+ }
4972	+
4973	+ // apply positional args
4974	+ foreach (array_values($vars) as $i => $val) {
4975	+ $finalArgs[$i] = $val;
4976	+ }
4977	+
4978	+ $keyArgs = array_merge($keyArgs, $vars);
4979	+ $prototypeHasMatch = true;
4980	+
4981	+ // overwrite positional args with keyword args
4982	+ foreach ($prototype as $i => $p) {
4983	+ $name = explode(':', $p)[0];
4984	+
4985	+ if (isset($keyArgs[$name])) {
4986	+ $finalArgs[$i] = $keyArgs[$name];
4987	+ }
4988
4989	+ // special null value as default: translate to real null here
4990	+ if ($finalArgs[$i] === [Type::T_KEYWORD, 'null']) {
4991	+ $finalArgs[$i] = null;
4992	+ }

4993	}
4994	+ // should we break if this prototype seems fulfilled?
4995	+ } catch (CompilerException $e) {
4996	+ $exceptionMessage = $e->getMessage();
4997	}
4998	}
4999
5000	+ if ($exceptionMessage && ! $prototypeHasMatch) {
5001	+ $this->throwError($exceptionMessage);
5002	+ }
5003	+
5004	return [$finalArgs, $keyArgs];
5005	}
5006
5007	/**
5008	* Apply argument values per definition
5009	*
5010	+ * @param array $argDef
5011	+ * @param array $argValues
5012	+ * @param boolean $storeInEnv
5013	+ * @param boolean $reduce
5014	+ * only used if $storeInEnv = false
5015	+ *
5016	+ * @return array
5017	*
5018	* @throws \Exception
5019	*/
5020	+ protected function applyArguments($argDef, $argValues, $storeInEnv = true, $reduce = true)
5021	{
5022	+ $output = [];
5023	+ if (is_array($argValues) && count($argValues) && end($argValues) === static::$null) {
5024	+ array_pop($argValues);
5025	+ }
5026
5027	+ if ($storeInEnv) {
5028	+ $storeEnv = $this->getStoreEnv();
5029	+
5030	+ $env = new Environment;
5031	+ $env->store = $storeEnv->store;
5032	+ }
5033
5034	$hasVariable = false;
5035	$args = [];

5041	$hasVariable \|= $isVariable;
5042	}
5043
5044	+ $splatSeparator = null;
5045	+ $keywordArgs = [];
5046	$deferredKeywordArgs = [];
5047	+ $remaining = [];
5048	+ $hasKeywordArgument = false;
5049
5050	// assign the keyword args
5051	foreach ((array) $argValues as $arg) {
5052	if (! empty($arg[0])) {
5053	+ $hasKeywordArgument = true;
5054	+
5055	+ $name = $arg[0][1];
5056	+ if (! isset($args[$name])) {
5057	+ foreach (array_keys($args) as $an) {
5058	+ if (str_replace("_", "-", $an) === str_replace("_", "-", $name)) {
5059	+ $name = $an;
5060	+ break;
5061	+ }
5062	+ }
5063	+ }
5064	+ if (! isset($args[$name]) \|\| $args[$name][3]) {
5065	if ($hasVariable) {
5066	+ $deferredKeywordArgs[$name] = $arg[1];
5067	} else {
5068	$this->throwError("Mixin or function doesn't have an argument named $%s.", $arg[0][1]);
5069	break;
5070	}
5071	+ } elseif ($args[$name][0] < count($remaining)) {
5072	$this->throwError("The argument $%s was passed both by position and by name.", $arg[0][1]);
5073	break;
5074	} else {
5075	+ $keywordArgs[$name] = $arg[1];
5076	}



5077	} elseif ($arg[2] === true) {
5078	$val = $this->reduce($arg[1], true);
5079
5080	if ($val[0] === Type::T_LIST) {
5081	foreach ($val[2] as $name => $item) {
5082	if (! is_numeric($name)) {
5083	+ if (! isset($args[$name])) {
5084	+ foreach (array_keys($args) as $an) {
5085	+ if (str_replace("_", "-", $an) === str_replace("_", "-", $name)) {
5086	+ $name = $an;
5087	+ break;
5088	+ }
5089	+ }
5090	+ }
5091	+
5092	+ if ($hasVariable) {
5093	+ $deferredKeywordArgs[$name] = $item;
5094	+ } else {
5095	+ $keywordArgs[$name] = $item;
5096	+ }
5097	} else {
5098	+ if (is_null($splatSeparator)) {
5099	+ $splatSeparator = $val[1];
5100	+ }
5101	+
5102	$remaining[] = $item;
5103	}
5104	}

5108	$item = $val[2][$i];
5109
5110	if (! is_numeric($name)) {
5111	+ if (! isset($args[$name])) {
5112	+ foreach (array_keys($args) as $an) {
5113	+ if (str_replace("_", "-", $an) === str_replace("_", "-", $name)) {
5114	+ $name = $an;
5115	+ break;
5116	+ }
5117	+ }
5118	+ }
5119	+
5120	+ if ($hasVariable) {
5121	+ $deferredKeywordArgs[$name] = $item;
5122	+ } else {
5123	+ $keywordArgs[$name] = $item;
5124	+ }
5125	+ } else {
5126	+ if (is_null($splatSeparator)) {
5127	+ $splatSeparator = $val[1];
5128	+ }
5129	+
5130	+ $remaining[] = $item;
5131	+ }
5132	+ }
5133	} else {
5134	$remaining[] = $val;
5135	}
5136	+ } elseif ($hasKeywordArgument) {
5137	+ $this->throwError('Positional arguments must come before keyword arguments.');
5138	+ break;
5139	} else {
5140	$remaining[] = $arg[1];
5141	}

5145	list($i, $name, $default, $isVariable) = $arg;
5146
5147	if ($isVariable) {
5148	+ $val = [Type::T_LIST, is_null($splatSeparator) ? ',' : $splatSeparator , [], $isVariable];
5149
5150	for ($count = count($remaining); $i < $count; $i++) {
5151	$val[2][] = $remaining[$i];

5165	break;
5166	}
5167
5168	+ if ($storeInEnv) {
5169	+ $this->set($name, $this->reduce($val, true), true, $env);
5170	+ } else {
5171	+ $output[$name] = ($reduce ? $this->reduce($val, true) : $val);
5172	+ }
5173	}
5174
5175	+ if ($storeInEnv) {
5176	+ $storeEnv->store = $env->store;
5177	+ }
5178
5179	foreach ($args as $arg) {
5180	list($i, $name, $default, $isVariable) = $arg;

5183	continue;
5184	}
5185
5186	+ if ($storeInEnv) {
5187	+ $this->set($name, $this->reduce($default, true), true);
5188	+ } else {
5189	+ $output[$name] = ($reduce ? $this->reduce($default, true) : $default);
5190	+ }
5191	}
5192	+
5193	+ return $output;
5194	}
5195
5196	/**

5198	*
5199	* @param mixed $value
5200	*
5201	+ * @return array\|\ScssPhp\ScssPhp\Node\Number
5202	*/
5203	+ protected function coerceValue($value)
5204	{
5205	if (is_array($value) \|\| $value instanceof \ArrayAccess) {
5206	return $value;

5210	return $this->toBool($value);
5211	}
5212
5213	+ if (is_null($value)) {
5214	return static::$null;
5215	}
5216

5222	return static::$emptyString;
5223	}
5224
5225	+ $value = [Type::T_KEYWORD, $value];
5226	+ $color = $this->coerceColor($value);

















5227
5228	+ if ($color) {
5229	return $color;
5230	}
5231
5232	+ return $value;
5233	}
5234
5235	/**

5245	return $item;
5246	}
5247
5248	+ if ($item[0] === static::$emptyList[0]
5249	+ && $item[1] === static::$emptyList[1]
5250	+ && $item[2] === static::$emptyList[2]) {
5251	return static::$emptyMap;
5252	}
5253

5277	$key = $keys[$i];
5278	$value = $values[$i];
5279
5280	+ switch ($key[0]) {
5281	+ case Type::T_LIST:
5282	+ case Type::T_MAP:
5283	+ case Type::T_STRING:
5284	+ break;
5285	+
5286	+ default:
5287	+ $key = [Type::T_KEYWORD, $this->compileStringContent($this->coerceString($key))];
5288	+ break;
5289	+ }
5290	+
5291	$list[] = [
5292	Type::T_LIST,
5293	'',
5294	+ [$key, $value]
5295	];
5296	}
5297

5324	*
5325	* @return array\|null
5326	*/
5327	+ protected function coerceColor($value, $inRGBFunction = false)
5328	{
5329	switch ($value[0]) {
5330	case Type::T_COLOR:
5331	+ for ($i = 1; $i <= 3; $i++) {
5332	+ if (! is_numeric($value[$i])) {
5333	+ $cv = $this->compileRGBAValue($value[$i]);
5334	+
5335	+ if (! is_numeric($cv)) {
5336	+ return null;
5337	+ }
5338	+
5339	+ $value[$i] = $cv;
5340	+ }
5341	+
5342	+ if (isset($value[4])) {
5343	+ if (! is_numeric($value[4])) {
5344	+ $cv = $this->compileRGBAValue($value[4], true);
5345	+
5346	+ if (! is_numeric($cv)) {
5347	+ return null;
5348	+ }
5349	+
5350	+ $value[4] = $cv;
5351	+ }
5352	+ }
5353	+ }
5354	+
5355	return $value;
5356
5357	+ case Type::T_LIST:
5358	+ if ($inRGBFunction) {
5359	+ if (count($value[2]) == 3 \|\| count($value[2]) == 4) {
5360	+ $color = $value[2];
5361	+ array_unshift($color, Type::T_COLOR);
5362	+
5363	+ return $this->coerceColor($color);
5364	+ }
5365	+ }
5366	+
5367	+ return null;
5368	+
5369	case Type::T_KEYWORD:
5370	+ if (! is_string($value[1])) {
5371	+ return null;
5372	+ }
5373	+
5374	$name = strtolower($value[1]);
5375	+ // hexa color?
5376	+ if (preg_match('/^#([0-9a-f]+)$/i', $name, $m)) {
5377	+ $nofValues = strlen($m[1]);
5378	+
5379	+ if (in_array($nofValues, [3, 4, 6, 8])) {
5380	+ $nbChannels = 3;
5381	+ $color = [];
5382	+ $num = hexdec($m[1]);
5383	+
5384	+ switch ($nofValues) {
5385	+ case 4:
5386	+ $nbChannels = 4;
5387	+ // then continuing with the case 3:
5388	+ case 3:
5389	+ for ($i = 0; $i < $nbChannels; $i++) {
5390	+ $t = $num & 0xf;
5391	+ array_unshift($color, $t << 4 \| $t);
5392	+ $num >>= 4;
5393	+ }
5394	+
5395	+ break;
5396	+
5397	+ case 8:
5398	+ $nbChannels = 4;
5399	+ // then continuing with the case 6:
5400	+ case 6:
5401	+ for ($i = 0; $i < $nbChannels; $i++) {
5402	+ array_unshift($color, $num & 0xff);
5403	+ $num >>= 8;
5404	+ }
5405	+
5406	+ break;
5407	+ }
5408
5409	+ if ($nbChannels === 4) {
5410	+ if ($color[3] === 255) {
5411	+ $color[3] = 1; // fully opaque
5412	+ } else {
5413	+ $color[3] = round($color[3] / 255, 3);
5414	+ }
5415	+ }
5416	+
5417	+ array_unshift($color, Type::T_COLOR);
5418
5419	+ return $color;
5420	+ }
5421	+ }
5422	+
5423	+ if ($rgba = Colors::colorNameToRGBa($name)) {
5424	return isset($rgba[3])
5425	+ ? [Type::T_COLOR, $rgba[0], $rgba[1], $rgba[2], $rgba[3]]
5426	+ : [Type::T_COLOR, $rgba[0], $rgba[1], $rgba[2]];
5427	}
5428
5429	return null;

5432	return null;
5433	}
5434
5435	+ /**
5436	+ * @param integer\|\ScssPhp\ScssPhp\Node\Number $value
5437	+ * @param boolean $isAlpha
5438	+ *
5439	+ * @return integer\|mixed
5440	+ */
5441	+ protected function compileRGBAValue($value, $isAlpha = false)
5442	+ {
5443	+ if ($isAlpha) {
5444	+ return $this->compileColorPartValue($value, 0, 1, false);
5445	+ }
5446	+
5447	+ return $this->compileColorPartValue($value, 0, 255, true);
5448	+ }
5449	+
5450	+ /**
5451	+ * @param mixed $value
5452	+ * @param integer\|float $min
5453	+ * @param integer\|float $max
5454	+ * @param boolean $isInt
5455	+ * @param boolean $clamp
5456	+ * @param boolean $modulo
5457	+ *
5458	+ * @return integer\|mixed
5459	+ */
5460	+ protected function compileColorPartValue($value, $min, $max, $isInt = true, $clamp = true, $modulo = false)
5461	+ {
5462	+ if (! is_numeric($value)) {
5463	+ if (is_array($value)) {
5464	+ $reduced = $this->reduce($value);
5465	+
5466	+ if (is_object($reduced) && $value->type === Type::T_NUMBER) {
5467	+ $value = $reduced;
5468	+ }
5469	+ }
5470	+
5471	+ if (is_object($value) && $value->type === Type::T_NUMBER) {
5472	+ $num = $value->dimension;
5473	+
5474	+ if (count($value->units)) {
5475	+ $unit = array_keys($value->units);
5476	+ $unit = reset($unit);
5477	+
5478	+ switch ($unit) {
5479	+ case '%':
5480	+ $num *= $max / 100;
5481	+ break;
5482	+ default:
5483	+ break;
5484	+ }
5485	+ }
5486	+
5487	+ $value = $num;
5488	+ } elseif (is_array($value)) {
5489	+ $value = $this->compileValue($value);
5490	+ }
5491	+ }
5492	+
5493	+ if (is_numeric($value)) {
5494	+ if ($isInt) {
5495	+ $value = round($value);
5496	+ }
5497	+
5498	+ if ($clamp) {
5499	+ $value = min($max, max($min, $value));
5500	+ }
5501	+
5502	+ if ($modulo) {
5503	+ $value = $value % $max;
5504	+
5505	+ // still negative?
5506	+ while ($value < $min) {
5507	+ $value += $max;
5508	+ }
5509	+ }
5510	+
5511	+ return $value;
5512	+ }
5513	+
5514	+ return $value;
5515	+ }
5516	+
5517	/**
5518	* Coerce value to string
5519	*

5566	$value = $this->coerceMap($value);
5567
5568	if ($value[0] !== Type::T_MAP) {
5569	+ $this->throwError('expecting map, %s received', $value[0]);
5570	}
5571
5572	return $value;

5586	public function assertList($value)
5587	{
5588	if ($value[0] !== Type::T_LIST) {
5589	+ $this->throwError('expecting list, %s received', $value[0]);
5590	}
5591
5592	return $value;

5609	return $color;
5610	}
5611
5612	+ $this->throwError('expecting color, %s received', $value[0]);
5613	}
5614
5615	/**

5626	public function assertNumber($value)
5627	{
5628	if ($value[0] !== Type::T_NUMBER) {
5629	+ $this->throwError('expecting number, %s received', $value[0]);
5630	}
5631
5632	return $value[1];

5703	*
5704	* @return float
5705	*/
5706	+ protected function hueToRGB($m1, $m2, $h)
5707	{
5708	if ($h < 0) {
5709	$h += 1;

5761
5762	// Built in functions
5763
5764	+ protected static $libCall = ['name', 'args...'];
5765	protected function libCall($args, $kwargs)
5766	{
5767	$name = $this->compileStringContent($this->coerceString($this->reduce(array_shift($args), true)));
5768	+ $callArgs = [];
5769
5770	+ // $kwargs['args'] is [Type::T_LIST, ',', [..]]
5771	+ foreach ($kwargs['args'][2] as $varname => $arg) {
5772	+ if (is_numeric($varname)) {
5773	+ $varname = null;
5774	+ } else {
5775	+ $varname = [ 'var', $varname];




5776	}
5777	+
5778	+ $callArgs[] = [$varname, $arg, false];
5779	}
5780
5781	+ return $this->reduce([Type::T_FUNCTION_CALL, $name, $callArgs]);
5782	}
5783
5784	+ protected static $libIf = ['condition', 'if-true', 'if-false:'];
5785	protected function libIf($args)
5786	{
5787	list($cond, $t, $f) = $args;

5825	return false === $key ? static::$null : $key + 1;
5826	}
5827
5828	+ protected static $libRgb = [
5829	+ ['color'],
5830	+ ['color', 'alpha'],
5831	+ ['channels'],
5832	+ ['red', 'green', 'blue'],
5833	+ ['red', 'green', 'blue', 'alpha'] ];
5834	+ protected function libRgb($args, $kwargs, $funcName = 'rgb')
5835	{
5836	+ switch (count($args)) {
5837	+ case 1:
5838	+ if (! $color = $this->coerceColor($args[0], true)) {
5839	+ $color = [Type::T_STRING, '', [$funcName . '(', $args[0], ')']];
5840	+ }
5841	+ break;
5842
5843	+ case 3:
5844	+ $color = [Type::T_COLOR, $args[0], $args[1], $args[2]];
5845
5846	+ if (! $color = $this->coerceColor($color)) {
5847	+ $color = [Type::T_STRING, '', [$funcName .'(', $args[0], ', ', $args[1], ', ', $args[2], ')']];
5848	+ }






5849
5850	+ return $color;
5851	+
5852	+ case 2:
5853	+ if ($color = $this->coerceColor($args[0], true)) {
5854	+ $alpha = $this->compileRGBAValue($args[1], true);
5855	+
5856	+ if (is_numeric($alpha)) {
5857	+ $color[4] = $alpha;
5858	+ } else {
5859	+ $color = [Type::T_STRING, '',
5860	+ [$funcName . '(', $color[1], ', ', $color[2], ', ', $color[3], ', ', $alpha, ')']];
5861	+ }
5862	+ } else {
5863	+ $color = [Type::T_STRING, '', [$funcName . '(', $args[0], ')']];
5864	+ }
5865	+ break;
5866	+
5867	+ case 4:
5868	+ default:
5869	+ $color = [Type::T_COLOR, $args[0], $args[1], $args[2], $args[3]];
5870	+
5871	+ if (! $color = $this->coerceColor($color)) {
5872	+ $color = [Type::T_STRING, '',
5873	+ [$funcName . '(', $args[0], ', ', $args[1], ', ', $args[2], ', ', $args[3], ')']];
5874	+ }
5875	+ break;
5876	}
5877
5878	+ return $color;
5879	+ }
5880
5881	+ protected static $libRgba = [
5882	+ ['color'],
5883	+ ['color', 'alpha'],
5884	+ ['channels'],
5885	+ ['red', 'green', 'blue'],
5886	+ ['red', 'green', 'blue', 'alpha'] ];
5887	+ protected function libRgba($args, $kwargs)
5888	+ {
5889	+ return $this->libRgb($args, $kwargs, 'rgba');
5890	}
5891
5892	// helper function for adjust_color, change_color, and scale_color

5894	{
5895	$color = $this->assertColor($args[0]);
5896
5897	+ foreach ([1 => 1, 2 => 2, 3 => 3, 7 => 4] as $iarg => $irgba) {
5898	+ if (isset($args[$iarg])) {
5899	+ $val = $this->assertNumber($args[$iarg]);
5900	+
5901	+ if (! isset($color[$irgba])) {
5902	+ $color[$irgba] = (($irgba < 4) ? 0 : 1);
5903	+ }
5904	+
5905	+ $color[$irgba] = call_user_func($fn, $color[$irgba], $val, $iarg);
5906	}
5907	}
5908
5909	+ if (! empty($args[4]) \|\| ! empty($args[5]) \|\| ! empty($args[6])) {
5910	$hsl = $this->toHSL($color[1], $color[2], $color[3]);
5911
5912	+ foreach ([4 => 1, 5 => 2, 6 => 3] as $iarg => $ihsl) {
5913	+ if (! empty($args[$iarg])) {
5914	+ $val = $this->assertNumber($args[$iarg]);
5915	+ $hsl[$ihsl] = call_user_func($fn, $hsl[$ihsl], $val, $iarg);
5916	}
5917	}
5918

5929	}
5930
5931	protected static $libAdjustColor = [
5932	+ 'color', 'red:null', 'green:null', 'blue:null',
5933	+ 'hue:null', 'saturation:null', 'lightness:null', 'alpha:null'
5934	];
5935	protected function libAdjustColor($args)
5936	{

5940	}
5941
5942	protected static $libChangeColor = [
5943	+ 'color', 'red:null', 'green:null', 'blue:null',
5944	+ 'hue:null', 'saturation:null', 'lightness:null', 'alpha:null'
5945	];
5946	protected function libChangeColor($args)
5947	{

5951	}
5952
5953	protected static $libScaleColor = [
5954	+ 'color', 'red:null', 'green:null', 'blue:null',
5955	+ 'hue:null', 'saturation:null', 'lightness:null', 'alpha:null'
5956	];
5957	protected function libScaleColor($args)
5958	{

5995	$color = $this->coerceColor($args[0]);
5996	$color[4] = isset($color[4]) ? round(255 * $color[4]) : 255;
5997
5998	+ return [Type::T_STRING, '', [sprintf('#%02X%02X%02X%02X', $color[4], $color[1], $color[2], $color[3])]];
5999	}
6000
6001	protected static $libRed = ['color'];

6046	}
6047
6048	// mix two colors
6049	+ protected static $libMix = ['color-1', 'color-2', 'weight:0.5'];
6050	protected function libMix($args)
6051	{
6052	list($first, $second, $weight) = $args;

6082	return $this->fixColor($new);
6083	}
6084
6085	+ protected static $libHsl =[
6086	+ ['channels'],
6087	+ ['hue', 'saturation', 'lightness'],
6088	+ ['hue', 'saturation', 'lightness', 'alpha'] ];
6089	+ protected function libHsl($args, $kwargs, $funcName = 'hsl')
6090	{
6091	+ if (count($args) == 1) {
6092	+ if ($args[0][0] !== Type::T_LIST \|\| count($args[0][2]) < 3 \|\| count($args[0][2]) > 4) {
6093	+ return [Type::T_STRING, '', [$funcName . '(', $args[0], ')']];
6094	+ }
6095
6096	+ $args = $args[0][2];
6097	+ }
6098
6099	+ $hue = $this->compileColorPartValue($args[0], 0, 360, false, false, true);
6100	+ $saturation = $this->compileColorPartValue($args[1], 0, 100, false);
6101	+ $lightness = $this->compileColorPartValue($args[2], 0, 100, false);
6102	+
6103	+ $alpha = null;
6104	+
6105	+ if (count($args) === 4) {
6106	+ $alpha = $this->compileColorPartValue($args[3], 0, 100, false);
6107	+
6108	+ if (! is_numeric($hue) \|\| ! is_numeric($saturation) \|\| ! is_numeric($lightness) \|\| ! is_numeric($alpha)) {
6109	+ return [Type::T_STRING, '',
6110	+ [$funcName . '(', $args[0], ', ', $args[1], ', ', $args[2], ', ', $args[3], ')']];
6111	+ }
6112	+ } else {
6113	+ if (! is_numeric($hue) \|\| ! is_numeric($saturation) \|\| ! is_numeric($lightness)) {
6114	+ return [Type::T_STRING, '', [$funcName . '(', $args[0], ', ', $args[1], ', ', $args[2], ')']];
6115	+ }
6116	+ }
6117
6118	+ $color = $this->toRGB($hue, $saturation, $lightness);
6119	+
6120	+ if (! is_null($alpha)) {
6121	+ $color[4] = $alpha;
6122	+ }
6123
6124	return $color;
6125	}
6126
6127	+ protected static $libHsla = [
6128	+ ['channels'],
6129	+ ['hue', 'saturation', 'lightness', 'alpha:1'] ];
6130	+ protected function libHsla($args, $kwargs)
6131	+ {
6132	+ return $this->libHsl($args, $kwargs, 'hsla');
6133	+ }
6134	+
6135	protected static $libHue = ['color'];
6136	protected function libHue($args)
6137	{

6199	return $this->adjustHsl($color, 3, -$amount);
6200	}
6201
6202	+ protected static $libSaturate = [['color', 'amount'], ['number']];
6203	protected function libSaturate($args)
6204	{
6205	$value = $args[0];

6241	return $this->adjustHsl($this->assertColor($args[0]), 1, 180);
6242	}
6243
6244	+ protected static $libInvert = ['color', 'weight:1'];
6245	protected function libInvert($args)
6246	{
6247	+ list($value, $weight) = $args;
6248	+
6249	+ if (! isset($weight)) {
6250	+ $weight = 1;
6251	+ } else {
6252	+ $weight = $this->coercePercent($weight);
6253	+ }
6254
6255	if ($value[0] === Type::T_NUMBER) {
6256	return null;
6257	}
6258
6259	$color = $this->assertColor($value);
6260	+ $inverted = $color;
6261	+ $inverted[1] = 255 - $inverted[1];
6262	+ $inverted[2] = 255 - $inverted[2];
6263	+ $inverted[3] = 255 - $inverted[3];
6264
6265	+ if ($weight < 1) {
6266	+ return $this->libMix([$inverted, $color, [Type::T_NUMBER, $weight]]);
6267	+ }
6268	+
6269	+ return $inverted;
6270	}
6271
6272	// increases opacity by amount

6375	$min = null;
6376
6377	foreach ($numbers as $key => $number) {
6378	+ if (is_null($min) \|\| $number[1] <= $min[1]) {
6379	$min = [$key, $number[1]];
6380	}
6381	}

6389	$max = null;
6390
6391	foreach ($numbers as $key => $number) {
6392	+ if (is_null($max) \|\| $number[1] >= $max[1]) {
6393	$max = [$key, $number[1]];
6394	}
6395	}

6406	*/
6407	protected function getNormalizedNumbers($args)
6408	{
6409	+ $unit = null;
6410	$originalUnit = null;
6411	+ $numbers = [];
6412
6413	foreach ($args as $key => $item) {
6414	if ($item[0] !== Type::T_NUMBER) {

6418
6419	$number = $item->normalize();
6420
6421	+ if (is_null($unit)) {
6422	$unit = $number[2];
6423	$originalUnit = $item->unitStr();
6424	+ } elseif ($number[1] && $unit !== $number[2]) {
6425	$this->throwError('Incompatible units: "%s" and "%s".', $originalUnit, $item->unitStr());
6426	break;
6427	}

6490	if (! isset($list[2][$n])) {
6491	$this->throwError('Invalid argument for "n"');
6492
6493	+ return null;
6494	}
6495
6496	$list[2][$n] = $args[2];

6502	protected function libMapGet($args)
6503	{
6504	$map = $this->assertMap($args[0]);
6505	+ $key = $args[1];
6506
6507	+ if (! is_null($key)) {
6508	+ $key = $this->compileStringContent($this->coerceString($key));
6509	+
6510	+ for ($i = count($map[1]) - 1; $i >= 0; $i--) {
6511	+ if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) {
6512	+ return $map[2][$i];
6513	+ }
6514	}
6515	}
6516

6572	$map1 = $this->assertMap($args[0]);
6573	$map2 = $this->assertMap($args[1]);
6574
6575	+ foreach ($map2[1] as $i2 => $key2) {
6576	+ $key = $this->compileStringContent($this->coerceString($key2));
6577	+
6578	+ foreach ($map1[1] as $i1 => $key1) {
6579	+ if ($key === $this->compileStringContent($this->coerceString($key1))) {
6580	+ $map1[2][$i1] = $map2[2][$i2];
6581	+ continue 2;
6582	+ }
6583	+ }
6584	+
6585	+ $map1[1][] = $map2[1][$i2];
6586	+ $map1[2][] = $map2[2][$i2];
6587	+ }
6588	+
6589	+ return $map1;
6590	}
6591
6592	protected static $libKeywords = ['args'];

6605	return [Type::T_MAP, $keys, $values];
6606	}
6607
6608	+ protected static $libIsBracketed = ['list'];
6609	+ protected function libIsBracketed($args)
6610	+ {
6611	+ $list = $args[0];
6612	+ $this->coerceList($list, ' ');
6613	+ if (! empty($list['enclosing']) && $list['enclosing'] === 'bracket') {
6614	+ return true;
6615	+ }
6616	+ return false;
6617	+ }
6618	+
6619	+
6620	protected function listSeparatorForJoin($list1, $sep)
6621	{
6622	if (! isset($sep)) {

6628	return ',';
6629
6630	case 'space':
6631	+ return ' ';
6632
6633	default:
6634	return $list1[1];
6635	}
6636	}
6637
6638	+ protected static $libJoin = ['list1', 'list2', 'separator:null', 'bracketed:auto'];
6639	protected function libJoin($args)
6640	{
6641	+ list($list1, $list2, $sep, $bracketed) = $args;
6642
6643	$list1 = $this->coerceList($list1, ' ');
6644	$list2 = $this->coerceList($list2, ' ');
6645	+ $sep = $this->listSeparatorForJoin($list1, $sep);
6646	+
6647	+ if ($bracketed === static::$true) {
6648	+ $bracketed = true;
6649	+ } elseif ($bracketed === static::$false) {
6650	+ $bracketed = false;
6651	+ } elseif ($bracketed === [Type::T_KEYWORD, 'auto']) {
6652	+ $bracketed = 'auto';
6653	+ } elseif ($bracketed === static::$null) {
6654	+ $bracketed = false;
6655	+ } else {
6656	+ $bracketed = $this->compileValue($bracketed);
6657	+ $bracketed = ! ! $bracketed;
6658	+ if ($bracketed === true) {
6659	+ $bracketed = true;
6660	+ }
6661	+ }
6662	+
6663	+ if ($bracketed === 'auto') {
6664	+ $bracketed = false;
6665	+ if (! empty($list1['enclosing']) && $list1['enclosing'] === 'bracket') {
6666	+ $bracketed = true;
6667	+ }
6668	+ }
6669
6670	+ $res = [Type::T_LIST, $sep, array_merge($list1[2], $list2[2])];
6671	+ if (isset($list1['enclosing'])) {
6672	+ $res['enlcosing'] = $list1['enclosing'];
6673	+ }
6674	+ if ($bracketed) {
6675	+ $res['enclosing'] = 'bracket';
6676	+ }
6677	+ return $res;
6678	}
6679
6680	+ protected static $libAppend = ['list', 'val', 'separator:null'];
6681	protected function libAppend($args)
6682	{
6683	list($list1, $value, $sep) = $args;

6685	$list1 = $this->coerceList($list1, ' ');
6686	$sep = $this->listSeparatorForJoin($list1, $sep);
6687
6688	+ $res = [Type::T_LIST, $sep, array_merge($list1[2], [$value])];
6689	+ if (isset($list1['enclosing'])) {
6690	+ $res['enclosing'] = $list1['enclosing'];
6691	+ }
6692	+ return $res;
6693	}
6694
6695	protected function libZip($args)
6696	{
6697	+ foreach ($args as $key => $arg) {
6698	+ $args[$key] = $this->coerceList($arg);
6699	}
6700
6701	$lists = [];

6778	) {
6779	$this->throwError('Invalid argument(s) for "comparable"');
6780
6781	+ return null;
6782	}
6783
6784	$number1 = $number1->normalize();

6826	return new Node\Number(strlen($stringContent), '');
6827	}
6828
6829	+ protected static $libStrSlice = ['string', 'start-at', 'end-at:-1'];
6830	protected function libStrSlice($args)
6831	{
6832	+ if (isset($args[2]) && ! $args[2][1]) {
6833	return static::$nullString;
6834	}
6835

6842	$start--;
6843	}
6844
6845	+ $end = isset($args[2]) ? (int) $args[2][1] : -1;
6846	$length = $end < 0 ? $end + 1 : ($end > 0 ? $end - $start : $end);
6847
6848	$string[2] = $length

6958	if ($n < 1) {
6959	$this->throwError("limit must be greater than or equal to 1");
6960
6961	+ return null;
6962	}
6963
6964	return new Node\Number(mt_rand(1, $n), '');

6980	return [Type::T_STRING, '', ['u' . str_pad(base_convert($id, 10, 36), 8, '0', STR_PAD_LEFT)]];
6981	}
6982
6983	+ protected function inspectFormatValue($value, $force_enclosing_display = false)
6984	+ {
6985	+ if ($value === static::$null) {
6986	+ $value = [Type::T_KEYWORD, 'null'];
6987	+ }
6988	+ $stringValue = [$value];
6989	+ if ($value[0] === Type::T_LIST) {
6990	+ if (end($value[2]) === static::$null) {
6991	+ array_pop($value[2]);
6992	+ $value[2][] = [Type::T_STRING, '', ['']];
6993	+ $force_enclosing_display = true;
6994	+ }
6995	+ if (! empty($value['enclosing'])) {
6996	+ if ($force_enclosing_display
6997	+ \|\| ($value['enclosing'] === 'bracket' )
6998	+ \|\| !count($value[2])) {
6999	+ $value['enclosing'] = 'forced_'.$value['enclosing'];
7000	+ $force_enclosing_display = true;
7001	+ }
7002	+ }
7003	+ foreach ($value[2] as $k => $listelement) {
7004	+ $value[2][$k] = $this->inspectFormatValue($listelement, $force_enclosing_display);
7005	+ }
7006	+ $stringValue = [$value];
7007	+ }
7008	+
7009	+ return [Type::T_STRING, '', $stringValue];
7010	+ }
7011	+
7012	protected static $libInspect = ['value'];
7013	protected function libInspect($args)
7014	{
7015	+ $value = $args[0];
7016	+ return $this->inspectFormatValue($value);
7017	+ }
7018	+
7019	+ /**
7020	+ * Preprocess selector args
7021	+ *
7022	+ * @param array $arg
7023	+ *
7024	+ * @return array\|boolean
7025	+ */
7026	+ protected function getSelectorArg($arg)
7027	+ {
7028	+ static $parser = null;
7029	+
7030	+ if (is_null($parser)) {
7031	+ $parser = $this->parserFactory(__METHOD__);
7032	+ }
7033	+
7034	+ $arg = $this->libUnquote([$arg]);
7035	+ $arg = $this->compileValue($arg);
7036	+
7037	+ $parsedSelector = [];
7038	+
7039	+ if ($parser->parseSelector($arg, $parsedSelector)) {
7040	+ $selector = $this->evalSelectors($parsedSelector);
7041	+ $gluedSelector = $this->glueFunctionSelectors($selector);
7042	+
7043	+ return $gluedSelector;
7044	+ }
7045	+
7046	+ return false;
7047	+ }
7048	+
7049	+ /**
7050	+ * Postprocess selector to output in right format
7051	+ *
7052	+ * @param array $selectors
7053	+ *
7054	+ * @return string
7055	+ */
7056	+ protected function formatOutputSelector($selectors)
7057	+ {
7058	+ $selectors = $this->collapseSelectors($selectors, true);
7059	+
7060	+ return $selectors;
7061	+ }
7062	+
7063	+ protected static $libIsSuperselector = ['super', 'sub'];
7064	+ protected function libIsSuperselector($args)
7065	+ {
7066	+ list($super, $sub) = $args;
7067	+
7068	+ $super = $this->getSelectorArg($super);
7069	+ $sub = $this->getSelectorArg($sub);
7070	+
7071	+ return $this->isSuperSelector($super, $sub);
7072	+ }
7073	+
7074	+ /**
7075	+ * Test a $super selector again $sub
7076	+ *
7077	+ * @param array $super
7078	+ * @param array $sub
7079	+ *
7080	+ * @return boolean
7081	+ */
7082	+ protected function isSuperSelector($super, $sub)
7083	+ {
7084	+ // one and only one selector for each arg
7085	+ if (! $super \|\| count($super) !== 1) {
7086	+ $this->throwError("Invalid super selector for isSuperSelector()");
7087	+ }
7088	+
7089	+ if (! $sub \|\| count($sub) !== 1) {
7090	+ $this->throwError("Invalid sub selector for isSuperSelector()");
7091	+ }
7092	+
7093	+ $super = reset($super);
7094	+ $sub = reset($sub);
7095	+
7096	+ $i = 0;
7097	+ $nextMustMatch = false;
7098	+
7099	+ foreach ($super as $node) {
7100	+ $compound = '';
7101	+
7102	+ array_walk_recursive(
7103	+ $node,
7104	+ function ($value, $key) use (&$compound) {
7105	+ $compound .= $value;
7106	+ }
7107	+ );
7108	+
7109	+ if ($this->isImmediateRelationshipCombinator($compound)) {
7110	+ if ($node !== $sub[$i]) {
7111	+ return false;
7112	+ }
7113	+
7114	+ $nextMustMatch = true;
7115	+ $i++;
7116	+ } else {
7117	+ while ($i < count($sub) && ! $this->isSuperPart($node, $sub[$i])) {
7118	+ if ($nextMustMatch) {
7119	+ return false;
7120	+ }
7121	+
7122	+ $i++;
7123	+ }
7124	+
7125	+ if ($i >= count($sub)) {
7126	+ return false;
7127	+ }
7128	+
7129	+ $nextMustMatch = false;
7130	+ $i++;
7131	+ }
7132	+ }
7133	+
7134	+ return true;
7135	+ }
7136	+
7137	+ /**
7138	+ * Test a part of super selector again a part of sub selector
7139	+ *
7140	+ * @param array $superParts
7141	+ * @param array $subParts
7142	+ *
7143	+ * @return boolean
7144	+ */
7145	+ protected function isSuperPart($superParts, $subParts)
7146	+ {
7147	+ $i = 0;
7148	+
7149	+ foreach ($superParts as $superPart) {
7150	+ while ($i < count($subParts) && $subParts[$i] !== $superPart) {
7151	+ $i++;
7152	+ }
7153	+
7154	+ if ($i >= count($subParts)) {
7155	+ return false;
7156	+ }
7157	+
7158	+ $i++;
7159	+ }
7160	+
7161	+ return true;
7162	+ }
7163	+
7164	+ protected static $libSelectorAppend = ['selector...'];
7165	+ protected function libSelectorAppend($args)
7166	+ {
7167	+ // get the selector... list
7168	+ $args = reset($args);
7169	+ $args = $args[2];
7170	+
7171	+ if (count($args) < 1) {
7172	+ $this->throwError("selector-append() needs at least 1 argument");
7173	+ }
7174	+
7175	+ $selectors = array_map([$this, 'getSelectorArg'], $args);
7176	+
7177	+ return $this->formatOutputSelector($this->selectorAppend($selectors));
7178	+ }
7179	+
7180	+ /**
7181	+ * Append parts of the last selector in the list to the previous, recursively
7182	+ *
7183	+ * @param array $selectors
7184	+ *
7185	+ * @return array
7186	+ *
7187	+ * @throws \ScssPhp\ScssPhp\Exception\CompilerException
7188	+ */
7189	+ protected function selectorAppend($selectors)
7190	+ {
7191	+ $lastSelectors = array_pop($selectors);
7192	+
7193	+ if (! $lastSelectors) {
7194	+ $this->throwError("Invalid selector list in selector-append()");
7195	+ }
7196	+
7197	+ while (count($selectors)) {
7198	+ $previousSelectors = array_pop($selectors);
7199	+
7200	+ if (! $previousSelectors) {
7201	+ $this->throwError("Invalid selector list in selector-append()");
7202	+ }
7203	+
7204	+ // do the trick, happening $lastSelector to $previousSelector
7205	+ $appended = [];
7206	+
7207	+ foreach ($lastSelectors as $lastSelector) {
7208	+ $previous = $previousSelectors;
7209	+
7210	+ foreach ($lastSelector as $lastSelectorParts) {
7211	+ foreach ($lastSelectorParts as $lastSelectorPart) {
7212	+ foreach ($previous as $i => $previousSelector) {
7213	+ foreach ($previousSelector as $j => $previousSelectorParts) {
7214	+ $previous[$i][$j][] = $lastSelectorPart;
7215	+ }
7216	+ }
7217	+ }
7218	+ }
7219	+
7220	+ foreach ($previous as $ps) {
7221	+ $appended[] = $ps;
7222	+ }
7223	+ }
7224	+
7225	+ $lastSelectors = $appended;
7226	+ }
7227	+
7228	+ return $lastSelectors;
7229	+ }
7230	+
7231	+ protected static $libSelectorExtend = ['selectors', 'extendee', 'extender'];
7232	+ protected function libSelectorExtend($args)
7233	+ {
7234	+ list($selectors, $extendee, $extender) = $args;
7235	+
7236	+ $selectors = $this->getSelectorArg($selectors);
7237	+ $extendee = $this->getSelectorArg($extendee);
7238	+ $extender = $this->getSelectorArg($extender);
7239	+
7240	+ if (! $selectors \|\| ! $extendee \|\| ! $extender) {
7241	+ $this->throwError("selector-extend() invalid arguments");
7242	+ }
7243	+
7244	+ $extended = $this->extendOrReplaceSelectors($selectors, $extendee, $extender);
7245	+
7246	+ return $this->formatOutputSelector($extended);
7247	+ }
7248	+
7249	+ protected static $libSelectorReplace = ['selectors', 'original', 'replacement'];
7250	+ protected function libSelectorReplace($args)
7251	+ {
7252	+ list($selectors, $original, $replacement) = $args;
7253	+
7254	+ $selectors = $this->getSelectorArg($selectors);
7255	+ $original = $this->getSelectorArg($original);
7256	+ $replacement = $this->getSelectorArg($replacement);
7257	+
7258	+ if (! $selectors \|\| ! $original \|\| ! $replacement) {
7259	+ $this->throwError("selector-replace() invalid arguments");
7260	+ }
7261	+
7262	+ $replaced = $this->extendOrReplaceSelectors($selectors, $original, $replacement, true);
7263	+
7264	+ return $this->formatOutputSelector($replaced);
7265	+ }
7266	+
7267	+ /**
7268	+ * Extend/replace in selectors
7269	+ * used by selector-extend and selector-replace that use the same logic
7270	+ *
7271	+ * @param array $selectors
7272	+ * @param array $extendee
7273	+ * @param array $extender
7274	+ * @param boolean $replace
7275	+ *
7276	+ * @return array
7277	+ */
7278	+ protected function extendOrReplaceSelectors($selectors, $extendee, $extender, $replace = false)
7279	+ {
7280	+ $saveExtends = $this->extends;
7281	+ $saveExtendsMap = $this->extendsMap;
7282	+
7283	+ $this->extends = [];
7284	+ $this->extendsMap = [];
7285	+
7286	+ foreach ($extendee as $es) {
7287	+ // only use the first one
7288	+ $this->pushExtends(reset($es), $extender, null);
7289	+ }
7290	+
7291	+ $extended = [];
7292	+
7293	+ foreach ($selectors as $selector) {
7294	+ if (! $replace) {
7295	+ $extended[] = $selector;
7296	+ }
7297	+
7298	+ $n = count($extended);
7299	+
7300	+ $this->matchExtends($selector, $extended);
7301	+
7302	+ // if didnt match, keep the original selector if we are in a replace operation
7303	+ if ($replace and count($extended) === $n) {
7304	+ $extended[] = $selector;
7305	+ }
7306	+ }
7307	+
7308	+ $this->extends = $saveExtends;
7309	+ $this->extendsMap = $saveExtendsMap;
7310	+
7311	+ return $extended;
7312	+ }
7313	+
7314	+ protected static $libSelectorNest = ['selector...'];
7315	+ protected function libSelectorNest($args)
7316	+ {
7317	+ // get the selector... list
7318	+ $args = reset($args);
7319	+ $args = $args[2];
7320	+
7321	+ if (count($args) < 1) {
7322	+ $this->throwError("selector-nest() needs at least 1 argument");
7323	+ }
7324	+
7325	+ $selectorsMap = array_map([$this, 'getSelectorArg'], $args);
7326	+ $envs = [];
7327	+
7328	+ foreach ($selectorsMap as $selectors) {
7329	+ $env = new Environment();
7330	+ $env->selectors = $selectors;
7331	+
7332	+ $envs[] = $env;
7333	+ }
7334	+
7335	+ $envs = array_reverse($envs);
7336	+ $env = $this->extractEnv($envs);
7337	+ $outputSelectors = $this->multiplySelectors($env);
7338	+
7339	+ return $this->formatOutputSelector($outputSelectors);
7340	+ }
7341	+
7342	+ protected static $libSelectorParse = ['selectors'];
7343	+ protected function libSelectorParse($args)
7344	+ {
7345	+ $selectors = reset($args);
7346	+ $selectors = $this->getSelectorArg($selectors);
7347	+
7348	+ return $this->formatOutputSelector($selectors);
7349	+ }
7350	+
7351	+ protected static $libSelectorUnify = ['selectors1', 'selectors2'];
7352	+ protected function libSelectorUnify($args)
7353	+ {
7354	+ list($selectors1, $selectors2) = $args;
7355	+
7356	+ $selectors1 = $this->getSelectorArg($selectors1);
7357	+ $selectors2 = $this->getSelectorArg($selectors2);
7358	+
7359	+ if (! $selectors1 \|\| ! $selectors2) {
7360	+ $this->throwError("selector-unify() invalid arguments");
7361	+ }
7362	+
7363	+ // only consider the first compound of each
7364	+ $compound1 = reset($selectors1);
7365	+ $compound2 = reset($selectors2);
7366	+
7367	+ // unify them and that's it
7368	+ $unified = $this->unifyCompoundSelectors($compound1, $compound2);
7369	+
7370	+ return $this->formatOutputSelector($unified);
7371	+ }
7372	+
7373	+ /**
7374	+ * The selector-unify magic as its best
7375	+ * (at least works as expected on test cases)
7376	+ *
7377	+ * @param array $compound1
7378	+ * @param array $compound2
7379	+ *
7380	+ * @return array\|mixed
7381	+ */
7382	+ protected function unifyCompoundSelectors($compound1, $compound2)
7383	+ {
7384	+ if (! count($compound1)) {
7385	+ return $compound2;
7386	+ }
7387	+
7388	+ if (! count($compound2)) {
7389	+ return $compound1;
7390	+ }
7391	+
7392	+ // check that last part are compatible
7393	+ $lastPart1 = array_pop($compound1);
7394	+ $lastPart2 = array_pop($compound2);
7395	+ $last = $this->mergeParts($lastPart1, $lastPart2);
7396	+
7397	+ if (! $last) {
7398	+ return [[]];
7399	+ }
7400	+
7401	+ $unifiedCompound = [$last];
7402	+ $unifiedSelectors = [$unifiedCompound];
7403	+
7404	+ // do the rest
7405	+ while (count($compound1) \|\| count($compound2)) {
7406	+ $part1 = end($compound1);
7407	+ $part2 = end($compound2);
7408	+
7409	+ if ($part1 && ($match2 = $this->matchPartInCompound($part1, $compound2))) {
7410	+ list($compound2, $part2, $after2) = $match2;
7411	+
7412	+ if ($after2) {
7413	+ $unifiedSelectors = $this->prependSelectors($unifiedSelectors, $after2);
7414	+ }
7415	+
7416	+ $c = $this->mergeParts($part1, $part2);
7417	+ $unifiedSelectors = $this->prependSelectors($unifiedSelectors, [$c]);
7418	+
7419	+ $part1 = $part2 = null;
7420	+
7421	+ array_pop($compound1);
7422	+ }
7423	+
7424	+ if ($part2 && ($match1 = $this->matchPartInCompound($part2, $compound1))) {
7425	+ list($compound1, $part1, $after1) = $match1;
7426	+
7427	+ if ($after1) {
7428	+ $unifiedSelectors = $this->prependSelectors($unifiedSelectors, $after1);
7429	+ }
7430	+
7431	+ $c = $this->mergeParts($part2, $part1);
7432	+ $unifiedSelectors = $this->prependSelectors($unifiedSelectors, [$c]);
7433	+
7434	+ $part1 = $part2 = null;
7435	+
7436	+ array_pop($compound2);
7437	+ }
7438	+
7439	+ $new = [];
7440	+
7441	+ if ($part1 && $part2) {
7442	+ array_pop($compound1);
7443	+ array_pop($compound2);
7444	+
7445	+ $s = $this->prependSelectors($unifiedSelectors, [$part2]);
7446	+ $new = array_merge($new, $this->prependSelectors($s, [$part1]));
7447	+ $s = $this->prependSelectors($unifiedSelectors, [$part1]);
7448	+ $new = array_merge($new, $this->prependSelectors($s, [$part2]));
7449	+ } elseif ($part1) {
7450	+ array_pop($compound1);
7451	+
7452	+ $new = array_merge($new, $this->prependSelectors($unifiedSelectors, [$part1]));
7453	+ } elseif ($part2) {
7454	+ array_pop($compound2);
7455	+
7456	+ $new = array_merge($new, $this->prependSelectors($unifiedSelectors, [$part2]));
7457	+ }
7458	+
7459	+ if ($new) {
7460	+ $unifiedSelectors = $new;
7461	+ }
7462	+ }
7463	+
7464	+ return $unifiedSelectors;
7465	+ }
7466	+
7467	+ /**
7468	+ * Prepend each selector from $selectors with $parts
7469	+ *
7470	+ * @param array $selectors
7471	+ * @param array $parts
7472	+ *
7473	+ * @return array
7474	+ */
7475	+ protected function prependSelectors($selectors, $parts)
7476	+ {
7477	+ $new = [];
7478	+
7479	+ foreach ($selectors as $compoundSelector) {
7480	+ array_unshift($compoundSelector, $parts);
7481	+
7482	+ $new[] = $compoundSelector;
7483	+ }
7484	+
7485	+ return $new;
7486	+ }
7487	+
7488	+ /**
7489	+ * Try to find a matching part in a compound:
7490	+ * - with same html tag name
7491	+ * - with some class or id or something in common
7492	+ *
7493	+ * @param array $part
7494	+ * @param array $compound
7495	+ *
7496	+ * @return array\|boolean
7497	+ */
7498	+ protected function matchPartInCompound($part, $compound)
7499	+ {
7500	+ $partTag = $this->findTagName($part);
7501	+ $before = $compound;
7502	+ $after = [];
7503	+
7504	+ // try to find a match by tag name first
7505	+ while (count($before)) {
7506	+ $p = array_pop($before);
7507	+
7508	+ if ($partTag && $partTag !== '*' && $partTag == $this->findTagName($p)) {
7509	+ return [$before, $p, $after];
7510	+ }
7511	+
7512	+ $after[] = $p;
7513	+ }
7514	+
7515	+ // try again matching a non empty intersection and a compatible tagname
7516	+ $before = $compound;
7517	+ $after = [];
7518	+
7519	+ while (count($before)) {
7520	+ $p = array_pop($before);
7521	+
7522	+ if ($this->checkCompatibleTags($partTag, $this->findTagName($p))) {
7523	+ if (count(array_intersect($part, $p))) {
7524	+ return [$before, $p, $after];
7525	+ }
7526	+ }
7527	+
7528	+ $after[] = $p;
7529	+ }
7530	+
7531	+ return false;
7532	+ }
7533	+
7534	+ /**
7535	+ * Merge two part list taking care that
7536	+ * - the html tag is coming first - if any
7537	+ * - the :something are coming last
7538	+ *
7539	+ * @param array $parts1
7540	+ * @param array $parts2
7541	+ *
7542	+ * @return array
7543	+ */
7544	+ protected function mergeParts($parts1, $parts2)
7545	+ {
7546	+ $tag1 = $this->findTagName($parts1);
7547	+ $tag2 = $this->findTagName($parts2);
7548	+ $tag = $this->checkCompatibleTags($tag1, $tag2);
7549	+
7550	+ // not compatible tags
7551	+ if ($tag === false) {
7552	+ return [];
7553	+ }
7554	+
7555	+ if ($tag) {
7556	+ if ($tag1) {
7557	+ $parts1 = array_diff($parts1, [$tag1]);
7558	+ }
7559	+
7560	+ if ($tag2) {
7561	+ $parts2 = array_diff($parts2, [$tag2]);
7562	+ }
7563	+ }
7564	+
7565	+ $mergedParts = array_merge($parts1, $parts2);
7566	+ $mergedOrderedParts = [];
7567	+
7568	+ foreach ($mergedParts as $part) {
7569	+ if (strpos($part, ':') === 0) {
7570	+ $mergedOrderedParts[] = $part;
7571	+ }
7572	+ }
7573	+
7574	+ $mergedParts = array_diff($mergedParts, $mergedOrderedParts);
7575	+ $mergedParts = array_merge($mergedParts, $mergedOrderedParts);
7576	+
7577	+ if ($tag) {
7578	+ array_unshift($mergedParts, $tag);
7579	+ }
7580	+
7581	+ return $mergedParts;
7582	+ }
7583	+
7584	+ /**
7585	+ * Check the compatibility between two tag names:
7586	+ * if both are defined they should be identical or one has to be '*'
7587	+ *
7588	+ * @param string $tag1
7589	+ * @param string $tag2
7590	+ *
7591	+ * @return array\|boolean
7592	+ */
7593	+ protected function checkCompatibleTags($tag1, $tag2)
7594	+ {
7595	+ $tags = [$tag1, $tag2];
7596	+ $tags = array_unique($tags);
7597	+ $tags = array_filter($tags);
7598	+
7599	+ if (count($tags) > 1) {
7600	+ $tags = array_diff($tags, ['*']);
7601	+ }
7602	+
7603	+ // not compatible nodes
7604	+ if (count($tags) > 1) {
7605	+ return false;
7606	+ }
7607	+
7608	+ return $tags;
7609	+ }
7610	+
7611	+ /**
7612	+ * Find the html tag name in a selector parts list
7613	+ *
7614	+ * @param array $parts
7615	+ *
7616	+ * @return mixed\|string
7617	+ */
7618	+ protected function findTagName($parts)
7619	+ {
7620	+ foreach ($parts as $part) {
7621	+ if (! preg_match('/^[\[.:#%_-]/', $part)) {
7622	+ return $part;
7623	+ }
7624	+ }
7625	+
7626	+ return '';
7627	+ }
7628	+
7629	+ protected static $libSimpleSelectors = ['selector'];
7630	+ protected function libSimpleSelectors($args)
7631	+ {
7632	+ $selector = reset($args);
7633	+ $selector = $this->getSelectorArg($selector);
7634	+
7635	+ // remove selectors list layer, keeping the first one
7636	+ $selector = reset($selector);
7637	+
7638	+ // remove parts list layer, keeping the first part
7639	+ $part = reset($selector);
7640	+
7641	+ $listParts = [];
7642	+
7643	+ foreach ($part as $p) {
7644	+ $listParts[] = [Type::T_STRING, '', [$p]];
7645	}
7646
7647	+ return [Type::T_LIST, ',', $listParts];
7648	}
7649	}

assets/libraries/scssphp/src/Compiler/Environment.php CHANGED Viewed

	@@ -2,14 +2,14 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp\Compiler;
13
14	/**
15	* Compiler environment
	@@ -19,12 +19,12 @@ namespace Leafo\ScssPhp\Compiler;
19	class Environment
20	{
21	/**
22	- * @var \~~Leafo~~\ScssPhp\Block
23	*/
24	public $block;
25
26	/**
27	- * @var \~~Leafo~~\ScssPhp\Compiler\Environment
28	*/
29	public $parent;
30
	@@ -33,6 +33,11 @@ class Environment
33	*/
34	public $store;
35





36	/**
37	* @var integer
38	*/


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp\Compiler;
13
14	/**
15	* Compiler environment

19	class Environment
20	{
21	/**
22	+ * @var \ScssPhp\ScssPhp\Block
23	*/
24	public $block;
25
26	/**
27	+ * @var \ScssPhp\ScssPhp\Compiler\Environment
28	*/
29	public $parent;
30

33	*/
34	public $store;
35
36	+ /**
37	+ * @var array
38	+ */
39	+ public $storeUnreduced;
40	+
41	/**
42	* @var integer
43	*/

assets/libraries/scssphp/src/Exception/CompilerException.php CHANGED Viewed

	@@ -2,14 +2,14 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp\Exception;
13
14	/**
15	* Compiler exception


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp\Exception;
13
14	/**
15	* Compiler exception

assets/libraries/scssphp/src/Exception/ParserException.php CHANGED Viewed

	@@ -2,14 +2,14 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp\Exception;
13
14	/**
15	* Parser Exception


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp\Exception;
13
14	/**
15	* Parser Exception

assets/libraries/scssphp/src/Exception/RangeException.php CHANGED Viewed

	@@ -2,14 +2,14 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp\Exception;
13
14	/**
15	* Range exception


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp\Exception;
13
14	/**
15	* Range exception

assets/libraries/scssphp/src/Exception/ServerException.php CHANGED Viewed

	@@ -2,14 +2,14 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp\Exception;
13
14	/**
15	* Server Exception


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp\Exception;
13
14	/**
15	* Server Exception

assets/libraries/scssphp/src/Formatter.php CHANGED Viewed

	@@ -2,17 +2,17 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp;
13
14	- use ~~Leafo~~\ScssPhp\Formatter\OutputBlock;
15	- use ~~Leafo~~\ScssPhp\SourceMap\SourceMapGenerator;
16
17	/**
18	* Base formatter
	@@ -62,7 +62,7 @@ abstract class Formatter
62	public $keepSemicolons;
63
64	/**
65	- * @var \~~Leafo~~\ScssPhp\Formatter\OutputBlock
66	*/
67	protected $currentBlock;
68
	@@ -77,10 +77,15 @@ abstract class Formatter
77	protected $currentColumn;
78
79	/**
80	- * @var \~~Leafo~~\ScssPhp\SourceMap\SourceMapGenerator
81	*/
82	protected $sourceMapGenerator;
83





84	/**
85	* Initialize formatter
86	*
	@@ -113,30 +118,10 @@ abstract class Formatter
113	return rtrim($name) . $this->assignSeparator . $value . ';';
114	}
115
116	- /**
117	- * Strip semi-colon appended by property(); it's a separator, not a terminator
118	- *
119	- * @api
120	- *
121	- * @param array $lines
122	- */
123	- public function stripSemicolon(&$lines)
124	- {
125	- if ($this->keepSemicolons) {
126	- return;
127	- }
128	-
129	- if (($count = count($lines))
130	- && substr($lines[$count - 1], -1) === ';'
131	- ) {
132	- $lines[$count - 1] = substr($lines[$count - 1], 0, -1);
133	- }
134	- }
135	-
136	/**
137	* Output lines inside a block
138	*
139	- * @param \~~Leafo~~\ScssPhp\Formatter\OutputBlock $block
140	*/
141	protected function blockLines(OutputBlock $block)
142	{
	@@ -154,7 +139,7 @@ abstract class Formatter
154	/**
155	* Output block selectors
156	*
157	- * @param \~~Leafo~~\ScssPhp\Formatter\OutputBlock $block
158	*/
159	protected function blockSelectors(OutputBlock $block)
160	{
	@@ -168,7 +153,7 @@ abstract class Formatter
168	/**
169	* Output block children
170	*
171	- * @param \~~Leafo~~\ScssPhp\Formatter\OutputBlock $block
172	*/
173	protected function blockChildren(OutputBlock $block)
174	{
	@@ -180,7 +165,7 @@ abstract class Formatter
180	/**
181	* Output non-empty block
182	*
183	- * @param \~~Leafo~~\ScssPhp\Formatter\OutputBlock $block
184	*/
185	protected function block(OutputBlock $block)
186	{
	@@ -209,6 +194,10 @@ abstract class Formatter
209	if (! empty($block->selectors)) {
210	$this->indentLevel--;
211




212	if (empty($block->children)) {
213	$this->write($this->break);
214	}
	@@ -217,13 +206,41 @@ abstract class Formatter
217	}
218	}
219




























220	/**
221	* Entry point to formatting a block
222	*
223	* @api
224	*
225	- * @param \~~Leafo~~\ScssPhp\Formatter\OutputBlock $block An abstract syntax tree
226	- * @param \~~Leafo~~\ScssPhp\SourceMap\SourceMapGenerator\|null $sourceMapGenerator Optional source map generator
227	*
228	* @return string
229	*/
	@@ -232,11 +249,13 @@ abstract class Formatter
232	$this->sourceMapGenerator = null;
233
234	if ($sourceMapGenerator) {
235	- $this->currentLine = 1;
236	- $this->currentColumn = 0;
237	$this->sourceMapGenerator = $sourceMapGenerator;
238	}
239


240	ob_start();
241
242	$this->block($block);
	@@ -247,16 +266,39 @@ abstract class Formatter
247	}
248
249	/**


250	* @param string $str
251	*/
252	protected function write($str)
253	{




















254	if ($this->sourceMapGenerator) {
255	$this->sourceMapGenerator->addMapping(
256	$this->currentLine,
257	$this->currentColumn,
258	$this->currentBlock->sourceLine,
259	- ~~$this->currentBlock->sourceColumn - 1,~~ //columns from parser are off by one

260	$this->currentBlock->sourceName
261	);
262


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp;
13
14	+ use ScssPhp\ScssPhp\Formatter\OutputBlock;
15	+ use ScssPhp\ScssPhp\SourceMap\SourceMapGenerator;
16
17	/**
18	* Base formatter

62	public $keepSemicolons;
63
64	/**
65	+ * @var \ScssPhp\ScssPhp\Formatter\OutputBlock
66	*/
67	protected $currentBlock;
68

77	protected $currentColumn;
78
79	/**
80	+ * @var \ScssPhp\ScssPhp\SourceMap\SourceMapGenerator
81	*/
82	protected $sourceMapGenerator;
83
84	+ /**
85	+ * @var string
86	+ */
87	+ protected $strippedSemicolon;
88	+
89	/**
90	* Initialize formatter
91	*

118	return rtrim($name) . $this->assignSeparator . $value . ';';
119	}
120




















121	/**
122	* Output lines inside a block
123	*
124	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
125	*/
126	protected function blockLines(OutputBlock $block)
127	{

139	/**
140	* Output block selectors
141	*
142	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
143	*/
144	protected function blockSelectors(OutputBlock $block)
145	{

153	/**
154	* Output block children
155	*
156	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
157	*/
158	protected function blockChildren(OutputBlock $block)
159	{

165	/**
166	* Output non-empty block
167	*
168	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
169	*/
170	protected function block(OutputBlock $block)
171	{

194	if (! empty($block->selectors)) {
195	$this->indentLevel--;
196
197	+ if (! $this->keepSemicolons) {
198	+ $this->strippedSemicolon = '';
199	+ }
200	+
201	if (empty($block->children)) {
202	$this->write($this->break);
203	}

206	}
207	}
208
209	+ /**
210	+ * Test and clean safely empty children
211	+ *
212	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
213	+ *
214	+ * @return boolean
215	+ */
216	+ protected function testEmptyChildren($block)
217	+ {
218	+ $isEmpty = empty($block->lines);
219	+
220	+ if ($block->children) {
221	+ foreach ($block->children as $k => &$child) {
222	+ if (! $this->testEmptyChildren($child)) {
223	+ $isEmpty = false;
224	+ continue;
225	+ }
226	+
227	+ if ($child->type === Type::T_MEDIA \|\| $child->type === Type::T_DIRECTIVE) {
228	+ $child->children = [];
229	+ $child->selectors = null;
230	+ }
231	+ }
232	+ }
233	+
234	+ return $isEmpty;
235	+ }
236	+
237	/**
238	* Entry point to formatting a block
239	*
240	* @api
241	*
242	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block An abstract syntax tree
243	+ * @param \ScssPhp\ScssPhp\SourceMap\SourceMapGenerator\|null $sourceMapGenerator Optional source map generator
244	*
245	* @return string
246	*/

249	$this->sourceMapGenerator = null;
250
251	if ($sourceMapGenerator) {
252	+ $this->currentLine = 1;
253	+ $this->currentColumn = 0;
254	$this->sourceMapGenerator = $sourceMapGenerator;
255	}
256
257	+ $this->testEmptyChildren($block);
258	+
259	ob_start();
260
261	$this->block($block);

266	}
267
268	/**
269	+ * Output content
270	+ *
271	* @param string $str
272	*/
273	protected function write($str)
274	{
275	+ if (! empty($this->strippedSemicolon)) {
276	+ echo $this->strippedSemicolon;
277	+
278	+ $this->strippedSemicolon = '';
279	+ }
280	+
281	+ /*
282	+ * Maybe Strip semi-colon appended by property(); it's a separator, not a terminator
283	+ * will be striped for real before a closing, otherwise displayed unchanged starting the next write
284	+ */
285	+ if (! $this->keepSemicolons &&
286	+ $str &&
287	+ (strpos($str, ';') !== false) &&
288	+ (substr($str, -1) === ';')
289	+ ) {
290	+ $str = substr($str, 0, -1);
291	+
292	+ $this->strippedSemicolon = ';';
293	+ }
294	+
295	if ($this->sourceMapGenerator) {
296	$this->sourceMapGenerator->addMapping(
297	$this->currentLine,
298	$this->currentColumn,
299	$this->currentBlock->sourceLine,
300	+ //columns from parser are off by one
301	+ $this->currentBlock->sourceColumn > 0 ? $this->currentBlock->sourceColumn - 1 : 0,
302	$this->currentBlock->sourceName
303	);
304

assets/libraries/scssphp/src/Formatter/Compact.php CHANGED Viewed

	@@ -2,16 +2,16 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp\Formatter;
13
14	- use ~~Leafo~~\ScssPhp\Formatter;
15
16	/**
17	* Compact formatter


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp\Formatter;
13
14	+ use ScssPhp\ScssPhp\Formatter;
15
16	/**
17	* Compact formatter

assets/libraries/scssphp/src/Formatter/Compressed.php CHANGED Viewed

	@@ -2,17 +2,17 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp\Formatter;
13
14	- use ~~Leafo~~\ScssPhp\Formatter;
15	- use ~~Leafo~~\ScssPhp\Formatter\OutputBlock;
16
17	/**
18	* Compressed formatter
	@@ -59,4 +59,23 @@ class Compressed extends Formatter
59	$this->write($this->break);
60	}
61	}



















62	}


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp\Formatter;
13
14	+ use ScssPhp\ScssPhp\Formatter;
15	+ use ScssPhp\ScssPhp\Formatter\OutputBlock;
16
17	/**
18	* Compressed formatter

59	$this->write($this->break);
60	}
61	}
62	+
63	+ /**
64	+ * Output block selectors
65	+ *
66	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
67	+ */
68	+ protected function blockSelectors(OutputBlock $block)
69	+ {
70	+ $inner = $this->indentStr();
71	+
72	+ $this->write(
73	+ $inner
74	+ . implode(
75	+ $this->tagSeparator,
76	+ str_replace([' > ', ' + ', ' ~ '], ['>', '+', '~'], $block->selectors)
77	+ )
78	+ . $this->open . $this->break
79	+ );
80	+ }
81	}

assets/libraries/scssphp/src/Formatter/Crunched.php CHANGED Viewed

	@@ -2,17 +2,17 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp\Formatter;
13
14	- use ~~Leafo~~\ScssPhp\Formatter;
15	- use ~~Leafo~~\ScssPhp\Formatter\OutputBlock;
16
17	/**
18	* Crunched formatter
	@@ -57,4 +57,23 @@ class Crunched extends Formatter
57	$this->write($this->break);
58	}
59	}



















60	}


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp\Formatter;
13
14	+ use ScssPhp\ScssPhp\Formatter;
15	+ use ScssPhp\ScssPhp\Formatter\OutputBlock;
16
17	/**
18	* Crunched formatter

57	$this->write($this->break);
58	}
59	}
60	+
61	+ /**
62	+ * Output block selectors
63	+ *
64	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
65	+ */
66	+ protected function blockSelectors(OutputBlock $block)
67	+ {
68	+ $inner = $this->indentStr();
69	+
70	+ $this->write(
71	+ $inner
72	+ . implode(
73	+ $this->tagSeparator,
74	+ str_replace([' > ', ' + ', ' ~ '], ['>', '+', '~'], $block->selectors)
75	+ )
76	+ . $this->open . $this->break
77	+ );
78	+ }
79	}

assets/libraries/scssphp/src/Formatter/Debug.php CHANGED Viewed

	@@ -2,17 +2,17 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp\Formatter;
13
14	- use ~~Leafo~~\ScssPhp\Formatter;
15	- use ~~Leafo~~\ScssPhp\Formatter\OutputBlock;
16
17	/**
18	* Debug formatter


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp\Formatter;
13
14	+ use ScssPhp\ScssPhp\Formatter;
15	+ use ScssPhp\ScssPhp\Formatter\OutputBlock;
16
17	/**
18	* Debug formatter

assets/libraries/scssphp/src/Formatter/Expanded.php CHANGED Viewed

	@@ -2,17 +2,17 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp\Formatter;
13
14	- use ~~Leafo~~\ScssPhp\Formatter;
15	- use ~~Leafo~~\ScssPhp\Formatter\OutputBlock;
16
17	/**
18	* Expanded formatter
	@@ -55,7 +55,7 @@ class Expanded extends Formatter
55
56	foreach ($block->lines as $index => $line) {
57	if (substr($line, 0, 2) === '/*') {
58	- $block->lines[$index] = preg_replace('/(\r\|\n)+/', $glue, $line);
59	}
60	}
61


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp\Formatter;
13
14	+ use ScssPhp\ScssPhp\Formatter;
15	+ use ScssPhp\ScssPhp\Formatter\OutputBlock;
16
17	/**
18	* Expanded formatter

55
56	foreach ($block->lines as $index => $line) {
57	if (substr($line, 0, 2) === '/*') {
58	+ $block->lines[$index] = preg_replace('/[\r\n]+/', $glue, $line);
59	}
60	}
61

assets/libraries/scssphp/src/Formatter/Nested.php CHANGED Viewed

@@ -2,17 +2,18 @@
             /**
              * SCSSPHP
+             *
-            -
             * @copyright 2012-2018 Leaf Corcoran
+             *
              * @license http://opensource.org/licenses/MIT MIT
+             *
-            -
             * @link http://leafo.github.io/scssphp
              */
-            -
            namespace Leafo\ScssPhp\Formatter;
-            -
            use Leafo\ScssPhp\Formatter;
-            -
            use Leafo\ScssPhp\Formatter\OutputBlock;
             /**
              * Nested formatter
@@ -62,58 +63,50 @@ class Nested extends Formatter
                     foreach ($block->lines as $index => $line) {
                         if (substr($line, 0, 2) === '/*') {
-            -
                            $block->lines[$index] = preg_replace('/(\r|\n)+/', $glue, $line);
+                        }
+                    }
                     $this->write($inner . implode($glue, $block->lines));
-            -
-            -
                    if (! empty($block->children)) {
-            -
                        $this->write($this->break);
-            -
                    }
+                }
                 /**
                  * {@inheritdoc}
                  */
-            -
                protected function blockSelectors(OutputBlock $block)
+                {
-            -
                    $inner = $this->indentStr();
-            -
-            -
                    $this->write($inner
-            -
                        . implode($this->tagSeparator, $block->selectors)
-            -
                        . $this->open . $this->break);
-            -
                }
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                protected function blockChildren(OutputBlock $block)
-            -
                {
-            -
                    foreach ($block->children as $i => $child) {
-            -
                        $this->block($child);
-            -
                        if ($i < count($block->children) - 1) {
-            -
                            $this->write($this->break);
-            -
                            if (isset($block->children[$i + 1])) {
-            -
                                $next = $block->children[$i + 1];
-            -
                                if ($next->depth === max($block->depth, 1) && $child->depth >= $next->depth) {
-            -
                                    $this->write($this->break);
-            -
                                }
-            -
                            }
+                        }
-            -
                    }
-            -
                }
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                protected function block(OutputBlock $block)
-            -
                {
-            -
                    if ($block->type === 'root') {
-            -
                        $this->adjustAllChildren($block);
+                    }
                     if (empty($block->lines) && empty($block->children)) {
@@ -122,27 +115,92 @@ class Nested extends Formatter
                     $this->currentBlock = $block;
-            -
                    $this->depth = $block->depth;
                     if (! empty($block->selectors)) {
                         $this->blockSelectors($block);
                         $this->indentLevel++;
+                    }
                     if (! empty($block->lines)) {
                         $this->blockLines($block);
+                    }
                     if (! empty($block->children)) {
-            -
                        $this->blockChildren($block);
+                    }
                     if (! empty($block->selectors)) {
                         $this->indentLevel--;
                         $this->write($this->close);
+                    }
                     if ($block->type === 'root') {
@@ -151,51 +209,20 @@ class Nested extends Formatter
+                }
                 /**
-            -
                 * Adjust the depths of all children, depth first
+                 *
-            -
                 * @param \Leafo\ScssPhp\Formatter\OutputBlock $block
                  */
-            -
                private function adjustAllChildren(OutputBlock $block)
+                {
-            -
                    // flatten empty nested blocks
-            -
                    $children = [];
-            -
-            -
                    foreach ($block->children as $i => $child) {
-            -
                        if (empty($child->lines) && empty($child->children)) {
-            -
                            if (isset($block->children[$i + 1])) {
-            -
                                $block->children[$i + 1]->depth = $child->depth;
-            -
                            }
-            -
-            -
                            continue;
-            -
                        }
-            -
-            -
                        $children[] = $child;
-            -
                    }
-            -
-            -
                    $count = count($children);
-            -
-            -
                    for ($i = 0; $i < $count; $i++) {
-            -
                        $depth = $children[$i]->depth;
-            -
                        $j = $i + 1;
-            -
-            -
                        if (isset($children[$j]) && $depth < $children[$j]->depth) {
-            -
                            $childDepth = $children[$j]->depth;
-            -
-            -
                            for (; $j < $count; $j++) {
-            -
                                if ($depth < $children[$j]->depth && $childDepth >= $children[$j]->depth) {
-            -
                                    $children[$j]->depth = $depth + 1;
-            -
                                }
-            -
                            }
+                        }
+                    }
-            -
                    $block->children = $children;
-            -
-            -
                    // make relative to parent
-            -
                    foreach ($block->children as $child) {
-            -
                        $this->adjustAllChildren($child);
-            -
-            -
                        $child->depth = $child->depth - $block->depth;
-            -
                    }
+                }
+            }


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp\Formatter;
13
14	+ use ScssPhp\ScssPhp\Formatter;
15	+ use ScssPhp\ScssPhp\Formatter\OutputBlock;
16	+ use ScssPhp\ScssPhp\Type;
17
18	/**
19	* Nested formatter

63
64	foreach ($block->lines as $index => $line) {
65	if (substr($line, 0, 2) === '/*') {
66	+ $block->lines[$index] = preg_replace('/[\r\n]+/', $glue, $line);
67	}
68	}
69
70	$this->write($inner . implode($glue, $block->lines));




71	}
72
73	/**
74	* {@inheritdoc}
75	*/
76	+ protected function block(OutputBlock $block)
77	{
78	+ static $depths;
79	+ static $downLevel;
80	+ static $closeBlock;
81	+ static $previousEmpty;
82	+ static $previousHasSelector;

83
84	+ if ($block->type === 'root') {
85	+ $depths = [ 0 ];
86	+ $downLevel = '';
87	+ $closeBlock = '';
88	+ $this->depth = 0;
89	+ $previousEmpty = false;
90	+ $previousHasSelector = false;
91	+ }
92
93	+ $isMediaOrDirective = in_array($block->type, [Type::T_DIRECTIVE, Type::T_MEDIA]);
94	+ $isSupport = ($block->type === Type::T_DIRECTIVE
95	+ && $block->selectors && strpos(implode('', $block->selectors), '@supports') !== false);
96
97	+ while ($block->depth < end($depths) \|\| ($block->depth == 1 && end($depths) == 1)) {
98	+ array_pop($depths);
99	+ $this->depth--;
100
101	+ if (! $this->depth && ($block->depth <= 1 \|\| (! $this->indentLevel && $block->type === Type::T_COMMENT)) &&
102	+ (($block->selectors && ! $isMediaOrDirective) \|\| $previousHasSelector)
103	+ ) {
104	+ $downLevel = $this->break;
105	}


106
107	+ if (empty($block->lines) && empty($block->children)) {
108	+ $previousEmpty = true;
109	+ }




110	}
111
112	if (empty($block->lines) && empty($block->children)) {

115
116	$this->currentBlock = $block;
117
118	+ if (! empty($block->lines) \|\| (! empty($block->children) && ($this->depth < 1 \|\| $isSupport))) {
119	+ if ($block->depth > end($depths)) {
120	+ if (! $previousEmpty \|\| $this->depth < 1) {
121	+ $this->depth++;
122	+ $depths[] = $block->depth;
123	+ } else {
124	+ // keep the current depth unchanged but take the block depth as a new reference for following blocks
125	+ array_pop($depths);
126	+ $depths[] = $block->depth;
127	+ }
128	+ }
129	+ }
130
131	+ $previousEmpty = ($block->type === Type::T_COMMENT);
132	+ $previousHasSelector = false;
133
134	if (! empty($block->selectors)) {
135	+ if ($closeBlock) {
136	+ $this->write($closeBlock);
137	+ $closeBlock = '';
138	+ }
139	+
140	+ if ($downLevel) {
141	+ $this->write($downLevel);
142	+ $downLevel = '';
143	+ }
144	+
145	$this->blockSelectors($block);
146
147	$this->indentLevel++;
148	}
149
150	if (! empty($block->lines)) {
151	+ if ($closeBlock) {
152	+ $this->write($closeBlock);
153	+ $closeBlock = '';
154	+ }
155	+
156	+ if ($downLevel) {
157	+ $this->write($downLevel);
158	+ $downLevel = '';
159	+ }
160	+
161	$this->blockLines($block);
162	+
163	+ $closeBlock = $this->break;
164	}
165
166	if (! empty($block->children)) {
167	+ if ($this->depth > 0 && ($isMediaOrDirective \|\| ! $this->hasFlatChild($block))) {
168	+ array_pop($depths);
169	+
170	+ $this->depth--;
171	+ $this->blockChildren($block);
172	+ $this->depth++;
173	+
174	+ $depths[] = $block->depth;
175	+ } else {
176	+ $this->blockChildren($block);
177	+ }
178	+ }
179	+
180	+ // reclear to not be spoiled by children if T_DIRECTIVE
181	+ if ($block->type === Type::T_DIRECTIVE) {
182	+ $previousHasSelector = false;
183	}
184
185	if (! empty($block->selectors)) {
186	$this->indentLevel--;
187
188	+ if (! $this->keepSemicolons) {
189	+ $this->strippedSemicolon = '';
190	+ }
191	+
192	$this->write($this->close);
193	+
194	+ $closeBlock = $this->break;
195	+
196	+ if ($this->depth > 1 && ! empty($block->children)) {
197	+ array_pop($depths);
198	+ $this->depth--;
199	+ }
200	+
201	+ if (! $isMediaOrDirective) {
202	+ $previousHasSelector = true;
203	+ }
204	}
205
206	if ($block->type === 'root') {

209	}
210
211	/**
212	+ * Block has flat child
213	+ *
214	+ * @param \ScssPhp\ScssPhp\Formatter\OutputBlock $block
215	*
216	+ * @return boolean
217	*/
218	+ private function hasFlatChild($block)
219	{
220	+ foreach ($block->children as $child) {
221	+ if (empty($child->selectors)) {
222	+ return true;


























223	}
224	}
225
226	+ return false;







227	}
228	}

assets/libraries/scssphp/src/Formatter/OutputBlock.php CHANGED Viewed

	@@ -2,14 +2,14 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp\Formatter;
13
14	/**
15	* Output block
	@@ -44,7 +44,7 @@ class OutputBlock
44	public $children;
45
46	/**
47	- * @var \~~Leafo~~\ScssPhp\Formatter\OutputBlock
48	*/
49	public $parent;
50


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp\Formatter;
13
14	/**
15	* Output block

44	public $children;
45
46	/**
47	+ * @var \ScssPhp\ScssPhp\Formatter\OutputBlock
48	*/
49	public $parent;
50

assets/libraries/scssphp/src/Node.php CHANGED Viewed

	@@ -2,14 +2,14 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp;
13
14	/**
15	* Base node


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp;
13
14	/**
15	* Base node

assets/libraries/scssphp/src/Node/Number.php CHANGED Viewed

	@@ -2,18 +2,18 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp\Node;
13
14	- use ~~Leafo~~\ScssPhp\Compiler;
15	- use ~~Leafo~~\ScssPhp\Node;
16	- use ~~Leafo~~\ScssPhp\Type;
17
18	/**
19	* Dimension + optional units
	@@ -100,7 +100,7 @@ class Number extends Node implements \ArrayAccess
100	*
101	* @param array $units
102	*
103	- * @return \~~Leafo~~\ScssPhp\Node\Number
104	*/
105	public function coerce($units)
106	{
	@@ -123,7 +123,7 @@ class Number extends Node implements \ArrayAccess
123	/**
124	* Normalize number
125	*
126	- * @return \~~Leafo~~\ScssPhp\Node\Number
127	*/
128	public function normalize()
129	{
	@@ -141,17 +141,17 @@ class Number extends Node implements \ArrayAccess
141	public function offsetExists($offset)
142	{
143	if ($offset === -3) {
144	- return $this->sourceColumn ~~!== null~~;
145	}
146
147	if ($offset === -2) {
148	- return $this->sourceLine ~~!== null~~;
149	}
150
151	- if ($offset === -1
152	- \|\| $offset === 0
153	- \|\| $offset === 1
154	- \|\| $offset === 2
155	) {
156	return true;
157	}
	@@ -259,7 +259,7 @@ class Number extends Node implements \ArrayAccess
259	/**
260	* Output number
261	*
262	- * @param \~~Leafo~~\ScssPhp\Compiler $compiler
263	*
264	* @return string
265	*/


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp\Node;
13
14	+ use ScssPhp\ScssPhp\Compiler;
15	+ use ScssPhp\ScssPhp\Node;
16	+ use ScssPhp\ScssPhp\Type;
17
18	/**
19	* Dimension + optional units

100	*
101	* @param array $units
102	*
103	+ * @return \ScssPhp\ScssPhp\Node\Number
104	*/
105	public function coerce($units)
106	{

123	/**
124	* Normalize number
125	*
126	+ * @return \ScssPhp\ScssPhp\Node\Number
127	*/
128	public function normalize()
129	{

141	public function offsetExists($offset)
142	{
143	if ($offset === -3) {
144	+ return ! is_null($this->sourceColumn);
145	}
146
147	if ($offset === -2) {
148	+ return ! is_null($this->sourceLine);
149	}
150
151	+ if ($offset === -1 \|\|
152	+ $offset === 0 \|\|
153	+ $offset === 1 \|\|
154	+ $offset === 2
155	) {
156	return true;
157	}

259	/**
260	* Output number
261	*
262	+ * @param \ScssPhp\ScssPhp\Compiler $compiler
263	*
264	* @return string
265	*/

assets/libraries/scssphp/src/Parser.php CHANGED Viewed

	@@ -2,20 +2,21 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp;
13
14	- use ~~Leafo~~\ScssPhp\Block;
15	- use ~~Leafo~~\ScssPhp\~~Compiler~~;
16	- use ~~Leafo~~\ScssPhp\~~Exception\ParserException~~;
17	- use ~~Leafo~~\ScssPhp\~~Node~~;
18	- use ~~Leafo~~\ScssPhp\~~Type~~;

19
20	/**
21	* Parser
	@@ -53,6 +54,8 @@ class Parser
53	protected static $operatorPattern;
54	protected static $whitePattern;
55


56	private $sourceName;
57	private $sourceIndex;
58	private $sourcePositions;
	@@ -61,27 +64,32 @@ class Parser
61	private $env;
62	private $inParens;
63	private $eatWhiteDefault;

64	private $buffer;
65	private $utf8;
66	private $encoding;
67	private $patternModifiers;

68
69	/**
70	* Constructor
71	*
72	* @api
73	*
74	- * @param string $sourceName
75	- * @param integer $sourceIndex
76	- * @param string $encoding

77	*/
78	- public function __construct($sourceName, $sourceIndex = 0, $encoding = 'utf-8')
79	{
80	$this->sourceName = $sourceName ?: '(stdin)';
81	$this->sourceIndex = $sourceIndex;
82	$this->charset = null;
83	$this->utf8 = ! $encoding \|\| strtolower($encoding) === 'utf-8';
84	$this->patternModifiers = $this->utf8 ? 'Aisu' : 'Ais';


85
86	if (empty(static::$operatorPattern)) {
87	static::$operatorPattern = '([*\/%+-]\|[!=]\=\|\>\=?\|\<\=\>\|\<\=?\|and\|or)';
	@@ -95,6 +103,10 @@ class Parser
95	? '/' . $commentSingle . '[^\n]\s\|(' . static::$commentPattern . ')\s*\|\s+/AisuS'
96	: '/' . $commentSingle . '[^\n]\s\|(' . static::$commentPattern . ')\s*\|\s+/AisS';
97	}




98	}
99
100	/**
	@@ -116,13 +128,15 @@ class Parser
116	*
117	* @param string $msg
118	*
119	- * @throws \~~Leafo~~\ScssPhp\Exception\ParserException
120	*/
121	public function throwParseError($msg = 'parse error')
122	{
123	- list($line, /* $column */) = $this->getSourcePosition($this->count);
124
125	- $loc = empty($this->sourceName) ~~? "line: $line" : "$this->sourceName on line $line";~~


126
127	if ($this->peek("(.*?)(\n\|$)", $m, $this->count)) {
128	throw new ParserException("$msg: failed at `$m[1]` $loc");
	@@ -138,10 +152,23 @@ class Parser
138	*
139	* @param string $buffer
140	*
141	- * @return \~~Leafo~~\ScssPhp\Block
142	*/
143	public function parse($buffer)
144	{













145	// strip BOM (byte order marker)
146	if (substr($buffer, 0, 3) === "\xef\xbb\xbf") {
147	$buffer = substr($buffer, 3);
	@@ -177,10 +204,12 @@ class Parser
177	array_unshift($this->env->children, $this->charset);
178	}
179
180	- $this->env->isRoot = true;
181	-
182	$this->restoreEncoding();
183




184	return $this->env;
185	}
186
	@@ -189,8 +218,8 @@ class Parser
189	*
190	* @api
191	*
192	- * @param string $buffer
193	- * @param string $out
194	*
195	* @return boolean
196	*/
	@@ -216,8 +245,8 @@ class Parser
216	*
217	* @api
218	*
219	- * @param string $buffer
220	- * @param string $out
221	*
222	* @return boolean
223	*/
	@@ -238,6 +267,33 @@ class Parser
238	return $selector;
239	}
240



























241	/**
242	* Parse a single chunk off the head of the buffer and append it to the
243	* current parse environment.
	@@ -271,7 +327,7 @@ class Parser
271	* the buffer position will be left at an invalid state. In order to
272	* avoid this, Compiler::seek() is used to remember and set buffer positions.
273	*
274	- * Before parsing a chain, use $s = $this->~~seek()~~ to remember the current
275	* position into $s. Then if a chain fails, use $this->seek($s) to
276	* go back where we started.
277	*
	@@ -279,25 +335,28 @@ class Parser
279	*/
280	protected function parseChunk()
281	{
282	- $s = $this->~~seek()~~;
283
284	// the directives
285	if (isset($this->buffer[$this->count]) && $this->buffer[$this->count] === '@') {
286	- if ($this->literal('@at-root') &&
287	($this->selectors($selector) \|\| true) &&
288	($this->map($with) \|\| true) &&
289	- $this->~~literal~~('{')



290	) {
291	$atRoot = $this->pushSpecialBlock(Type::T_AT_ROOT, $s);
292	$atRoot->selector = $selector;
293	- $atRoot->with = $with;
294
295	return true;
296	}
297
298	$this->seek($s);
299
300	- if ($this->literal('@media') && $this->mediaQueryList($mediaQueryList) && $this->~~literal~~('{')) {
301	$media = $this->pushSpecialBlock(Type::T_MEDIA, $s);
302	$media->queryList = $mediaQueryList[2];
303
	@@ -306,10 +365,10 @@ class Parser
306
307	$this->seek($s);
308
309	- if ($this->literal('@mixin') &&
310	$this->keyword($mixinName) &&
311	($this->argumentDef($args) \|\| true) &&
312	- $this->~~literal~~('{')
313	) {
314	$mixin = $this->pushSpecialBlock(Type::T_MIXIN, $s);
315	$mixin->name = $mixinName;
	@@ -320,15 +379,24 @@ class Parser
320
321	$this->seek($s);
322
323	- if ($this->literal('@include') &&
324	$this->keyword($mixinName) &&
325	- ($this->~~literal~~('(') &&
326	($this->argValues($argValues) \|\| true) &&
327	- $this->~~literal~~(')') \|\| true) &&
328	($this->end() \|\|
329	- $this->literal('{') && ~~$hasBlock = true)~~



330	) {
331	- $child = [~~Type::T_INCLUDE, $mixinName, isset($argValues) ? $argValues : null, null];~~






332
333	if (! empty($hasBlock)) {
334	$include = $this->pushSpecialBlock(Type::T_INCLUDE, $s);
	@@ -342,7 +410,7 @@ class Parser
342
343	$this->seek($s);
344
345	- if ($this->literal('@scssphp-import-once') &&
346	$this->valueList($importPath) &&
347	$this->end()
348	) {
	@@ -353,7 +421,7 @@ class Parser
353
354	$this->seek($s);
355
356	- if ($this->literal('@import') &&
357	$this->valueList($importPath) &&
358	$this->end()
359	) {
	@@ -364,7 +432,7 @@ class Parser
364
365	$this->seek($s);
366
367	- if ($this->literal('@import') &&
368	$this->url($importPath) &&
369	$this->end()
370	) {
	@@ -375,7 +443,7 @@ class Parser
375
376	$this->seek($s);
377
378	- if ($this->literal('@extend') &&
379	$this->selectors($selectors) &&
380	$this->end()
381	) {
	@@ -388,10 +456,10 @@ class Parser
388
389	$this->seek($s);
390
391	- if ($this->literal('@function') &&
392	$this->keyword($fnName) &&
393	$this->argumentDef($args) &&
394	- $this->~~literal~~('{')
395	) {
396	$func = $this->pushSpecialBlock(Type::T_FUNCTION, $s);
397	$func->name = $fnName;
	@@ -402,7 +470,7 @@ class Parser
402
403	$this->seek($s);
404
405	- if ($this->literal('@break') && $this->end()) {
406	$this->append([Type::T_BREAK], $s);
407
408	return true;
	@@ -410,7 +478,7 @@ class Parser
410
411	$this->seek($s);
412
413	- if ($this->literal('@continue') && $this->end()) {
414	$this->append([Type::T_CONTINUE], $s);
415
416	return true;
	@@ -418,8 +486,7 @@ class Parser
418
419	$this->seek($s);
420
421	-
422	- if ($this->literal('@return') && ($this->valueList($retVal) \|\| true) && $this->end()) {
423	$this->append([Type::T_RETURN, isset($retVal) ? $retVal : [Type::T_NULL]], $s);
424
425	return true;
	@@ -427,11 +494,11 @@ class Parser
427
428	$this->seek($s);
429
430	- if ($this->literal('@each') &&
431	$this->genericList($varNames, 'variable', ',', false) &&
432	- $this->literal('in') &&
433	$this->valueList($list) &&
434	- $this->~~literal~~('{')
435	) {
436	$each = $this->pushSpecialBlock(Type::T_EACH, $s);
437
	@@ -446,9 +513,9 @@ class Parser
446
447	$this->seek($s);
448
449	- if ($this->literal('@while') &&
450	$this->expression($cond) &&
451	- $this->~~literal~~('{')
452	) {
453	$while = $this->pushSpecialBlock(Type::T_WHILE, $s);
454	$while->cond = $cond;
	@@ -458,19 +525,19 @@ class Parser
458
459	$this->seek($s);
460
461	- if ($this->literal('@for') &&
462	$this->variable($varName) &&
463	- $this->literal('from') &&
464	$this->expression($start) &&
465	- ($this->literal('through') \|\|
466	- ($forUntil = true && $this->literal('to'))) &&
467	$this->expression($end) &&
468	- $this->~~literal~~('{')
469	) {
470	$for = $this->pushSpecialBlock(Type::T_FOR, $s);
471	- $for->var = $varName[1];
472	$for->start = $start;
473	- $for->end = $end;
474	$for->until = isset($forUntil);
475
476	return true;
	@@ -478,9 +545,15 @@ class Parser
478
479	$this->seek($s);
480
481	- if ($this->literal('@if') && $this->valueList($cond) && $this->~~literal~~('{')) {
482	$if = $this->pushSpecialBlock(Type::T_IF, $s);
483	- $~~if->~~cond = ~~$cond;~~






484	$if->cases = [];
485
486	return true;
	@@ -488,7 +561,7 @@ class Parser
488
489	$this->seek($s);
490
491	- if ($this->literal('@debug') &&
492	$this->valueList($value) &&
493	$this->end()
494	) {
	@@ -499,7 +572,7 @@ class Parser
499
500	$this->seek($s);
501
502	- if ($this->literal('@warn') &&
503	$this->valueList($value) &&
504	$this->end()
505	) {
	@@ -510,7 +583,7 @@ class Parser
510
511	$this->seek($s);
512
513	- if ($this->literal('@error') &&
514	$this->valueList($value) &&
515	$this->end()
516	) {
	@@ -521,8 +594,15 @@ class Parser
521
522	$this->seek($s);
523
524	- if ($this->literal('@content') ~~&& $this->end(~~)) {
525	- ~~$this->append([Type::T_MIXIN_CONTENT], $s);~~







526
527	return true;
528	}
	@@ -534,10 +614,10 @@ class Parser
534	if (isset($last) && $last[0] === Type::T_IF) {
535	list(, $if) = $last;
536
537	- if ($this->literal('@else')) {
538	- if ($this->~~literal~~('{')) {
539	$else = $this->pushSpecialBlock(Type::T_ELSE, $s);
540	- } elseif ($this->literal('if') && $this->valueList($cond) && $this->~~literal~~('{')) {
541	$else = $this->pushSpecialBlock(Type::T_ELSEIF, $s);
542	$else->cond = $cond;
543	}
	@@ -554,7 +634,7 @@ class Parser
554	}
555
556	// only retain the first @charset directive encountered
557	- if ($this->literal('@charset') &&
558	$this->valueList($charset) &&
559	$this->end()
560	) {
	@@ -575,11 +655,24 @@ class Parser
575
576	$this->seek($s);
577













578	// doesn't match built in directive, do generic one
579	- if ($this->~~literal~~('@', false) &&
580	$this->keyword($dirName) &&
581	($this->variable($dirValue) \|\| $this->openString('{', $dirValue) \|\| true) &&
582	- $this->~~literal~~('{')
583	) {
584	if ($dirName === 'media') {
585	$directive = $this->pushSpecialBlock(Type::T_MEDIA, $s);
	@@ -597,13 +690,26 @@ class Parser
597
598	$this->seek($s);
599













600	return false;
601	}
602
603	// property shortcut
604	// captures most properties before having to parse a selector
605	if ($this->keyword($name, false) &&
606	- $this->literal(': ') &&
607	$this->valueList($value) &&
608	$this->end()
609	) {
	@@ -617,7 +723,7 @@ class Parser
617
618	// variable assigns
619	if ($this->variable($name) &&
620	- $this->~~literal~~(':') &&
621	$this->valueList($value) &&
622	$this->end()
623	) {
	@@ -631,31 +737,42 @@ class Parser
631	$this->seek($s);
632
633	// misc
634	- if ($this->literal('-->')) {
635	return true;
636	}
637
638	// opening css block
639	- if ($this->selectors($selectors) && $this->~~literal~~('{')) {
640	$this->pushBlock($selectors, $s);
641





642	return true;
643	}
644
645	$this->seek($s);
646
647	// property assign, or nested assign
648	- if ($this->propertyName($name) && $this->~~literal~~(':')) {
649	$foundSomething = false;
650
651	if ($this->valueList($value)) {




652	$this->append([Type::T_ASSIGN, $name, $value], $s);
653	$foundSomething = true;
654	}
655
656	- if ($this->~~literal~~('{')) {
657	$propBlock = $this->pushSpecialBlock(Type::T_NESTED_PROPERTY, $s);
658	$propBlock->prefix = $name;


659	$foundSomething = true;
660	} elseif ($foundSomething) {
661	$foundSomething = $this->end();
	@@ -669,9 +786,15 @@ class Parser
669	$this->seek($s);
670
671	// closing a block
672	- if ($this->~~literal~~('}')) {
673	$block = $this->popBlock();
674






675	if (isset($block->type) && $block->type === Type::T_INCLUDE) {
676	$include = $block->child;
677	unset($block->child);
	@@ -682,12 +805,21 @@ class Parser
682	$this->append([$type, $block], $s);
683	}
684









685	return true;
686	}
687
688	// extra stuff
689	- if ($this->~~literal~~(';') \|\|
690	- $this->literal('<!--')
691	) {
692	return true;
693	}
	@@ -701,7 +833,7 @@ class Parser
701	* @param array $selectors
702	* @param integer $pos
703	*
704	- * @return \~~Leafo~~\ScssPhp\Block
705	*/
706	protected function pushBlock($selectors, $pos = 0)
707	{
	@@ -729,6 +861,15 @@ class Parser
729
730	$this->env = $b;
731









732	return $b;
733	}
734
	@@ -738,7 +879,7 @@ class Parser
738	* @param string $type
739	* @param integer $pos
740	*
741	- * @return \~~Leafo~~\ScssPhp\Block
742	*/
743	protected function pushSpecialBlock($type, $pos)
744	{
	@@ -751,26 +892,33 @@ class Parser
751	/**
752	* Pop scope and return last block
753	*
754	- * @return \~~Leafo~~\ScssPhp\Block
755	*
756	* @throws \Exception
757	*/
758	protected function popBlock()
759	{







760	$block = $this->env;
761
762	if (empty($block->parent)) {
763	$this->throwParseError('unexpected }');
764	}
765





766	$this->env = $block->parent;
767	- unset($block->parent);
768
769	- $~~comments = $~~block->~~comments~~;
770	- if (count($comments)) {
771	- $this->env->comments = $comments;
772	- unset($block->comments);
773	- }
774
775	return $block;
776	}
	@@ -800,18 +948,10 @@ class Parser
800	* Seek to position in input stream (or return current position in input stream)
801	*
802	* @param integer $where
803	- *
804	- * @return integer
805	*/
806	- protected function seek($where ~~= null~~)
807	{
808	- if ($where === null) {
809	- return $this->count;
810	- }
811	-
812	$this->count = $where;
813	-
814	- return true;
815	}
816
817	/**
	@@ -866,52 +1006,78 @@ class Parser
866	*/
867	protected function match($regex, &$out, $eatWhitespace = null)
868	{








869	if (! isset($eatWhitespace)) {
870	$eatWhitespace = $this->eatWhiteDefault;
871	}
872
873	- $r ~~= '/' .~~ $~~regex~~ ~~. '/' . $this->patternModifiers;~~


874
875	- if ~~(preg_match($r, $this->buffer, $out, null, $this->count)) {~~
876	- ~~$this->count += strlen($out[0]);~~
877
878	- ~~if ($eatWhitespace) {~~
879	- ~~$this->whitespace();~~
880	- }










881
882	- ~~return true;~~



883	}
884
885	- ~~return~~ ~~false;~~




886	}
887
888	/**
889	* Match literal string
890	*
891	* @param string $what

892	* @param boolean $eatWhitespace
893	*
894	* @return boolean
895	*/
896	- protected function literal($what, $eatWhitespace = null)
897	{
898	- if (~~! isset~~($~~eatWhitespace~~)) {
899	- ~~$eatWhitespace~~ ~~= $this->eatWhiteDefault~~;
900	}
901
902	- $~~len~~ = ~~strlen(~~$~~what)~~;
903
904	- if (~~strcasecmp~~(~~substr(~~$~~this->buffer, $this->count, $len~~)~~, $what~~) ~~=== 0)~~ {
905	- $~~this->count~~ += $~~len~~;
906	-
907	- if ($eatWhitespace) {
908	- $this->whitespace();
909	- }
910
911	- ~~return~~ ~~true;~~

912	}
913
914	- return ~~false~~;
915	}
916
917	/**
	@@ -925,12 +1091,59 @@ class Parser
925
926	while (preg_match(static::$whitePattern, $this->buffer, $m, null, $this->count)) {
927	if (isset($m[1]) && empty($this->commentsSeen[$this->count])) {
928	- ~~$this->appendComment([Type::T_COMMENT,~~ ~~$m[1]]);~~
































929
930	- ~~$this->commentsSeen[$this->count]~~ = ~~true;~~
















931	}
932
933	- $this->count += strlen($m[0]);
934	$gotWhite = true;
935	}
936
	@@ -944,9 +1157,26 @@ class Parser
944	*/
945	protected function appendComment($comment)
946	{
947	- ~~$comment[1]~~ ~~= substr~~(~~preg_replace(['/^\s+/m',~~ ~~'/^(.)/m'], ['', ' \1'],~~ $~~comment[1]~~), ~~1);~~
















948
949	- $this->env->comments[] = $comment;

950	}
951
952	/**
	@@ -957,19 +1187,21 @@ class Parser
957	*/
958	protected function append($statement, $pos = null)
959	{
960	- if ($~~pos !== null~~) {
961	- ~~list~~(~~$line,~~ ~~$column) = $this->getSourcePosition~~($pos);

962
963	- $statement[static::SOURCE_LINE] = $line;
964	- $statement[static::SOURCE_COLUMN] = $column;
965	- $statement[static::SOURCE_INDEX] = $this->sourceIndex;
966	- }
967
968	- $this->env->children[] = $statement;

969
970	$comments = $this->env->comments;
971
972	- if (~~count(~~$comments)) {
973	$this->env->children = array_merge($this->env->children, $comments);
974	$this->env->comments = [];
975	}
	@@ -1013,7 +1245,7 @@ class Parser
1013	$expressions = null;
1014	$parts = [];
1015
1016	- if (($this->literal('only') && ($only = true) \|\| $this->literal('not') && ($not = true) \|\| true) &&
1017	$this->mixedKeyword($mediaType)
1018	) {
1019	$prop = [Type::T_MEDIA_TYPE];
	@@ -1040,7 +1272,7 @@ class Parser
1040	$parts[] = $prop;
1041	}
1042
1043	- if (empty($parts) \|\| $this->literal('and')) {
1044	$this->genericList($expressions, 'mediaExpression', 'and', false);
1045
1046	if (is_array($expressions)) {
	@@ -1053,6 +1285,130 @@ class Parser
1053	return true;
1054	}
1055




























































































































1056	/**
1057	* Parse media expression
1058	*
	@@ -1062,13 +1418,13 @@ class Parser
1062	*/
1063	protected function mediaExpression(&$out)
1064	{
1065	- $s = $this->~~seek()~~;
1066	$value = null;
1067
1068	- if ($this->~~literal~~('(') &&
1069	$this->expression($feature) &&
1070	- ($this->~~literal~~(':') && $this->expression($value) \|\| true) &&
1071	- $this->~~literal~~(')')
1072	) {
1073	$out = [Type::T_MEDIA_EXPRESSION, $feature];
1074
	@@ -1111,20 +1467,21 @@ class Parser
1111	*/
1112	protected function argValue(&$out)
1113	{
1114	- $s = $this->~~seek()~~;
1115
1116	$keyword = null;
1117
1118	- if (! $this->variable($keyword) \|\| ! $this->~~literal~~(':')) {
1119	$this->seek($s);

1120	$keyword = null;
1121	}
1122
1123	if ($this->genericList($value, 'expression')) {
1124	$out = [$keyword, $value, false];
1125	- $s = $this->~~seek()~~;
1126
1127	- if ($this->literal('...')) {
1128	$out[2] = true;
1129	} else {
1130	$this->seek($s);
	@@ -1139,13 +1496,18 @@ class Parser
1139	/**
1140	* Parse comma separated value list
1141	*
1142	- * @param ~~string~~ $out
1143	*
1144	* @return boolean
1145	*/
1146	protected function valueList(&$out)
1147	{
1148	- ~~return~~ $this->~~genericList($out, 'spaceList', ',')~~;





1149	}
1150
1151	/**
	@@ -1172,25 +1534,31 @@ class Parser
1172	*/
1173	protected function genericList(&$out, $parseItem, $delim = '', $flatten = true)
1174	{
1175	- $s = $this->~~seek()~~;
1176	$items = [];

1177
1178	while ($this->$parseItem($value)) {

1179	$items[] = $value;
1180
1181	if ($delim) {
1182	- if (! $this->literal($delim)) {
1183	break;
1184	}

1185	}
1186	}
1187
1188	- if (~~count(~~$items) ~~=== 0)~~ {
1189	$this->seek($s);
1190
1191	return false;
1192	}
1193



1194	if ($flatten && count($items) === 1) {
1195	$out = $items[0];
1196	} else {
	@@ -1204,36 +1572,110 @@ class Parser
1204	* Parse expression
1205	*
1206	* @param array $out


1207	*
1208	* @return boolean
1209	*/
1210	- protected function expression(&$out)
1211	{
1212	- $s = $this->~~seek()~~;











1213
1214	- ~~if (~~$this->~~literal('('))~~ {
1215	- if ($this->literal(')')) {
1216	- $out = [Type::T_LIST, '', []];
1217
1218	return true;
1219	}
1220
1221	- ~~if (~~$this->~~valueList~~($~~out~~) ~~&& $this->literal(')') && $out[0] === Type::T_LIST) {~~











1222	return true;
1223	}
1224
1225	$this->seek($s);

1226
1227	- if ($this->~~map~~($~~out~~)) {
1228	- ~~return~~ ~~true;~~



1229	}
1230
1231	- $this->~~seek(~~$s);


1232	}
1233
1234	- ~~if (~~$this->~~value(~~$~~lhs)) {~~
1235	- ~~$out~~ ~~= $this->expHelper($lhs, 0)~~;

1236













































1237	return true;
1238	}
1239
	@@ -1252,7 +1694,7 @@ class Parser
1252	{
1253	$operators = static::$operatorPattern;
1254
1255	- $ss = $this->~~seek()~~;
1256	$whiteBefore = isset($this->buffer[$this->count - 1]) &&
1257	ctype_space($this->buffer[$this->count - 1]);
1258
	@@ -1271,7 +1713,7 @@ class Parser
1271	break;
1272	}
1273
1274	- if (! $this->value($rhs)) {
1275	break;
1276	}
1277
	@@ -1281,7 +1723,7 @@ class Parser
1281	}
1282
1283	$lhs = [Type::T_EXPRESSION, $op, $lhs, $rhs, $this->inParens, $whiteBefore, $whiteAfter];
1284	- $ss = $this->~~seek()~~;
1285	$whiteBefore = isset($this->buffer[$this->count - 1]) &&
1286	ctype_space($this->buffer[$this->count - 1]);
1287	}
	@@ -1300,14 +1742,23 @@ class Parser
1300	*/
1301	protected function value(&$out)
1302	{
1303	- $s = $this->~~seek(~~);


1304
1305	- ~~if (~~$~~this->literal('url(')~~ && $this->~~match('data:([a-z]+)\/([a-z0-9.+-]+)~~;~~base64,', $m, false)) {~~
1306	- $~~len~~ = ~~strspn(~~$this->buffer~~, 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwyxz0123456789+/=',~~ $this->count);







1307
1308	$this->count += $len;
1309
1310	- if ($this->~~literal~~(')')) {
1311	$content = substr($this->buffer, $s, $this->count - $s);
1312	$out = [Type::T_KEYWORD, $content];
1313
	@@ -1317,56 +1768,113 @@ class Parser
1317
1318	$this->seek($s);
1319
1320	- if ($this->literal('~~not~~', false) && $this->~~whitespace~~() && $~~this->value($inner~~)) {
1321	- $~~out~~ = ~~[Type::T_UNARY,~~ '~~not~~', ~~$inner,~~ $~~this->inParens~~];
1322
1323	- ~~return~~ ~~true;~~





1324	}
1325
1326	$this->seek($s);
1327
1328	- if ~~($this->literal('~~not~~', false) && $this->parenValue($inner)) {~~
1329	- $~~out~~ = ~~[Type::T_UNARY,~~ 'not', ~~$inner~~, ~~$this->inParens];~~







1330







































1331	return true;
1332	}
1333
1334	- ~~$this->seek~~($s);




1335
1336	- if ($this->~~literal~~('+') ~~&& $this->value($inner~~)) {
1337	- $out = [Type::~~T_UNARY, '+', $inner, $this->inParens~~];
1338
1339	return true;
1340	}
1341
1342	- $this->~~seek~~($s);


1343
1344	- // ~~negation~~
1345	- if ~~($this->literal('-', false) &&~~
1346	- ~~($this->variable($inner) \|\|~~
1347	- $this->unit($inner) \|\|
1348	- $this->parenValue($inner))
1349	- ) {
1350	- $out = [Type::T_UNARY, '-', $inner, $this->inParens];
1351

1352	return true;
1353	}
1354
1355	- $this->~~seek~~($s);






1356
1357	- if ($this->parenValue($out) \|\|
1358	- $this->interpolation($out) \|\|
1359	- $this->variable($out) \|\|
1360	- $this->color($out) \|\|
1361	- $this->unit($out) \|\|
1362	- $this->string($out) \|\|
1363	- $this->func($out) \|\|
1364	- $this->progid($out)
1365	- ) {
1366	return true;
1367	}
1368
1369	- if ($this->keyword($keyword)) {






1370	if ($keyword === 'null') {
1371	$out = [Type::T_NULL];
1372	} else {
	@@ -1388,12 +1896,12 @@ class Parser
1388	*/
1389	protected function parenValue(&$out)
1390	{
1391	- $s = $this->~~seek()~~;
1392
1393	$inParens = $this->inParens;
1394
1395	- if ($this->~~literal~~('(')) {
1396	- if ($this->~~literal~~(')')) {
1397	$out = [Type::T_LIST, '', []];
1398
1399	return true;
	@@ -1401,7 +1909,7 @@ class Parser
1401
1402	$this->inParens = true;
1403
1404	- if ($this->expression($exp) && $this->~~literal~~(')')) {
1405	$out = $exp;
1406	$this->inParens = $inParens;
1407
	@@ -1424,15 +1932,15 @@ class Parser
1424	*/
1425	protected function progid(&$out)
1426	{
1427	- $s = $this->~~seek()~~;
1428
1429	- if ($this->literal('progid:', false) &&
1430	$this->openString('(', $fn) &&
1431	- $this->~~literal~~('(')
1432	) {
1433	$this->openString(')', $args, '(');
1434
1435	- if ($this->~~literal~~(')')) {
1436	$out = [Type::T_STRING, '', [
1437	'progid:', $fn, '(', $args, ')'
1438	]];
	@@ -1449,17 +1957,16 @@ class Parser
1449	/**
1450	* Parse function call
1451	*
1452	- * @param ~~array~~ $~~out~~

1453	*
1454	* @return boolean
1455	*/
1456	- protected function func(&$func)
1457	{
1458	- $s = $this->~~seek()~~;
1459
1460	- if ($this->~~keyword~~(~~$name, false~~) &&
1461	- $this->literal('(')
1462	- ) {
1463	if ($name === 'alpha' && $this->argumentList($args)) {
1464	$func = [Type::T_FUNCTION, $name, [Type::T_STRING, '', $args]];
1465
	@@ -1467,9 +1974,9 @@ class Parser
1467	}
1468
1469	if ($name !== 'expression' && ! preg_match('/^(-[a-z]+-)?calc$/', $name)) {
1470	- $ss = $this->~~seek()~~;
1471
1472	- if ($this->argValues($args) && $this->~~literal~~(')')) {
1473	$func = [Type::T_FUNCTION_CALL, $name, $args];
1474
1475	return true;
	@@ -1479,7 +1986,7 @@ class Parser
1479	}
1480
1481	if (($this->openString(')', $str, '(') \|\| true) &&
1482	- $this->~~literal~~(')')
1483	) {
1484	$args = [];
1485
	@@ -1507,13 +2014,13 @@ class Parser
1507	*/
1508	protected function argumentList(&$out)
1509	{
1510	- $s = $this->~~seek()~~;
1511	- $this->~~literal~~('(');
1512
1513	$args = [];
1514
1515	while ($this->keyword($var)) {
1516	- if ($this->~~literal~~('=') && $this->expression($exp)) {
1517	$args[] = [Type::T_STRING, '', [$var . '=']];
1518	$arg = $exp;
1519	} else {
	@@ -1522,14 +2029,14 @@ class Parser
1522
1523	$args[] = $arg;
1524
1525	- if (! $this->~~literal~~(',')) {
1526	break;
1527	}
1528
1529	$args[] = [Type::T_STRING, '', [', ']];
1530	}
1531
1532	- if (! $this->~~literal~~(')') \|\| ! ~~count(~~$args)) {
1533	$this->seek($s);
1534
1535	return false;
	@@ -1549,28 +2056,28 @@ class Parser
1549	*/
1550	protected function argumentDef(&$out)
1551	{
1552	- $s = $this->~~seek()~~;
1553	- $this->~~literal~~('(');
1554
1555	$args = [];
1556
1557	while ($this->variable($var)) {
1558	$arg = [$var[1], null, false];
1559
1560	- $ss = $this->~~seek()~~;
1561
1562	- if ($this->~~literal~~(':') && $this->genericList($defaultVal, 'expression')) {
1563	$arg[1] = $defaultVal;
1564	} else {
1565	$this->seek($ss);
1566	}
1567
1568	- $ss = $this->~~seek()~~;
1569
1570	- if ($this->literal('...')) {
1571	- $sss = $this->~~seek()~~;
1572
1573	- if (! $this->~~literal~~(')')) {
1574	$this->throwParseError('... has to be after the final argument');
1575	}
1576
	@@ -1582,12 +2089,12 @@ class Parser
1582
1583	$args[] = $arg;
1584
1585	- if (! $this->~~literal~~(',')) {
1586	break;
1587	}
1588	}
1589
1590	- if (! $this->~~literal~~(')')) {
1591	$this->seek($s);
1592
1593	return false;
	@@ -1607,27 +2114,27 @@ class Parser
1607	*/
1608	protected function map(&$out)
1609	{
1610	- $s = $this->~~seek()~~;
1611
1612	- if (! $this->~~literal~~('(')) {
1613	return false;
1614	}
1615
1616	$keys = [];
1617	$values = [];
1618
1619	- while ($this->genericList($key, 'expression') && $this->~~literal~~(':') &&
1620	$this->genericList($value, 'expression')
1621	) {
1622	$keys[] = $key;
1623	$values[] = $value;
1624
1625	- if (! $this->~~literal~~(',')) {
1626	break;
1627	}
1628	}
1629
1630	- if (! ~~count(~~$keys) \|\| ! $this->~~literal~~(')')) {
1631	$this->seek($s);
1632
1633	return false;
	@@ -1647,29 +2154,16 @@ class Parser
1647	*/
1648	protected function color(&$out)
1649	{
1650	- $~~color~~ = ~~[Type::T_COLOR]~~;
1651
1652	- if ($this->match('(#([0-9a-f]~~{6}~~)~~\|#([0-9a-f]{3}~~))', $m)) {
1653	- if (~~isset~~($m[3])) {
1654	- $~~num~~ = ~~hexdec(~~$m[3]);
1655	-
1656	- foreach ([3, 2, 1] as $i) {
1657	- $t = $num & 0xf;
1658	- $color[$i] = $t << 4 \| $t;
1659	- $num >>= 4;
1660	- }
1661	- } else {
1662	- $num = hexdec($m[2]);
1663	-
1664	- foreach ([3, 2, 1] as $i) {
1665	- $color[$i] = $num & 0xff;
1666	- $num >>= 8;
1667	- }
1668	}
1669
1670	- $~~out =~~ $~~color~~;
1671	-
1672	- return true;
1673	}
1674
1675	return false;
	@@ -1678,16 +2172,24 @@ class Parser
1678	/**
1679	* Parse number with unit
1680	*
1681	- * @param array $~~out~~
1682	*
1683	* @return boolean
1684	*/
1685	protected function unit(&$unit)
1686	{
1687	- if ($this->~~match('([0-9]*(\.)?[0-9]+)([%a-zA-Z]+)?', $m)) {~~
1688	- $unit = new Node\Number($m[1], empty($m[3]) ? '' : $m[3]);
1689
1690	- ~~return~~ ~~true;~~









1691	}
1692
1693	return false;
	@@ -1702,11 +2204,11 @@ class Parser
1702	*/
1703	protected function string(&$out)
1704	{
1705	- $s = $this->~~seek()~~;
1706
1707	- if ($this->~~literal~~('"', false)) {
1708	$delim = '"';
1709	- } elseif ($this->~~literal~~("'", false)) {
1710	$delim = "'";
1711	} else {
1712	return false;
	@@ -1733,10 +2235,18 @@ class Parser
1733	$content[] = '#{'; // ignore it
1734	}
1735	} elseif ($m[2] === '\\') {
1736	- if ($this->~~literal~~('"', false)) {
1737	$content[] = $m[2] . '"';
1738	- } elseif ($this->~~literal~~("'", false)) {
1739	$content[] = $m[2] . "'";








1740	} else {
1741	$content[] = $m[2];
1742	}
	@@ -1748,12 +2258,14 @@ class Parser
1748
1749	$this->eatWhiteDefault = $oldWhite;
1750
1751	- if ($this->literal($delim)) {
1752	if ($hasInterpolation) {
1753	$delim = '"';
1754
1755	foreach ($content as &$string) {
1756	- if ($string === "~~\\'~~") {


1757	$string = "'";
1758	} elseif ($string === '\\"') {
1759	$string = '"';
	@@ -1774,11 +2286,12 @@ class Parser
1774	/**
1775	* Parse keyword or interpolation
1776	*
1777	- * @param array $out

1778	*
1779	* @return boolean
1780	*/
1781	- protected function mixedKeyword(&$out)
1782	{
1783	$parts = [];
1784
	@@ -1786,7 +2299,7 @@ class Parser
1786	$this->eatWhiteDefault = false;
1787
1788	for (;;) {
1789	- if ($this->keyword($key)) {
1790	$parts[] = $key;
1791	continue;
1792	}
	@@ -1801,7 +2314,7 @@ class Parser
1801
1802	$this->eatWhiteDefault = $oldWhite;
1803
1804	- if (~~count(~~$parts) ~~=== 0)~~ {
1805	return false;
1806	}
1807
	@@ -1867,7 +2380,7 @@ class Parser
1867
1868	$this->eatWhiteDefault = $oldWhite;
1869
1870	- if (~~count(~~$content) ~~=== 0)~~ {
1871	return false;
1872	}
1873
	@@ -1884,8 +2397,8 @@ class Parser
1884	/**
1885	* Parser interpolation
1886	*
1887	- * @param array $out
1888	- * @param boolean $lookWhite save information about whitespace before and after
1889	*
1890	* @return boolean
1891	*/
	@@ -1894,17 +2407,22 @@ class Parser
1894	$oldWhite = $this->eatWhiteDefault;
1895	$this->eatWhiteDefault = true;
1896
1897	- $s = $this->~~seek()~~;
1898
1899	- if ($this->literal('#{') && $this->valueList($value) && $this->~~literal~~('}', false)) {
1900	- if ($~~lookWhite~~) {
1901	- $~~left~~ = ~~preg_match('/\s/',~~ $~~this->buffer[$s - 1]) ? ' ' : ''~~;
1902	- $right = preg_match('/\s/', $this->buffer[$this->count]) ? ' ': '';
1903	} else {
1904	- ~~$left~~ = $~~right~~ ~~= false;~~







1905	}
1906
1907	- $out = [Type::T_INTERPOLATE, $value, $left, $right];
1908	$this->eatWhiteDefault = $oldWhite;
1909
1910	if ($this->eatWhiteDefault) {
	@@ -1915,6 +2433,7 @@ class Parser
1915	}
1916
1917	$this->seek($s);

1918	$this->eatWhiteDefault = $oldWhite;
1919
1920	return false;
	@@ -1945,7 +2464,7 @@ class Parser
1945	continue;
1946	}
1947
1948	- if (~~count(~~$parts) ~~=== 0~~ && $this->match('[:.#]', $m, false)) {
1949	// css hacks
1950	$parts[] = $m[0];
1951	continue;
	@@ -1956,7 +2475,7 @@ class Parser
1956
1957	$this->eatWhiteDefault = $oldWhite;
1958
1959	- if (~~count(~~$parts) ~~=== 0)~~ {
1960	return false;
1961	}
1962
	@@ -1984,28 +2503,29 @@ class Parser
1984	/**
1985	* Parse comma separated selector list
1986	*
1987	- * @param array $out

1988	*
1989	* @return boolean
1990	*/
1991	- protected function selectors(&$out)
1992	{
1993	- $s = $this->~~seek()~~;
1994	$selectors = [];
1995
1996	- while ($this->selector($sel)) {
1997	$selectors[] = $sel;
1998
1999	- if (! $this->~~literal~~(',')) {
2000	break;
2001	}
2002
2003	- while ($this->~~literal~~(',')) {
2004	; // ignore extra
2005	}
2006	}
2007
2008	- if (~~count(~~$selectors) ~~=== 0)~~ {
2009	$this->seek($s);
2010
2011	return false;
	@@ -2019,27 +2539,36 @@ class Parser
2019	/**
2020	* Parse whitespace separated selector list
2021	*
2022	- * @param array $out

2023	*
2024	* @return boolean
2025	*/
2026	- protected function selector(&$out)
2027	{
2028	$selector = [];
2029
2030	for (;;) {
2031	- if ($this->~~match('[>+~]+', $m)) {~~
2032	- ~~$selector[] = [$m[0]];~~
2033	- ~~continue;~~








2034	}
2035
2036	- if ($this->selectorSingle($part)) {
2037	$selector[] = $part;
2038	$this->match('\s+', $m);
2039	continue;
2040	}
2041
2042	- if ($this->match('\/[^\/]+\/', $m)) {
2043	$selector[] = [$m[0]];
2044	continue;
2045	}
	@@ -2047,11 +2576,12 @@ class Parser
2047	break;
2048	}
2049
2050	- if (~~count(~~$selector) ~~=== 0)~~ {
2051	return false;
2052	}
2053
2054	$out = $selector;

2055	return true;
2056	}
2057
	@@ -2062,112 +2592,176 @@ class Parser
2062	* div[yes=no]#something.hello.world:nth-child(-2n+1)%placeholder
2063	* }}
2064	*
2065	- * @param array $out

2066	*
2067	* @return boolean
2068	*/
2069	- protected function selectorSingle(&$out)
2070	{
2071	$oldWhite = $this->eatWhiteDefault;
2072	$this->eatWhiteDefault = false;
2073
2074	$parts = [];
2075
2076	- if ($this->~~literal~~('*', false)) {
2077	$parts[] = '*';
2078	}
2079
2080	for (;;) {
2081	- ~~// see~~ if we ~~can~~ ~~stop early~~
2082	- if ($this->match('\s*[{,]', $m)) {
2083	- $this->count--;
2084	break;
2085	}
2086
2087	- $s = $this->~~seek()~~;

2088
2089	- // ~~self~~
2090	- if ($~~this->literal(~~'&', ~~false~~)) {
2091	- ~~$parts[] = Compiler::$selfSelector~~;
2092	- continue;
2093	}
2094
2095	- if (~~$this->literal('.',~~ ~~false~~)~~) {~~
2096	- $~~parts[]~~ = '.';
2097	- ~~continue~~;
2098	}
2099
2100	- ~~if ($this->literal('\|', false)) {~~
2101	- $~~parts[]~~ ~~= '\|';~~
2102	- ~~continue;~~













2103	}
2104
2105	- if ($this->match('\\\\\S', $m)) {
2106	$parts[] = $m[0];
2107	continue;
2108	}
2109
2110	- // ~~for~~ ~~keyframes~~
2111	- ~~if (~~$this->~~unit($unit)) {~~
2112	- $parts[] = $unit;
2113	- continue;
2114	- }
2115
2116	- if ($this->~~keyword~~($~~name~~)) {
2117	- $parts[] = ~~$name~~;
2118	- ~~continue~~;
2119	- }

2120
2121	- ~~if ($this->interpolation($inter)) {~~
2122	- $parts[] = $inter;
2123	- continue;
2124	}
2125
2126	- if ($~~this->literal(~~'%'~~, false~~) ~~&& $this->placeholder($placeholder))~~ {
2127	- $~~parts[]~~ ~~= '%';~~
2128	- $parts[] = $~~placeholder~~;
2129	- continue;
2130	- }
2131
2132	- if ($this->literal('#', false)) {
2133	$parts[] = '#';

2134	continue;
2135	}
2136
2137	// a pseudo selector
2138	- if ($~~this->match(~~'~~::?~~'~~, $m~~) ~~&& $this->mixedKeyword($nameParts))~~ {
2139	- $~~parts~~[] = ~~$m[0];~~
2140	-
2141	- ~~foreach (~~$~~nameParts~~ as ~~$sub) {~~
2142	- ~~$parts[]~~ = ~~$sub;~~


2143	}
2144
2145	- ~~$ss~~ = $this->~~seek~~();

2146
2147	- if ($~~this->literal('('~~) &&
2148	- ($~~this->openString(')',~~ $~~str, '(') \|\| true) &&~~
2149	- ~~$this->literal(')')~~
2150	- ) {
2151	- $parts[] = '(';
2152
2153	- if (! ~~empty(~~$~~str)) {~~
2154	- ~~$parts[] = $str;~~















































2155	}
2156
2157	- ~~$parts[] = ')'~~;
2158	- } else {
2159	- $this->seek($ss);
2160	}

2161
2162	- ~~continue~~;








2163	}
2164
2165	$this->seek($s);
2166
2167	// attribute selector
2168	- if ($~~this->literal(~~'[') &&
2169	- ($this->~~openString~~('~~]', $str, '~~[') ~~\|\| true)~~ &&
2170	- $this->~~literal~~(']')

2171	) {
2172	$parts[] = '[';
2173
	@@ -2176,18 +2770,28 @@ class Parser
2176	}
2177
2178	$parts[] = ']';
2179	-
2180	continue;
2181	}
2182
2183	$this->seek($s);
2184











2185	break;
2186	}
2187
2188	$this->eatWhiteDefault = $oldWhite;
2189
2190	- if (~~count(~~$parts) ~~=== 0)~~ {
2191	return false;
2192	}
2193
	@@ -2205,9 +2809,9 @@ class Parser
2205	*/
2206	protected function variable(&$out)
2207	{
2208	- $s = $this->~~seek()~~;
2209
2210	- if ($this->~~literal~~('$', false) && $this->keyword($name)) {
2211	$out = [Type::T_VARIABLE, $name];
2212
2213	return true;
	@@ -2230,7 +2834,7 @@ class Parser
2230	{
2231	if ($this->match(
2232	$this->utf8
2233	- ? '(([\pL\w_\-\!"\']\|[\\\\].)([\pL\w\-_"\']\|[\\\\].))'
2234	: '(([\w_\-\!"\']\|[\\\\].)([\w\-_"\']\|[\\\\].))',
2235	$m,
2236	$eatWhitespace
	@@ -2243,10 +2847,31 @@ class Parser
2243	return false;
2244	}
2245





















2246	/**
2247	* Parse a placeholder
2248	*
2249	- * @param string $placeholder
2250	*
2251	* @return boolean
2252	*/
	@@ -2254,8 +2879,8 @@ class Parser
2254	{
2255	if ($this->match(
2256	$this->utf8
2257	- ? '([\pL\w\-_]~~+\|#[{][$][\pL\w\-_]~~+~~[}]~~)'
2258	- : '([\w\-_]~~+\|#[{][$][\w\-_]~~+~~[}]~~)',
2259	$m
2260	)) {
2261	$placeholder = $m[1];
	@@ -2263,6 +2888,10 @@ class Parser
2263	return true;
2264	}
2265




2266	return false;
2267	}
2268
	@@ -2291,7 +2920,7 @@ class Parser
2291	*/
2292	protected function end()
2293	{
2294	- if ($this->~~literal~~(';')) {
2295	return true;
2296	}
2297
	@@ -2320,12 +2949,9 @@ class Parser
2320	while ($lastNode[0] === Type::T_KEYWORD && in_array($lastNode[1], ['!default', '!global'])) {
2321	array_pop($token[2]);
2322
2323	- $node = end($token[2]);
2324	-
2325	- $~~token~~ = $~~this->flattenList($token)~~;
2326	-
2327	- $flags[] = $lastNode[1];
2328	-
2329	$lastNode = $node;
2330	}
2331	}
	@@ -2343,9 +2969,8 @@ class Parser
2343	protected function stripOptionalFlag(&$selectors)
2344	{
2345	$optional = false;
2346	-
2347	$selector = end($selectors);
2348	- $part = end($selector);
2349
2350	if ($part === ['!optional']) {
2351	array_pop($selectors[count($selectors) - 1]);
	@@ -2389,6 +3014,8 @@ class Parser
2389	$validChars = $allowNewline ? '.' : "[^\n]";
2390	}
2391


2392	if (! $this->match('(' . $validChars . '*?)' . $this->pregQuote($what), $m, ! $until)) {
2393	return false;
2394	}
	@@ -2453,7 +3080,7 @@ class Parser
2453	*
2454	* @param integer $pos
2455	*
2456	- * @return ~~integer~~
2457	*/
2458	private function getSourcePosition($pos)
2459	{
	@@ -2488,9 +3115,10 @@ class Parser
2488	return;
2489	}
2490
2491	- ~~$iniDirective = 'mbstring' . '.func_overload';~~ // deprecated in PHP 7.2

2492
2493	- if (ini_get($iniDirective) & 2) {
2494	$this->encoding = mb_internal_encoding();
2495
2496	mb_internal_encoding('iso-8859-1');
	@@ -2502,7 +3130,7 @@ class Parser
2502	*/
2503	private function restoreEncoding()
2504	{
2505	- if ($this->encoding) {
2506	mb_internal_encoding($this->encoding);
2507	}
2508	}


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp;
13
14	+ use ScssPhp\ScssPhp\Block;
15	+ use ScssPhp\ScssPhp\Cache;
16	+ use ScssPhp\ScssPhp\Compiler;
17	+ use ScssPhp\ScssPhp\Exception\ParserException;
18	+ use ScssPhp\ScssPhp\Node;
19	+ use ScssPhp\ScssPhp\Type;
20
21	/**
22	* Parser

54	protected static $operatorPattern;
55	protected static $whitePattern;
56
57	+ protected $cache;
58	+
59	private $sourceName;
60	private $sourceIndex;
61	private $sourcePositions;

64	private $env;
65	private $inParens;
66	private $eatWhiteDefault;
67	+ private $discardComments;
68	private $buffer;
69	private $utf8;
70	private $encoding;
71	private $patternModifiers;
72	+ private $commentsSeen;
73
74	/**
75	* Constructor
76	*
77	* @api
78	*
79	+ * @param string $sourceName
80	+ * @param integer $sourceIndex
81	+ * @param string $encoding
82	+ * @param \ScssPhp\ScssPhp\Cache $cache
83	*/
84	+ public function __construct($sourceName, $sourceIndex = 0, $encoding = 'utf-8', $cache = null)
85	{
86	$this->sourceName = $sourceName ?: '(stdin)';
87	$this->sourceIndex = $sourceIndex;
88	$this->charset = null;
89	$this->utf8 = ! $encoding \|\| strtolower($encoding) === 'utf-8';
90	$this->patternModifiers = $this->utf8 ? 'Aisu' : 'Ais';
91	+ $this->commentsSeen = [];
92	+ $this->discardComments = false;
93
94	if (empty(static::$operatorPattern)) {
95	static::$operatorPattern = '([*\/%+-]\|[!=]\=\|\>\=?\|\<\=\>\|\<\=?\|and\|or)';

103	? '/' . $commentSingle . '[^\n]\s\|(' . static::$commentPattern . ')\s*\|\s+/AisuS'
104	: '/' . $commentSingle . '[^\n]\s\|(' . static::$commentPattern . ')\s*\|\s+/AisS';
105	}
106	+
107	+ if ($cache) {
108	+ $this->cache = $cache;
109	+ }
110	}
111
112	/**

128	*
129	* @param string $msg
130	*
131	+ * @throws \ScssPhp\ScssPhp\Exception\ParserException
132	*/
133	public function throwParseError($msg = 'parse error')
134	{
135	+ list($line, $column) = $this->getSourcePosition($this->count);
136
137	+ $loc = empty($this->sourceName)
138	+ ? "line: $line, column: $column"
139	+ : "$this->sourceName on line $line, at column $column";
140
141	if ($this->peek("(.*?)(\n\|$)", $m, $this->count)) {
142	throw new ParserException("$msg: failed at `$m[1]` $loc");

152	*
153	* @param string $buffer
154	*
155	+ * @return \ScssPhp\ScssPhp\Block
156	*/
157	public function parse($buffer)
158	{
159	+ if ($this->cache) {
160	+ $cacheKey = $this->sourceName . ":" . md5($buffer);
161	+ $parseOptions = [
162	+ 'charset' => $this->charset,
163	+ 'utf8' => $this->utf8,
164	+ ];
165	+ $v = $this->cache->getCache("parse", $cacheKey, $parseOptions);
166	+
167	+ if (! is_null($v)) {
168	+ return $v;
169	+ }
170	+ }
171	+
172	// strip BOM (byte order marker)
173	if (substr($buffer, 0, 3) === "\xef\xbb\xbf") {
174	$buffer = substr($buffer, 3);

204	array_unshift($this->env->children, $this->charset);
205	}
206


207	$this->restoreEncoding();
208
209	+ if ($this->cache) {
210	+ $this->cache->setCache("parse", $cacheKey, $this->env, $parseOptions);
211	+ }
212	+
213	return $this->env;
214	}
215

218	*
219	* @api
220	*
221	+ * @param string $buffer
222	+ * @param string\|array $out
223	*
224	* @return boolean
225	*/

245	*
246	* @api
247	*
248	+ * @param string $buffer
249	+ * @param string\|array $out
250	*
251	* @return boolean
252	*/

267	return $selector;
268	}
269
270	+ /**
271	+ * Parse a media Query
272	+ *
273	+ * @api
274	+ *
275	+ * @param string $buffer
276	+ * @param string\|array $out
277	+ *
278	+ * @return boolean
279	+ */
280	+ public function parseMediaQueryList($buffer, &$out)
281	+ {
282	+ $this->count = 0;
283	+ $this->env = null;
284	+ $this->inParens = false;
285	+ $this->eatWhiteDefault = true;
286	+ $this->buffer = (string) $buffer;
287	+
288	+ $this->saveEncoding();
289	+
290	+ $isMediaQuery = $this->mediaQueryList($out);
291	+
292	+ $this->restoreEncoding();
293	+
294	+ return $isMediaQuery;
295	+ }
296	+
297	/**
298	* Parse a single chunk off the head of the buffer and append it to the
299	* current parse environment.

327	* the buffer position will be left at an invalid state. In order to
328	* avoid this, Compiler::seek() is used to remember and set buffer positions.
329	*
330	+ * Before parsing a chain, use $s = $this->count to remember the current
331	* position into $s. Then if a chain fails, use $this->seek($s) to
332	* go back where we started.
333	*

335	*/
336	protected function parseChunk()
337	{
338	+ $s = $this->count;
339
340	// the directives
341	if (isset($this->buffer[$this->count]) && $this->buffer[$this->count] === '@') {
342	+ if ($this->literal('@at-root', 8) &&
343	($this->selectors($selector) \|\| true) &&
344	($this->map($with) \|\| true) &&
345	+ (($this->matchChar('(')
346	+ && $this->interpolation($with)
347	+ && $this->matchChar(')')) \|\| true) &&
348	+ $this->matchChar('{', false)
349	) {
350	$atRoot = $this->pushSpecialBlock(Type::T_AT_ROOT, $s);
351	$atRoot->selector = $selector;
352	+ $atRoot->with = $with;
353
354	return true;
355	}
356
357	$this->seek($s);
358
359	+ if ($this->literal('@media', 6) && $this->mediaQueryList($mediaQueryList) && $this->matchChar('{', false)) {
360	$media = $this->pushSpecialBlock(Type::T_MEDIA, $s);
361	$media->queryList = $mediaQueryList[2];
362

365
366	$this->seek($s);
367
368	+ if ($this->literal('@mixin', 6) &&
369	$this->keyword($mixinName) &&
370	($this->argumentDef($args) \|\| true) &&
371	+ $this->matchChar('{', false)
372	) {
373	$mixin = $this->pushSpecialBlock(Type::T_MIXIN, $s);
374	$mixin->name = $mixinName;

379
380	$this->seek($s);
381
382	+ if ($this->literal('@include', 8) &&
383	$this->keyword($mixinName) &&
384	+ ($this->matchChar('(') &&
385	($this->argValues($argValues) \|\| true) &&
386	+ $this->matchChar(')') \|\| true) &&
387	($this->end() \|\|
388	+ ($this->literal('using', 5) &&
389	+ $this->argumentDef($argUsing) &&
390	+ ($this->end() \|\| $this->matchChar('{') && $hasBlock = true)) \|\|
391	+ $this->matchChar('{') && $hasBlock = true)
392	) {
393	+ $child = [
394	+ Type::T_INCLUDE,
395	+ $mixinName,
396	+ isset($argValues) ? $argValues : null,
397	+ null,
398	+ isset($argUsing) ? $argUsing : null
399	+ ];
400
401	if (! empty($hasBlock)) {
402	$include = $this->pushSpecialBlock(Type::T_INCLUDE, $s);

410
411	$this->seek($s);
412
413	+ if ($this->literal('@scssphp-import-once', 20) &&
414	$this->valueList($importPath) &&
415	$this->end()
416	) {

421
422	$this->seek($s);
423
424	+ if ($this->literal('@import', 7) &&
425	$this->valueList($importPath) &&
426	$this->end()
427	) {

432
433	$this->seek($s);
434
435	+ if ($this->literal('@import', 7) &&
436	$this->url($importPath) &&
437	$this->end()
438	) {

443
444	$this->seek($s);
445
446	+ if ($this->literal('@extend', 7) &&
447	$this->selectors($selectors) &&
448	$this->end()
449	) {

456
457	$this->seek($s);
458
459	+ if ($this->literal('@function', 9) &&
460	$this->keyword($fnName) &&
461	$this->argumentDef($args) &&
462	+ $this->matchChar('{', false)
463	) {
464	$func = $this->pushSpecialBlock(Type::T_FUNCTION, $s);
465	$func->name = $fnName;

470
471	$this->seek($s);
472
473	+ if ($this->literal('@break', 6) && $this->end()) {
474	$this->append([Type::T_BREAK], $s);
475
476	return true;

478
479	$this->seek($s);
480
481	+ if ($this->literal('@continue', 9) && $this->end()) {
482	$this->append([Type::T_CONTINUE], $s);
483
484	return true;

486
487	$this->seek($s);
488
489	+ if ($this->literal('@return', 7) && ($this->valueList($retVal) \|\| true) && $this->end()) {

490	$this->append([Type::T_RETURN, isset($retVal) ? $retVal : [Type::T_NULL]], $s);
491
492	return true;

494
495	$this->seek($s);
496
497	+ if ($this->literal('@each', 5) &&
498	$this->genericList($varNames, 'variable', ',', false) &&
499	+ $this->literal('in', 2) &&
500	$this->valueList($list) &&
501	+ $this->matchChar('{', false)
502	) {
503	$each = $this->pushSpecialBlock(Type::T_EACH, $s);
504

513
514	$this->seek($s);
515
516	+ if ($this->literal('@while', 6) &&
517	$this->expression($cond) &&
518	+ $this->matchChar('{', false)
519	) {
520	$while = $this->pushSpecialBlock(Type::T_WHILE, $s);
521	$while->cond = $cond;

525
526	$this->seek($s);
527
528	+ if ($this->literal('@for', 4) &&
529	$this->variable($varName) &&
530	+ $this->literal('from', 4) &&
531	$this->expression($start) &&
532	+ ($this->literal('through', 7) \|\|
533	+ ($forUntil = true && $this->literal('to', 2))) &&
534	$this->expression($end) &&
535	+ $this->matchChar('{', false)
536	) {
537	$for = $this->pushSpecialBlock(Type::T_FOR, $s);
538	+ $for->var = $varName[1];
539	$for->start = $start;
540	+ $for->end = $end;
541	$for->until = isset($forUntil);
542
543	return true;

545
546	$this->seek($s);
547
548	+ if ($this->literal('@if', 3) && $this->valueList($cond) && $this->matchChar('{', false)) {
549	$if = $this->pushSpecialBlock(Type::T_IF, $s);
550	+ while ($cond[0] === Type::T_LIST
551	+ && !empty($cond['enclosing'])
552	+ && $cond['enclosing'] === 'parent'
553	+ && count($cond[2]) == 1) {
554	+ $cond = reset($cond[2]);
555	+ }
556	+ $if->cond = $cond;
557	$if->cases = [];
558
559	return true;

561
562	$this->seek($s);
563
564	+ if ($this->literal('@debug', 6) &&
565	$this->valueList($value) &&
566	$this->end()
567	) {

572
573	$this->seek($s);
574
575	+ if ($this->literal('@warn', 5) &&
576	$this->valueList($value) &&
577	$this->end()
578	) {

583
584	$this->seek($s);
585
586	+ if ($this->literal('@error', 6) &&
587	$this->valueList($value) &&
588	$this->end()
589	) {

594
595	$this->seek($s);
596
597	+ #if ($this->literal('@content', 8))
598	+
599	+ if ($this->literal('@content', 8) &&
600	+ ($this->end() \|\|
601	+ $this->matchChar('(') &&
602	+ $this->argValues($argContent) &&
603	+ $this->matchChar(')') &&
604	+ $this->end())) {
605	+ $this->append([Type::T_MIXIN_CONTENT, isset($argContent) ? $argContent : null], $s);
606
607	return true;
608	}

614	if (isset($last) && $last[0] === Type::T_IF) {
615	list(, $if) = $last;
616
617	+ if ($this->literal('@else', 5)) {
618	+ if ($this->matchChar('{', false)) {
619	$else = $this->pushSpecialBlock(Type::T_ELSE, $s);
620	+ } elseif ($this->literal('if', 2) && $this->valueList($cond) && $this->matchChar('{', false)) {
621	$else = $this->pushSpecialBlock(Type::T_ELSEIF, $s);
622	$else->cond = $cond;
623	}

634	}
635
636	// only retain the first @charset directive encountered
637	+ if ($this->literal('@charset', 8) &&
638	$this->valueList($charset) &&
639	$this->end()
640	) {

655
656	$this->seek($s);
657
658	+ if ($this->literal('@supports', 9) &&
659	+ ($t1=$this->supportsQuery($supportQuery)) &&
660	+ ($t2=$this->matchChar('{', false))
661	+ ) {
662	+ $directive = $this->pushSpecialBlock(Type::T_DIRECTIVE, $s);
663	+ $directive->name = 'supports';
664	+ $directive->value = $supportQuery;
665	+
666	+ return true;
667	+ }
668	+
669	+ $this->seek($s);
670	+
671	// doesn't match built in directive, do generic one
672	+ if ($this->matchChar('@', false) &&
673	$this->keyword($dirName) &&
674	($this->variable($dirValue) \|\| $this->openString('{', $dirValue) \|\| true) &&
675	+ $this->matchChar('{', false)
676	) {
677	if ($dirName === 'media') {
678	$directive = $this->pushSpecialBlock(Type::T_MEDIA, $s);

690
691	$this->seek($s);
692
693	+ // maybe it's a generic blockless directive
694	+ if ($this->matchChar('@', false) &&
695	+ $this->keyword($dirName) &&
696	+ $this->valueList($dirValue) &&
697	+ $this->end()
698	+ ) {
699	+ $this->append([Type::T_DIRECTIVE, [$dirName, $dirValue]], $s);
700	+
701	+ return true;
702	+ }
703	+
704	+ $this->seek($s);
705	+
706	return false;
707	}
708
709	// property shortcut
710	// captures most properties before having to parse a selector
711	if ($this->keyword($name, false) &&
712	+ $this->literal(': ', 2) &&
713	$this->valueList($value) &&
714	$this->end()
715	) {

723
724	// variable assigns
725	if ($this->variable($name) &&
726	+ $this->matchChar(':') &&
727	$this->valueList($value) &&
728	$this->end()
729	) {

737	$this->seek($s);
738
739	// misc
740	+ if ($this->literal('-->', 3)) {
741	return true;
742	}
743
744	// opening css block
745	+ if ($this->selectors($selectors) && $this->matchChar('{', false)) {
746	$this->pushBlock($selectors, $s);
747
748	+ if ($this->eatWhiteDefault) {
749	+ $this->whitespace();
750	+ $this->append(null); // collect comments at the beginning if needed
751	+ }
752	+
753	return true;
754	}
755
756	$this->seek($s);
757
758	// property assign, or nested assign
759	+ if ($this->propertyName($name) && $this->matchChar(':')) {
760	$foundSomething = false;
761
762	if ($this->valueList($value)) {
763	+ if (empty($this->env->parent)) {
764	+ $this->throwParseError('expected "{"');
765	+ }
766	+
767	$this->append([Type::T_ASSIGN, $name, $value], $s);
768	$foundSomething = true;
769	}
770
771	+ if ($this->matchChar('{', false)) {
772	$propBlock = $this->pushSpecialBlock(Type::T_NESTED_PROPERTY, $s);
773	$propBlock->prefix = $name;
774	+ $propBlock->hasValue = $foundSomething;
775	+
776	$foundSomething = true;
777	} elseif ($foundSomething) {
778	$foundSomething = $this->end();

786	$this->seek($s);
787
788	// closing a block
789	+ if ($this->matchChar('}', false)) {
790	$block = $this->popBlock();
791
792	+ if (! isset($block->type) \|\| $block->type !== Type::T_IF) {
793	+ if ($this->env->parent) {
794	+ $this->append(null); // collect comments before next statement if needed
795	+ }
796	+ }
797	+
798	if (isset($block->type) && $block->type === Type::T_INCLUDE) {
799	$include = $block->child;
800	unset($block->child);

805	$this->append([$type, $block], $s);
806	}
807
808	+ // collect comments just after the block closing if needed
809	+ if ($this->eatWhiteDefault) {
810	+ $this->whitespace();
811	+
812	+ if ($this->env->comments) {
813	+ $this->append(null);
814	+ }
815	+ }
816	+
817	return true;
818	}
819
820	// extra stuff
821	+ if ($this->matchChar(';') \|\|
822	+ $this->literal('<!--', 4)
823	) {
824	return true;
825	}

833	* @param array $selectors
834	* @param integer $pos
835	*
836	+ * @return \ScssPhp\ScssPhp\Block
837	*/
838	protected function pushBlock($selectors, $pos = 0)
839	{

861
862	$this->env = $b;
863
864	+ // collect comments at the beginning of a block if needed
865	+ if ($this->eatWhiteDefault) {
866	+ $this->whitespace();
867	+
868	+ if ($this->env->comments) {
869	+ $this->append(null);
870	+ }
871	+ }
872	+
873	return $b;
874	}
875

879	* @param string $type
880	* @param integer $pos
881	*
882	+ * @return \ScssPhp\ScssPhp\Block
883	*/
884	protected function pushSpecialBlock($type, $pos)
885	{

892	/**
893	* Pop scope and return last block
894	*
895	+ * @return \ScssPhp\ScssPhp\Block
896	*
897	* @throws \Exception
898	*/
899	protected function popBlock()
900	{
901	+
902	+ // collect comments ending just before of a block closing
903	+ if ($this->env->comments) {
904	+ $this->append(null);
905	+ }
906	+
907	+ // pop the block
908	$block = $this->env;
909
910	if (empty($block->parent)) {
911	$this->throwParseError('unexpected }');
912	}
913
914	+ if ($block->type == Type::T_AT_ROOT) {
915	+ // keeps the parent in case of self selector &
916	+ $block->selfParent = $block->parent;
917	+ }
918	+
919	$this->env = $block->parent;

920
921	+ unset($block->parent);




922
923	return $block;
924	}

948	* Seek to position in input stream (or return current position in input stream)
949	*
950	* @param integer $where


951	*/
952	+ protected function seek($where)
953	{




954	$this->count = $where;


955	}
956
957	/**

1006	*/
1007	protected function match($regex, &$out, $eatWhitespace = null)
1008	{
1009	+ $r = '/' . $regex . '/' . $this->patternModifiers;
1010	+
1011	+ if (! preg_match($r, $this->buffer, $out, null, $this->count)) {
1012	+ return false;
1013	+ }
1014	+
1015	+ $this->count += strlen($out[0]);
1016	+
1017	if (! isset($eatWhitespace)) {
1018	$eatWhitespace = $this->eatWhiteDefault;
1019	}
1020
1021	+ if ($eatWhitespace) {
1022	+ $this->whitespace();
1023	+ }
1024
1025	+ return true;
1026	+ }
1027
1028	+ /**
1029	+ * Match a single string
1030	+ *
1031	+ * @param string $char
1032	+ * @param boolean $eatWhitespace
1033	+ *
1034	+ * @return boolean
1035	+ */
1036	+ protected function matchChar($char, $eatWhitespace = null)
1037	+ {
1038	+ if (! isset($this->buffer[$this->count]) \|\| $this->buffer[$this->count] !== $char) {
1039	+ return false;
1040	+ }
1041
1042	+ $this->count++;
1043	+
1044	+ if (! isset($eatWhitespace)) {
1045	+ $eatWhitespace = $this->eatWhiteDefault;
1046	}
1047
1048	+ if ($eatWhitespace) {
1049	+ $this->whitespace();
1050	+ }
1051	+
1052	+ return true;
1053	}
1054
1055	/**
1056	* Match literal string
1057	*
1058	* @param string $what
1059	+ * @param integer $len
1060	* @param boolean $eatWhitespace
1061	*
1062	* @return boolean
1063	*/
1064	+ protected function literal($what, $len, $eatWhitespace = null)
1065	{
1066	+ if (strcasecmp(substr($this->buffer, $this->count, $len), $what) !== 0) {
1067	+ return false;
1068	}
1069
1070	+ $this->count += $len;
1071
1072	+ if (! isset($eatWhitespace)) {
1073	+ $eatWhitespace = $this->eatWhiteDefault;
1074	+ }



1075
1076	+ if ($eatWhitespace) {
1077	+ $this->whitespace();
1078	}
1079
1080	+ return true;
1081	}
1082
1083	/**

1091
1092	while (preg_match(static::$whitePattern, $this->buffer, $m, null, $this->count)) {
1093	if (isset($m[1]) && empty($this->commentsSeen[$this->count])) {
1094	+ // comment that are kept in the output CSS
1095	+ $comment = [];
1096	+ $startCommentCount = $this->count;
1097	+ $endCommentCount = $this->count + strlen($m[1]);
1098	+
1099	+ // find interpolations in comment
1100	+ $p = strpos($this->buffer, '#{', $this->count);
1101	+
1102	+ while ($p !== false && $p < $endCommentCount) {
1103	+ $c = substr($this->buffer, $this->count, $p - $this->count);
1104	+ $comment[] = $c;
1105	+ $this->count = $p;
1106	+ $out = null;
1107	+
1108	+ if ($this->interpolation($out)) {
1109	+ // keep right spaces in the following string part
1110	+ if ($out[3]) {
1111	+ while ($this->buffer[$this->count-1] !== '}') {
1112	+ $this->count--;
1113	+ }
1114	+
1115	+ $out[3] = '';
1116	+ }
1117	+
1118	+ $comment[] = [Type::T_COMMENT, substr($this->buffer, $p, $this->count - $p), $out];
1119	+ } else {
1120	+ $comment[] = substr($this->buffer, $this->count, 2);
1121	+
1122	+ $this->count += 2;
1123	+ }
1124	+
1125	+ $p = strpos($this->buffer, '#{', $this->count);
1126	+ }
1127
1128	+ // remaining part
1129	+ $c = substr($this->buffer, $this->count, $endCommentCount - $this->count);
1130	+
1131	+ if (! $comment) {
1132	+ // single part static comment
1133	+ $this->appendComment([Type::T_COMMENT, $c]);
1134	+ } else {
1135	+ $comment[] = $c;
1136	+ $staticComment = substr($this->buffer, $startCommentCount, $endCommentCount - $startCommentCount);
1137	+ $this->appendComment([Type::T_COMMENT, $staticComment, [Type::T_STRING, '', $comment]]);
1138	+ }
1139	+
1140	+ $this->commentsSeen[$startCommentCount] = true;
1141	+ $this->count = $endCommentCount;
1142	+ } else {
1143	+ // comment that are ignored and not kept in the output css
1144	+ $this->count += strlen($m[0]);
1145	}
1146

1147	$gotWhite = true;
1148	}
1149

1157	*/
1158	protected function appendComment($comment)
1159	{
1160	+ if (! $this->discardComments) {
1161	+ if ($comment[0] === Type::T_COMMENT) {
1162	+ if (is_string($comment[1])) {
1163	+ $comment[1] = substr(preg_replace(['/^\s+/m', '/^(.)/m'], ['', ' \1'], $comment[1]), 1);
1164	+ }
1165	+ if (isset($comment[2]) and is_array($comment[2]) and $comment[2][0] === Type::T_STRING) {
1166	+ foreach ($comment[2][2] as $k => $v) {
1167	+ if (is_string($v)) {
1168	+ $p = strpos($v, "\n");
1169	+ if ($p !== false) {
1170	+ $comment[2][2][$k] = substr($v, 0, $p + 1)
1171	+ . preg_replace(['/^\s+/m', '/^(.)/m'], ['', ' \1'], substr($v, $p+1));
1172	+ }
1173	+ }
1174	+ }
1175	+ }
1176	+ }
1177
1178	+ $this->env->comments[] = $comment;
1179	+ }
1180	}
1181
1182	/**

1187	*/
1188	protected function append($statement, $pos = null)
1189	{
1190	+ if (! is_null($statement)) {
1191	+ if (! is_null($pos)) {
1192	+ list($line, $column) = $this->getSourcePosition($pos);
1193
1194	+ $statement[static::SOURCE_LINE] = $line;
1195	+ $statement[static::SOURCE_COLUMN] = $column;
1196	+ $statement[static::SOURCE_INDEX] = $this->sourceIndex;
1197	+ }
1198
1199	+ $this->env->children[] = $statement;
1200	+ }
1201
1202	$comments = $this->env->comments;
1203
1204	+ if ($comments) {
1205	$this->env->children = array_merge($this->env->children, $comments);
1206	$this->env->comments = [];
1207	}

1245	$expressions = null;
1246	$parts = [];
1247
1248	+ if (($this->literal('only', 4) && ($only = true) \|\| $this->literal('not', 3) && ($not = true) \|\| true) &&
1249	$this->mixedKeyword($mediaType)
1250	) {
1251	$prop = [Type::T_MEDIA_TYPE];

1272	$parts[] = $prop;
1273	}
1274
1275	+ if (empty($parts) \|\| $this->literal('and', 3)) {
1276	$this->genericList($expressions, 'mediaExpression', 'and', false);
1277
1278	if (is_array($expressions)) {

1285	return true;
1286	}
1287
1288	+ /**
1289	+ * Parse supports query
1290	+ *
1291	+ * @param array $out
1292	+ *
1293	+ * @return boolean
1294	+ */
1295	+ protected function supportsQuery(&$out)
1296	+ {
1297	+ $expressions = null;
1298	+ $parts = [];
1299	+
1300	+ $s = $this->count;
1301	+
1302	+ $not = false;
1303	+
1304	+ if (($this->literal('not', 3) && ($not = true) \|\| true) &&
1305	+ $this->matchChar('(') &&
1306	+ ($this->expression($property)) &&
1307	+ $this->literal(': ', 2) &&
1308	+ $this->valueList($value) &&
1309	+ $this->matchChar(')')
1310	+ ) {
1311	+ $support = [Type::T_STRING, '', [[Type::T_KEYWORD, ($not ? 'not ' : '') . '(']]];
1312	+ $support[2][] = $property;
1313	+ $support[2][] = [Type::T_KEYWORD, ': '];
1314	+ $support[2][] = $value;
1315	+ $support[2][] = [Type::T_KEYWORD, ')'];
1316	+
1317	+ $parts[] = $support;
1318	+ $s = $this->count;
1319	+ } else {
1320	+ $this->seek($s);
1321	+ }
1322	+
1323	+ if ($this->matchChar('(') &&
1324	+ $this->supportsQuery($subQuery) &&
1325	+ $this->matchChar(')')
1326	+ ) {
1327	+ $parts[] = [Type::T_STRING, '', [[Type::T_KEYWORD, '('], $subQuery, [Type::T_KEYWORD, ')']]];
1328	+ $s = $this->count;
1329	+ } else {
1330	+ $this->seek($s);
1331	+ }
1332	+
1333	+ if ($this->literal('not', 3) &&
1334	+ $this->supportsQuery($subQuery)
1335	+ ) {
1336	+ $parts[] = [Type::T_STRING, '', [[Type::T_KEYWORD, 'not '], $subQuery]];
1337	+ $s = $this->count;
1338	+ } else {
1339	+ $this->seek($s);
1340	+ }
1341	+
1342	+ if ($this->literal('selector(', 9) &&
1343	+ $this->selector($selector) &&
1344	+ $this->matchChar(')')
1345	+ ) {
1346	+ $support = [Type::T_STRING, '', [[Type::T_KEYWORD, 'selector(']]];
1347	+
1348	+ $selectorList = [Type::T_LIST, '', []];
1349	+
1350	+ foreach ($selector as $sc) {
1351	+ $compound = [Type::T_STRING, '', []];
1352	+
1353	+ foreach ($sc as $scp) {
1354	+ if (is_array($scp)) {
1355	+ $compound[2][] = $scp;
1356	+ } else {
1357	+ $compound[2][] = [Type::T_KEYWORD, $scp];
1358	+ }
1359	+ }
1360	+
1361	+ $selectorList[2][] = $compound;
1362	+ }
1363	+ $support[2][] = $selectorList;
1364	+ $support[2][] = [Type::T_KEYWORD, ')'];
1365	+ $parts[] = $support;
1366	+ $s = $this->count;
1367	+ } else {
1368	+ $this->seek($s);
1369	+ }
1370	+
1371	+ if ($this->variable($var) or $this->interpolation($var)) {
1372	+ $parts[] = $var;
1373	+ $s = $this->count;
1374	+ } else {
1375	+ $this->seek($s);
1376	+ }
1377	+
1378	+ if ($this->literal('and', 3) &&
1379	+ $this->genericList($expressions, 'supportsQuery', ' and', false)) {
1380	+ array_unshift($expressions[2], [Type::T_STRING, '', $parts]);
1381	+
1382	+ $parts = [$expressions];
1383	+ $s = $this->count;
1384	+ } else {
1385	+ $this->seek($s);
1386	+ }
1387	+
1388	+ if ($this->literal('or', 2) &&
1389	+ $this->genericList($expressions, 'supportsQuery', ' or', false)) {
1390	+ array_unshift($expressions[2], [Type::T_STRING, '', $parts]);
1391	+
1392	+ $parts = [$expressions];
1393	+ $s = $this->count;
1394	+ } else {
1395	+ $this->seek($s);
1396	+ }
1397	+
1398	+ if (count($parts)) {
1399	+ if ($this->eatWhiteDefault) {
1400	+ $this->whitespace();
1401	+ }
1402	+
1403	+ $out = [Type::T_STRING, '', $parts];
1404	+
1405	+ return true;
1406	+ }
1407	+
1408	+ return false;
1409	+ }
1410	+
1411	+
1412	/**
1413	* Parse media expression
1414	*

1418	*/
1419	protected function mediaExpression(&$out)
1420	{
1421	+ $s = $this->count;
1422	$value = null;
1423
1424	+ if ($this->matchChar('(') &&
1425	$this->expression($feature) &&
1426	+ ($this->matchChar(':') && $this->expression($value) \|\| true) &&
1427	+ $this->matchChar(')')
1428	) {
1429	$out = [Type::T_MEDIA_EXPRESSION, $feature];
1430

1467	*/
1468	protected function argValue(&$out)
1469	{
1470	+ $s = $this->count;
1471
1472	$keyword = null;
1473
1474	+ if (! $this->variable($keyword) \|\| ! $this->matchChar(':')) {
1475	$this->seek($s);
1476	+
1477	$keyword = null;
1478	}
1479
1480	if ($this->genericList($value, 'expression')) {
1481	$out = [$keyword, $value, false];
1482	+ $s = $this->count;
1483
1484	+ if ($this->literal('...', 3)) {
1485	$out[2] = true;
1486	} else {
1487	$this->seek($s);

1496	/**
1497	* Parse comma separated value list
1498	*
1499	+ * @param array $out
1500	*
1501	* @return boolean
1502	*/
1503	protected function valueList(&$out)
1504	{
1505	+ $discardComments = $this->discardComments;
1506	+ $this->discardComments = true;
1507	+ $res = $this->genericList($out, 'spaceList', ',');
1508	+ $this->discardComments = $discardComments;
1509	+
1510	+ return $res;
1511	}
1512
1513	/**

1534	*/
1535	protected function genericList(&$out, $parseItem, $delim = '', $flatten = true)
1536	{
1537	+ $s = $this->count;
1538	$items = [];
1539	+ $value = null;
1540
1541	while ($this->$parseItem($value)) {
1542	+ $trailing_delim = false;
1543	$items[] = $value;
1544
1545	if ($delim) {
1546	+ if (! $this->literal($delim, strlen($delim))) {
1547	break;
1548	}
1549	+ $trailing_delim = true;
1550	}
1551	}
1552
1553	+ if (! $items) {
1554	$this->seek($s);
1555
1556	return false;
1557	}
1558
1559	+ if ($trailing_delim) {
1560	+ $items[] = [Type::T_NULL];
1561	+ }
1562	if ($flatten && count($items) === 1) {
1563	$out = $items[0];
1564	} else {

1572	* Parse expression
1573	*
1574	* @param array $out
1575	+ * @param bool $listOnly
1576	+ * @param bool $lookForExp
1577	*
1578	* @return boolean
1579	*/
1580	+ protected function expression(&$out, $listOnly = false, $lookForExp = true)
1581	{
1582	+ $s = $this->count;
1583	+ $discard = $this->discardComments;
1584	+ $this->discardComments = true;
1585	+ $allowedTypes = ($listOnly ? [Type::T_LIST] : [Type::T_LIST, Type::T_MAP]);
1586	+
1587	+ if ($this->matchChar('(')) {
1588	+ if ($this->enclosedExpression($lhs, $s, ")", $allowedTypes)) {
1589	+ if ($lookForExp) {
1590	+ $out = $this->expHelper($lhs, 0);
1591	+ } else {
1592	+ $out = $lhs;
1593	+ }
1594
1595	+ $this->discardComments = $discard;


1596
1597	return true;
1598	}
1599
1600	+ $this->seek($s);
1601	+ }
1602	+
1603	+ if (in_array(Type::T_LIST, $allowedTypes) && $this->matchChar('[')) {
1604	+ if ($this->enclosedExpression($lhs, $s, "]", [Type::T_LIST])) {
1605	+ if ($lookForExp) {
1606	+ $out = $this->expHelper($lhs, 0);
1607	+ } else {
1608	+ $out = $lhs;
1609	+ }
1610	+ $this->discardComments = $discard;
1611	+
1612	return true;
1613	}
1614
1615	$this->seek($s);
1616	+ }
1617
1618	+ if (!$listOnly && $this->value($lhs)) {
1619	+ if ($lookForExp) {
1620	+ $out = $this->expHelper($lhs, 0);
1621	+ } else {
1622	+ $out = $lhs;
1623	}
1624
1625	+ $this->discardComments = $discard;
1626	+
1627	+ return true;
1628	}
1629
1630	+ $this->discardComments = $discard;
1631	+ return false;
1632	+ }
1633
1634	+ /**
1635	+ * Parse expression specifically checking for lists in parenthesis or brackets
1636	+ *
1637	+ * @param array $out
1638	+ * @param integer $s
1639	+ * @param string $closingParen
1640	+ * @param array $allowedTypes
1641	+ *
1642	+ * @return boolean
1643	+ */
1644	+ protected function enclosedExpression(&$out, $s, $closingParen = ")", $allowedTypes = [Type::T_LIST, Type::T_MAP])
1645	+ {
1646	+ if ($this->matchChar($closingParen) && in_array(Type::T_LIST, $allowedTypes)) {
1647	+ $out = [Type::T_LIST, '', []];
1648	+ switch ($closingParen) {
1649	+ case ")":
1650	+ $out['enclosing'] = 'parent'; // parenthesis list
1651	+ break;
1652	+ case "]":
1653	+ $out['enclosing'] = 'bracket'; // bracketed list
1654	+ break;
1655	+ }
1656	+ return true;
1657	+ }
1658	+
1659	+ if ($this->valueList($out) && $this->matchChar($closingParen)
1660	+ && in_array($out[0], [Type::T_LIST, Type::T_KEYWORD])
1661	+ && in_array(Type::T_LIST, $allowedTypes)) {
1662	+ if ($out[0] !== Type::T_LIST \|\| ! empty($out['enclosing'])) {
1663	+ $out = [Type::T_LIST, '', [$out]];
1664	+ }
1665	+ switch ($closingParen) {
1666	+ case ")":
1667	+ $out['enclosing'] = 'parent'; // parenthesis list
1668	+ break;
1669	+ case "]":
1670	+ $out['enclosing'] = 'bracket'; // bracketed list
1671	+ break;
1672	+ }
1673	+ return true;
1674	+ }
1675	+
1676	+ $this->seek($s);
1677	+
1678	+ if (in_array(Type::T_MAP, $allowedTypes) && $this->map($out)) {
1679	return true;
1680	}
1681

1694	{
1695	$operators = static::$operatorPattern;
1696
1697	+ $ss = $this->count;
1698	$whiteBefore = isset($this->buffer[$this->count - 1]) &&
1699	ctype_space($this->buffer[$this->count - 1]);
1700

1713	break;
1714	}
1715
1716	+ if (! $this->value($rhs) && ! $this->expression($rhs, true, false)) {
1717	break;
1718	}
1719

1723	}
1724
1725	$lhs = [Type::T_EXPRESSION, $op, $lhs, $rhs, $this->inParens, $whiteBefore, $whiteAfter];
1726	+ $ss = $this->count;
1727	$whiteBefore = isset($this->buffer[$this->count - 1]) &&
1728	ctype_space($this->buffer[$this->count - 1]);
1729	}

1742	*/
1743	protected function value(&$out)
1744	{
1745	+ if (! isset($this->buffer[$this->count])) {
1746	+ return false;
1747	+ }
1748
1749	+ $s = $this->count;
1750	+ $char = $this->buffer[$this->count];
1751	+
1752	+ if ($this->literal('url(', 4) && $this->match('data:([a-z]+)\/([a-z0-9.+-]+);base64,', $m, false)) {
1753	+ $len = strspn(
1754	+ $this->buffer,
1755	+ 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwyxz0123456789+/=',
1756	+ $this->count
1757	+ );
1758
1759	$this->count += $len;
1760
1761	+ if ($this->matchChar(')')) {
1762	$content = substr($this->buffer, $s, $this->count - $s);
1763	$out = [Type::T_KEYWORD, $content];
1764

1768
1769	$this->seek($s);
1770
1771	+ if ($this->literal('url(', 4, false) && $this->match('\s(\/\/[^\s\)]+)\s', $m)) {
1772	+ $content = 'url(' . $m[1];
1773
1774	+ if ($this->matchChar(')')) {
1775	+ $content .= ')';
1776	+ $out = [Type::T_KEYWORD, $content];
1777	+
1778	+ return true;
1779	+ }
1780	}
1781
1782	$this->seek($s);
1783
1784	+ // not
1785	+ if ($char === 'n' && $this->literal('not', 3, false)) {
1786	+ if ($this->whitespace() && $this->value($inner)) {
1787	+ $out = [Type::T_UNARY, 'not', $inner, $this->inParens];
1788	+
1789	+ return true;
1790	+ }
1791	+
1792	+ $this->seek($s);
1793
1794	+ if ($this->parenValue($inner)) {
1795	+ $out = [Type::T_UNARY, 'not', $inner, $this->inParens];
1796	+
1797	+ return true;
1798	+ }
1799	+
1800	+ $this->seek($s);
1801	+ }
1802	+
1803	+ // addition
1804	+ if ($char === '+') {
1805	+ $this->count++;
1806	+
1807	+ if ($this->value($inner)) {
1808	+ $out = [Type::T_UNARY, '+', $inner, $this->inParens];
1809	+
1810	+ return true;
1811	+ }
1812	+
1813	+ $this->count--;
1814	+
1815	+ return false;
1816	+ }
1817	+
1818	+ // negation
1819	+ if ($char === '-') {
1820	+ $this->count++;
1821	+
1822	+ if ($this->variable($inner) \|\| $this->unit($inner) \|\| $this->parenValue($inner)) {
1823	+ $out = [Type::T_UNARY, '-', $inner, $this->inParens];
1824	+
1825	+ return true;
1826	+ }
1827	+
1828	+ $this->count--;
1829	+ }
1830	+
1831	+ // paren
1832	+ if ($char === '(' && $this->parenValue($out)) {
1833	return true;
1834	}
1835
1836	+ if ($char === '#') {
1837	+ if ($this->interpolation($out) \|\| $this->color($out)) {
1838	+ return true;
1839	+ }
1840	+ }
1841
1842	+ if ($this->matchChar('&', true)) {
1843	+ $out = [Type::T_SELF];
1844
1845	return true;
1846	}
1847
1848	+ if ($char === '$' && $this->variable($out)) {
1849	+ return true;
1850	+ }
1851
1852	+ if ($char === 'p' && $this->progid($out)) {
1853	+ return true;
1854	+ }




1855
1856	+ if (($char === '"' \|\| $char === "'") && $this->string($out)) {
1857	return true;
1858	}
1859
1860	+ if ($this->unit($out)) {
1861	+ return true;
1862	+ }
1863	+
1864	+ // unicode range with wildcards
1865	+ if ($this->literal('U+', 2) && $this->match('([0-9A-F]+\?*)(-([0-9A-F]+))?', $m, false)) {
1866	+ $out = [Type::T_KEYWORD, 'U+' . $m[0]];
1867









1868	return true;
1869	}
1870
1871	+ if ($this->keyword($keyword, false)) {
1872	+ if ($this->func($keyword, $out)) {
1873	+ return true;
1874	+ }
1875	+
1876	+ $this->whitespace();
1877	+
1878	if ($keyword === 'null') {
1879	$out = [Type::T_NULL];
1880	} else {

1896	*/
1897	protected function parenValue(&$out)
1898	{
1899	+ $s = $this->count;
1900
1901	$inParens = $this->inParens;
1902
1903	+ if ($this->matchChar('(')) {
1904	+ if ($this->matchChar(')')) {
1905	$out = [Type::T_LIST, '', []];
1906
1907	return true;

1909
1910	$this->inParens = true;
1911
1912	+ if ($this->expression($exp) && $this->matchChar(')')) {
1913	$out = $exp;
1914	$this->inParens = $inParens;
1915

1932	*/
1933	protected function progid(&$out)
1934	{
1935	+ $s = $this->count;
1936
1937	+ if ($this->literal('progid:', 7, false) &&
1938	$this->openString('(', $fn) &&
1939	+ $this->matchChar('(')
1940	) {
1941	$this->openString(')', $args, '(');
1942
1943	+ if ($this->matchChar(')')) {
1944	$out = [Type::T_STRING, '', [
1945	'progid:', $fn, '(', $args, ')'
1946	]];

1957	/**
1958	* Parse function call
1959	*
1960	+ * @param string $name
1961	+ * @param array $func
1962	*
1963	* @return boolean
1964	*/
1965	+ protected function func($name, &$func)
1966	{
1967	+ $s = $this->count;
1968
1969	+ if ($this->matchChar('(')) {


1970	if ($name === 'alpha' && $this->argumentList($args)) {
1971	$func = [Type::T_FUNCTION, $name, [Type::T_STRING, '', $args]];
1972

1974	}
1975
1976	if ($name !== 'expression' && ! preg_match('/^(-[a-z]+-)?calc$/', $name)) {
1977	+ $ss = $this->count;
1978
1979	+ if ($this->argValues($args) && $this->matchChar(')')) {
1980	$func = [Type::T_FUNCTION_CALL, $name, $args];
1981
1982	return true;

1986	}
1987
1988	if (($this->openString(')', $str, '(') \|\| true) &&
1989	+ $this->matchChar(')')
1990	) {
1991	$args = [];
1992

2014	*/
2015	protected function argumentList(&$out)
2016	{
2017	+ $s = $this->count;
2018	+ $this->matchChar('(');
2019
2020	$args = [];
2021
2022	while ($this->keyword($var)) {
2023	+ if ($this->matchChar('=') && $this->expression($exp)) {
2024	$args[] = [Type::T_STRING, '', [$var . '=']];
2025	$arg = $exp;
2026	} else {

2029
2030	$args[] = $arg;
2031
2032	+ if (! $this->matchChar(',')) {
2033	break;
2034	}
2035
2036	$args[] = [Type::T_STRING, '', [', ']];
2037	}
2038
2039	+ if (! $this->matchChar(')') \|\| ! $args) {
2040	$this->seek($s);
2041
2042	return false;

2056	*/
2057	protected function argumentDef(&$out)
2058	{
2059	+ $s = $this->count;
2060	+ $this->matchChar('(');
2061
2062	$args = [];
2063
2064	while ($this->variable($var)) {
2065	$arg = [$var[1], null, false];
2066
2067	+ $ss = $this->count;
2068
2069	+ if ($this->matchChar(':') && $this->genericList($defaultVal, 'expression')) {
2070	$arg[1] = $defaultVal;
2071	} else {
2072	$this->seek($ss);
2073	}
2074
2075	+ $ss = $this->count;
2076
2077	+ if ($this->literal('...', 3)) {
2078	+ $sss = $this->count;
2079
2080	+ if (! $this->matchChar(')')) {
2081	$this->throwParseError('... has to be after the final argument');
2082	}
2083

2089
2090	$args[] = $arg;
2091
2092	+ if (! $this->matchChar(',')) {
2093	break;
2094	}
2095	}
2096
2097	+ if (! $this->matchChar(')')) {
2098	$this->seek($s);
2099
2100	return false;

2114	*/
2115	protected function map(&$out)
2116	{
2117	+ $s = $this->count;
2118
2119	+ if (! $this->matchChar('(')) {
2120	return false;
2121	}
2122
2123	$keys = [];
2124	$values = [];
2125
2126	+ while ($this->genericList($key, 'expression') && $this->matchChar(':') &&
2127	$this->genericList($value, 'expression')
2128	) {
2129	$keys[] = $key;
2130	$values[] = $value;
2131
2132	+ if (! $this->matchChar(',')) {
2133	break;
2134	}
2135	}
2136
2137	+ if (! $keys \|\| ! $this->matchChar(')')) {
2138	$this->seek($s);
2139
2140	return false;

2154	*/
2155	protected function color(&$out)
2156	{
2157	+ $s = $this->count;
2158
2159	+ if ($this->match('(#([0-9a-f]+))', $m)) {
2160	+ if (in_array(strlen($m[2]), [3,4,6,8])) {
2161	+ $out = [Type::T_KEYWORD, $m[0]];
2162	+ return true;












2163	}
2164
2165	+ $this->seek($s);
2166	+ return false;

2167	}
2168
2169	return false;

2172	/**
2173	* Parse number with unit
2174	*
2175	+ * @param array $unit
2176	*
2177	* @return boolean
2178	*/
2179	protected function unit(&$unit)
2180	{
2181	+ $s = $this->count;

2182
2183	+ if ($this->match('([0-9]*(\.)?[0-9]+)([%a-zA-Z]+)?', $m, false)) {
2184	+ if (strlen($this->buffer) === $this->count \|\| ! ctype_digit($this->buffer[$this->count])) {
2185	+ $this->whitespace();
2186	+
2187	+ $unit = new Node\Number($m[1], empty($m[3]) ? '' : $m[3]);
2188	+
2189	+ return true;
2190	+ }
2191	+
2192	+ $this->seek($s);
2193	}
2194
2195	return false;

2204	*/
2205	protected function string(&$out)
2206	{
2207	+ $s = $this->count;
2208
2209	+ if ($this->matchChar('"', false)) {
2210	$delim = '"';
2211	+ } elseif ($this->matchChar("'", false)) {
2212	$delim = "'";
2213	} else {
2214	return false;

2235	$content[] = '#{'; // ignore it
2236	}
2237	} elseif ($m[2] === '\\') {
2238	+ if ($this->matchChar('"', false)) {
2239	$content[] = $m[2] . '"';
2240	+ } elseif ($this->matchChar("'", false)) {
2241	$content[] = $m[2] . "'";
2242	+ } elseif ($this->literal("\\", 1, false)) {
2243	+ $content[] = $m[2] . "\\";
2244	+ } elseif ($this->literal("\r\n", 2, false) \|\|
2245	+ $this->matchChar("\r", false) \|\|
2246	+ $this->matchChar("\n", false) \|\|
2247	+ $this->matchChar("\f", false)
2248	+ ) {
2249	+ // this is a continuation escaping, to be ignored
2250	} else {
2251	$content[] = $m[2];
2252	}

2258
2259	$this->eatWhiteDefault = $oldWhite;
2260
2261	+ if ($this->literal($delim, strlen($delim))) {
2262	if ($hasInterpolation) {
2263	$delim = '"';
2264
2265	foreach ($content as &$string) {
2266	+ if ($string === "\\\\") {
2267	+ $string = "\\";
2268	+ } elseif ($string === "\\'") {
2269	$string = "'";
2270	} elseif ($string === '\\"') {
2271	$string = '"';

2286	/**
2287	* Parse keyword or interpolation
2288	*
2289	+ * @param array $out
2290	+ * @param boolean $restricted
2291	*
2292	* @return boolean
2293	*/
2294	+ protected function mixedKeyword(&$out, $restricted = false)
2295	{
2296	$parts = [];
2297

2299	$this->eatWhiteDefault = false;
2300
2301	for (;;) {
2302	+ if ($restricted ? $this->restrictedKeyword($key) : $this->keyword($key)) {
2303	$parts[] = $key;
2304	continue;
2305	}

2314
2315	$this->eatWhiteDefault = $oldWhite;
2316
2317	+ if (! $parts) {
2318	return false;
2319	}
2320

2380
2381	$this->eatWhiteDefault = $oldWhite;
2382
2383	+ if (! $content) {
2384	return false;
2385	}
2386

2397	/**
2398	* Parser interpolation
2399	*
2400	+ * @param string\|array $out
2401	+ * @param boolean $lookWhite save information about whitespace before and after
2402	*
2403	* @return boolean
2404	*/

2407	$oldWhite = $this->eatWhiteDefault;
2408	$this->eatWhiteDefault = true;
2409
2410	+ $s = $this->count;
2411
2412	+ if ($this->literal('#{', 2) && $this->valueList($value) && $this->matchChar('}', false)) {
2413	+ if ($value === [Type::T_SELF]) {
2414	+ $out = $value;

2415	} else {
2416	+ if ($lookWhite) {
2417	+ $left = ($s > 0 && preg_match('/\s/', $this->buffer[$s - 1])) ? ' ' : '';
2418	+ $right = preg_match('/\s/', $this->buffer[$this->count]) ? ' ': '';
2419	+ } else {
2420	+ $left = $right = false;
2421	+ }
2422	+
2423	+ $out = [Type::T_INTERPOLATE, $value, $left, $right];
2424	}
2425

2426	$this->eatWhiteDefault = $oldWhite;
2427
2428	if ($this->eatWhiteDefault) {

2433	}
2434
2435	$this->seek($s);
2436	+
2437	$this->eatWhiteDefault = $oldWhite;
2438
2439	return false;

2464	continue;
2465	}
2466
2467	+ if (! $parts && $this->match('[:.#]', $m, false)) {
2468	// css hacks
2469	$parts[] = $m[0];
2470	continue;

2475
2476	$this->eatWhiteDefault = $oldWhite;
2477
2478	+ if (! $parts) {
2479	return false;
2480	}
2481

2503	/**
2504	* Parse comma separated selector list
2505	*
2506	+ * @param array $out
2507	+ * @param boolean $subSelector
2508	*
2509	* @return boolean
2510	*/
2511	+ protected function selectors(&$out, $subSelector = false)
2512	{
2513	+ $s = $this->count;
2514	$selectors = [];
2515
2516	+ while ($this->selector($sel, $subSelector)) {
2517	$selectors[] = $sel;
2518
2519	+ if (! $this->matchChar(',', true)) {
2520	break;
2521	}
2522
2523	+ while ($this->matchChar(',', true)) {
2524	; // ignore extra
2525	}
2526	}
2527
2528	+ if (! $selectors) {
2529	$this->seek($s);
2530
2531	return false;

2539	/**
2540	* Parse whitespace separated selector list
2541	*
2542	+ * @param array $out
2543	+ * @param boolean $subSelector
2544	*
2545	* @return boolean
2546	*/
2547	+ protected function selector(&$out, $subSelector = false)
2548	{
2549	$selector = [];
2550
2551	for (;;) {
2552	+ $s = $this->count;
2553	+
2554	+ if ($this->match('[>+~]+', $m, true)) {
2555	+ if ($subSelector && is_string($subSelector) && strpos($subSelector, 'nth-') === 0 &&
2556	+ $m[0] === '+' && $this->match("(\d+\|n\b)", $counter)
2557	+ ) {
2558	+ $this->seek($s);
2559	+ } else {
2560	+ $selector[] = [$m[0]];
2561	+ continue;
2562	+ }
2563	}
2564
2565	+ if ($this->selectorSingle($part, $subSelector)) {
2566	$selector[] = $part;
2567	$this->match('\s+', $m);
2568	continue;
2569	}
2570
2571	+ if ($this->match('\/[^\/]+\/', $m, true)) {
2572	$selector[] = [$m[0]];
2573	continue;
2574	}

2576	break;
2577	}
2578
2579	+ if (! $selector) {
2580	return false;
2581	}
2582
2583	$out = $selector;
2584	+
2585	return true;
2586	}
2587

2592	* div[yes=no]#something.hello.world:nth-child(-2n+1)%placeholder
2593	* }}
2594	*
2595	+ * @param array $out
2596	+ * @param boolean $subSelector
2597	*
2598	* @return boolean
2599	*/
2600	+ protected function selectorSingle(&$out, $subSelector = false)
2601	{
2602	$oldWhite = $this->eatWhiteDefault;
2603	$this->eatWhiteDefault = false;
2604
2605	$parts = [];
2606
2607	+ if ($this->matchChar('*', false)) {
2608	$parts[] = '*';
2609	}
2610
2611	for (;;) {
2612	+ if (! isset($this->buffer[$this->count])) {


2613	break;
2614	}
2615
2616	+ $s = $this->count;
2617	+ $char = $this->buffer[$this->count];
2618
2619	+ // see if we can stop early
2620	+ if ($char === '{' \|\| $char === ',' \|\| $char === ';' \|\| $char === '}' \|\| $char === '@') {
2621	+ break;

2622	}
2623
2624	+ // parsing a sub selector in () stop with the closing )
2625	+ if ($subSelector && $char === ')') {
2626	+ break;
2627	}
2628
2629	+ //self
2630	+ switch ($char) {
2631	+ case '&':
2632	+ $parts[] = Compiler::$selfSelector;
2633	+ $this->count++;
2634	+ continue 2;
2635	+
2636	+ case '.':
2637	+ $parts[] = '.';
2638	+ $this->count++;
2639	+ continue 2;
2640	+
2641	+ case '\|':
2642	+ $parts[] = '\|';
2643	+ $this->count++;
2644	+ continue 2;
2645	}
2646
2647	+ if ($char === '\\' && $this->match('\\\\\S', $m)) {
2648	$parts[] = $m[0];
2649	continue;
2650	}
2651
2652	+ if ($char === '%') {
2653	+ $this->count++;



2654
2655	+ if ($this->placeholder($placeholder)) {
2656	+ $parts[] = '%';
2657	+ $parts[] = $placeholder;
2658	+ continue;
2659	+ }
2660
2661	+ break;


2662	}
2663
2664	+ if ($char === '#') {
2665	+ if ($this->interpolation($inter)) {
2666	+ $parts[] = $inter;
2667	+ continue;
2668	+ }
2669

2670	$parts[] = '#';
2671	+ $this->count++;
2672	continue;
2673	}
2674
2675	// a pseudo selector
2676	+ if ($char === ':') {
2677	+ if ($this->buffer[$this->count + 1] === ':') {
2678	+ $this->count += 2;
2679	+ $part = '::';
2680	+ } else {
2681	+ $this->count++;
2682	+ $part = ':';
2683	}
2684
2685	+ if ($this->mixedKeyword($nameParts, true)) {
2686	+ $parts[] = $part;
2687
2688	+ foreach ($nameParts as $sub) {
2689	+ $parts[] = $sub;
2690	+ }


2691
2692	+ $ss = $this->count;
2693	+
2694	+ if ($nameParts === ['not'] \|\| $nameParts === ['is'] \|\|
2695	+ $nameParts === ['has'] \|\| $nameParts === ['where'] \|\|
2696	+ $nameParts === ['slotted'] \|\|
2697	+ $nameParts === ['nth-child'] \|\| $nameParts == ['nth-last-child'] \|\|
2698	+ $nameParts === ['nth-of-type'] \|\| $nameParts == ['nth-last-of-type']
2699	+ ) {
2700	+ if ($this->matchChar('(', true) &&
2701	+ ($this->selectors($subs, reset($nameParts)) \|\| true) &&
2702	+ $this->matchChar(')')
2703	+ ) {
2704	+ $parts[] = '(';
2705	+
2706	+ while ($sub = array_shift($subs)) {
2707	+ while ($ps = array_shift($sub)) {
2708	+ foreach ($ps as &$p) {
2709	+ $parts[] = $p;
2710	+ }
2711	+
2712	+ if (count($sub) && reset($sub)) {
2713	+ $parts[] = ' ';
2714	+ }
2715	+ }
2716	+
2717	+ if (count($subs) && reset($subs)) {
2718	+ $parts[] = ', ';
2719	+ }
2720	+ }
2721	+
2722	+ $parts[] = ')';
2723	+ } else {
2724	+ $this->seek($ss);
2725	+ }
2726	+ } else {
2727	+ if ($this->matchChar('(') &&
2728	+ ($this->openString(')', $str, '(') \|\| true) &&
2729	+ $this->matchChar(')')
2730	+ ) {
2731	+ $parts[] = '(';
2732	+
2733	+ if (! empty($str)) {
2734	+ $parts[] = $str;
2735	+ }
2736	+
2737	+ $parts[] = ')';
2738	+ } else {
2739	+ $this->seek($ss);
2740	+ }
2741	}
2742
2743	+ continue;


2744	}
2745	+ }
2746
2747	+ $this->seek($s);
2748	+
2749	+ // 2n+1
2750	+ if ($subSelector && is_string($subSelector) && strpos($subSelector, 'nth-') === 0) {
2751	+ if ($this->match("(\s(\+\s\|\-\s*)?(\d+\|n\|\d+n))+", $counter)) {
2752	+ $parts[] = $counter[0];
2753	+ //$parts[] = str_replace(' ', '', $counter[0]);
2754	+ continue;
2755	+ }
2756	}
2757
2758	$this->seek($s);
2759
2760	// attribute selector
2761	+ if ($char === '[' &&
2762	+ $this->matchChar('[') &&
2763	+ ($this->openString(']', $str, '[') \|\| true) &&
2764	+ $this->matchChar(']')
2765	) {
2766	$parts[] = '[';
2767

2770	}
2771
2772	$parts[] = ']';

2773	continue;
2774	}
2775
2776	$this->seek($s);
2777
2778	+ // for keyframes
2779	+ if ($this->unit($unit)) {
2780	+ $parts[] = $unit;
2781	+ continue;
2782	+ }
2783	+
2784	+ if ($this->restrictedKeyword($name)) {
2785	+ $parts[] = $name;
2786	+ continue;
2787	+ }
2788	+
2789	break;
2790	}
2791
2792	$this->eatWhiteDefault = $oldWhite;
2793
2794	+ if (! $parts) {
2795	return false;
2796	}
2797

2809	*/
2810	protected function variable(&$out)
2811	{
2812	+ $s = $this->count;
2813
2814	+ if ($this->matchChar('$', false) && $this->keyword($name)) {
2815	$out = [Type::T_VARIABLE, $name];
2816
2817	return true;

2834	{
2835	if ($this->match(
2836	$this->utf8
2837	+ ? '(([\pL\w\x{00A0}-\x{10FFFF}_\-\!"\']\|[\\\\].)([\pL\w\x{00A0}-\x{10FFFF}\-_"\']\|[\\\\].))'
2838	: '(([\w_\-\!"\']\|[\\\\].)([\w\-_"\']\|[\\\\].))',
2839	$m,
2840	$eatWhitespace

2847	return false;
2848	}
2849
2850	+ /**
2851	+ * Parse a keyword that should not start with a number
2852	+ *
2853	+ * @param string $word
2854	+ * @param boolean $eatWhitespace
2855	+ *
2856	+ * @return boolean
2857	+ */
2858	+ protected function restrictedKeyword(&$word, $eatWhitespace = null)
2859	+ {
2860	+ $s = $this->count;
2861	+
2862	+ if ($this->keyword($word, $eatWhitespace) && (ord($word[0]) > 57 \|\| ord($word[0]) < 48)) {
2863	+ return true;
2864	+ }
2865	+
2866	+ $this->seek($s);
2867	+
2868	+ return false;
2869	+ }
2870	+
2871	/**
2872	* Parse a placeholder
2873	*
2874	+ * @param string\|array $placeholder
2875	*
2876	* @return boolean
2877	*/

2879	{
2880	if ($this->match(
2881	$this->utf8
2882	+ ? '([\pL\w\-_]+)'
2883	+ : '([\w\-_]+)',
2884	$m
2885	)) {
2886	$placeholder = $m[1];

2888	return true;
2889	}
2890
2891	+ if ($this->interpolation($placeholder)) {
2892	+ return true;
2893	+ }
2894	+
2895	return false;
2896	}
2897

2920	*/
2921	protected function end()
2922	{
2923	+ if ($this->matchChar(';')) {
2924	return true;
2925	}
2926

2949	while ($lastNode[0] === Type::T_KEYWORD && in_array($lastNode[1], ['!default', '!global'])) {
2950	array_pop($token[2]);
2951
2952	+ $node = end($token[2]);
2953	+ $token = $this->flattenList($token);
2954	+ $flags[] = $lastNode[1];



2955	$lastNode = $node;
2956	}
2957	}

2969	protected function stripOptionalFlag(&$selectors)
2970	{
2971	$optional = false;

2972	$selector = end($selectors);
2973	+ $part = end($selector);
2974
2975	if ($part === ['!optional']) {
2976	array_pop($selectors[count($selectors) - 1]);

3014	$validChars = $allowNewline ? '.' : "[^\n]";
3015	}
3016
3017	+ $m = null;
3018	+
3019	if (! $this->match('(' . $validChars . '*?)' . $this->pregQuote($what), $m, ! $until)) {
3020	return false;
3021	}

3080	*
3081	* @param integer $pos
3082	*
3083	+ * @return array
3084	*/
3085	private function getSourcePosition($pos)
3086	{

3115	return;
3116	}
3117
3118	+ // deprecated in PHP 7.2
3119	+ $iniDirective = 'mbstring.func_overload';
3120
3121	+ if (extension_loaded('mbstring') && ini_get($iniDirective) & 2) {
3122	$this->encoding = mb_internal_encoding();
3123
3124	mb_internal_encoding('iso-8859-1');

3130	*/
3131	private function restoreEncoding()
3132	{
3133	+ if (extension_loaded('mbstring') && $this->encoding) {
3134	mb_internal_encoding($this->encoding);
3135	}
3136	}

assets/libraries/scssphp/src/SourceMap/Base64.php ADDED Viewed

	@@ -0,0 +1,184 @@


1	+ <?php
2	+ /**
3	+ * SCSSPHP
4	+ *
5	+ * @copyright 2012-2020 Leaf Corcoran
6	+ *
7	+ * @license http://opensource.org/licenses/MIT MIT
8	+ *
9	+ * @link http://scssphp.github.io/scssphp
10	+ */
11	+
12	+ namespace ScssPhp\ScssPhp\SourceMap;
13	+
14	+ /**
15	+ * Base 64 Encode/Decode
16	+ *
17	+ * @author Anthon Pang <anthon.pang@gmail.com>
18	+ */
19	+ class Base64
20	+ {
21	+ /**
22	+ * @var array
23	+ */
24	+ private static $encodingMap = [
25	+ 0 => 'A',
26	+ 1 => 'B',
27	+ 2 => 'C',
28	+ 3 => 'D',
29	+ 4 => 'E',
30	+ 5 => 'F',
31	+ 6 => 'G',
32	+ 7 => 'H',
33	+ 8 => 'I',
34	+ 9 => 'J',
35	+ 10 => 'K',
36	+ 11 => 'L',
37	+ 12 => 'M',
38	+ 13 => 'N',
39	+ 14 => 'O',
40	+ 15 => 'P',
41	+ 16 => 'Q',
42	+ 17 => 'R',
43	+ 18 => 'S',
44	+ 19 => 'T',
45	+ 20 => 'U',
46	+ 21 => 'V',
47	+ 22 => 'W',
48	+ 23 => 'X',
49	+ 24 => 'Y',
50	+ 25 => 'Z',
51	+ 26 => 'a',
52	+ 27 => 'b',
53	+ 28 => 'c',
54	+ 29 => 'd',
55	+ 30 => 'e',
56	+ 31 => 'f',
57	+ 32 => 'g',
58	+ 33 => 'h',
59	+ 34 => 'i',
60	+ 35 => 'j',
61	+ 36 => 'k',
62	+ 37 => 'l',
63	+ 38 => 'm',
64	+ 39 => 'n',
65	+ 40 => 'o',
66	+ 41 => 'p',
67	+ 42 => 'q',
68	+ 43 => 'r',
69	+ 44 => 's',
70	+ 45 => 't',
71	+ 46 => 'u',
72	+ 47 => 'v',
73	+ 48 => 'w',
74	+ 49 => 'x',
75	+ 50 => 'y',
76	+ 51 => 'z',
77	+ 52 => '0',
78	+ 53 => '1',
79	+ 54 => '2',
80	+ 55 => '3',
81	+ 56 => '4',
82	+ 57 => '5',
83	+ 58 => '6',
84	+ 59 => '7',
85	+ 60 => '8',
86	+ 61 => '9',
87	+ 62 => '+',
88	+ 63 => '/',
89	+ ];
90	+
91	+ /**
92	+ * @var array
93	+ */
94	+ private static $decodingMap = [
95	+ 'A' => 0,
96	+ 'B' => 1,
97	+ 'C' => 2,
98	+ 'D' => 3,
99	+ 'E' => 4,
100	+ 'F' => 5,
101	+ 'G' => 6,
102	+ 'H' => 7,
103	+ 'I' => 8,
104	+ 'J' => 9,
105	+ 'K' => 10,
106	+ 'L' => 11,
107	+ 'M' => 12,
108	+ 'N' => 13,
109	+ 'O' => 14,
110	+ 'P' => 15,
111	+ 'Q' => 16,
112	+ 'R' => 17,
113	+ 'S' => 18,
114	+ 'T' => 19,
115	+ 'U' => 20,
116	+ 'V' => 21,
117	+ 'W' => 22,
118	+ 'X' => 23,
119	+ 'Y' => 24,
120	+ 'Z' => 25,
121	+ 'a' => 26,
122	+ 'b' => 27,
123	+ 'c' => 28,
124	+ 'd' => 29,
125	+ 'e' => 30,
126	+ 'f' => 31,
127	+ 'g' => 32,
128	+ 'h' => 33,
129	+ 'i' => 34,
130	+ 'j' => 35,
131	+ 'k' => 36,
132	+ 'l' => 37,
133	+ 'm' => 38,
134	+ 'n' => 39,
135	+ 'o' => 40,
136	+ 'p' => 41,
137	+ 'q' => 42,
138	+ 'r' => 43,
139	+ 's' => 44,
140	+ 't' => 45,
141	+ 'u' => 46,
142	+ 'v' => 47,
143	+ 'w' => 48,
144	+ 'x' => 49,
145	+ 'y' => 50,
146	+ 'z' => 51,
147	+ 0 => 52,
148	+ 1 => 53,
149	+ 2 => 54,
150	+ 3 => 55,
151	+ 4 => 56,
152	+ 5 => 57,
153	+ 6 => 58,
154	+ 7 => 59,
155	+ 8 => 60,
156	+ 9 => 61,
157	+ '+' => 62,
158	+ '/' => 63,
159	+ ];
160	+
161	+ /**
162	+ * Convert to base64
163	+ *
164	+ * @param integer $value
165	+ *
166	+ * @return string
167	+ */
168	+ public static function encode($value)
169	+ {
170	+ return self::$encodingMap[$value];
171	+ }
172	+
173	+ /**
174	+ * Convert from base64
175	+ *
176	+ * @param string $value
177	+ *
178	+ * @return integer
179	+ */
180	+ public static function decode($value)
181	+ {
182	+ return self::$decodingMap[$value];
183	+ }
184	+ }

assets/libraries/scssphp/src/SourceMap/Base64VLQ.php ADDED Viewed

	@@ -0,0 +1,146 @@


1	+ <?php
2	+ /**
3	+ * SCSSPHP
4	+ *
5	+ * @copyright 2012-2020 Leaf Corcoran
6	+ *
7	+ * @license http://opensource.org/licenses/MIT MIT
8	+ *
9	+ * @link http://scssphp.github.io/scssphp
10	+ */
11	+
12	+ namespace ScssPhp\ScssPhp\SourceMap;
13	+
14	+ use ScssPhp\ScssPhp\SourceMap\Base64;
15	+
16	+ /**
17	+ * Base 64 VLQ
18	+ *
19	+ * Based on the Base 64 VLQ implementation in Closure Compiler:
20	+ * https://github.com/google/closure-compiler/blob/master/src/com/google/debugging/sourcemap/Base64VLQ.java
21	+ *
22	+ * Copyright 2011 The Closure Compiler Authors.
23	+ *
24	+ * Licensed under the Apache License, Version 2.0 (the "License");
25	+ * you may not use this file except in compliance with the License.
26	+ * You may obtain a copy of the License at
27	+ *
28	+ * http://www.apache.org/licenses/LICENSE-2.0
29	+ *
30	+ * Unless required by applicable law or agreed to in writing, software
31	+ * distributed under the License is distributed on an "AS IS" BASIS,
32	+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
33	+ * See the License for the specific language governing permissions and
34	+ * limitations under the License.
35	+ *
36	+ * @author John Lenz <johnlenz@google.com>
37	+ * @author Anthon Pang <anthon.pang@gmail.com>
38	+ */
39	+ class Base64VLQ
40	+ {
41	+ // A Base64 VLQ digit can represent 5 bits, so it is base-32.
42	+ const VLQ_BASE_SHIFT = 5;
43	+
44	+ // A mask of bits for a VLQ digit (11111), 31 decimal.
45	+ const VLQ_BASE_MASK = 31;
46	+
47	+ // The continuation bit is the 6th bit.
48	+ const VLQ_CONTINUATION_BIT = 32;
49	+
50	+ /**
51	+ * Returns the VLQ encoded value.
52	+ *
53	+ * @param integer $value
54	+ *
55	+ * @return string
56	+ */
57	+ public static function encode($value)
58	+ {
59	+ $encoded = '';
60	+ $vlq = self::toVLQSigned($value);
61	+
62	+ do {
63	+ $digit = $vlq & self::VLQ_BASE_MASK;
64	+ $vlq >>= self::VLQ_BASE_SHIFT;
65	+
66	+ if ($vlq > 0) {
67	+ $digit \|= self::VLQ_CONTINUATION_BIT;
68	+ }
69	+
70	+ $encoded .= Base64::encode($digit);
71	+ } while ($vlq > 0);
72	+
73	+ return $encoded;
74	+ }
75	+
76	+ /**
77	+ * Decodes VLQValue.
78	+ *
79	+ * @param string $str
80	+ * @param integer $index
81	+ *
82	+ * @return integer
83	+ */
84	+ public static function decode($str, &$index)
85	+ {
86	+ $result = 0;
87	+ $shift = 0;
88	+
89	+ do {
90	+ $c = $str[$index++];
91	+ $digit = Base64::decode($c);
92	+ $continuation = ($digit & self::VLQ_CONTINUATION_BIT) != 0;
93	+ $digit &= self::VLQ_BASE_MASK;
94	+ $result = $result + ($digit << $shift);
95	+ $shift = $shift + self::VLQ_BASE_SHIFT;
96	+ } while ($continuation);
97	+
98	+ return self::fromVLQSigned($result);
99	+ }
100	+
101	+ /**
102	+ * Converts from a two-complement value to a value where the sign bit is
103	+ * is placed in the least significant bit. For example, as decimals:
104	+ * 1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
105	+ * 2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
106	+ *
107	+ * @param integer $value
108	+ *
109	+ * @return integer
110	+ */
111	+ private static function toVLQSigned($value)
112	+ {
113	+ if ($value < 0) {
114	+ return ((-$value) << 1) + 1;
115	+ }
116	+
117	+ return ($value << 1) + 0;
118	+ }
119	+
120	+ /**
121	+ * Converts to a two-complement value from a value where the sign bit is
122	+ * is placed in the least significant bit. For example, as decimals:
123	+ * 2 (10 binary) becomes 1, 3 (11 binary) becomes -1
124	+ * 4 (100 binary) becomes 2, 5 (101 binary) becomes -2
125	+ *
126	+ * @param integer $value
127	+ *
128	+ * @return integer
129	+ */
130	+ private static function fromVLQSigned($value)
131	+ {
132	+ $negate = ($value & 1) === 1;
133	+ $value = ($value >> 1) & ~(1<<(8 * PHP_INT_SIZE - 1)); // unsigned right shift
134	+
135	+ if (! $negate) {
136	+ return $value;
137	+ }
138	+
139	+ // We need to OR 0x80000000 here to ensure the 32nd bit (the sign bit) is
140	+ // always set for negative numbers. If `value` were 1, (meaning `negate` is
141	+ // true and all other bits were zeros), `value` would now be 0. -0 is just
142	+ // 0, and doesn't flip the 32nd bit as intended. All positive numbers will
143	+ // successfully flip the 32nd bit without issue, so it's a noop for them.
144	+ return -$value \| 0x80000000;
145	+ }
146	+ }

assets/libraries/scssphp/src/SourceMap/Base64VLQEncoder.php DELETED Viewed

@@ -1,218 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2018 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\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 = array(
-            -
                    '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 = array(
-            -
                     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)
-            -
                {
-            -
                    $bmin = $b - 1;
-            -
                    return ($a >= 0) ? ($a >> $b) : ($a >> $b) & (PHP_INT_MAX >> ($bmin));
-            -
                }
-            -
-            -
                /**
-            -
                 * 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];
-            -
                }
-            -
            }

assets/libraries/scssphp/src/SourceMap/SourceMapGenerator.php CHANGED Viewed

	@@ -2,16 +2,16 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp\SourceMap;
13
14	- use ~~Leafo~~\ScssPhp\Exception\CompilerException;
15
16	/**
17	* Source Map Generator
	@@ -33,7 +33,7 @@ class SourceMapGenerator
33	*
34	* @var array
35	*/
36	- protected $defaultOptions = ~~array(~~
37	// an optional source root, useful for relocating source files
38	// on a server or removing repeated values in the 'sources' entry.
39	// This value is prepended to the individual entries in the 'source' field.
	@@ -56,12 +56,12 @@ class SourceMapGenerator
56
57	// base path for filename normalization
58	'sourceMapBasepath' => ''
59	- );
60
61	/**
62	* The base64 VLQ encoder
63	*
64	- * @var \~~Leafo~~\ScssPhp\SourceMap\~~Base64VLQEncoder~~
65	*/
66	protected $encoder;
67
	@@ -70,22 +70,22 @@ class SourceMapGenerator
70	*
71	* @var array
72	*/
73	- protected $mappings = ~~array()~~;
74
75	/**
76	* Array of contents map
77	*
78	* @var array
79	*/
80	- protected $contentsMap = ~~array()~~;
81
82	/**
83	* File to content map
84	*
85	* @var array
86	*/
87	- protected $sources = ~~array()~~;
88	- protected $~~source_keys~~ = ~~array()~~;
89
90	/**
91	* @var array
	@@ -95,7 +95,7 @@ class SourceMapGenerator
95	public function __construct(array $options = [])
96	{
97	$this->options = array_merge($this->defaultOptions, $options);
98	- $this->encoder = new ~~Base64VLQEncoder~~();
99	}
100
101	/**
	@@ -109,13 +109,13 @@ class SourceMapGenerator
109	*/
110	public function addMapping($generatedLine, $generatedColumn, $originalLine, $originalColumn, $sourceFile)
111	{
112	- $this->mappings[] = ~~array(~~
113	- 'generated_line' => $generatedLine,
114	'generated_column' => $generatedColumn,
115	- 'original_line' => $originalLine,
116	- 'original_column' => $originalColumn,
117	- 'source_file' => $sourceFile
118	- );
119
120	$this->sources[$sourceFile] = $sourceFile;
121	}
	@@ -123,10 +123,11 @@ class SourceMapGenerator
123	/**
124	* Saves the source map to a file
125	*
126	- * @param string $file The absolute path to a file
127	* @param string $content The content to write
128	*
129	- * @~~throws~~ ~~\Leafo\ScssPhp\Exception\CompilerException If the file could not be saved~~


130	*/
131	public function saveMap($content)
132	{
	@@ -136,7 +137,9 @@ class SourceMapGenerator
136	// directory does not exist
137	if (! is_dir($dir)) {
138	// FIXME: create the dir automatically?
139	- throw new CompilerException(~~sprintf('The directory "%s" does not exist. Cannot save the source map.', $dir));~~


140	}
141
142	// FIXME: proper saving, with dir write check!
	@@ -156,7 +159,7 @@ class SourceMapGenerator
156	*/
157	public function generateJson()
158	{
159	- $sourceMap = ~~array()~~;
160	$mappings = $this->generateMappings();
161
162	// File version (always the first entry in the object) and must be a positive integer.
	@@ -178,14 +181,14 @@ class SourceMapGenerator
178	}
179
180	// A list of original sources used by the 'mappings' entry.
181	- $sourceMap['sources'] = ~~array()~~;
182
183	- foreach ($this->sources as $~~source_uri~~ => $~~source_filename~~) {
184	- $sourceMap['sources'][] = $this->normalizeFilename($~~source_filename~~);
185	}
186
187	// A list of symbol names used by the 'mappings' entry.
188	- $sourceMap['names'] = ~~array()~~;
189
190	// A string with the encoded mapping data.
191	$sourceMap['mappings'] = $mappings;
	@@ -202,7 +205,7 @@ class SourceMapGenerator
202	unset($sourceMap['sourceRoot']);
203	}
204
205	- return json_encode($sourceMap);
206	}
207
208	/**
	@@ -216,7 +219,7 @@ class SourceMapGenerator
216	return null;
217	}
218
219	- $content = ~~array()~~;
220
221	foreach ($this->sources as $sourceFile) {
222	$content[] = file_get_contents($sourceFile);
	@@ -236,10 +239,10 @@ class SourceMapGenerator
236	return '';
237	}
238
239	- $this->~~source_keys~~ = array_flip(array_keys($this->sources));
240
241	// group mappings by generated line number.
242	- $groupedMap = $groupedMapEncoded = ~~array()~~;
243
244	foreach ($this->mappings as $m) {
245	$groupedMap[$m['generated_line']][] = $m;
	@@ -248,15 +251,15 @@ class SourceMapGenerator
248	ksort($groupedMap);
249	$lastGeneratedLine = $lastOriginalIndex = $lastOriginalLine = $lastOriginalColumn = 0;
250
251	- foreach ($groupedMap as $lineNumber => $~~line_map~~) {
252	while (++$lastGeneratedLine < $lineNumber) {
253	$groupedMapEncoded[] = ';';
254	}
255
256	- $lineMapEncoded = ~~array()~~;
257	$lastGeneratedColumn = 0;
258
259	- foreach ($~~line_map~~ as $m) {
260	$mapEncoded = $this->encoder->encode($m['generated_column'] - $lastGeneratedColumn);
261	$lastGeneratedColumn = $m['generated_column'];
262
	@@ -293,9 +296,16 @@ class SourceMapGenerator
293	*/
294	protected function findFileIndex($filename)
295	{
296	- return $this->~~source_keys~~[$filename];
297	}
298







299	protected function normalizeFilename($filename)
300	{
301	$filename = $this->fixWindowsPath($filename);
	@@ -303,7 +313,7 @@ class SourceMapGenerator
303	$basePath = $this->options['sourceMapBasepath'];
304
305	// "Trim" the 'sourceMapBasepath' from the output filename.
306	- if (strpos($filename, $basePath) === 0) {
307	$filename = substr($filename, strlen($basePath));
308	}
309


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp\SourceMap;
13
14	+ use ScssPhp\ScssPhp\Exception\CompilerException;
15
16	/**
17	* Source Map Generator

33	*
34	* @var array
35	*/
36	+ protected $defaultOptions = [
37	// an optional source root, useful for relocating source files
38	// on a server or removing repeated values in the 'sources' entry.
39	// This value is prepended to the individual entries in the 'source' field.

56
57	// base path for filename normalization
58	'sourceMapBasepath' => ''
59	+ ];
60
61	/**
62	* The base64 VLQ encoder
63	*
64	+ * @var \ScssPhp\ScssPhp\SourceMap\Base64VLQ
65	*/
66	protected $encoder;
67

70	*
71	* @var array
72	*/
73	+ protected $mappings = [];
74
75	/**
76	* Array of contents map
77	*
78	* @var array
79	*/
80	+ protected $contentsMap = [];
81
82	/**
83	* File to content map
84	*
85	* @var array
86	*/
87	+ protected $sources = [];
88	+ protected $sourceKeys = [];
89
90	/**
91	* @var array

95	public function __construct(array $options = [])
96	{
97	$this->options = array_merge($this->defaultOptions, $options);
98	+ $this->encoder = new Base64VLQ();
99	}
100
101	/**

109	*/
110	public function addMapping($generatedLine, $generatedColumn, $originalLine, $originalColumn, $sourceFile)
111	{
112	+ $this->mappings[] = [
113	+ 'generated_line' => $generatedLine,
114	'generated_column' => $generatedColumn,
115	+ 'original_line' => $originalLine,
116	+ 'original_column' => $originalColumn,
117	+ 'source_file' => $sourceFile
118	+ ];
119
120	$this->sources[$sourceFile] = $sourceFile;
121	}

123	/**
124	* Saves the source map to a file
125	*

126	* @param string $content The content to write
127	*
128	+ * @return string
129	+ *
130	+ * @throws \ScssPhp\ScssPhp\Exception\CompilerException If the file could not be saved
131	*/
132	public function saveMap($content)
133	{

137	// directory does not exist
138	if (! is_dir($dir)) {
139	// FIXME: create the dir automatically?
140	+ throw new CompilerException(
141	+ sprintf('The directory "%s" does not exist. Cannot save the source map.', $dir)
142	+ );
143	}
144
145	// FIXME: proper saving, with dir write check!

159	*/
160	public function generateJson()
161	{
162	+ $sourceMap = [];
163	$mappings = $this->generateMappings();
164
165	// File version (always the first entry in the object) and must be a positive integer.

181	}
182
183	// A list of original sources used by the 'mappings' entry.
184	+ $sourceMap['sources'] = [];
185
186	+ foreach ($this->sources as $sourceUri => $sourceFilename) {
187	+ $sourceMap['sources'][] = $this->normalizeFilename($sourceFilename);
188	}
189
190	// A list of symbol names used by the 'mappings' entry.
191	+ $sourceMap['names'] = [];
192
193	// A string with the encoded mapping data.
194	$sourceMap['mappings'] = $mappings;

205	unset($sourceMap['sourceRoot']);
206	}
207
208	+ return json_encode($sourceMap, JSON_UNESCAPED_SLASHES);
209	}
210
211	/**

219	return null;
220	}
221
222	+ $content = [];
223
224	foreach ($this->sources as $sourceFile) {
225	$content[] = file_get_contents($sourceFile);

239	return '';
240	}
241
242	+ $this->sourceKeys = array_flip(array_keys($this->sources));
243
244	// group mappings by generated line number.
245	+ $groupedMap = $groupedMapEncoded = [];
246
247	foreach ($this->mappings as $m) {
248	$groupedMap[$m['generated_line']][] = $m;

251	ksort($groupedMap);
252	$lastGeneratedLine = $lastOriginalIndex = $lastOriginalLine = $lastOriginalColumn = 0;
253
254	+ foreach ($groupedMap as $lineNumber => $lineMap) {
255	while (++$lastGeneratedLine < $lineNumber) {
256	$groupedMapEncoded[] = ';';
257	}
258
259	+ $lineMapEncoded = [];
260	$lastGeneratedColumn = 0;
261
262	+ foreach ($lineMap as $m) {
263	$mapEncoded = $this->encoder->encode($m['generated_column'] - $lastGeneratedColumn);
264	$lastGeneratedColumn = $m['generated_column'];
265

296	*/
297	protected function findFileIndex($filename)
298	{
299	+ return $this->sourceKeys[$filename];
300	}
301
302	+ /**
303	+ * Normalize filename
304	+ *
305	+ * @param string $filename
306	+ *
307	+ * @return string
308	+ */
309	protected function normalizeFilename($filename)
310	{
311	$filename = $this->fixWindowsPath($filename);

313	$basePath = $this->options['sourceMapBasepath'];
314
315	// "Trim" the 'sourceMapBasepath' from the output filename.
316	+ if (strlen($basePath) && strpos($filename, $basePath) === 0) {
317	$filename = substr($filename, strlen($basePath));
318	}
319

assets/libraries/scssphp/src/Type.php CHANGED Viewed

	@@ -2,14 +2,14 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp;
13
14	/**
15	* Block/node types


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp;
13
14	/**
15	* Block/node types

assets/libraries/scssphp/src/Util.php CHANGED Viewed

	@@ -2,17 +2,17 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp;
13
14	- use ~~Leafo~~\ScssPhp\Base\Range;
15	- use ~~Leafo~~\ScssPhp\Exception\RangeException;
16
17	/**
18	* Utilty functions
	@@ -26,13 +26,13 @@ class Util
26	* room for slight floating-point errors.
27	*
28	* @param string $name The name of the value. Used in the error message.
29	- * @param \~~Leafo~~\ScssPhp\Base\Range $range Range of values.
30	* @param array $value The value to check.
31	* @param string $unit The unit of the value. Used in error reporting.
32	*
33	* @return mixed `value` adjusted to fall within range, if it was outside by a floating-point margin.
34	*
35	- * @throws \~~Leafo~~\ScssPhp\Exception\RangeException
36	*/
37	public static function checkRange($name, Range $range, $value, $unit = '')
38	{
	@@ -63,7 +63,7 @@ class Util
63	*/
64	public static function encodeURIComponent($string)
65	{
66	- $revert = ~~array(~~'%21' => '!', '%2A' => '*', '%27' => "'", '%28' => '(', '%29' => ')');
67
68	return strtr(rawurlencode($string), $revert);
69	}


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp;
13
14	+ use ScssPhp\ScssPhp\Base\Range;
15	+ use ScssPhp\ScssPhp\Exception\RangeException;
16
17	/**
18	* Utilty functions

26	* room for slight floating-point errors.
27	*
28	* @param string $name The name of the value. Used in the error message.
29	+ * @param \ScssPhp\ScssPhp\Base\Range $range Range of values.
30	* @param array $value The value to check.
31	* @param string $unit The unit of the value. Used in error reporting.
32	*
33	* @return mixed `value` adjusted to fall within range, if it was outside by a floating-point margin.
34	*
35	+ * @throws \ScssPhp\ScssPhp\Exception\RangeException
36	*/
37	public static function checkRange($name, Range $range, $value, $unit = '')
38	{

63	*/
64	public static function encodeURIComponent($string)
65	{
66	+ $revert = ['%21' => '!', '%2A' => '*', '%27' => "'", '%28' => '(', '%29' => ')'];
67
68	return strtr(rawurlencode($string), $revert);
69	}

assets/libraries/scssphp/src/Version.php CHANGED Viewed

	@@ -2,14 +2,14 @@
2	/**
3	* SCSSPHP
4	*
5	- * @copyright 2012-~~2018~~ Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	- * @link http://~~leafo~~.github.io/scssphp
10	*/
11
12	- namespace ~~Leafo~~\ScssPhp;
13
14	/**
15	* SCSSPHP version
	@@ -18,5 +18,5 @@ namespace Leafo\ScssPhp;
18	*/
19	class Version
20	{
21	- const VERSION = 'v0.7.6';
22	}


2	/**
3	* SCSSPHP
4	*
5	+ * @copyright 2012-2020 Leaf Corcoran
6	*
7	* @license http://opensource.org/licenses/MIT MIT
8	*
9	+ * @link http://scssphp.github.io/scssphp
10	*/
11
12	+ namespace ScssPhp\ScssPhp;
13
14	/**
15	* SCSSPHP version

18	*/
19	class Version
20	{
21	+ const VERSION = 'v1.0.7';
22	}

assets/libraries/scssphp_legacy/scss.inc.php DELETED Viewed

@@ -1,29 +0,0 @@
-            -
            <?php
-            -
-            -
            if (version_compare(PHP_VERSION, '5.3') < 0) {
-            -
                die('Requires PHP 5.3 or above');
-            -
            }
-            -
-            -
            if (! class_exists('scssc', false)) {
-            -
                include_once __DIR__ . '/src/Base/Range.php';
-            -
                include_once __DIR__ . '/src/Block.php';
-            -
                include_once __DIR__ . '/src/Colors.php';
-            -
                include_once __DIR__ . '/src/Compiler.php';
-            -
                include_once __DIR__ . '/src/Compiler/Environment.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/Type.php';
-            -
                include_once __DIR__ . '/src/Util.php';
-            -
                include_once __DIR__ . '/src/Version.php';
-            -
                include_once __DIR__ . '/src/Server.php';
-            -
             //   include_once __DIR__ . '/classmap.php';
-            -
            }

assets/libraries/scssphp_legacy/src/Base/Range.php DELETED Viewed

@@ -1,47 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp\Base;
-            -
-            -
            /**
-            -
             * Range class
-            -
             *
-            -
             * @author Anthon Pang <anthon.pang@gmail.com>
-            -
             */
-            -
            class Range
-            -
            {
-            -
                public $first;
-            -
                public $last;
-            -
-            -
                /**
-            -
                 * Initialize range
-            -
                 *
-            -
                 * @param integer|float $first
-            -
                 * @param integer|float $last
-            -
                 */
-            -
                public function __construct($first, $last)
-            -
                {
-            -
                    $this->first = $first;
-            -
                    $this->last = $last;
-            -
                }
-            -
-            -
                /**
-            -
                 * Test for inclusion in range
-            -
                 *
-            -
                 * @param integer|float $value
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                public function includes($value)
-            -
                {
-            -
                    return $value >= $this->first && $value <= $this->last;
-            -
                }
-            -
            }

assets/libraries/scssphp_legacy/src/Block.php DELETED Viewed

@@ -1,55 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp;
-            -
-            -
            /**
-            -
             * SCSS block
-            -
             *
-            -
             * @author Anthon Pang <anthon.pang@gmail.com>
-            -
             */
-            -
            class Block
-            -
            {
-            -
                /**
-            -
                 * @var string
-            -
                 */
-            -
                public $type;
-            -
-            -
                /**
-            -
                 * @var \Leafo\ScssPhp\Block
-            -
                 */
-            -
                public $parent;
-            -
-            -
                /**
-            -
                 * @var integer
-            -
                 */
-            -
                public $sourcePosition;
-            -
-            -
                /**
-            -
                 * @var integer
-            -
                 */
-            -
                public $sourceIndex;
-            -
-            -
                /**
-            -
                 * @var array
-            -
                 */
-            -
                public $selectors;
-            -
-            -
                /**
-            -
                 * @var array
-            -
                 */
-            -
                public $comments;
-            -
-            -
                /**
-            -
                 * @var array
-            -
                 */
-            -
                public $children;
-            -
            }

assets/libraries/scssphp_legacy/src/Colors.php DELETED Viewed

@@ -1,178 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp;
-            -
-            -
            /**
-            -
             * CSS Colors
-            -
             *
-            -
             * @author Leaf Corcoran <leafot@gmail.com>
-            -
             */
-            -
            class Colors
-            -
            {
-            -
                /**
-            -
                 * CSS Colors
-            -
                 *
-            -
                 * @see http://www.w3.org/TR/css3-color
-            -
                 *
-            -
                 * @var array
-            -
                 */
-            -
                public static $cssColors = array(
-            -
                    'aliceblue' => '240,248,255',
-            -
                    'antiquewhite' => '250,235,215',
-            -
                    'aqua' => '0,255,255',
-            -
                    'aquamarine' => '127,255,212',
-            -
                    'azure' => '240,255,255',
-            -
                    'beige' => '245,245,220',
-            -
                    'bisque' => '255,228,196',
-            -
                    'black' => '0,0,0',
-            -
                    'blanchedalmond' => '255,235,205',
-            -
                    'blue' => '0,0,255',
-            -
                    'blueviolet' => '138,43,226',
-            -
                    'brown' => '165,42,42',
-            -
                    'burlywood' => '222,184,135',
-            -
                    'cadetblue' => '95,158,160',
-            -
                    'chartreuse' => '127,255,0',
-            -
                    'chocolate' => '210,105,30',
-            -
                    'coral' => '255,127,80',
-            -
                    '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',
-            -
                    'darkkhaki' => '189,183,107',
-            -
                    'darkmagenta' => '139,0,139',
-            -
                    'darkolivegreen' => '85,107,47',
-            -
                    'darkorange' => '255,140,0',
-            -
                    'darkorchid' => '153,50,204',
-            -
                    'darkred' => '139,0,0',
-            -
                    'darksalmon' => '233,150,122',
-            -
                    'darkseagreen' => '143,188,143',
-            -
                    'darkslateblue' => '72,61,139',
-            -
                    'darkslategray' => '47,79,79',
-            -
                    'darkslategrey' => '47,79,79',
-            -
                    'darkturquoise' => '0,206,209',
-            -
                    'darkviolet' => '148,0,211',
-            -
                    'deeppink' => '255,20,147',
-            -
                    'deepskyblue' => '0,191,255',
-            -
                    'dimgray' => '105,105,105',
-            -
                    'dimgrey' => '105,105,105',
-            -
                    'dodgerblue' => '30,144,255',
-            -
                    'firebrick' => '178,34,34',
-            -
                    'floralwhite' => '255,250,240',
-            -
                    'forestgreen' => '34,139,34',
-            -
                    'fuchsia' => '255,0,255',
-            -
                    'gainsboro' => '220,220,220',
-            -
                    'ghostwhite' => '248,248,255',
-            -
                    'gold' => '255,215,0',
-            -
                    'goldenrod' => '218,165,32',
-            -
                    'gray' => '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',
-            -
                    'indigo' => '75,0,130',
-            -
                    'ivory' => '255,255,240',
-            -
                    'khaki' => '240,230,140',
-            -
                    'lavender' => '230,230,250',
-            -
                    'lavenderblush' => '255,240,245',
-            -
                    'lawngreen' => '124,252,0',
-            -
                    'lemonchiffon' => '255,250,205',
-            -
                    'lightblue' => '173,216,230',
-            -
                    'lightcoral' => '240,128,128',
-            -
                    'lightcyan' => '224,255,255',
-            -
                    'lightgoldenrodyellow' => '250,250,210',
-            -
                    'lightgray' => '211,211,211',
-            -
                    'lightgreen' => '144,238,144',
-            -
                    'lightgrey' => '211,211,211',
-            -
                    'lightpink' => '255,182,193',
-            -
                    'lightsalmon' => '255,160,122',
-            -
                    'lightseagreen' => '32,178,170',
-            -
                    'lightskyblue' => '135,206,250',
-            -
                    'lightslategray' => '119,136,153',
-            -
                    'lightslategrey' => '119,136,153',
-            -
                    'lightsteelblue' => '176,196,222',
-            -
                    'lightyellow' => '255,255,224',
-            -
                    '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',
-            -
                    'mediumorchid' => '186,85,211',
-            -
                    'mediumpurple' => '147,112,219',
-            -
                    'mediumseagreen' => '60,179,113',
-            -
                    'mediumslateblue' => '123,104,238',
-            -
                    'mediumspringgreen' => '0,250,154',
-            -
                    'mediumturquoise' => '72,209,204',
-            -
                    'mediumvioletred' => '199,21,133',
-            -
                    'midnightblue' => '25,25,112',
-            -
                    'mintcream' => '245,255,250',
-            -
                    'mistyrose' => '255,228,225',
-            -
                    'moccasin' => '255,228,181',
-            -
                    'navajowhite' => '255,222,173',
-            -
                    'navy' => '0,0,128',
-            -
                    'oldlace' => '253,245,230',
-            -
                    'olive' => '128,128,0',
-            -
                    'olivedrab' => '107,142,35',
-            -
                    'orange' => '255,165,0',
-            -
                    'orangered' => '255,69,0',
-            -
                    'orchid' => '218,112,214',
-            -
                    'palegoldenrod' => '238,232,170',
-            -
                    'palegreen' => '152,251,152',
-            -
                    'paleturquoise' => '175,238,238',
-            -
                    'palevioletred' => '219,112,147',
-            -
                    'papayawhip' => '255,239,213',
-            -
                    'peachpuff' => '255,218,185',
-            -
                    'peru' => '205,133,63',
-            -
                    'pink' => '255,192,203',
-            -
                    'plum' => '221,160,221',
-            -
                    'powderblue' => '176,224,230',
-            -
                    'purple' => '128,0,128',
-            -
                    'red' => '255,0,0',
-            -
                    'rosybrown' => '188,143,143',
-            -
                    'royalblue' => '65,105,225',
-            -
                    'saddlebrown' => '139,69,19',
-            -
                    'salmon' => '250,128,114',
-            -
                    'sandybrown' => '244,164,96',
-            -
                    'seagreen' => '46,139,87',
-            -
                    'seashell' => '255,245,238',
-            -
                    'sienna' => '160,82,45',
-            -
                    'silver' => '192,192,192',
-            -
                    'skyblue' => '135,206,235',
-            -
                    'slateblue' => '106,90,205',
-            -
                    'slategray' => '112,128,144',
-            -
                    'slategrey' => '112,128,144',
-            -
                    'snow' => '255,250,250',
-            -
                    'springgreen' => '0,255,127',
-            -
                    'steelblue' => '70,130,180',
-            -
                    'tan' => '210,180,140',
-            -
                    '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',
-            -
                    'white' => '255,255,255',
-            -
                    'whitesmoke' => '245,245,245',
-            -
                    'yellow' => '255,255,0',
-            -
                    'yellowgreen' => '154,205,50'
-            -
                );
-            -
            }

assets/libraries/scssphp_legacy/src/Compiler.php DELETED Viewed

@@ -1,4924 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp;
-            -
-            -
            use Leafo\ScssPhp\Base\Range;
-            -
            use Leafo\ScssPhp\Block;
-            -
            use Leafo\ScssPhp\Colors;
-            -
            use Leafo\ScssPhp\Compiler\Environment;
-            -
            use Leafo\ScssPhp\Formatter\OutputBlock;
-            -
            use Leafo\ScssPhp\Node;
-            -
            use Leafo\ScssPhp\Type;
-            -
            use Leafo\ScssPhp\Parser;
-            -
            use Leafo\ScssPhp\Util;
-            -
-            -
            /**
-            -
             * The scss compiler and parser.
-            -
             *
-            -
             * Converting SCSS to CSS is a three stage process. The incoming file is parsed
-            -
             * by `Parser` into a syntax tree, then it is compiled into another tree
-            -
             * representing the CSS structure by `Compiler`. The CSS tree is fed into a
-            -
             * formatter, like `Formatter` which then outputs CSS as a string.
-            -
             *
-            -
             * During the first compile, all values are *reduced*, which means that their
-            -
             * types are brought to the lowest form before being dump as strings. This
-            -
             * handles math equations, variable dereferences, and the like.
-            -
             *
-            -
             * The `compile` function of `Compiler` is the entry point.
-            -
             *
-            -
             * In summary:
-            -
             *
-            -
             * The `Compiler` class creates an instance of the parser, feeds it SCSS code,
-            -
             * then transforms the resulting tree to a CSS tree. This class also holds the
-            -
             * evaluation context, such as all available mixins and variables at any given
-            -
             * time.
-            -
             *
-            -
             * The `Parser` class is only concerned with parsing its input.
-            -
             *
-            -
             * The `Formatter` takes a CSS tree, and dumps it to a formatted string,
-            -
             * handling things like indentation.
-            -
             */
-            -
-            -
            /**
-            -
             * SCSS compiler
-            -
             *
-            -
             * @author Leaf Corcoran <leafot@gmail.com>
-            -
             */
-            -
            class Compiler
-            -
            {
-            -
                const LINE_COMMENTS = 1;
-            -
                const DEBUG_INFO    = 2;
-            -
-            -
                const WITH_RULE     = 1;
-            -
                const WITH_MEDIA    = 2;
-            -
                const WITH_SUPPORTS = 4;
-            -
                const WITH_ALL      = 7;
-            -
-            -
                /**
-            -
                 * @var array
-            -
                 */
-            -
                static protected $operatorNames = array(
-            -
                    '+'   => 'add',
-            -
                    '-'   => 'sub',
-            -
                    '*'   => 'mul',
-            -
                    '/'   => 'div',
-            -
                    '%'   => 'mod',
-            -
-            -
                    '=='  => 'eq',
-            -
                    '!='  => 'neq',
-            -
                    '<'   => 'lt',
-            -
                    '>'   => 'gt',
-            -
-            -
                    '<='  => 'lte',
-            -
                    '>='  => 'gte',
-            -
                    '<=>' => 'cmp',
-            -
                );
-            -
-            -
                /**
-            -
                 * @var array
-            -
                 */
-            -
                static protected $namespaces = array(
-            -
                    'special'  => '%',
-            -
                    'mixin'    => '@',
-            -
                    'function' => '^',
-            -
                );
-            -
-            -
                static public $true = array(Type::T_KEYWORD, 'true');
-            -
                static public $false = array(Type::T_KEYWORD, 'false');
-            -
                static public $null = array(Type::T_NULL);
-            -
                static public $defaultValue = array(Type::T_KEYWORD, '');
-            -
                static public $selfSelector = array(Type::T_SELF);
-            -
                static public $emptyList = array(Type::T_LIST, '', array());
-            -
                static public $emptyMap = array(Type::T_MAP, array(), array());
-            -
                static public $emptyString = array(Type::T_STRING, '"', array());
-            -
                static public $with = array(Type::T_KEYWORD, 'with');
-            -
                static public $without = array(Type::T_KEYWORD, 'without');
-            -
-            -
                protected $importPaths = array('');
-            -
                protected $importCache = array();
-            -
                protected $userFunctions = array();
-            -
                protected $registeredVars = array();
-            -
                protected $registeredFeatures = array(
-            -
                    'extend-selector-pseudoclass' => false,
-            -
                    'at-error'                    => true,
-            -
                    'units-level-3'               => false,
-            -
                    'global-variable-shadowing'   => false,
-            -
                );
-            -
-            -
                protected $lineNumberStyle = null;
-            -
-            -
                protected $formatter = 'Leafo\ScssPhp\Formatter\Nested';
-            -
-            -
                protected $rootEnv;
-            -
                protected $rootBlock;
-            -
-            -
                private $indentLevel;
-            -
                private $commentsSeen;
-            -
                private $extends;
-            -
                private $extendsMap;
-            -
                private $parsedFiles;
-            -
                private $env;
-            -
                private $scope;
-            -
                private $parser;
-            -
                private $sourcePos;
-            -
                private $sourceParsers;
-            -
                private $sourceIndex;
-            -
                private $storeEnv;
-            -
                private $charsetSeen;
-            -
                private $stderr;
-            -
                private $shouldEvaluate;
-            -
-            -
                /**
-            -
                 * Compile scss
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string $code
-            -
                 * @param string $path
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                public function compile($code, $path = null)
-            -
                {
-            -
                    $locale = setlocale(LC_NUMERIC, 0);
-            -
                    setlocale(LC_NUMERIC, 'C');
-            -
-            -
                    $this->indentLevel   = -1;
-            -
                    $this->commentsSeen  = array();
-            -
                    $this->extends       = array();
-            -
                    $this->extendsMap    = array();
-            -
                    $this->parsedFiles   = array();
-            -
                    $this->sourceParsers = array();
-            -
                    $this->sourceIndex   = null;
-            -
                    $this->env           = null;
-            -
                    $this->scope         = null;
-            -
                    $this->storeEnv      = null;
-            -
                    $this->stderr        = fopen('php://stderr', 'w');
-            -
-            -
                    $this->parser = $this->parserFactory($path);
-            -
                    $tree = $this->parser->parse($code);
-            -
-            -
                    $this->formatter = new $this->formatter();
-            -
-            -
                    $this->rootEnv = $this->pushEnv($tree);
-            -
                    $this->injectVariables($this->registeredVars);
-            -
                    $this->compileRoot($tree);
-            -
                    $this->popEnv();
-            -
-            -
                    $out = $this->formatter->format($this->scope);
-            -
-            -
                    setlocale(LC_NUMERIC, $locale);
-            -
-            -
                    return $out;
-            -
                }
-            -
-            -
                /**
-            -
                 * Instantiate parser
-            -
                 *
-            -
                 * @param string $path
-            -
                 *
-            -
                 * @return \Leafo\ScssPhp\Parser
-            -
                 */
-            -
                private function parserFactory($path)
-            -
                {
-            -
                    $parser = new Parser($path, count($this->sourceParsers));
-            -
-            -
                    $this->sourceParsers[] = $parser;
-            -
                    $this->addParsedFile($path);
-            -
-            -
                    return $parser;
-            -
                }
-            -
-            -
                /**
-            -
                 * Is self extend?
-            -
                 *
-            -
                 * @param array $target
-            -
                 * @param array $origin
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function isSelfExtend($target, $origin)
-            -
                {
-            -
                    foreach ($origin as $sel) {
-            -
                        if (in_array($target, $sel)) {
-            -
                            return true;
-            -
                        }
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Push extends
-            -
                 *
-            -
                 * @param array $target
-            -
                 * @param array $origin
-            -
                 */
-            -
                protected function pushExtends($target, $origin)
-            -
                {
-            -
                    if ($this->isSelfExtend($target, $origin)) {
-            -
                        return;
-            -
                    }
-            -
-            -
                    $i = count($this->extends);
-            -
                    $this->extends[] = array($target, $origin);
-            -
-            -
                    foreach ($target as $part) {
-            -
                        if (isset($this->extendsMap[$part])) {
-            -
                            $this->extendsMap[$part][] = $i;
-            -
                        } else {
-            -
                            $this->extendsMap[$part] = array($i);
-            -
                        }
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Make output block
-            -
                 *
-            -
                 * @param string $type
-            -
                 * @param array  $selectors
-            -
                 *
-            -
                 * @return \Leafo\ScssPhp\Formatter\OutputBlock
-            -
                 */
-            -
                protected function makeOutputBlock($type, $selectors = null)
-            -
                {
-            -
                    $out = new OutputBlock;
-            -
                    $out->type      = $type;
-            -
                    $out->lines     = array();
-            -
                    $out->children  = array();
-            -
                    $out->parent    = $this->scope;
-            -
                    $out->selectors = $selectors;
-            -
                    $out->depth     = $this->env->depth;
-            -
-            -
                    return $out;
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile root
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Block $rootBlock
-            -
                 */
-            -
                protected function compileRoot(Block $rootBlock)
-            -
                {
-            -
                    $this->rootBlock = $this->scope = $this->makeOutputBlock(Type::T_ROOT);
-            -
-            -
                    $this->compileChildrenNoReturn($rootBlock->children, $this->scope);
-            -
                    $this->flattenSelectors($this->scope);
-            -
                }
-            -
-            -
                /**
-            -
                 * Flatten selectors
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Formatter\OutputBlock $block
-            -
                 * @param string                               $parentKey
-            -
                 */
-            -
                protected function flattenSelectors(OutputBlock $block, $parentKey = null)
-            -
                {
-            -
                    if ($block->selectors) {
-            -
                        $selectors = array();
-            -
-            -
                        foreach ($block->selectors as $s) {
-            -
                            $selectors[] = $s;
-            -
-            -
                            if (! is_array($s)) {
-            -
                                continue;
-            -
                            }
-            -
-            -
                            // check extends
-            -
                            if (! empty($this->extendsMap)) {
-            -
                                $this->matchExtends($s, $selectors);
-            -
-            -
                                // remove duplicates
-            -
                                array_walk($selectors, function (&$value) {
-            -
                                    $value = serialize($value);
-            -
                                });
-            -
-            -
                                $selectors = array_unique($selectors);
-            -
-            -
                                array_walk($selectors, function (&$value) {
-            -
                                    $value = unserialize($value);
-            -
                                });
-            -
                            }
-            -
                        }
-            -
-            -
                        $block->selectors = array();
-            -
                        $placeholderSelector = false;
-            -
-            -
                        foreach ($selectors as $selector) {
-            -
                            if ($this->hasSelectorPlaceholder($selector)) {
-            -
                                $placeholderSelector = true;
-            -
                                continue;
-            -
                            }
-            -
-            -
                            $block->selectors[] = $this->compileSelector($selector);
-            -
                        }
-            -
-            -
                        if ($placeholderSelector && 0 === count($block->selectors) && null !== $parentKey) {
-            -
                            unset($block->parent->children[$parentKey]);
-            -
-            -
                            return;
-            -
                        }
-            -
                    }
-            -
-            -
                    foreach ($block->children as $key => $child) {
-            -
                        $this->flattenSelectors($child, $key);
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Match extends
-            -
                 *
-            -
                 * @param array   $selector
-            -
                 * @param array   $out
-            -
                 * @param integer $from
-            -
                 * @param boolean $initial
-            -
                 */
-            -
                protected function matchExtends($selector, &$out, $from = 0, $initial = true)
-            -
                {
-            -
                    foreach ($selector as $i => $part) {
-            -
                        if ($i < $from) {
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if ($this->matchExtendsSingle($part, $origin)) {
-            -
                            $before = array_slice($selector, 0, $i);
-            -
                            $after = array_slice($selector, $i + 1);
-            -
                            $s = count($before);
-            -
-            -
                            foreach ($origin as $new) {
-            -
                                $k = 0;
-            -
-            -
                                // remove shared parts
-            -
                                if ($initial) {
-            -
                                    while ($k < $s && isset($new[$k]) && $before[$k] === $new[$k]) {
-            -
                                        $k++;
-            -
                                    }
-            -
                                }
-            -
-            -
                                $result = array_merge(
-            -
                                    $before,
-            -
                                    $k > 0 ? array_slice($new, $k) : $new,
-            -
                                    $after
-            -
                                );
-            -
-            -
                                if ($result === $selector) {
-            -
                                    continue;
-            -
                                }
-            -
-            -
                                $out[] = $result;
-            -
-            -
                                // recursively check for more matches
-            -
                                $this->matchExtends($result, $out, $i, false);
-            -
-            -
                                // selector sequence merging
-            -
                                if (! empty($before) && count($new) > 1) {
-            -
                                    $result2 = array_merge(
-            -
                                        array_slice($new, 0, -1),
-            -
                                        $k > 0 ? array_slice($before, $k) : $before,
-            -
                                        array_slice($new, -1),
-            -
                                        $after
-            -
                                    );
-            -
-            -
                                    $out[] = $result2;
-            -
                                }
-            -
                            }
-            -
                        }
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Match extends single
-            -
                 *
-            -
                 * @param array $rawSingle
-            -
                 * @param array $outOrigin
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function matchExtendsSingle($rawSingle, &$outOrigin)
-            -
                {
-            -
                    $counts = array();
-            -
                    $single = array();
-            -
-            -
                    foreach ($rawSingle as $part) {
-            -
                        // matches Number
-            -
                        if (! is_string($part)) {
-            -
                            return false;
-            -
                        }
-            -
-            -
                        if (! preg_match('/^[\[.:#%]/', $part) && count($single)) {
-            -
                            $single[count($single) - 1] .= $part;
-            -
                        } else {
-            -
                            $single[] = $part;
-            -
                        }
-            -
                    }
-            -
-            -
                    foreach ($single as $part) {
-            -
                        if (isset($this->extendsMap[$part])) {
-            -
                            foreach ($this->extendsMap[$part] as $idx) {
-            -
                                $counts[$idx] = isset($counts[$idx]) ? $counts[$idx] + 1 : 1;
-            -
                            }
-            -
                        }
-            -
                    }
-            -
-            -
                    $outOrigin = array();
-            -
                    $found = false;
-            -
-            -
                    foreach ($counts as $idx => $count) {
-            -
                        list($target, $origin) = $this->extends[$idx];
-            -
-            -
                        // check count
-            -
                        if ($count !== count($target)) {
-            -
                            continue;
-            -
                        }
-            -
-            -
                        $rem = array_diff($single, $target);
-            -
-            -
                        foreach ($origin as $j => $new) {
-            -
                            // prevent infinite loop when target extends itself
-            -
                            if ($this->isSelfExtend($single, $origin)) {
-            -
                                return false;
-            -
                            }
-            -
-            -
                            $origin[$j][count($origin[$j]) - 1] = $this->combineSelectorSingle(end($new), $rem);
-            -
                        }
-            -
-            -
                        $outOrigin = array_merge($outOrigin, $origin);
-            -
-            -
                        $found = true;
-            -
                    }
-            -
-            -
                    return $found;
-            -
                }
-            -
-            -
                /**
-            -
                 * Combine selector single
-            -
                 *
-            -
                 * @param array $base
-            -
                 * @param array $other
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function combineSelectorSingle($base, $other)
-            -
                {
-            -
                    $tag = null;
-            -
                    $out = array();
-            -
-            -
                    foreach (array($base, $other) as $single) {
-            -
                        foreach ($single as $part) {
-            -
                            if (preg_match('/^[^\[.#:]/', $part)) {
-            -
                                $tag = $part;
-            -
                            } else {
-            -
                                $out[] = $part;
-            -
                            }
-            -
                        }
-            -
                    }
-            -
-            -
                    if ($tag) {
-            -
                        array_unshift($out, $tag);
-            -
                    }
-            -
-            -
                    return $out;
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile media
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Block $media
-            -
                 */
-            -
                protected function compileMedia(Block $media)
-            -
                {
-            -
                    $this->pushEnv($media);
-            -
-            -
                    $mediaQuery = $this->compileMediaQuery($this->multiplyMedia($this->env));
-            -
-            -
                    if (! empty($mediaQuery)) {
-            -
                        $this->scope = $this->makeOutputBlock(Type::T_MEDIA, array($mediaQuery));
-            -
-            -
                        $parentScope = $this->mediaParent($this->scope);
-            -
                        $parentScope->children[] = $this->scope;
-            -
-            -
                        // top level properties in a media cause it to be wrapped
-            -
                        $needsWrap = false;
-            -
-            -
                        foreach ($media->children as $child) {
-            -
                            $type = $child[0];
-            -
-            -
                            if ($type !== Type::T_BLOCK &&
-            -
                                $type !== Type::T_MEDIA &&
-            -
                                $type !== Type::T_DIRECTIVE &&
-            -
                                $type !== Type::T_IMPORT
-            -
                            ) {
-            -
                                $needsWrap = true;
-            -
                                break;
-            -
                            }
-            -
                        }
-            -
-            -
                        if ($needsWrap) {
-            -
                            $wrapped = new Block;
-            -
                            $wrapped->selectors = array();
-            -
                            $wrapped->children  = $media->children;
-            -
-            -
                            $media->children = array(array(Type::T_BLOCK, $wrapped));
-            -
                        }
-            -
-            -
                        $this->compileChildrenNoReturn($media->children, $this->scope);
-            -
-            -
                        $this->scope = $this->scope->parent;
-            -
                    }
-            -
-            -
                    $this->popEnv();
-            -
                }
-            -
-            -
                /**
-            -
                 * Media parent
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Formatter\OutputBlock $scope
-            -
                 *
-            -
                 * @return \Leafo\ScssPhp\Formatter\OutputBlock
-            -
                 */
-            -
                protected function mediaParent(OutputBlock $scope)
-            -
                {
-            -
                    while (! empty($scope->parent)) {
-            -
                        if (! empty($scope->type) && $scope->type !== Type::T_MEDIA) {
-            -
                            break;
-            -
                        }
-            -
-            -
                        $scope = $scope->parent;
-            -
                    }
-            -
-            -
                    return $scope;
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile directive
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Block $block
-            -
                 */
-            -
                protected function compileDirective(Block $block)
-            -
                {
-            -
                    $s = '@' . $block->name;
-            -
-            -
                    if (! empty($block->value)) {
-            -
                        $s .= ' ' . $this->compileValue($block->value);
-            -
                    }
-            -
-            -
                    if ($block->name === 'keyframes' || substr($block->name, -10) === '-keyframes') {
-            -
                        $this->compileKeyframeBlock($block, array($s));
-            -
                    } else {
-            -
                        $this->compileNestedBlock($block, array($s));
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile at-root
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Block $block
-            -
                 */
-            -
                protected function compileAtRoot(Block $block)
-            -
                {
-            -
                    $env     = $this->pushEnv($block);
-            -
                    $envs    = $this->compactEnv($env);
-            -
                    $without = isset($block->with) ? $this->compileWith($block->with) : self::WITH_RULE;
-            -
-            -
                    // wrap inline selector
-            -
                    if ($block->selector) {
-            -
                        $wrapped = new Block;
-            -
                        $wrapped->parent         = $block;
-            -
                        $wrapped->sourcePosition = $block->sourcePosition;
-            -
                        $wrapped->sourceIndex    = $block->sourceIndex;
-            -
                        $wrapped->selectors      = $block->selector;
-            -
                        $wrapped->comments       = array();
-            -
                        $wrapped->children       = $block->children;
-            -
-            -
                        $block->children = array(array(Type::T_BLOCK, $wrapped));
-            -
                    }
-            -
-            -
                    $this->env = $this->filterWithout($envs, $without);
-            -
                    $newBlock  = $this->spliceTree($envs, $block, $without);
-            -
-            -
                    $saveScope   = $this->scope;
-            -
                    $this->scope = $this->rootBlock;
-            -
-            -
                    $this->compileChild($newBlock, $this->scope);
-            -
-            -
                    $this->scope = $saveScope;
-            -
                    $this->env   = $this->extractEnv($envs);
-            -
-            -
                    $this->popEnv();
-            -
                }
-            -
-            -
                /**
-            -
                 * Splice parse tree
-            -
                 *
-            -
                 * @param array                $envs
-            -
                 * @param \Leafo\ScssPhp\Block $block
-            -
                 * @param integer              $without
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                private function spliceTree($envs, Block $block, $without)
-            -
                {
-            -
                    $newBlock = null;
-            -
-            -
                    foreach ($envs as $e) {
-            -
                        if (! isset($e->block)) {
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if (isset($e->block) && $e->block === $block) {
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if (isset($e->block->type) && $e->block->type === Type::T_AT_ROOT) {
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if (($without & self::WITH_RULE) && isset($e->block->selectors)) {
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if (($without & self::WITH_MEDIA) &&
-            -
                            isset($e->block->type) && $e->block->type === Type::T_MEDIA
-            -
                        ) {
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if (($without & self::WITH_SUPPORTS) &&
-            -
                            isset($e->block->type) && $e->block->type === Type::T_DIRECTIVE &&
-            -
                            isset($e->block->name) && $e->block->name === 'supports'
-            -
                        ) {
-            -
                            continue;
-            -
                        }
-            -
-            -
                        $b = new Block;
-            -
-            -
                        if (isset($e->block->sourcePosition)) {
-            -
                            $b->sourcePosition = $e->block->sourcePosition;
-            -
                        }
-            -
-            -
                        if (isset($e->block->sourceIndex)) {
-            -
                            $b->sourceIndex = $e->block->sourceIndex;
-            -
                        }
-            -
-            -
                        $b->selectors = array();
-            -
-            -
                        if (isset($e->block->comments)) {
-            -
                            $b->comments = $e->block->comments;
-            -
                        }
-            -
-            -
                        if (isset($e->block->type)) {
-            -
                            $b->type = $e->block->type;
-            -
                        }
-            -
-            -
                        if (isset($e->block->name)) {
-            -
                            $b->name = $e->block->name;
-            -
                        }
-            -
-            -
                        if (isset($e->block->queryList)) {
-            -
                            $b->queryList = $e->block->queryList;
-            -
                        }
-            -
-            -
                        if (isset($e->block->value)) {
-            -
                            $b->value = $e->block->value;
-            -
                        }
-            -
-            -
                        if ($newBlock) {
-            -
                            $type = isset($newBlock->type) ? $newBlock->type : Type::T_BLOCK;
-            -
-            -
                            $b->children = array(array($type, $newBlock));
-            -
-            -
                            $newBlock->parent = $b;
-            -
                        } elseif (count($block->children)) {
-            -
                            foreach ($block->children as $child) {
-            -
                                if ($child[0] === Type::T_BLOCK) {
-            -
                                    $child[1]->parent = $b;
-            -
                                }
-            -
                            }
-            -
-            -
                            $b->children = $block->children;
-            -
                        }
-            -
-            -
                        $b->parent = null;
-            -
-            -
                        $newBlock = $b;
-            -
                    }
-            -
-            -
                    $type = isset($newBlock->type) ? $newBlock->type : Type::T_BLOCK;
-            -
-            -
                    return array($type, $newBlock);
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile @at-root's with: inclusion / without: exclusion into filter flags
-            -
                 *
-            -
                 * @param array $with
-            -
                 *
-            -
                 * @return integer
-            -
                 */
-            -
                private function compileWith($with)
-            -
                {
-            -
                    static $mapping = array(
-            -
                        'rule'     => self::WITH_RULE,
-            -
                        'media'    => self::WITH_MEDIA,
-            -
                        'supports' => self::WITH_SUPPORTS,
-            -
                        'all'      => self::WITH_ALL,
-            -
                    );
-            -
-            -
                    // exclude selectors by default
-            -
                    $without = self::WITH_RULE;
-            -
-            -
                    if ($this->libMapHasKey(array($with, self::$with))) {
-            -
                        $without = self::WITH_ALL;
-            -
-            -
                        $list = $this->coerceList($this->libMapGet(array($with, self::$with)));
-            -
-            -
                        foreach ($list[2] as $item) {
-            -
                            $keyword = $this->compileStringContent($this->coerceString($item));
-            -
-            -
                            if (array_key_exists($keyword, $mapping)) {
-            -
                                $without &= ~($mapping[$keyword]);
-            -
                            }
-            -
                        }
-            -
                    }
-            -
-            -
                    if ($this->libMapHasKey(array($with, self::$without))) {
-            -
                        $without = 0;
-            -
-            -
                        $list = $this->coerceList($this->libMapGet(array($with, self::$without)));
-            -
-            -
                        foreach ($list[2] as $item) {
-            -
                            $keyword = $this->compileStringContent($this->coerceString($item));
-            -
-            -
                            if (array_key_exists($keyword, $mapping)) {
-            -
                                $without |= $mapping[$keyword];
-            -
                            }
-            -
                        }
-            -
                    }
-            -
-            -
                    return $without;
-            -
                }
-            -
-            -
                /**
-            -
                 * Filter env stack
-            -
                 *
-            -
                 * @param array   $envs
-            -
                 * @param integer $without
-            -
                 *
-            -
                 * @return \Leafo\ScssPhp\Compiler\Environment
-            -
                 */
-            -
                private function filterWithout($envs, $without)
-            -
                {
-            -
                    $filtered = array();
-            -
-            -
                    foreach ($envs as $e) {
-            -
                        if (($without & self::WITH_RULE) && isset($e->block->selectors)) {
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if (($without & self::WITH_MEDIA) &&
-            -
                            isset($e->block->type) && $e->block->type === Type::T_MEDIA
-            -
                        ) {
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if (($without & self::WITH_SUPPORTS) &&
-            -
                            isset($e->block->type) && $e->block->type === Type::T_DIRECTIVE &&
-            -
                            isset($e->block->name) && $e->block->name === 'supports'
-            -
                        ) {
-            -
                            continue;
-            -
                        }
-            -
-            -
                        $filtered[] = $e;
-            -
                    }
-            -
-            -
                    return $this->extractEnv($filtered);
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile keyframe block
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Block $block
-            -
                 * @param array                $selectors
-            -
                 */
-            -
                protected function compileKeyframeBlock(Block $block, $selectors)
-            -
                {
-            -
                    $env = $this->pushEnv($block);
-            -
-            -
                    $envs = $this->compactEnv($env);
-            -
-            -
                    $this->env = $this->extractEnv(array_filter($envs, function ($e) {
-            -
                        return ! isset($e->block->selectors);
-            -
                    }));
-            -
-            -
                    $this->scope = $this->makeOutputBlock($block->type, $selectors);
-            -
                    $this->scope->depth = 1;
-            -
                    $this->scope->parent->children[] = $this->scope;
-            -
-            -
                    $this->compileChildrenNoReturn($block->children, $this->scope);
-            -
-            -
                    $this->scope = $this->scope->parent;
-            -
                    $this->env   = $this->extractEnv($envs);
-            -
-            -
                    $this->popEnv();
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile nested block
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Block $block
-            -
                 * @param array                $selectors
-            -
                 */
-            -
                protected function compileNestedBlock(Block $block, $selectors)
-            -
                {
-            -
                    $this->pushEnv($block);
-            -
-            -
                    $this->scope = $this->makeOutputBlock($block->type, $selectors);
-            -
                    $this->scope->parent->children[] = $this->scope;
-            -
-            -
                    $this->compileChildrenNoReturn($block->children, $this->scope);
-            -
-            -
                    $this->scope = $this->scope->parent;
-            -
-            -
                    $this->popEnv();
-            -
                }
-            -
-            -
                /**
-            -
                 * Recursively compiles a block.
-            -
                 *
-            -
                 * A block is analogous to a CSS block in most cases. A single SCSS document
-            -
                 * is encapsulated in a block when parsed, but it does not have parent tags
-            -
                 * so all of its children appear on the root level when compiled.
-            -
                 *
-            -
                 * Blocks are made up of selectors and children.
-            -
                 *
-            -
                 * The children of a block are just all the blocks that are defined within.
-            -
                 *
-            -
                 * Compiling the block involves pushing a fresh environment on the stack,
-            -
                 * and iterating through the props, compiling each one.
-            -
                 *
-            -
                 * @see Compiler::compileChild()
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Block $block
-            -
                 */
-            -
                protected function compileBlock(Block $block)
-            -
                {
-            -
                    $env = $this->pushEnv($block);
-            -
                    $env->selectors = $this->evalSelectors($block->selectors);
-            -
-            -
                    $out = $this->makeOutputBlock(null);
-            -
-            -
                    if (isset($this->lineNumberStyle) && count($env->selectors) && count($block->children)) {
-            -
                        $annotation = $this->makeOutputBlock(Type::T_COMMENT);
-            -
                        $annotation->depth = 0;
-            -
-            -
                        $parser = $this->sourceParsers[$block->sourceIndex];
-            -
                        $file = $parser->getSourceName();
-            -
                        $line = $parser->getLineNo($block->sourcePosition);
-            -
-            -
                        switch ($this->lineNumberStyle) {
-            -
                            case self::LINE_COMMENTS:
-            -
                                $annotation->lines[] = '/* line ' . $line . ', ' . $file . ' */';
-            -
                                break;
-            -
-            -
                            case self::DEBUG_INFO:
-            -
                                $annotation->lines[] = '@media -sass-debug-info{filename{font-family:"' . $file
-            -
                                                     . '"}line{font-family:' . $line . '}}';
-            -
                                break;
-            -
                        }
-            -
-            -
                        $this->scope->children[] = $annotation;
-            -
                    }
-            -
-            -
                    $this->scope->children[] = $out;
-            -
-            -
                    if (count($block->children)) {
-            -
                        $out->selectors = $this->multiplySelectors($env);
-            -
-            -
                        $this->compileChildrenNoReturn($block->children, $out);
-            -
                    }
-            -
-            -
                    $this->formatter->stripSemicolon($out->lines);
-            -
-            -
                    $this->popEnv();
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile root level comment
-            -
                 *
-            -
                 * @param array $block
-            -
                 */
-            -
                protected function compileComment($block)
-            -
                {
-            -
                    $out = $this->makeOutputBlock(Type::T_COMMENT);
-            -
                    $out->lines[] = $block[1];
-            -
                    $this->scope->children[] = $out;
-            -
                }
-            -
-            -
                /**
-            -
                 * Evaluate selectors
-            -
                 *
-            -
                 * @param array $selectors
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function evalSelectors($selectors)
-            -
                {
-            -
                    $this->shouldEvaluate = false;
-            -
-            -
                    $selectors = array_map(array($this, 'evalSelector'), $selectors);
-            -
-            -
                    // after evaluating interpolates, we might need a second pass
-            -
                    if ($this->shouldEvaluate) {
-            -
                        $buffer = $this->collapseSelectors($selectors);
-            -
                        $parser = $this->parserFactory(__METHOD__);
-            -
-            -
                        if ($parser->parseSelector($buffer, $newSelectors)) {
-            -
                            $selectors = array_map(array($this, 'evalSelector'), $newSelectors);
-            -
                        }
-            -
                    }
-            -
-            -
                    return $selectors;
-            -
                }
-            -
-            -
                /**
-            -
                 * Evaluate selector
-            -
                 *
-            -
                 * @param array $selector
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function evalSelector($selector)
-            -
                {
-            -
                    return array_map(array($this, 'evalSelectorPart'), $selector);
-            -
                }
-            -
-            -
                /**
-            -
                 * Evaluate selector part; replaces all the interpolates, stripping quotes
-            -
                 *
-            -
                 * @param array $part
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function evalSelectorPart($part)
-            -
                {
-            -
                    foreach ($part as &$p) {
-            -
                        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 &&
-            -
                            ($first = $p[0]) && ($first === '"' || $first === "'") &&
-            -
                            substr($p, -1) === $first
-            -
                        ) {
-            -
                            $p = substr($p, 1, -1);
-            -
                        }
-            -
                    }
-            -
-            -
                    return $this->flattenSelectorSingle($part);
-            -
                }
-            -
-            -
                /**
-            -
                 * Collapse selectors
-            -
                 *
-            -
                 * @param array $selectors
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                protected function collapseSelectors($selectors)
-            -
                {
-            -
                    $parts = array();
-            -
-            -
                    foreach ($selectors as $selector) {
-            -
                        $output = '';
-            -
-            -
                        array_walk_recursive(
-            -
                            $selector,
-            -
                            function ($value, $key) use (&$output) {
-            -
                                $output .= $value;
-            -
                            }
-            -
                        );
-            -
-            -
                        $parts[] = $output;
-            -
                    }
-            -
-            -
                    return implode(', ', $parts);
-            -
                }
-            -
-            -
                /**
-            -
                 * Flatten selector single; joins together .classes and #ids
-            -
                 *
-            -
                 * @param array $single
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function flattenSelectorSingle($single)
-            -
                {
-            -
                    $joined = array();
-            -
-            -
                    foreach ($single as $part) {
-            -
                        if (empty($joined) ||
-            -
                            ! is_string($part) ||
-            -
                            preg_match('/[\[.:#%]/', $part)
-            -
                        ) {
-            -
                            $joined[] = $part;
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if (is_array(end($joined))) {
-            -
                            $joined[] = $part;
-            -
                        } else {
-            -
                            $joined[count($joined) - 1] .= $part;
-            -
                        }
-            -
                    }
-            -
-            -
                    return $joined;
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile selector to string; self(&) should have been replaced by now
-            -
                 *
-            -
                 * @param array $selector
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                protected function compileSelector($selector)
-            -
                {
-            -
                    if (! is_array($selector)) {
-            -
                        return $selector; // media and the like
-            -
                    }
-            -
-            -
                    return implode(
-            -
                        ' ',
-            -
                        array_map(
-            -
                            array($this, 'compileSelectorPart'),
-            -
                            $selector
-            -
                        )
-            -
                    );
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile selector part
-            -
                 *
-            -
                 * @param arary $piece
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                protected function compileSelectorPart($piece)
-            -
                {
-            -
                    foreach ($piece as &$p) {
-            -
                        if (! is_array($p)) {
-            -
                            continue;
-            -
                        }
-            -
-            -
                        switch ($p[0]) {
-            -
                            case Type::T_SELF:
-            -
                                $p = '&';
-            -
                                break;
-            -
-            -
                            default:
-            -
                                $p = $this->compileValue($p);
-            -
                                break;
-            -
                        }
-            -
                    }
-            -
-            -
                    return implode($piece);
-            -
                }
-            -
-            -
                /**
-            -
                 * Has selector placeholder?
-            -
                 *
-            -
                 * @param array $selector
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function hasSelectorPlaceholder($selector)
-            -
                {
-            -
                    if (! is_array($selector)) {
-            -
                        return false;
-            -
                    }
-            -
-            -
                    foreach ($selector as $parts) {
-            -
                        foreach ($parts as $part) {
-            -
                            if ('%' === $part[0]) {
-            -
                                return true;
-            -
                            }
-            -
                        }
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile children and return result
-            -
                 *
-            -
                 * @param array                                $stms
-            -
                 * @param \Leafo\ScssPhp\Formatter\OutputBlock $out
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function compileChildren($stms, OutputBlock $out)
-            -
                {
-            -
                    foreach ($stms as $stm) {
-            -
                        $ret = $this->compileChild($stm, $out);
-            -
-            -
                        if (isset($ret)) {
-            -
                            return $ret;
-            -
                        }
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile children and throw exception if unexpected @return
-            -
                 *
-            -
                 * @param array                                $stms
-            -
                 * @param \Leafo\ScssPhp\Formatter\OutputBlock $out
-            -
                 *
-            -
                 * @throws \Exception
-            -
                 */
-            -
                protected function compileChildrenNoReturn($stms, OutputBlock $out)
-            -
                {
-            -
                    foreach ($stms as $stm) {
-            -
                        $ret = $this->compileChild($stm, $out);
-            -
-            -
                        if (isset($ret)) {
-            -
                            $this->throwError('@return may only be used within a function');
-            -
                        }
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile media query
-            -
                 *
-            -
                 * @param array $queryList
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                protected function compileMediaQuery($queryList)
-            -
                {
-            -
                    $out = '@media';
-            -
                    $first = true;
-            -
-            -
                    foreach ($queryList as $query) {
-            -
                        $type = null;
-            -
                        $parts = array();
-            -
-            -
                        foreach ($query as $q) {
-            -
                            switch ($q[0]) {
-            -
                                case Type::T_MEDIA_TYPE:
-            -
                                    if ($type) {
-            -
                                        $type = $this->mergeMediaTypes(
-            -
                                            $type,
-            -
                                            array_map(array($this, 'compileValue'), array_slice($q, 1))
-            -
                                        );
-            -
-            -
                                        if (empty($type)) { // merge failed
-            -
                                            return null;
-            -
                                        }
-            -
                                    } else {
-            -
                                        $type = array_map(array($this, 'compileValue'), array_slice($q, 1));
-            -
                                    }
-            -
                                    break;
-            -
-            -
                                case Type::T_MEDIA_EXPRESSION:
-            -
                                    if (isset($q[2])) {
-            -
                                        $parts[] = '('
-            -
                                            . $this->compileValue($q[1])
-            -
                                            . $this->formatter->assignSeparator
-            -
                                            . $this->compileValue($q[2])
-            -
                                            . ')';
-            -
                                    } else {
-            -
                                        $parts[] = '('
-            -
                                            . $this->compileValue($q[1])
-            -
                                            . ')';
-            -
                                    }
-            -
                                    break;
-            -
-            -
                                case Type::T_MEDIA_VALUE:
-            -
                                    $parts[] = $this->compileValue($q[1]);
-            -
                                    break;
-            -
                            }
-            -
                        }
-            -
-            -
                        if ($type) {
-            -
                            array_unshift($parts, implode(' ', array_filter($type)));
-            -
                        }
-            -
-            -
                        if (! empty($parts)) {
-            -
                            if ($first) {
-            -
                                $first = false;
-            -
                                $out .= ' ';
-            -
                            } else {
-            -
                                $out .= $this->formatter->tagSeparator;
-            -
                            }
-            -
-            -
                            $out .= implode(' and ', $parts);
-            -
                        }
-            -
                    }
-            -
-            -
                    return $out;
-            -
                }
-            -
-            -
                /**
-            -
                 * Merge media types
-            -
                 *
-            -
                 * @param array $type1
-            -
                 * @param array $type2
-            -
                 *
-            -
                 * @return array|null
-            -
                 */
-            -
                protected function mergeMediaTypes($type1, $type2)
-            -
                {
-            -
                    if (empty($type1)) {
-            -
                        return $type2;
-            -
                    }
-            -
-            -
                    if (empty($type2)) {
-            -
                        return $type1;
-            -
                    }
-            -
-            -
                    $m1 = '';
-            -
                    $t1 = '';
-            -
-            -
                    if (count($type1) > 1) {
-            -
                        $m1= strtolower($type1[0]);
-            -
                        $t1= strtolower($type1[1]);
-            -
                    } else {
-            -
                        $t1 = strtolower($type1[0]);
-            -
                    }
-            -
-            -
                    $m2 = '';
-            -
                    $t2 = '';
-            -
-            -
                    if (count($type2) > 1) {
-            -
                        $m2 = strtolower($type2[0]);
-            -
                        $t2 = strtolower($type2[1]);
-            -
                    } else {
-            -
                        $t2 = strtolower($type2[0]);
-            -
                    }
-            -
-            -
                    if (($m1 === Type::T_NOT) ^ ($m2 === Type::T_NOT)) {
-            -
                        if ($t1 === $t2) {
-            -
                            return null;
-            -
                        }
-            -
-            -
                        return array(
-            -
                            $m1 === Type::T_NOT ? $m2 : $m1,
-            -
                            $m1 === Type::T_NOT ? $t2 : $t1,
-            -
                        );
-            -
                    }
-            -
-            -
                    if ($m1 === Type::T_NOT && $m2 === Type::T_NOT) {
-            -
                        // CSS has no way of representing "neither screen nor print"
-            -
                        if ($t1 !== $t2) {
-            -
                            return null;
-            -
                        }
-            -
-            -
                        return array(Type::T_NOT, $t1);
-            -
                    }
-            -
-            -
                    if ($t1 !== $t2) {
-            -
                        return null;
-            -
                    }
-            -
-            -
                    // t1 == t2, neither m1 nor m2 are "not"
-            -
                    return array(empty($m1)? $m2 : $m1, $t1);
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile import; returns true if the value was something that could be imported
-            -
                 *
-            -
                 * @param array $rawPath
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function compileImport($rawPath, $out)
-            -
                {
-            -
                    if ($rawPath[0] === Type::T_STRING) {
-            -
                        $path = $this->compileStringContent($rawPath);
-            -
-            -
                        if ($path = $this->findImport($path)) {
-            -
                            $this->importFile($path, $out);
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        return false;
-            -
                    }
-            -
-            -
                    if ($rawPath[0] === Type::T_LIST) {
-            -
                        // handle a list of strings
-            -
                        if (count($rawPath[2]) === 0) {
-            -
                            return false;
-            -
                        }
-            -
-            -
                        foreach ($rawPath[2] as $path) {
-            -
                            if ($path[0] !== Type::T_STRING) {
-            -
                                return false;
-            -
                            }
-            -
                        }
-            -
-            -
                        foreach ($rawPath[2] as $path) {
-            -
                            $this->compileImport($path, $out);
-            -
                        }
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile child; returns a value to halt execution
-            -
                 *
-            -
                 * @param array                                $child
-            -
                 * @param \Leafo\ScssPhp\Formatter\OutputBlock $out
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function compileChild($child, OutputBlock $out)
-            -
                {
-            -
                    $this->sourceIndex = isset($child[Parser::SOURCE_INDEX]) ? $child[Parser::SOURCE_INDEX] : null;
-            -
                    $this->sourcePos = isset($child[Parser::SOURCE_POSITION]) ? $child[Parser::SOURCE_POSITION] : -1;
-            -
-            -
                    switch ($child[0]) {
-            -
                        case Type::T_IMPORT:
-            -
                            list(, $rawPath) = $child;
-            -
-            -
                            $rawPath = $this->reduce($rawPath);
-            -
-            -
                            if (! $this->compileImport($rawPath, $out)) {
-            -
                                $out->lines[] = '@import ' . $this->compileValue($rawPath) . ';';
-            -
                            }
-            -
                            break;
-            -
-            -
                        case Type::T_DIRECTIVE:
-            -
                            $this->compileDirective($child[1]);
-            -
                            break;
-            -
-            -
                        case Type::T_AT_ROOT:
-            -
                            $this->compileAtRoot($child[1]);
-            -
                            break;
-            -
-            -
                        case Type::T_MEDIA:
-            -
                            $this->compileMedia($child[1]);
-            -
                            break;
-            -
-            -
                        case Type::T_BLOCK:
-            -
                            $this->compileBlock($child[1]);
-            -
                            break;
-            -
-            -
                        case Type::T_CHARSET:
-            -
                            if (! $this->charsetSeen) {
-            -
                                $this->charsetSeen = true;
-            -
-            -
                                $out->lines[] = '@charset ' . $this->compileValue($child[1]) . ';';
-            -
                            }
-            -
                            break;
-            -
-            -
                        case Type::T_ASSIGN:
-            -
                            list(, $name, $value) = $child;
-            -
-            -
                            if ($name[0] === Type::T_VARIABLE) {
-            -
                                $flag = isset($child[3]) ? $child[3] : null;
-            -
                                $isDefault = $flag === '!default';
-            -
                                $isGlobal = $flag === '!global';
-            -
-            -
                                if ($isGlobal) {
-            -
                                    $this->set($name[1], $this->reduce($value), false, $this->rootEnv);
-            -
                                    break;
-            -
                                }
-            -
-            -
                                $shouldSet = $isDefault &&
-            -
                                    (($result = $this->get($name[1], false)) === null
-            -
                                    || $result === self::$null);
-            -
-            -
                                if (! $isDefault || $shouldSet) {
-            -
                                    $this->set($name[1], $this->reduce($value));
-            -
                                }
-            -
                                break;
-            -
                            }
-            -
-            -
                            $compiledName = $this->compileValue($name);
-            -
-            -
                            // handle shorthand syntax: size / line-height
-            -
                            if ($compiledName === 'font') {
-            -
                                if ($value[0] === Type::T_EXPRESSION && $value[1] === '/') {
-            -
                                    $value = $this->expToString($value);
-            -
                                } elseif ($value[0] === Type::T_LIST) {
-            -
                                    foreach ($value[2] as &$item) {
-            -
                                        if ($item[0] === Type::T_EXPRESSION && $item[1] === '/') {
-            -
                                            $item = $this->expToString($item);
-            -
                                        }
-            -
                                    }
-            -
                                }
-            -
                            }
-            -
-            -
                            // 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) {
-            -
                                    break;
-            -
                                }
-            -
                            }
-            -
-            -
                            $compiledValue = $this->compileValue($value);
-            -
-            -
                            $out->lines[] = $this->formatter->property(
-            -
                                $compiledName,
-            -
                                $compiledValue
-            -
                            );
-            -
                            break;
-            -
-            -
                        case Type::T_COMMENT:
-            -
                            if ($out->type === Type::T_ROOT) {
-            -
                                $this->compileComment($child);
-            -
                                break;
-            -
                            }
-            -
-            -
                            $out->lines[] = $child[1];
-            -
                            break;
-            -
-            -
                        case Type::T_MIXIN:
-            -
                        case Type::T_FUNCTION:
-            -
                            list(, $block) = $child;
-            -
-            -
                            $this->set(self::$namespaces[$block->type] . $block->name, $block);
-            -
                            break;
-            -
-            -
                        case Type::T_EXTEND:
-            -
                            list(, $selectors) = $child;
-            -
-            -
                            foreach ($selectors as $sel) {
-            -
                                $results = $this->evalSelectors(array($sel));
-            -
-            -
                                foreach ($results as $result) {
-            -
                                    // only use the first one
-            -
                                    $result = current($result);
-            -
-            -
                                    $this->pushExtends($result, $out->selectors);
-            -
                                }
-            -
                            }
-            -
                            break;
-            -
-            -
                        case Type::T_IF:
-            -
                            list(, $if) = $child;
-            -
-            -
                            if ($this->isTruthy($this->reduce($if->cond, true))) {
-            -
                                return $this->compileChildren($if->children, $out);
-            -
                            }
-            -
-            -
                            foreach ($if->cases as $case) {
-            -
                                if ($case->type === Type::T_ELSE ||
-            -
                                    $case->type === Type::T_ELSEIF && $this->isTruthy($this->reduce($case->cond))
-            -
                                ) {
-            -
                                    return $this->compileChildren($case->children, $out);
-            -
                                }
-            -
                            }
-            -
                            break;
-            -
-            -
                        case Type::T_EACH:
-            -
                            list(, $each) = $child;
-            -
-            -
                            $list = $this->coerceList($this->reduce($each->list));
-            -
-            -
                            $this->pushEnv();
-            -
-            -
                            foreach ($list[2] as $item) {
-            -
                                if (count($each->vars) === 1) {
-            -
                                    $this->set($each->vars[0], $item, true);
-            -
                                } else {
-            -
                                    list(,, $values) = $this->coerceList($item);
-            -
-            -
                                    foreach ($each->vars as $i => $var) {
-            -
                                        $this->set($var, isset($values[$i]) ? $values[$i] : self::$null, true);
-            -
                                    }
-            -
                                }
-            -
-            -
                                $ret = $this->compileChildren($each->children, $out);
-            -
-            -
                                if ($ret) {
-            -
                                    if ($ret[0] !== Type::T_CONTROL) {
-            -
                                        $this->popEnv();
-            -
-            -
                                        return $ret;
-            -
                                    }
-            -
-            -
                                    if ($ret[1]) {
-            -
                                        break;
-            -
                                    }
-            -
                                }
-            -
                            }
-            -
-            -
                            $this->popEnv();
-            -
                            break;
-            -
-            -
                        case Type::T_WHILE:
-            -
                            list(, $while) = $child;
-            -
-            -
                            while ($this->isTruthy($this->reduce($while->cond, true))) {
-            -
                                $ret = $this->compileChildren($while->children, $out);
-            -
-            -
                                if ($ret) {
-            -
                                    if ($ret[0] !== Type::T_CONTROL) {
-            -
                                        return $ret;
-            -
                                    }
-            -
-            -
                                    if ($ret[1]) {
-            -
                                        break;
-            -
                                    }
-            -
                                }
-            -
                            }
-            -
                            break;
-            -
-            -
                        case Type::T_FOR:
-            -
                            list(, $for) = $child;
-            -
-            -
                            $start = $this->reduce($for->start, true);
-            -
                            $start = $start[1];
-            -
                            $end = $this->reduce($for->end, true);
-            -
                            $end = $end[1];
-            -
                            $d = $start < $end ? 1 : -1;
-            -
-            -
                            while (true) {
-            -
                                if ((! $for->until && $start - $d == $end) ||
-            -
                                    ($for->until && $start == $end)
-            -
                                ) {
-            -
                                    break;
-            -
                                }
-            -
-            -
                                $this->set($for->var, new Node\Number($start, ''));
-            -
                                $start += $d;
-            -
-            -
                                $ret = $this->compileChildren($for->children, $out);
-            -
-            -
                                if ($ret) {
-            -
                                    if ($ret[0] !== Type::T_CONTROL) {
-            -
                                        return $ret;
-            -
                                    }
-            -
-            -
                                    if ($ret[1]) {
-            -
                                        break;
-            -
                                    }
-            -
                                }
-            -
                            }
-            -
                            break;
-            -
-            -
                        case Type::T_BREAK:
-            -
                            return array(Type::T_CONTROL, true);
-            -
-            -
                        case Type::T_CONTINUE:
-            -
                            return array(Type::T_CONTROL, false);
-            -
-            -
                        case Type::T_RETURN:
-            -
                            return $this->reduce($child[1], true);
-            -
-            -
                        case Type::T_NESTED_PROPERTY:
-            -
                            list(, $prop) = $child;
-            -
-            -
                            $prefixed = array();
-            -
                            $prefix = $this->compileValue($prop->prefix) . '-';
-            -
-            -
                            foreach ($prop->children as $child) {
-            -
                                if ($child[0] === Type::T_ASSIGN) {
-            -
                                    array_unshift($child[1][2], $prefix);
-            -
                                }
-            -
-            -
                                if ($child[0] === Type::T_NESTED_PROPERTY) {
-            -
                                    array_unshift($child[1]->prefix[2], $prefix);
-            -
                                }
-            -
-            -
                                $prefixed[] = $child;
-            -
                            }
-            -
-            -
                            $this->compileChildrenNoReturn($prefixed, $out);
-            -
                            break;
-            -
-            -
                        case Type::T_INCLUDE:
-            -
                            // including a mixin
-            -
                            list(, $name, $argValues, $content) = $child;
-            -
-            -
                            $mixin = $this->get(self::$namespaces['mixin'] . $name, false);
-            -
-            -
                            if (! $mixin) {
-            -
                                $this->throwError("Undefined mixin $name");
-            -
                            }
-            -
-            -
                            $callingScope = $this->getStoreEnv();
-            -
-            -
                            // push scope, apply args
-            -
                            $this->pushEnv();
-            -
                            $this->env->depth--;
-            -
-            -
                            if (isset($content)) {
-            -
                                $content->scope = $callingScope;
-            -
-            -
                                $this->setRaw(self::$namespaces['special'] . 'content', $content, $this->getStoreEnv());
-            -
                            }
-            -
-            -
                            if (isset($mixin->args)) {
-            -
                                $this->applyArguments($mixin->args, $argValues);
-            -
                            }
-            -
-            -
                            $this->env->marker = 'mixin';
-            -
-            -
                            $this->compileChildrenNoReturn($mixin->children, $out);
-            -
-            -
                            $this->popEnv();
-            -
                            break;
-            -
-            -
                        case Type::T_MIXIN_CONTENT:
-            -
                            $content = $this->get(self::$namespaces['special'] . 'content', false, $this->getStoreEnv());
-            -
-            -
                            if (! $content) {
-            -
                                $this->throwError('Expected @content inside of mixin');
-            -
                            }
-            -
-            -
                            if (! isset($content->children)) {
-            -
                                break;
-            -
                            }
-            -
-            -
                            $storeEnv = $this->storeEnv;
-            -
                            $this->storeEnv = $content->scope;
-            -
-            -
                            $this->compileChildrenNoReturn($content->children, $out);
-            -
-            -
                            $this->storeEnv = $storeEnv;
-            -
                            break;
-            -
-            -
                        case Type::T_DEBUG:
-            -
                            list(, $value) = $child;
-            -
-            -
                            $line = $this->parser->getLineNo($this->sourcePos);
-            -
                            $value = $this->compileValue($this->reduce($value, true));
-            -
                            fwrite($this->stderr, "Line $line DEBUG: $value\n");
-            -
                            break;
-            -
-            -
                        case Type::T_WARN:
-            -
                            list(, $value) = $child;
-            -
-            -
                            $line = $this->parser->getLineNo($this->sourcePos);
-            -
                            $value = $this->compileValue($this->reduce($value, true));
-            -
                            echo "Line $line WARN: $value\n";
-            -
                            break;
-            -
-            -
                        case Type::T_ERROR:
-            -
                            list(, $value) = $child;
-            -
-            -
                            $line = $this->parser->getLineNo($this->sourcePos);
-            -
                            $value = $this->compileValue($this->reduce($value, true));
-            -
                            $this->throwError("Line $line ERROR: $value\n");
-            -
                            break;
-            -
-            -
                        case Type::T_CONTROL:
-            -
                            $this->throwError('@break/@continue not permitted in this scope');
-            -
                            break;
-            -
-            -
                        default:
-            -
                            $this->throwError("unknown child type: $child[0]");
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Reduce expression to string
-            -
                 *
-            -
                 * @param array $exp
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function expToString($exp)
-            -
                {
-            -
                    list(, $op, $left, $right, $inParens, $whiteLeft, $whiteRight) = $exp;
-            -
-            -
                    $content = array($this->reduce($left));
-            -
-            -
                    if ($whiteLeft) {
-            -
                        $content[] = ' ';
-            -
                    }
-            -
-            -
                    $content[] = $op;
-            -
-            -
                    if ($whiteRight) {
-            -
                        $content[] = ' ';
-            -
                    }
-            -
-            -
                    $content[] = $this->reduce($right);
-            -
-            -
                    return array(Type::T_STRING, '', $content);
-            -
                }
-            -
-            -
                /**
-            -
                 * Is truthy?
-            -
                 *
-            -
                 * @param array $value
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function isTruthy($value)
-            -
                {
-            -
                    return $value !== self::$false && $value !== self::$null;
-            -
                }
-            -
-            -
                /**
-            -
                 * Should $value cause its operand to eval
-            -
                 *
-            -
                 * @param array $value
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function shouldEval($value)
-            -
                {
-            -
                    switch ($value[0]) {
-            -
                        case Type::T_EXPRESSION:
-            -
                            if ($value[1] === '/') {
-            -
                                return $this->shouldEval($value[2], $value[3]);
-            -
                            }
-            -
-            -
                            // fall-thru
-            -
                        case Type::T_VARIABLE:
-            -
                        case Type::T_FUNCTION_CALL:
-            -
                            return true;
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Reduce value
-            -
                 *
-            -
                 * @param array   $value
-            -
                 * @param boolean $inExp
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function reduce($value, $inExp = false)
-            -
                {
-            -
                    list($type) = $value;
-            -
-            -
                    switch ($type) {
-            -
                        case Type::T_EXPRESSION:
-            -
                            list(, $op, $left, $right, $inParens) = $value;
-            -
-            -
                            $opName = isset(self::$operatorNames[$op]) ? self::$operatorNames[$op] : $op;
-            -
                            $inExp = $inExp || $this->shouldEval($left) || $this->shouldEval($right);
-            -
-            -
                            $left = $this->reduce($left, true);
-            -
-            -
                            if ($op !== 'and' && $op !== 'or') {
-            -
                                $right = $this->reduce($right, true);
-            -
                            }
-            -
-            -
                            // special case: looks like css shorthand
-            -
                            if ($opName == 'div' && ! $inParens && ! $inExp && isset($right[2])
-            -
                                && (($right[0] !== Type::T_NUMBER && $right[2] != '')
-            -
                                || ($right[0] === Type::T_NUMBER && ! $right->unitless()))
-            -
                            ) {
-            -
                                return $this->expToString($value);
-            -
                            }
-            -
-            -
                            $left = $this->coerceForExpression($left);
-            -
                            $right = $this->coerceForExpression($right);
-            -
-            -
                            $ltype = $left[0];
-            -
                            $rtype = $right[0];
-            -
-            -
                            $ucOpName = ucfirst($opName);
-            -
                            $ucLType  = ucfirst($ltype);
-            -
                            $ucRType  = ucfirst($rtype);
-            -
-            -
                            // this tries:
-            -
                            // 1. op[op name][left type][right type]
-            -
                            // 2. op[left type][right type] (passing the op as first arg
-            -
                            // 3. op[op name]
-            -
                            $fn = "op${ucOpName}${ucLType}${ucRType}";
-            -
-            -
                            if (is_callable(array($this, $fn)) ||
-            -
                                (($fn = "op${ucLType}${ucRType}") &&
-            -
                                    is_callable(array($this, $fn)) &&
-            -
                                    $passOp = true) ||
-            -
                                (($fn = "op${ucOpName}") &&
-            -
                                    is_callable(array($this, $fn)) &&
-            -
                                    $genOp = true)
-            -
                            ) {
-            -
                                $unitChange = false;
-            -
-            -
                                if (! isset($genOp) &&
-            -
                                    $left[0] === Type::T_NUMBER && $right[0] === Type::T_NUMBER
-            -
                                ) {
-            -
                                    if ($opName === 'mod' && ! $right->unitless()) {
-            -
                                        $this->throwError(
-            -
                                            'Cannot modulo by a number with units: %s%s',
-            -
                                            $right[1],
-            -
                                            $right->unitStr()
-            -
                                        );
-            -
                                    }
-            -
-            -
                                    $unitChange = true;
-            -
                                    $emptyUnit = $left->unitless() || $right->unitless();
-            -
                                    $targetUnit = $left->unitless() ? $right[2] : $left[2];
-            -
-            -
                                    if ($opName !== 'mul') {
-            -
                                        $left[2] = $left->unitless() ? $targetUnit : $left[2];
-            -
                                        $right[2] = $right->unitless() ? $targetUnit : $right[2];
-            -
                                    }
-            -
-            -
                                    if ($opName !== 'mod') {
-            -
                                        $left = $left->normalize();
-            -
                                        $right = $right->normalize();
-            -
                                    }
-            -
-            -
                                    if ($opName === 'div' && ! $emptyUnit && $left[2] === $right[2]) {
-            -
                                        $targetUnit = '';
-            -
                                    }
-            -
-            -
                                    if ($opName === 'mul') {
-            -
                                        $left[2] = $left->unitless() ? $right[2] : $left[2];
-            -
                                        $right[2] = $right->unitless() ? $left[2] : $right[2];
-            -
                                    } elseif ($opName === 'div' && $left[2] === $right[2]) {
-            -
                                        $left[2] = '';
-            -
                                        $right[2] = '';
-            -
                                    }
-            -
                                }
-            -
-            -
                                $shouldEval = $inParens || $inExp;
-            -
-            -
                                if (isset($passOp)) {
-            -
                                    $out = $this->$fn($op, $left, $right, $shouldEval);
-            -
                                } else {
-            -
                                    $out = $this->$fn($left, $right, $shouldEval);
-            -
                                }
-            -
-            -
                                if (isset($out)) {
-            -
                                    if ($unitChange && $out[0] === Type::T_NUMBER) {
-            -
                                        $out = $out->coerce($targetUnit);
-            -
                                    }
-            -
-            -
                                    return $out;
-            -
                                }
-            -
                            }
-            -
-            -
                            return $this->expToString($value);
-            -
-            -
                        case Type::T_UNARY:
-            -
                            list(, $op, $exp, $inParens) = $value;
-            -
-            -
                            $inExp = $inExp || $this->shouldEval($exp);
-            -
                            $exp = $this->reduce($exp);
-            -
-            -
                            if ($exp[0] === Type::T_NUMBER) {
-            -
                                switch ($op) {
-            -
                                    case '+':
-            -
                                        return new Node\Number($exp[1], $exp[2]);
-            -
-            -
                                    case '-':
-            -
                                        return new Node\Number(-$exp[1], $exp[2]);
-            -
                                }
-            -
                            }
-            -
-            -
                            if ($op === 'not') {
-            -
                                if ($inExp || $inParens) {
-            -
                                    if ($exp === self::$false) {
-            -
                                        return self::$true;
-            -
                                    }
-            -
-            -
                                    return self::$false;
-            -
                                }
-            -
-            -
                                $op = $op . ' ';
-            -
                            }
-            -
-            -
                            return array(Type::T_STRING, '', array($op, $exp));
-            -
-            -
                        case Type::T_VARIABLE:
-            -
                            list(, $name) = $value;
-            -
-            -
                            return $this->reduce($this->get($name));
-            -
-            -
                        case Type::T_LIST:
-            -
                            foreach ($value[2] as &$item) {
-            -
                                $item = $this->reduce($item);
-            -
                            }
-            -
-            -
                            return $value;
-            -
-            -
                        case Type::T_MAP:
-            -
                            foreach ($value[1] as &$item) {
-            -
                                $item = $this->reduce($item);
-            -
                            }
-            -
-            -
                            foreach ($value[2] as &$item) {
-            -
                                $item = $this->reduce($item);
-            -
                            }
-            -
-            -
                            return $value;
-            -
-            -
                        case Type::T_STRING:
-            -
                            foreach ($value[2] as &$item) {
-            -
                                if (is_array($item) || $item instanceof \ArrayAccess) {
-            -
                                    $item = $this->reduce($item);
-            -
                                }
-            -
                            }
-            -
-            -
                            return $value;
-            -
-            -
                        case Type::T_INTERPOLATE:
-            -
                            $value[1] = $this->reduce($value[1]);
-            -
-            -
                            return $value;
-            -
-            -
                        case Type::T_FUNCTION_CALL:
-            -
                            list(, $name, $argValues) = $value;
-            -
-            -
                            return $this->fncall($name, $argValues);
-            -
-            -
                        default:
-            -
                            return $value;
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Function caller
-            -
                 *
-            -
                 * @param string $name
-            -
                 * @param array  $argValues
-            -
                 *
-            -
                 * @return array|null
-            -
                 */
-            -
                private function fncall($name, $argValues)
-            -
                {
-            -
                    // SCSS @function
-            -
                    if ($this->callScssFunction($name, $argValues, $returnValue)) {
-            -
                        return $returnValue;
-            -
                    }
-            -
-            -
                    // native PHP functions
-            -
                    if ($this->callNativeFunction($name, $argValues, $returnValue)) {
-            -
                        return $returnValue;
-            -
                    }
-            -
-            -
                    // for CSS functions, simply flatten the arguments into a list
-            -
                    $listArgs = array();
-            -
-            -
                    foreach ((array) $argValues as $arg) {
-            -
                        if (empty($arg[0])) {
-            -
                            $listArgs[] = $this->reduce($arg[1]);
-            -
                        }
-            -
                    }
-            -
-            -
                    return array(Type::T_FUNCTION, $name, array(Type::T_LIST, ',', $listArgs));
-            -
                }
-            -
-            -
                /**
-            -
                 * Normalize name
-            -
                 *
-            -
                 * @param string $name
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                protected function normalizeName($name)
-            -
                {
-            -
                    return str_replace('-', '_', $name);
-            -
                }
-            -
-            -
                /**
-            -
                 * Normalize value
-            -
                 *
-            -
                 * @param array $value
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                public function normalizeValue($value)
-            -
                {
-            -
                    $value = $this->coerceForExpression($this->reduce($value));
-            -
                    list($type) = $value;
-            -
-            -
                    switch ($type) {
-            -
                        case Type::T_LIST:
-            -
                            $value = $this->extractInterpolation($value);
-            -
-            -
                            if ($value[0] !== Type::T_LIST) {
-            -
                                return array(Type::T_KEYWORD, $this->compileValue($value));
-            -
                            }
-            -
-            -
                            foreach ($value[2] as $key => $item) {
-            -
                                $value[2][$key] = $this->normalizeValue($item);
-            -
                            }
-            -
-            -
                            return $value;
-            -
-            -
                        case Type::T_STRING:
-            -
                            return array($type, '"', array($this->compileStringContent($value)));
-            -
-            -
                        case Type::T_NUMBER:
-            -
                            return $value->normalize();
-            -
-            -
                        case Type::T_INTERPOLATE:
-            -
                            return array(Type::T_KEYWORD, $this->compileValue($value));
-            -
-            -
                        default:
-            -
                            return $value;
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Add numbers
-            -
                 *
-            -
                 * @param array $left
-            -
                 * @param array $right
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opAddNumberNumber($left, $right)
-            -
                {
-            -
                    return new Node\Number($left[1] + $right[1], $left[2]);
-            -
                }
-            -
-            -
                /**
-            -
                 * Multiply numbers
-            -
                 *
-            -
                 * @param array $left
-            -
                 * @param array $right
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opMulNumberNumber($left, $right)
-            -
                {
-            -
                    return new Node\Number($left[1] * $right[1], $left[2]);
-            -
                }
-            -
-            -
                /**
-            -
                 * Subtract numbers
-            -
                 *
-            -
                 * @param array $left
-            -
                 * @param array $right
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opSubNumberNumber($left, $right)
-            -
                {
-            -
                    return new Node\Number($left[1] - $right[1], $left[2]);
-            -
                }
-            -
-            -
                /**
-            -
                 * Divide numbers
-            -
                 *
-            -
                 * @param array $left
-            -
                 * @param array $right
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opDivNumberNumber($left, $right)
-            -
                {
-            -
                    if ($right[1] == 0) {
-            -
                        return array(Type::T_STRING, '', array($left[1] . $left[2] . '/' . $right[1] . $right[2]));
-            -
                    }
-            -
-            -
                    return new Node\Number($left[1] / $right[1], $left[2]);
-            -
                }
-            -
-            -
                /**
-            -
                 * Mod numbers
-            -
                 *
-            -
                 * @param array $left
-            -
                 * @param array $right
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opModNumberNumber($left, $right)
-            -
                {
-            -
                    return new Node\Number($left[1] % $right[1], $left[2]);
-            -
                }
-            -
-            -
                /**
-            -
                 * Add strings
-            -
                 *
-            -
                 * @param array $left
-            -
                 * @param array $right
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opAdd($left, $right)
-            -
                {
-            -
                    if ($strLeft = $this->coerceString($left)) {
-            -
                        if ($right[0] === Type::T_STRING) {
-            -
                            $right[1] = '';
-            -
                        }
-            -
-            -
                        $strLeft[2][] = $right;
-            -
-            -
                        return $strLeft;
-            -
                    }
-            -
-            -
                    if ($strRight = $this->coerceString($right)) {
-            -
                        if ($left[0] === Type::T_STRING) {
-            -
                            $left[1] = '';
-            -
                        }
-            -
-            -
                        array_unshift($strRight[2], $left);
-            -
-            -
                        return $strRight;
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Boolean and
-            -
                 *
-            -
                 * @param array   $left
-            -
                 * @param array   $right
-            -
                 * @param boolean $shouldEval
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opAnd($left, $right, $shouldEval)
-            -
                {
-            -
                    if (! $shouldEval) {
-            -
                        return;
-            -
                    }
-            -
-            -
                    if ($left !== self::$false) {
-            -
                        return $this->reduce($right, true);
-            -
                    }
-            -
-            -
                    return $left;
-            -
                }
-            -
-            -
                /**
-            -
                 * Boolean or
-            -
                 *
-            -
                 * @param array   $left
-            -
                 * @param array   $right
-            -
                 * @param boolean $shouldEval
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opOr($left, $right, $shouldEval)
-            -
                {
-            -
                    if (! $shouldEval) {
-            -
                        return;
-            -
                    }
-            -
-            -
                    if ($left !== self::$false) {
-            -
                        return $left;
-            -
                    }
-            -
-            -
                    return $this->reduce($right, true);
-            -
                }
-            -
-            -
                /**
-            -
                 * Compare colors
-            -
                 *
-            -
                 * @param string $op
-            -
                 * @param array  $left
-            -
                 * @param array  $right
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opColorColor($op, $left, $right)
-            -
                {
-            -
                    $out = array(Type::T_COLOR);
-            -
-            -
                    foreach (array(1, 2, 3) as $i) {
-            -
                        $lval = isset($left[$i]) ? $left[$i] : 0;
-            -
                        $rval = isset($right[$i]) ? $right[$i] : 0;
-            -
-            -
                        switch ($op) {
-            -
                            case '+':
-            -
                                $out[] = $lval + $rval;
-            -
                                break;
-            -
-            -
                            case '-':
-            -
                                $out[] = $lval - $rval;
-            -
                                break;
-            -
-            -
                            case '*':
-            -
                                $out[] = $lval * $rval;
-            -
                                break;
-            -
-            -
                            case '%':
-            -
                                $out[] = $lval % $rval;
-            -
                                break;
-            -
-            -
                            case '/':
-            -
                                if ($rval == 0) {
-            -
                                    $this->throwError("color: Can't divide by zero");
-            -
                                }
-            -
-            -
                                $out[] = (int) ($lval / $rval);
-            -
                                break;
-            -
-            -
                            case '==':
-            -
                                return $this->opEq($left, $right);
-            -
-            -
                            case '!=':
-            -
                                return $this->opNeq($left, $right);
-            -
-            -
                            default:
-            -
                                $this->throwError("color: unknown op $op");
-            -
                        }
-            -
                    }
-            -
-            -
                    if (isset($left[4])) {
-            -
                        $out[4] = $left[4];
-            -
                    } elseif (isset($right[4])) {
-            -
                        $out[4] = $right[4];
-            -
                    }
-            -
-            -
                    return $this->fixColor($out);
-            -
                }
-            -
-            -
                /**
-            -
                 * Compare color and number
-            -
                 *
-            -
                 * @param string $op
-            -
                 * @param array  $left
-            -
                 * @param array  $right
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opColorNumber($op, $left, $right)
-            -
                {
-            -
                    $value = $right[1];
-            -
-            -
                    return $this->opColorColor(
-            -
                        $op,
-            -
                        $left,
-            -
                        array(Type::T_COLOR, $value, $value, $value)
-            -
                    );
-            -
                }
-            -
-            -
                /**
-            -
                 * Compare number and color
-            -
                 *
-            -
                 * @param string $op
-            -
                 * @param array  $left
-            -
                 * @param array  $right
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opNumberColor($op, $left, $right)
-            -
                {
-            -
                    $value = $left[1];
-            -
-            -
                    return $this->opColorColor(
-            -
                        $op,
-            -
                        array(Type::T_COLOR, $value, $value, $value),
-            -
                        $right
-            -
                    );
-            -
                }
-            -
-            -
                /**
-            -
                 * Compare number1 == number2
-            -
                 *
-            -
                 * @param array $left
-            -
                 * @param array $right
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opEq($left, $right)
-            -
                {
-            -
                    if (($lStr = $this->coerceString($left)) && ($rStr = $this->coerceString($right))) {
-            -
                        $lStr[1] = '';
-            -
                        $rStr[1] = '';
-            -
-            -
                        $left = $this->compileValue($lStr);
-            -
                        $right = $this->compileValue($rStr);
-            -
                    }
-            -
-            -
                    return $this->toBool($left === $right);
-            -
                }
-            -
-            -
                /**
-            -
                 * Compare number1 != number2
-            -
                 *
-            -
                 * @param array $left
-            -
                 * @param array $right
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opNeq($left, $right)
-            -
                {
-            -
                    if (($lStr = $this->coerceString($left)) && ($rStr = $this->coerceString($right))) {
-            -
                        $lStr[1] = '';
-            -
                        $rStr[1] = '';
-            -
-            -
                        $left = $this->compileValue($lStr);
-            -
                        $right = $this->compileValue($rStr);
-            -
                    }
-            -
-            -
                    return $this->toBool($left !== $right);
-            -
                }
-            -
-            -
                /**
-            -
                 * Compare number1 >= number2
-            -
                 *
-            -
                 * @param array $left
-            -
                 * @param array $right
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opGteNumberNumber($left, $right)
-            -
                {
-            -
                    return $this->toBool($left[1] >= $right[1]);
-            -
                }
-            -
-            -
                /**
-            -
                 * Compare number1 > number2
-            -
                 *
-            -
                 * @param array $left
-            -
                 * @param array $right
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opGtNumberNumber($left, $right)
-            -
                {
-            -
                    return $this->toBool($left[1] > $right[1]);
-            -
                }
-            -
-            -
                /**
-            -
                 * Compare number1 <= number2
-            -
                 *
-            -
                 * @param array $left
-            -
                 * @param array $right
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opLteNumberNumber($left, $right)
-            -
                {
-            -
                    return $this->toBool($left[1] <= $right[1]);
-            -
                }
-            -
-            -
                /**
-            -
                 * Compare number1 < number2
-            -
                 *
-            -
                 * @param array $left
-            -
                 * @param array $right
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opLtNumberNumber($left, $right)
-            -
                {
-            -
                    return $this->toBool($left[1] < $right[1]);
-            -
                }
-            -
-            -
                /**
-            -
                 * Three-way comparison, aka spaceship operator
-            -
                 *
-            -
                 * @param array $left
-            -
                 * @param array $right
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function opCmpNumberNumber($left, $right)
-            -
                {
-            -
                    $n = $left[1] - $right[1];
-            -
-            -
                    return new Node\Number($n ? $n / abs($n) : 0, '');
-            -
                }
-            -
-            -
                /**
-            -
                 * Cast to boolean
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param mixed $thing
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                public function toBool($thing)
-            -
                {
-            -
                    return $thing ? self::$true : self::$false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Compiles a primitive value into a CSS property value.
-            -
                 *
-            -
                 * Values in scssphp are typed by being wrapped in arrays, their format is
-            -
                 * typically:
-            -
                 *
-            -
                 *     array(type, contents [, additional_contents]*)
-            -
                 *
-            -
                 * The input is expected to be reduced. This function will not work on
-            -
                 * things like expressions and variables.
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param array $value
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                public function compileValue($value)
-            -
                {
-            -
                    $value = $this->reduce($value);
-            -
-            -
                    list($type) = $value;
-            -
-            -
                    switch ($type) {
-            -
                        case Type::T_KEYWORD:
-            -
                            return $value[1];
-            -
-            -
                        case Type::T_COLOR:
-            -
                            // [1] - red component (either number for a %)
-            -
                            // [2] - green component
-            -
                            // [3] - blue component
-            -
                            // [4] - optional alpha component
-            -
                            list(, $r, $g, $b) = $value;
-            -
-            -
                            $r = round($r);
-            -
                            $g = round($g);
-            -
                            $b = round($b);
-            -
-            -
                            if (count($value) === 5 && $value[4] !== 1) { // rgba
-            -
                                return 'rgba(' . $r . ', ' . $g . ', ' . $b . ', ' . $value[4] . ')';
-            -
                            }
-            -
-            -
                            $h = sprintf('#%02x%02x%02x', $r, $g, $b);
-            -
-            -
                            // Converting hex color to short notation (e.g. #003399 to #039)
-            -
                            if ($h[1] === $h[2] && $h[3] === $h[4] && $h[5] === $h[6]) {
-            -
                                $h = '#' . $h[1] . $h[3] . $h[5];
-            -
                            }
-            -
-            -
                            return $h;
-            -
-            -
                        case Type::T_NUMBER:
-            -
                            return (string) $value;
-            -
-            -
                        case Type::T_STRING:
-            -
                            return $value[1] . $this->compileStringContent($value) . $value[1];
-            -
-            -
                        case Type::T_FUNCTION:
-            -
                            $args = ! empty($value[2]) ? $this->compileValue($value[2]) : '';
-            -
-            -
                            return "$value[1]($args)";
-            -
-            -
                        case Type::T_LIST:
-            -
                            $value = $this->extractInterpolation($value);
-            -
-            -
                            if ($value[0] !== Type::T_LIST) {
-            -
                                return $this->compileValue($value);
-            -
                            }
-            -
-            -
                            list(, $delim, $items) = $value;
-            -
-            -
                            if ($delim !== ' ') {
-            -
                                $delim .= ' ';
-            -
                            }
-            -
-            -
                            $filtered = array();
-            -
-            -
                            foreach ($items as $item) {
-            -
                                if ($item[0] === Type::T_NULL) {
-            -
                                    continue;
-            -
                                }
-            -
-            -
                                $filtered[] = $this->compileValue($item);
-            -
                            }
-            -
-            -
                            return implode("$delim", $filtered);
-            -
-            -
                        case Type::T_MAP:
-            -
                            $keys = $value[1];
-            -
                            $values = $value[2];
-            -
                            $filtered = array();
-            -
-            -
                            for ($i = 0, $s = count($keys); $i < $s; $i++) {
-            -
                                $filtered[$this->compileValue($keys[$i])] = $this->compileValue($values[$i]);
-            -
                            }
-            -
-            -
                            array_walk($filtered, function (&$value, $key) {
-            -
                                $value = $key . ': ' . $value;
-            -
                            });
-            -
-            -
                            return '(' . implode(', ', $filtered) . ')';
-            -
-            -
                        case Type::T_INTERPOLATED:
-            -
                            // node created by extractInterpolation
-            -
                            list(, $interpolate, $left, $right) = $value;
-            -
                            list(,, $whiteLeft, $whiteRight) = $interpolate;
-            -
-            -
                            $left = count($left[2]) > 0 ?
-            -
                                $this->compileValue($left) . $whiteLeft : '';
-            -
-            -
                            $right = count($right[2]) > 0 ?
-            -
                                $whiteRight . $this->compileValue($right) : '';
-            -
-            -
                            return $left . $this->compileValue($interpolate) . $right;
-            -
-            -
                        case Type::T_INTERPOLATE:
-            -
                            // raw parse node
-            -
                            list(, $exp) = $value;
-            -
-            -
                            // strip quotes if it's a string
-            -
                            $reduced = $this->reduce($exp);
-            -
-            -
                            switch ($reduced[0]) {
-            -
                                case Type::T_STRING:
-            -
                                    $reduced = array(Type::T_KEYWORD, $this->compileStringContent($reduced));
-            -
                                    break;
-            -
-            -
                                case Type::T_NULL:
-            -
                                    $reduced = array(Type::T_KEYWORD, '');
-            -
                            }
-            -
-            -
                            return $this->compileValue($reduced);
-            -
-            -
                        case Type::T_NULL:
-            -
                            return 'null';
-            -
-            -
                        default:
-            -
                            $this->throwError("unknown value type: $type");
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Flatten list
-            -
                 *
-            -
                 * @param array $list
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                protected function flattenList($list)
-            -
                {
-            -
                    return $this->compileValue($list);
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile string content
-            -
                 *
-            -
                 * @param array $string
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                protected function compileStringContent($string)
-            -
                {
-            -
                    $parts = array();
-            -
-            -
                    foreach ($string[2] as $part) {
-            -
                        if (is_array($part) || $part instanceof \ArrayAccess) {
-            -
                            $parts[] = $this->compileValue($part);
-            -
                        } else {
-            -
                            $parts[] = $part;
-            -
                        }
-            -
                    }
-            -
-            -
                    return implode($parts);
-            -
                }
-            -
-            -
                /**
-            -
                 * Extract interpolation; it doesn't need to be recursive, compileValue will handle that
-            -
                 *
-            -
                 * @param array $list
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function extractInterpolation($list)
-            -
                {
-            -
                    $items = $list[2];
-            -
-            -
                    foreach ($items as $i => $item) {
-            -
                        if ($item[0] === Type::T_INTERPOLATE) {
-            -
                            $before = array(Type::T_LIST, $list[1], array_slice($items, 0, $i));
-            -
                            $after  = array(Type::T_LIST, $list[1], array_slice($items, $i + 1));
-            -
-            -
                            return array(Type::T_INTERPOLATED, $item, $before, $after);
-            -
                        }
-            -
                    }
-            -
-            -
                    return $list;
-            -
                }
-            -
-            -
                /**
-            -
                 * Find the final set of selectors
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Compiler\Environment $env
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function multiplySelectors(Environment $env)
-            -
                {
-            -
                    $envs            = $this->compactEnv($env);
-            -
                    $selectors       = array();
-            -
                    $parentSelectors = array(array());
-            -
-            -
                    while ($env = array_pop($envs)) {
-            -
                        if (empty($env->selectors)) {
-            -
                            continue;
-            -
                        }
-            -
-            -
                        $selectors = array();
-            -
-            -
                        foreach ($env->selectors as $selector) {
-            -
                            foreach ($parentSelectors as $parent) {
-            -
                                $selectors[] = $this->joinSelectors($parent, $selector);
-            -
                            }
-            -
                        }
-            -
-            -
                        $parentSelectors = $selectors;
-            -
                    }
-            -
-            -
                    return $selectors;
-            -
                }
-            -
-            -
                /**
-            -
                 * Join selectors; looks for & to replace, or append parent before child
-            -
                 *
-            -
                 * @param array $parent
-            -
                 * @param array $child
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function joinSelectors($parent, $child)
-            -
                {
-            -
                    $setSelf = false;
-            -
                    $out = array();
-            -
-            -
                    foreach ($child as $part) {
-            -
                        $newPart = array();
-            -
-            -
                        foreach ($part as $p) {
-            -
                            if ($p === self::$selfSelector) {
-            -
                                $setSelf = true;
-            -
-            -
                                foreach ($parent as $i => $parentPart) {
-            -
                                    if ($i > 0) {
-            -
                                        $out[] = $newPart;
-            -
                                        $newPart = array();
-            -
                                    }
-            -
-            -
                                    foreach ($parentPart as $pp) {
-            -
                                        $newPart[] = $pp;
-            -
                                    }
-            -
                                }
-            -
                            } else {
-            -
                                $newPart[] = $p;
-            -
                            }
-            -
                        }
-            -
-            -
                        $out[] = $newPart;
-            -
                    }
-            -
-            -
                    return $setSelf ? $out : array_merge($parent, $child);
-            -
                }
-            -
-            -
                /**
-            -
                 * Multiply media
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Compiler\Environment $env
-            -
                 * @param array                               $childQueries
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function multiplyMedia(Environment $env = null, $childQueries = null)
-            -
                {
-            -
                    if (! isset($env) ||
-            -
                        ! empty($env->block->type) && $env->block->type !== Type::T_MEDIA
-            -
                    ) {
-            -
                        return $childQueries;
-            -
                    }
-            -
-            -
                    // plain old block, skip
-            -
                    if (empty($env->block->type)) {
-            -
                        return $this->multiplyMedia($env->parent, $childQueries);
-            -
                    }
-            -
-            -
                    $parentQueries = isset($env->block->queryList)
-            -
                        ? $env->block->queryList
-            -
                        : array(array(array(Type::T_MEDIA_VALUE, $env->block->value)));
-            -
-            -
                    if ($childQueries === null) {
-            -
                        $childQueries = $parentQueries;
-            -
                    } else {
-            -
                        $originalQueries = $childQueries;
-            -
                        $childQueries = array();
-            -
-            -
                        foreach ($parentQueries as $parentQuery) {
-            -
                            foreach ($originalQueries as $childQuery) {
-            -
                                $childQueries []= array_merge($parentQuery, $childQuery);
-            -
                            }
-            -
                        }
-            -
                    }
-            -
-            -
                    return $this->multiplyMedia($env->parent, $childQueries);
-            -
                }
-            -
-            -
                /**
-            -
                 * Convert env linked list to stack
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Compiler\Environment $env
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                private function compactEnv(Environment $env)
-            -
                {
-            -
                    for ($envs = array(); $env; $env = $env->parent) {
-            -
                        $envs[] = $env;
-            -
                    }
-            -
-            -
                    return $envs;
-            -
                }
-            -
-            -
                /**
-            -
                 * Convert env stack to singly linked list
-            -
                 *
-            -
                 * @param array $envs
-            -
                 *
-            -
                 * @return \Leafo\ScssPhp\Compiler\Environment
-            -
                 */
-            -
                private function extractEnv($envs)
-            -
                {
-            -
                    for ($env = null; $e = array_pop($envs);) {
-            -
                        $e->parent = $env;
-            -
                        $env = $e;
-            -
                    }
-            -
-            -
                    return $env;
-            -
                }
-            -
-            -
                /**
-            -
                 * Push environment
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Block $block
-            -
                 *
-            -
                 * @return \Leafo\ScssPhp\Compiler\Environment
-            -
                 */
-            -
                protected function pushEnv(Block $block = null)
-            -
                {
-            -
                    $env = new Environment;
-            -
                    $env->parent = $this->env;
-            -
                    $env->store  = array();
-            -
                    $env->block  = $block;
-            -
                    $env->depth  = isset($this->env->depth) ? $this->env->depth + 1 : 0;
-            -
-            -
                    $this->env = $env;
-            -
-            -
                    return $env;
-            -
                }
-            -
-            -
                /**
-            -
                 * Pop environment
-            -
                 */
-            -
                protected function popEnv()
-            -
                {
-            -
                    $this->env = $this->env->parent;
-            -
                }
-            -
-            -
                /**
-            -
                 * Get store environment
-            -
                 *
-            -
                 * @return \Leafo\ScssPhp\Compiler\Environment
-            -
                 */
-            -
                protected function getStoreEnv()
-            -
                {
-            -
                    return isset($this->storeEnv) ? $this->storeEnv : $this->env;
-            -
                }
-            -
-            -
                /**
-            -
                 * Set variable
-            -
                 *
-            -
                 * @param string                              $name
-            -
                 * @param mixed                               $value
-            -
                 * @param boolean                             $shadow
-            -
                 * @param \Leafo\ScssPhp\Compiler\Environment $env
-            -
                 */
-            -
                protected function set($name, $value, $shadow = false, Environment $env = null)
-            -
                {
-            -
                    $name = $this->normalizeName($name);
-            -
-            -
                    if (! isset($env)) {
-            -
                        $env = $this->getStoreEnv();
-            -
                    }
-            -
-            -
                    if ($shadow) {
-            -
                        $this->setRaw($name, $value, $env);
-            -
                    } else {
-            -
                        $this->setExisting($name, $value, $env);
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Set existing variable
-            -
                 *
-            -
                 * @param string                              $name
-            -
                 * @param mixed                               $value
-            -
                 * @param \Leafo\ScssPhp\Compiler\Environment $env
-            -
                 */
-            -
                protected function setExisting($name, $value, Environment $env)
-            -
                {
-            -
                    $storeEnv = $env;
-            -
-            -
                    $hasNamespace = $name[0] === '^' || $name[0] === '@' || $name[0] === '%';
-            -
-            -
                    for (;;) {
-            -
                        if (array_key_exists($name, $env->store)) {
-            -
                            break;
-            -
                        }
-            -
-            -
                        if (! $hasNamespace && isset($env->marker)) {
-            -
                            $env = $storeEnv;
-            -
                            break;
-            -
                        }
-            -
-            -
                        if (! isset($env->parent)) {
-            -
                            $env = $storeEnv;
-            -
                            break;
-            -
                        }
-            -
-            -
                        $env = $env->parent;
-            -
                    }
-            -
-            -
                    $env->store[$name] = $value;
-            -
                }
-            -
-            -
                /**
-            -
                 * Set raw variable
-            -
                 *
-            -
                 * @param string                              $name
-            -
                 * @param mixed                               $value
-            -
                 * @param \Leafo\ScssPhp\Compiler\Environment $env
-            -
                 */
-            -
                protected function setRaw($name, $value, Environment $env)
-            -
                {
-            -
                    $env->store[$name] = $value;
-            -
                }
-            -
-            -
                /**
-            -
                 * Get variable
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string                              $name
-            -
                 * @param boolean                             $shouldThrow
-            -
                 * @param \Leafo\ScssPhp\Compiler\Environment $env
-            -
                 *
-            -
                 * @return mixed
-            -
                 */
-            -
                public function get($name, $shouldThrow = true, Environment $env = null)
-            -
                {
-            -
                    $name = $this->normalizeName($name);
-            -
-            -
                    if (! isset($env)) {
-            -
                        $env = $this->getStoreEnv();
-            -
                    }
-            -
-            -
                    $hasNamespace = $name[0] === '^' || $name[0] === '@' || $name[0] === '%';
-            -
-            -
                    for (;;) {
-            -
                        if (array_key_exists($name, $env->store)) {
-            -
                            return $env->store[$name];
-            -
                        }
-            -
-            -
                        if (! $hasNamespace && isset($env->marker)) {
-            -
                            $env = $this->rootEnv;
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if (! isset($env->parent)) {
-            -
                            break;
-            -
                        }
-            -
-            -
                        $env = $env->parent;
-            -
                    }
-            -
-            -
                    if ($shouldThrow) {
-            -
                        $this->throwError("Undefined variable \$$name");
-            -
                    }
-            -
-            -
                    // found nothing
-            -
                }
-            -
-            -
                /**
-            -
                 * Has variable?
-            -
                 *
-            -
                 * @param string                              $name
-            -
                 * @param \Leafo\ScssPhp\Compiler\Environment $env
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function has($name, Environment $env = null)
-            -
                {
-            -
                    return $this->get($name, false, $env) !== null;
-            -
                }
-            -
-            -
                /**
-            -
                 * Inject variables
-            -
                 *
-            -
                 * @param array $args
-            -
                 */
-            -
                protected function injectVariables(array $args)
-            -
                {
-            -
                    if (empty($args)) {
-            -
                        return;
-            -
                    }
-            -
-            -
                    $parser = $this->parserFactory(__METHOD__);
-            -
-            -
                    foreach ($args as $name => $strValue) {
-            -
                        if ($name[0] === '$') {
-            -
                            $name = substr($name, 1);
-            -
                        }
-            -
-            -
                        if (! $parser->parseValue($strValue, $value)) {
-            -
                            $value = $this->coerceValue($strValue);
-            -
                        }
-            -
-            -
                        $this->set($name, $value);
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Set variables
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param array $variables
-            -
                 */
-            -
                public function setVariables(array $variables)
-            -
                {
-            -
                    $this->registeredVars = array_merge($this->registeredVars, $variables);
-            -
                }
-            -
-            -
                /**
-            -
                 * Unset variable
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string $name
-            -
                 */
-            -
                public function unsetVariable($name)
-            -
                {
-            -
                    unset($this->registeredVars[$name]);
-            -
                }
-            -
-            -
                /**
-            -
                 * Returns list of variables
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                public function getVariables()
-            -
                {
-            -
                    return $this->registeredVars;
-            -
                }
-            -
-            -
                /**
-            -
                 * Adds to list of parsed files
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string $path
-            -
                 */
-            -
                public function addParsedFile($path)
-            -
                {
-            -
                    if (isset($path) && file_exists($path)) {
-            -
                        $this->parsedFiles[realpath($path)] = filemtime($path);
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Returns list of parsed files
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                public function getParsedFiles()
-            -
                {
-            -
                    return $this->parsedFiles;
-            -
                }
-            -
-            -
                /**
-            -
                 * Add import path
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string $path
-            -
                 */
-            -
                public function addImportPath($path)
-            -
                {
-            -
                    if (! in_array($path, $this->importPaths)) {
-            -
                        $this->importPaths[] = $path;
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Set import paths
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string|array $path
-            -
                 */
-            -
                public function setImportPaths($path)
-            -
                {
-            -
                    $this->importPaths = (array) $path;
-            -
                }
-            -
-            -
                /**
-            -
                 * Set number precision
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param integer $numberPrecision
-            -
                 */
-            -
                public function setNumberPrecision($numberPrecision)
-            -
                {
-            -
                    Node\Number::$precision = $numberPrecision;
-            -
                }
-            -
-            -
                /**
-            -
                 * Set formatter
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string $formatterName
-            -
                 */
-            -
                public function setFormatter($formatterName)
-            -
                {
-            -
                    $this->formatter = $formatterName;
-            -
                }
-            -
-            -
                /**
-            -
                 * Set line number style
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string $lineNumberStyle
-            -
                 */
-            -
                public function setLineNumberStyle($lineNumberStyle)
-            -
                {
-            -
                    $this->lineNumberStyle = $lineNumberStyle;
-            -
                }
-            -
-            -
                /**
-            -
                 * Register function
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string   $name
-            -
                 * @param callable $func
-            -
                 * @param array    $prototype
-            -
                 */
-            -
                public function registerFunction($name, $func, $prototype = null)
-            -
                {
-            -
                    $this->userFunctions[$this->normalizeName($name)] = array($func, $prototype);
-            -
                }
-            -
-            -
                /**
-            -
                 * Unregister function
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string $name
-            -
                 */
-            -
                public function unregisterFunction($name)
-            -
                {
-            -
                    unset($this->userFunctions[$this->normalizeName($name)]);
-            -
                }
-            -
-            -
                /**
-            -
                 * Add feature
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string $name
-            -
                 */
-            -
                public function addFeature($name)
-            -
                {
-            -
                    $this->registeredFeatures[$name] = true;
-            -
                }
-            -
-            -
                /**
-            -
                 * Import file
-            -
                 *
-            -
                 * @param string $path
-            -
                 * @param array  $out
-            -
                 */
-            -
                protected function importFile($path, $out)
-            -
                {
-            -
                    // see if tree is cached
-            -
                    $realPath = realpath($path);
-            -
-            -
                    if (isset($this->importCache[$realPath])) {
-            -
                        $this->handleImportLoop($realPath);
-            -
-            -
                        $tree = $this->importCache[$realPath];
-            -
                    } else {
-            -
                        $code   = file_get_contents($path);
-            -
                        $parser = $this->parserFactory($path);
-            -
                        $tree   = $parser->parse($code);
-            -
-            -
                        $this->importCache[$realPath] = $tree;
-            -
                    }
-            -
-            -
                    $pi = pathinfo($path);
-            -
                    array_unshift($this->importPaths, $pi['dirname']);
-            -
                    $this->compileChildrenNoReturn($tree->children, $out);
-            -
                    array_shift($this->importPaths);
-            -
                }
-            -
-            -
                /**
-            -
                 * Return the file path for an import url if it exists
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string $url
-            -
                 *
-            -
                 * @return string|null
-            -
                 */
-            -
                public function findImport($url)
-            -
                {
-            -
                    $urls = array();
-            -
-            -
                    // for "normal" scss imports (ignore vanilla css and external requests)
-            -
                    if (! preg_match('/\.css$|^https?:\/\//', $url)) {
-            -
                        // try both normal and the _partial filename
-            -
                        $urls = array($url, preg_replace('/[^\/]+$/', '_\0', $url));
-            -
                    }
-            -
-            -
                    foreach ($this->importPaths as $dir) {
-            -
                        if (is_string($dir)) {
-            -
                            // check urls for normal import paths
-            -
                            foreach ($urls as $full) {
-            -
                                $full = $dir
-            -
                                    . (! empty($dir) && substr($dir, -1) !== '/' ? '/' : '')
-            -
                                    . $full;
-            -
-            -
                                if ($this->fileExists($file = $full . '.scss') ||
-            -
                                    $this->fileExists($file = $full)
-            -
                                ) {
-            -
                                    return $file;
-            -
                                }
-            -
                            }
-            -
                        } elseif (is_callable($dir)) {
-            -
                            // check custom callback for import path
-            -
                            $file = call_user_func($dir, $url);
-            -
-            -
                            if ($file !== null) {
-            -
                                return $file;
-            -
                            }
-            -
                        }
-            -
                    }
-            -
-            -
                    return null;
-            -
                }
-            -
-            -
                /**
-            -
                 * Throw error (exception)
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string $msg Message with optional sprintf()-style vararg parameters
-            -
                 *
-            -
                 * @throws \Exception
-            -
                 */
-            -
                public function throwError($msg)
-            -
                {
-            -
                    if (func_num_args() > 1) {
-            -
                        $msg = call_user_func_array('sprintf', func_get_args());
-            -
                    }
-            -
-            -
                    if ($this->sourcePos >= 0 && isset($this->sourceIndex)) {
-            -
                        $parser = $this->sourceParsers[$this->sourceIndex];
-            -
                        $parser->throwParseError($msg, $this->sourcePos);
-            -
                    }
-            -
-            -
                    throw new \Exception($msg);
-            -
                }
-            -
-            -
                /**
-            -
                 * Handle import loop
-            -
                 *
-            -
                 * @param string $name
-            -
                 *
-            -
                 * @throws \Exception
-            -
                 */
-            -
                private function handleImportLoop($name)
-            -
                {
-            -
                    for ($env = $this->env; $env; $env = $env->parent) {
-            -
                        $parser = $this->sourceParsers[$env->block->sourceIndex];
-            -
                        $file = $parser->getSourceName();
-            -
-            -
                        if (realpath($file) === $name) {
-            -
                            $this->throwError('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 is_file($name);
-            -
                }
-            -
-            -
                /**
-            -
                 * Call SCSS @function
-            -
                 *
-            -
                 * @param string $name
-            -
                 * @param array  $args
-            -
                 * @param array  $returnValue
-            -
                 *
-            -
                 * @return boolean Returns true if returnValue is set; otherwise, false
-            -
                 */
-            -
                protected function callScssFunction($name, $argValues, &$returnValue)
-            -
                {
-            -
                    $func = $this->get(self::$namespaces['function'] . $name, false);
-            -
-            -
                    if (! $func) {
-            -
                        return false;
-            -
                    }
-            -
-            -
                    $this->pushEnv();
-            -
-            -
                    // set the args
-            -
                    if (isset($func->args)) {
-            -
                        $this->applyArguments($func->args, $argValues);
-            -
                    }
-            -
-            -
                    // throw away lines and children
-            -
                    $tmp = new OutputBlock;
-            -
                    $tmp->lines    = array();
-            -
                    $tmp->children = array();
-            -
-            -
                    $this->env->marker = 'function';
-            -
-            -
                    $ret = $this->compileChildren($func->children, $tmp);
-            -
-            -
                    $this->popEnv();
-            -
-            -
                    $returnValue = ! isset($ret) ? self::$defaultValue : $ret;
-            -
-            -
                    return true;
-            -
                }
-            -
-            -
                /**
-            -
                 * Call built-in and registered (PHP) functions
-            -
                 *
-            -
                 * @param string $name
-            -
                 * @param array  $args
-            -
                 * @param array  $returnValue
-            -
                 *
-            -
                 * @return boolean Returns true if returnValue is set; otherwise, false
-            -
                 */
-            -
                protected function callNativeFunction($name, $args, &$returnValue)
-            -
                {
-            -
                    // try a lib function
-            -
                    $name = $this->normalizeName($name);
-            -
-            -
                    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(self::$$libName) ? self::$$libName : null;
-            -
                    } else {
-            -
                        return false;
-            -
                    }
-            -
-            -
                    list($sorted, $kwargs) = $this->sortArgs($prototype, $args);
-            -
-            -
                    if ($name !== 'if' && $name !== 'call') {
-            -
                        foreach ($sorted as &$val) {
-            -
                            $val = $this->reduce($val, true);
-            -
                        }
-            -
                    }
-            -
-            -
                    $returnValue = call_user_func($f, $sorted, $kwargs);
-            -
-            -
                    if (! isset($returnValue)) {
-            -
                        return false;
-            -
                    }
-            -
-            -
                    $returnValue = $this->coerceValue($returnValue);
-            -
-            -
                    return true;
-            -
                }
-            -
-            -
                /**
-            -
                 * Get built-in function
-            -
                 *
-            -
                 * @param string $name Normalized name
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function getBuiltinFunction($name)
-            -
                {
-            -
                    $libName = 'lib' . preg_replace_callback(
-            -
                        '/_(.)/',
-            -
                        function ($m) {
-            -
                            return ucfirst($m[1]);
-            -
                        },
-            -
                        ucfirst($name)
-            -
                    );
-            -
-            -
                    return array($this, $libName);
-            -
                }
-            -
-            -
                /**
-            -
                 * Sorts keyword arguments
-            -
                 *
-            -
                 * @todo Merge with applyArguments()?
-            -
                 *
-            -
                 * @param array $prototype
-            -
                 * @param array $args
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function sortArgs($prototype, $args)
-            -
                {
-            -
                    $keyArgs = array();
-            -
                    $posArgs = array();
-            -
-            -
                    // separate positional and keyword arguments
-            -
                    foreach ($args as $arg) {
-            -
                        list($key, $value) = $arg;
-            -
-            -
                        $key = $key[1];
-            -
-            -
                        if (empty($key)) {
-            -
                            $posArgs[] = $value;
-            -
                        } else {
-            -
                            $keyArgs[$key] = $value;
-            -
                        }
-            -
                    }
-            -
-            -
                    if (! isset($prototype)) {
-            -
                        return array($posArgs, $keyArgs);
-            -
                    }
-            -
-            -
                    // copy positional args
-            -
                    $finalArgs = array_pad($posArgs, count($prototype), null);
-            -
-            -
                    // overwrite positional args with keyword args
-            -
                    foreach ($prototype as $i => $names) {
-            -
                        foreach ((array) $names as $name) {
-            -
                            if (isset($keyArgs[$name])) {
-            -
                                $finalArgs[$i] = $keyArgs[$name];
-            -
                            }
-            -
                        }
-            -
                    }
-            -
-            -
                    return array($finalArgs, $keyArgs);
-            -
                }
-            -
-            -
                /**
-            -
                 * Apply argument values per definition
-            -
                 *
-            -
                 * @param array $argDef
-            -
                 * @param array $argValues
-            -
                 *
-            -
                 * @throws \Exception
-            -
                 */
-            -
                protected function applyArguments($argDef, $argValues)
-            -
                {
-            -
                    $storeEnv = $this->getStoreEnv();
-            -
-            -
                    $env = new Environment;
-            -
                    $env->store = $storeEnv->store;
-            -
-            -
                    $hasVariable = false;
-            -
                    $args = array();
-            -
-            -
                    foreach ($argDef as $i => $arg) {
-            -
                        list($name, $default, $isVariable) = $argDef[$i];
-            -
-            -
                        $args[$name] = array($i, $name, $default, $isVariable);
-            -
                        $hasVariable |= $isVariable;
-            -
                    }
-            -
-            -
                    $keywordArgs = array();
-            -
                    $deferredKeywordArgs = array();
-            -
                    $remaining = array();
-            -
-            -
                    // assign the keyword args
-            -
                    foreach ((array) $argValues as $arg) {
-            -
                        if (! empty($arg[0])) {
-            -
                            if (! isset($args[$arg[0][1]])) {
-            -
                                if ($hasVariable) {
-            -
                                    $deferredKeywordArgs[$arg[0][1]] = $arg[1];
-            -
                                } else {
-            -
                                    $this->throwError("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]);
-            -
                            } else {
-            -
                                $keywordArgs[$arg[0][1]] = $arg[1];
-            -
                            }
-            -
                        } elseif (count($keywordArgs)) {
-            -
                            $this->throwError('Positional arguments must come before keyword arguments.');
-            -
                        } elseif ($arg[2] === true) {
-            -
                            $val = $this->reduce($arg[1], true);
-            -
-            -
                            if ($val[0] === Type::T_LIST) {
-            -
                                foreach ($val[2] as $name => $item) {
-            -
                                    if (! is_numeric($name)) {
-            -
                                        $keywordArgs[$name] = $item;
-            -
                                    } else {
-            -
                                        $remaining[] = $item;
-            -
                                    }
-            -
                                }
-            -
                            } elseif ($val[0] === Type::T_MAP) {
-            -
                                foreach ($val[1] as $i => $name) {
-            -
                                    $name = $this->compileStringContent($this->coerceString($name));
-            -
                                    $item = $val[2][$i];
-            -
-            -
                                    if (! is_numeric($name)) {
-            -
                                        $keywordArgs[$name] = $item;
-            -
                                    } else {
-            -
                                        $remaining[] = $item;
-            -
                                    }
-            -
                                }
-            -
                            } else {
-            -
                                $remaining[] = $val;
-            -
                            }
-            -
                        } else {
-            -
                            $remaining[] = $arg[1];
-            -
                        }
-            -
                    }
-            -
-            -
                    foreach ($args as $arg) {
-            -
                        list($i, $name, $default, $isVariable) = $arg;
-            -
-            -
                        if ($isVariable) {
-            -
                            $val = array(Type::T_LIST, ',', array(), $isVariable);
-            -
-            -
                            for ($count = count($remaining); $i < $count; $i++) {
-            -
                                $val[2][] = $remaining[$i];
-            -
                            }
-            -
-            -
                            foreach ($deferredKeywordArgs as $itemName => $item) {
-            -
                                $val[2][$itemName] = $item;
-            -
                            }
-            -
                        } elseif (isset($remaining[$i])) {
-            -
                            $val = $remaining[$i];
-            -
                        } elseif (isset($keywordArgs[$name])) {
-            -
                            $val = $keywordArgs[$name];
-            -
                        } elseif (! empty($default)) {
-            -
                            continue;
-            -
                        } else {
-            -
                            $this->throwError("Missing argument $name");
-            -
                        }
-            -
-            -
                        $this->set($name, $this->reduce($val, true), true, $env);
-            -
                    }
-            -
-            -
                    $storeEnv->store = $env->store;
-            -
-            -
                    foreach ($args as $arg) {
-            -
                        list($i, $name, $default, $isVariable) = $arg;
-            -
-            -
                        if ($isVariable || isset($remaining[$i]) || isset($keywordArgs[$name]) || empty($default)) {
-            -
                            continue;
-            -
                        }
-            -
-            -
                        $this->set($name, $this->reduce($default, true), true);
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Coerce a php value into a scss one
-            -
                 *
-            -
                 * @param mixed $value
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                private function coerceValue($value)
-            -
                {
-            -
                    if (is_array($value) || $value instanceof \ArrayAccess) {
-            -
                        return $value;
-            -
                    }
-            -
-            -
                    if (is_bool($value)) {
-            -
                        return $this->toBool($value);
-            -
                    }
-            -
-            -
                    if ($value === null) {
-            -
                        $value = self::$null;
-            -
                    }
-            -
-            -
                    if (is_numeric($value)) {
-            -
                        return new Node\Number($value, '');
-            -
                    }
-            -
-            -
                    if ($value === '') {
-            -
                        return self::$emptyString;
-            -
                    }
-            -
-            -
                    return array(Type::T_KEYWORD, $value);
-            -
                }
-            -
-            -
                /**
-            -
                 * Coerce something to map
-            -
                 *
-            -
                 * @param array $item
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function coerceMap($item)
-            -
                {
-            -
                    if ($item[0] === Type::T_MAP) {
-            -
                        return $item;
-            -
                    }
-            -
-            -
                    if ($item === self::$emptyList) {
-            -
                        return self::$emptyMap;
-            -
                    }
-            -
-            -
                    return array(Type::T_MAP, array($item), array(self::$null));
-            -
                }
-            -
-            -
                /**
-            -
                 * Coerce something to list
-            -
                 *
-            -
                 * @param array $item
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function coerceList($item, $delim = ',')
-            -
                {
-            -
                    if (isset($item) && $item[0] === Type::T_LIST) {
-            -
                        return $item;
-            -
                    }
-            -
-            -
                    if (isset($item) && $item[0] === Type::T_MAP) {
-            -
                        $keys = $item[1];
-            -
                        $values = $item[2];
-            -
                        $list = array();
-            -
-            -
                        for ($i = 0, $s = count($keys); $i < $s; $i++) {
-            -
                            $key = $keys[$i];
-            -
                            $value = $values[$i];
-            -
-            -
                            $list[] = array(
-            -
                                Type::T_LIST,
-            -
                                '',
-            -
                                array(array(Type::T_KEYWORD, $this->compileStringContent($this->coerceString($key))), $value)
-            -
                            );
-            -
                        }
-            -
-            -
                        return array(Type::T_LIST, ',', $list);
-            -
                    }
-            -
-            -
                    return array(Type::T_LIST, $delim, ! isset($item) ? array(): array($item));
-            -
                }
-            -
-            -
                /**
-            -
                 * Coerce color for expression
-            -
                 *
-            -
                 * @param array $value
-            -
                 *
-            -
                 * @return array|null
-            -
                 */
-            -
                protected function coerceForExpression($value)
-            -
                {
-            -
                    if ($color = $this->coerceColor($value)) {
-            -
                        return $color;
-            -
                    }
-            -
-            -
                    return $value;
-            -
                }
-            -
-            -
                /**
-            -
                 * Coerce value to color
-            -
                 *
-            -
                 * @param array $value
-            -
                 *
-            -
                 * @return array|null
-            -
                 */
-            -
                protected function coerceColor($value)
-            -
                {
-            -
                    switch ($value[0]) {
-            -
                        case Type::T_COLOR:
-            -
                            return $value;
-            -
-            -
                        case Type::T_KEYWORD:
-            -
                            $name = strtolower($value[1]);
-            -
-            -
                            if (isset(Colors::$cssColors[$name])) {
-            -
                                $rgba = explode(',', Colors::$cssColors[$name]);
-            -
-            -
                                return isset($rgba[3])
-            -
                                    ? array(Type::T_COLOR, (int) $rgba[0], (int) $rgba[1], (int) $rgba[2], (int) $rgba[3])
-            -
                                    : array(Type::T_COLOR, (int) $rgba[0], (int) $rgba[1], (int) $rgba[2]);
-            -
                            }
-            -
-            -
                            return null;
-            -
                    }
-            -
-            -
                    return null;
-            -
                }
-            -
-            -
                /**
-            -
                 * Coerce value to string
-            -
                 *
-            -
                 * @param array $value
-            -
                 *
-            -
                 * @return array|null
-            -
                 */
-            -
                protected function coerceString($value)
-            -
                {
-            -
                    if ($value[0] === Type::T_STRING) {
-            -
                        return $value;
-            -
                    }
-            -
-            -
                    return array(Type::T_STRING, '', array($this->compileValue($value)));
-            -
                }
-            -
-            -
                /**
-            -
                 * Coerce value to a percentage
-            -
                 *
-            -
                 * @param array $value
-            -
                 *
-            -
                 * @return integer|float
-            -
                 */
-            -
                protected function coercePercent($value)
-            -
                {
-            -
                    if ($value[0] === Type::T_NUMBER) {
-            -
                        if ($value[2] === '%') {
-            -
                            return $value[1] / 100;
-            -
                        }
-            -
-            -
                        return $value[1];
-            -
                    }
-            -
-            -
                    return 0;
-            -
                }
-            -
-            -
                /**
-            -
                 * Assert value is a map
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param array $value
-            -
                 *
-            -
                 * @return array
-            -
                 *
-            -
                 * @throws \Exception
-            -
                 */
-            -
                public function assertMap($value)
-            -
                {
-            -
                    $value = $this->coerceMap($value);
-            -
-            -
                    if ($value[0] !== Type::T_MAP) {
-            -
                        $this->throwError('expecting map');
-            -
                    }
-            -
-            -
                    return $value;
-            -
                }
-            -
-            -
                /**
-            -
                 * Assert value is a list
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param array $value
-            -
                 *
-            -
                 * @return array
-            -
                 *
-            -
                 * @throws \Exception
-            -
                 */
-            -
                public function assertList($value)
-            -
                {
-            -
                    if ($value[0] !== Type::T_LIST) {
-            -
                        $this->throwError('expecting list');
-            -
                    }
-            -
-            -
                    return $value;
-            -
                }
-            -
-            -
                /**
-            -
                 * Assert value is a color
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param array $value
-            -
                 *
-            -
                 * @return array
-            -
                 *
-            -
                 * @throws \Exception
-            -
                 */
-            -
                public function assertColor($value)
-            -
                {
-            -
                    if ($color = $this->coerceColor($value)) {
-            -
                        return $color;
-            -
                    }
-            -
-            -
                    $this->throwError('expecting color');
-            -
                }
-            -
-            -
                /**
-            -
                 * Assert value is a number
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param array $value
-            -
                 *
-            -
                 * @return integer|float
-            -
                 *
-            -
                 * @throws \Exception
-            -
                 */
-            -
                public function assertNumber($value)
-            -
                {
-            -
                    if ($value[0] !== Type::T_NUMBER) {
-            -
                        $this->throwError('expecting number');
-            -
                    }
-            -
-            -
                    return $value[1];
-            -
                }
-            -
-            -
                /**
-            -
                 * Make sure a color's components don't go out of bounds
-            -
                 *
-            -
                 * @param array $c
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function fixColor($c)
-            -
                {
-            -
                    foreach (array(1, 2, 3) as $i) {
-            -
                        if ($c[$i] < 0) {
-            -
                            $c[$i] = 0;
-            -
                        }
-            -
-            -
                        if ($c[$i] > 255) {
-            -
                            $c[$i] = 255;
-            -
                        }
-            -
                    }
-            -
-            -
                    return $c;
-            -
                }
-            -
-            -
                /**
-            -
                 * Convert RGB to HSL
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param integer $red
-            -
                 * @param integer $green
-            -
                 * @param integer $blue
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                public function toHSL($red, $green, $blue)
-            -
                {
-            -
                    $min = min($red, $green, $blue);
-            -
                    $max = max($red, $green, $blue);
-            -
-            -
                    $l = $min + $max;
-            -
                    $d = $max - $min;
-            -
-            -
                    if ((int) $d === 0) {
-            -
                        $h = $s = 0;
-            -
                    } else {
-            -
                        if ($l < 255) {
-            -
                            $s = $d / $l;
-            -
                        } else {
-            -
                            $s = $d / (510 - $l);
-            -
                        }
-            -
-            -
                        if ($red == $max) {
-            -
                            $h = 60 * ($green - $blue) / $d;
-            -
                        } elseif ($green == $max) {
-            -
                            $h = 60 * ($blue - $red) / $d + 120;
-            -
                        } elseif ($blue == $max) {
-            -
                            $h = 60 * ($red - $green) / $d + 240;
-            -
                        }
-            -
                    }
-            -
-            -
                    return array(Type::T_HSL, fmod($h, 360), $s * 100, $l / 5.1);
-            -
                }
-            -
-            -
                /**
-            -
                 * Hue to RGB helper
-            -
                 *
-            -
                 * @param float $m1
-            -
                 * @param float $m2
-            -
                 * @param float $h
-            -
                 *
-            -
                 * @return float
-            -
                 */
-            -
                private function hueToRGB($m1, $m2, $h)
-            -
                {
-            -
                    if ($h < 0) {
-            -
                        $h += 1;
-            -
                    } elseif ($h > 1) {
-            -
                        $h -= 1;
-            -
                    }
-            -
-            -
                    if ($h * 6 < 1) {
-            -
                        return $m1 + ($m2 - $m1) * $h * 6;
-            -
                    }
-            -
-            -
                    if ($h * 2 < 1) {
-            -
                        return $m2;
-            -
                    }
-            -
-            -
                    if ($h * 3 < 2) {
-            -
                        return $m1 + ($m2 - $m1) * (2/3 - $h) * 6;
-            -
                    }
-            -
-            -
                    return $m1;
-            -
                }
-            -
-            -
                /**
-            -
                 * Convert HSL to RGB
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param integer $hue        H from 0 to 360
-            -
                 * @param integer $saturation S from 0 to 100
-            -
                 * @param integer $lightness  L from 0 to 100
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                public function toRGB($hue, $saturation, $lightness)
-            -
                {
-            -
                    if ($hue < 0) {
-            -
                        $hue += 360;
-            -
                    }
-            -
-            -
                    $h = $hue / 360;
-            -
                    $s = min(100, max(0, $saturation)) / 100;
-            -
                    $l = min(100, max(0, $lightness)) / 100;
-            -
-            -
                    $m2 = $l <= 0.5 ? $l * ($s + 1) : $l + $s - $l * $s;
-            -
                    $m1 = $l * 2 - $m2;
-            -
-            -
                    $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;
-            -
-            -
                    $out = array(Type::T_COLOR, $r, $g, $b);
-            -
-            -
                    return $out;
-            -
                }
-            -
-            -
                // Built in functions
-            -
-            -
                //protected static $libCall = array('name', 'args...');
-            -
                protected function libCall($args, $kwargs)
-            -
                {
-            -
                    $name = $this->compileStringContent($this->coerceString($this->reduce(array_shift($args), true)));
-            -
-            -
                    $args = array_map(
-            -
                        function ($a) {
-            -
                            return array(null, $a, false);
-            -
                        },
-            -
                        $args
-            -
                    );
-            -
-            -
                    if (count($kwargs)) {
-            -
                        foreach ($kwargs as $key => $value) {
-            -
                            $args[] = array(array(Type::T_VARIABLE, $key), $value, false);
-            -
                        }
-            -
                    }
-            -
-            -
                    return $this->reduce(array(Type::T_FUNCTION_CALL, $name, $args));
-            -
                }
-            -
-            -
                protected static $libIf = array('condition', 'if-true', 'if-false');
-            -
                protected function libIf($args)
-            -
                {
-            -
                    list($cond, $t, $f) = $args;
-            -
-            -
                    if (! $this->isTruthy($this->reduce($cond, true))) {
-            -
                        return $this->reduce($f, true);
-            -
                    }
-            -
-            -
                    return $this->reduce($t, true);
-            -
                }
-            -
-            -
                protected static $libIndex = array('list', 'value');
-            -
                protected function libIndex($args)
-            -
                {
-            -
                    list($list, $value) = $args;
-            -
-            -
                    if ($value[0] === Type::T_MAP) {
-            -
                        return self::$null;
-            -
                    }
-            -
-            -
                    if ($list[0] === Type::T_MAP ||
-            -
                        $list[0] === Type::T_STRING ||
-            -
                        $list[0] === Type::T_KEYWORD ||
-            -
                        $list[0] === Type::T_INTERPOLATE
-            -
                    ) {
-            -
                        $list = $this->coerceList($list, ' ');
-            -
                    }
-            -
-            -
                    if ($list[0] !== Type::T_LIST) {
-            -
                        return self::$null;
-            -
                    }
-            -
-            -
                    $values = array();
-            -
-            -
                    foreach ($list[2] as $item) {
-            -
                        $values[] = $this->normalizeValue($item);
-            -
                    }
-            -
-            -
                    $key = array_search($this->normalizeValue($value), $values);
-            -
-            -
                    return false === $key ? self::$null : $key + 1;
-            -
                }
-            -
-            -
                protected static $libRgb = array('red', 'green', 'blue');
-            -
                protected function libRgb($args)
-            -
                {
-            -
                    list($r, $g, $b) = $args;
-            -
-            -
                    return array(Type::T_COLOR, $r[1], $g[1], $b[1]);
-            -
                }
-            -
-            -
                protected static $libRgba = array(
-            -
                    array('red', 'color'),
-            -
                    'green', 'blue', 'alpha');
-            -
                protected function libRgba($args)
-            -
                {
-            -
                    if ($color = $this->coerceColor($args[0])) {
-            -
                        // workaround https://github.com/facebook/hhvm/issues/5457
-            -
                        reset($args);
-            -
-            -
                        $num = ! isset($args[1]) ? $args[3] : $args[1];
-            -
                        $alpha = $this->assertNumber($num);
-            -
                        $color[4] = $alpha;
-            -
-            -
                        return $color;
-            -
                    }
-            -
-            -
                    list($r, $g, $b, $a) = $args;
-            -
-            -
                    return array(Type::T_COLOR, $r[1], $g[1], $b[1], $a[1]);
-            -
                }
-            -
-            -
                // helper function for adjust_color, change_color, and scale_color
-            -
                protected function alterColor($args, $fn)
-            -
                {
-            -
                    $color = $this->assertColor($args[0]);
-            -
-            -
                    // workaround https://github.com/facebook/hhvm/issues/5457
-            -
                    reset($args);
-            -
-            -
                    foreach (array(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);
-            -
                        }
-            -
                    }
-            -
-            -
                    if (isset($args[4]) || isset($args[5]) || isset($args[6])) {
-            -
                        $hsl = $this->toHSL($color[1], $color[2], $color[3]);
-            -
-            -
                        foreach (array(4, 5, 6) as $i) {
-            -
                            if (isset($args[$i])) {
-            -
                                $val = $this->assertNumber($args[$i]);
-            -
                                $hsl[$i - 3] = call_user_func($fn, $hsl[$i - 3], $val, $i);
-            -
                            }
-            -
                        }
-            -
-            -
                        $rgb = $this->toRGB($hsl[1], $hsl[2], $hsl[3]);
-            -
-            -
                        if (isset($color[4])) {
-            -
                            $rgb[4] = $color[4];
-            -
                        }
-            -
-            -
                        $color = $rgb;
-            -
                    }
-            -
-            -
                    return $color;
-            -
                }
-            -
-            -
                protected static $libAdjustColor = array(
-            -
                    'color', 'red', 'green', 'blue',
-            -
                    'hue', 'saturation', 'lightness', 'alpha'
-            -
                );
-            -
                protected function libAdjustColor($args)
-            -
                {
-            -
                    return $this->alterColor($args, function ($base, $alter, $i) {
-            -
                        return $base + $alter;
-            -
                    });
-            -
                }
-            -
-            -
                protected static $libChangeColor = array(
-            -
                    'color', 'red', 'green', 'blue',
-            -
                    'hue', 'saturation', 'lightness', 'alpha'
-            -
                );
-            -
                protected function libChangeColor($args)
-            -
                {
-            -
                    return $this->alterColor($args, function ($base, $alter, $i) {
-            -
                        return $alter;
-            -
                    });
-            -
                }
-            -
-            -
                protected static $libScaleColor = array(
-            -
                    'color', 'red', 'green', 'blue',
-            -
                    'hue', 'saturation', 'lightness', 'alpha'
-            -
                );
-            -
                protected function libScaleColor($args)
-            -
                {
-            -
                    return $this->alterColor($args, function ($base, $scale, $i) {
-            -
                        // 1, 2, 3 - rgb
-            -
                        // 4, 5, 6 - hsl
-            -
                        // 7 - a
-            -
                        switch ($i) {
-            -
                            case 1:
-            -
                            case 2:
-            -
                            case 3:
-            -
                                $max = 255;
-            -
                                break;
-            -
-            -
                            case 4:
-            -
                                $max = 360;
-            -
                                break;
-            -
-            -
                            case 7:
-            -
                                $max = 1;
-            -
                                break;
-            -
-            -
                            default:
-            -
                                $max = 100;
-            -
                        }
-            -
-            -
                        $scale = $scale / 100;
-            -
-            -
                        if ($scale < 0) {
-            -
                            return $base * $scale + $base;
-            -
                        }
-            -
-            -
                        return ($max - $base) * $scale + $base;
-            -
                    });
-            -
                }
-            -
-            -
                protected static $libIeHexStr = array('color');
-            -
                protected function libIeHexStr($args)
-            -
                {
-            -
                    $color = $this->coerceColor($args[0]);
-            -
                    $color[4] = isset($color[4]) ? round(255*$color[4]) : 255;
-            -
-            -
                    return sprintf('#%02X%02X%02X%02X', $color[4], $color[1], $color[2], $color[3]);
-            -
                }
-            -
-            -
                protected static $libRed = array('color');
-            -
                protected function libRed($args)
-            -
                {
-            -
                    $color = $this->coerceColor($args[0]);
-            -
-            -
                    return $color[1];
-            -
                }
-            -
-            -
                protected static $libGreen = array('color');
-            -
                protected function libGreen($args)
-            -
                {
-            -
                    $color = $this->coerceColor($args[0]);
-            -
-            -
                    return $color[2];
-            -
                }
-            -
-            -
                protected static $libBlue = array('color');
-            -
                protected function libBlue($args)
-            -
                {
-            -
                    $color = $this->coerceColor($args[0]);
-            -
-            -
                    return $color[3];
-            -
                }
-            -
-            -
                protected static $libAlpha = array('color');
-            -
                protected function libAlpha($args)
-            -
                {
-            -
                    if ($color = $this->coerceColor($args[0])) {
-            -
                        return isset($color[4]) ? $color[4] : 1;
-            -
                    }
-            -
-            -
                    // this might be the IE function, so return value unchanged
-            -
                    return null;
-            -
                }
-            -
-            -
                protected static $libOpacity = array('color');
-            -
                protected function libOpacity($args)
-            -
                {
-            -
                    $value = $args[0];
-            -
-            -
                    if ($value[0] === Type::T_NUMBER) {
-            -
                        return null;
-            -
                    }
-            -
-            -
                    return $this->libAlpha($args);
-            -
                }
-            -
-            -
                // mix two colors
-            -
                protected static $libMix = array('color-1', 'color-2', 'weight');
-            -
                protected function libMix($args)
-            -
                {
-            -
                    list($first, $second, $weight) = $args;
-            -
-            -
                    $first = $this->assertColor($first);
-            -
                    $second = $this->assertColor($second);
-            -
-            -
                    if (! isset($weight)) {
-            -
                        $weight = 0.5;
-            -
                    } else {
-            -
                        $weight = $this->coercePercent($weight);
-            -
                    }
-            -
-            -
                    $firstAlpha = isset($first[4]) ? $first[4] : 1;
-            -
                    $secondAlpha = isset($second[4]) ? $second[4] : 1;
-            -
-            -
                    $w = $weight * 2 - 1;
-            -
                    $a = $firstAlpha - $secondAlpha;
-            -
-            -
                    $w1 = (($w * $a === -1 ? $w : ($w + $a) / (1 + $w * $a)) + 1) / 2.0;
-            -
                    $w2 = 1.0 - $w1;
-            -
-            -
                    $new = array(Type::T_COLOR,
-            -
                        $w1 * $first[1] + $w2 * $second[1],
-            -
                        $w1 * $first[2] + $w2 * $second[2],
-            -
                        $w1 * $first[3] + $w2 * $second[3],
-            -
                    );
-            -
-            -
                    if ($firstAlpha != 1.0 || $secondAlpha != 1.0) {
-            -
                        $new[] = $firstAlpha * $weight + $secondAlpha * ($weight - 1);
-            -
                    }
-            -
-            -
                    return $this->fixColor($new);
-            -
                }
-            -
-            -
                protected static $libHsl = array('hue', 'saturation', 'lightness');
-            -
                protected function libHsl($args)
-            -
                {
-            -
                    list($h, $s, $l) = $args;
-            -
-            -
                    return $this->toRGB($h[1], $s[1], $l[1]);
-            -
                }
-            -
-            -
                protected static $libHsla = array('hue', 'saturation', 'lightness', 'alpha');
-            -
                protected function libHsla($args)
-            -
                {
-            -
                    list($h, $s, $l, $a) = $args;
-            -
-            -
                    $color = $this->toRGB($h[1], $s[1], $l[1]);
-            -
                    $color[4] = $a[1];
-            -
-            -
                    return $color;
-            -
                }
-            -
-            -
                protected static $libHue = array('color');
-            -
                protected function libHue($args)
-            -
                {
-            -
                    $color = $this->assertColor($args[0]);
-            -
                    $hsl = $this->toHSL($color[1], $color[2], $color[3]);
-            -
-            -
                    return new Node\Number($hsl[1], 'deg');
-            -
                }
-            -
-            -
                protected static $libSaturation = array('color');
-            -
                protected function libSaturation($args)
-            -
                {
-            -
                    $color = $this->assertColor($args[0]);
-            -
                    $hsl = $this->toHSL($color[1], $color[2], $color[3]);
-            -
-            -
                    return new Node\Number($hsl[2], '%');
-            -
                }
-            -
-            -
                protected static $libLightness = array('color');
-            -
                protected function libLightness($args)
-            -
                {
-            -
                    $color = $this->assertColor($args[0]);
-            -
                    $hsl = $this->toHSL($color[1], $color[2], $color[3]);
-            -
-            -
                    return new Node\Number($hsl[3], '%');
-            -
                }
-            -
-            -
                protected function adjustHsl($color, $idx, $amount)
-            -
                {
-            -
                    $hsl = $this->toHSL($color[1], $color[2], $color[3]);
-            -
                    $hsl[$idx] += $amount;
-            -
                    $out = $this->toRGB($hsl[1], $hsl[2], $hsl[3]);
-            -
-            -
                    if (isset($color[4])) {
-            -
                        $out[4] = $color[4];
-            -
                    }
-            -
-            -
                    return $out;
-            -
                }
-            -
-            -
                protected static $libAdjustHue = array('color', 'degrees');
-            -
                protected function libAdjustHue($args)
-            -
                {
-            -
                    $color = $this->assertColor($args[0]);
-            -
                    $degrees = $this->assertNumber($args[1]);
-            -
-            -
                    return $this->adjustHsl($color, 1, $degrees);
-            -
                }
-            -
-            -
                protected static $libLighten = array('color', 'amount');
-            -
                protected function libLighten($args)
-            -
                {
-            -
                    $color = $this->assertColor($args[0]);
-            -
                    $amount = Util::checkRange('amount', new Range(0, 100), $args[1], '%');
-            -
-            -
                    return $this->adjustHsl($color, 3, $amount);
-            -
                }
-            -
-            -
                protected static $libDarken = array('color', 'amount');
-            -
                protected function libDarken($args)
-            -
                {
-            -
                    $color = $this->assertColor($args[0]);
-            -
                    $amount = Util::checkRange('amount', new Range(0, 100), $args[1], '%');
-            -
-            -
                    return $this->adjustHsl($color, 3, -$amount);
-            -
                }
-            -
-            -
                protected static $libSaturate = array('color', 'amount');
-            -
                protected function libSaturate($args)
-            -
                {
-            -
                    $value = $args[0];
-            -
-            -
                    if ($value[0] === Type::T_NUMBER) {
-            -
                        return null;
-            -
                    }
-            -
-            -
                    $color = $this->assertColor($value);
-            -
                    $amount = 100 * $this->coercePercent($args[1]);
-            -
-            -
                    return $this->adjustHsl($color, 2, $amount);
-            -
                }
-            -
-            -
                protected static $libDesaturate = array('color', 'amount');
-            -
                protected function libDesaturate($args)
-            -
                {
-            -
                    $color = $this->assertColor($args[0]);
-            -
                    $amount = 100 * $this->coercePercent($args[1]);
-            -
-            -
                    return $this->adjustHsl($color, 2, -$amount);
-            -
                }
-            -
-            -
                protected static $libGrayscale = array('color');
-            -
                protected function libGrayscale($args)
-            -
                {
-            -
                    $value = $args[0];
-            -
-            -
                    if ($value[0] === Type::T_NUMBER) {
-            -
                        return null;
-            -
                    }
-            -
-            -
                    return $this->adjustHsl($this->assertColor($value), 2, -100);
-            -
                }
-            -
-            -
                protected static $libComplement = array('color');
-            -
                protected function libComplement($args)
-            -
                {
-            -
                    return $this->adjustHsl($this->assertColor($args[0]), 1, 180);
-            -
                }
-            -
-            -
                protected static $libInvert = array('color');
-            -
                protected function libInvert($args)
-            -
                {
-            -
                    $value = $args[0];
-            -
-            -
                    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];
-            -
-            -
                    return $color;
-            -
                }
-            -
-            -
                // increases opacity by amount
-            -
                protected static $libOpacify = array('color', 'amount');
-            -
                protected function libOpacify($args)
-            -
                {
-            -
                    $color = $this->assertColor($args[0]);
-            -
                    $amount = $this->coercePercent($args[1]);
-            -
-            -
                    $color[4] = (isset($color[4]) ? $color[4] : 1) + $amount;
-            -
                    $color[4] = min(1, max(0, $color[4]));
-            -
-            -
                    return $color;
-            -
                }
-            -
-            -
                protected static $libFadeIn = array('color', 'amount');
-            -
                protected function libFadeIn($args)
-            -
                {
-            -
                    return $this->libOpacify($args);
-            -
                }
-            -
-            -
                // decreases opacity by amount
-            -
                protected static $libTransparentize = array('color', 'amount');
-            -
                protected function libTransparentize($args)
-            -
                {
-            -
                    $color = $this->assertColor($args[0]);
-            -
                    $amount = $this->coercePercent($args[1]);
-            -
-            -
                    $color[4] = (isset($color[4]) ? $color[4] : 1) - $amount;
-            -
                    $color[4] = min(1, max(0, $color[4]));
-            -
-            -
                    return $color;
-            -
                }
-            -
-            -
                protected static $libFadeOut = array('color', 'amount');
-            -
                protected function libFadeOut($args)
-            -
                {
-            -
                    return $this->libTransparentize($args);
-            -
                }
-            -
-            -
                protected static $libUnquote = array('string');
-            -
                protected function libUnquote($args)
-            -
                {
-            -
                    $str = $args[0];
-            -
-            -
                    if ($str[0] === Type::T_STRING) {
-            -
                        $str[1] = '';
-            -
                    }
-            -
-            -
                    return $str;
-            -
                }
-            -
-            -
                protected static $libQuote = array('string');
-            -
                protected function libQuote($args)
-            -
                {
-            -
                    $value = $args[0];
-            -
-            -
                    if ($value[0] === Type::T_STRING && ! empty($value[1])) {
-            -
                        return $value;
-            -
                    }
-            -
-            -
                    return array(Type::T_STRING, '"', array($value));
-            -
                }
-            -
-            -
                protected static $libPercentage = array('value');
-            -
                protected function libPercentage($args)
-            -
                {
-            -
                    return new Node\Number($this->coercePercent($args[0]) * 100, '%');
-            -
                }
-            -
-            -
                protected static $libRound = array('value');
-            -
                protected function libRound($args)
-            -
                {
-            -
                    $num = $args[0];
-            -
                    $num[1] = round($num[1]);
-            -
-            -
                    return $num;
-            -
                }
-            -
-            -
                protected static $libFloor = array('value');
-            -
                protected function libFloor($args)
-            -
                {
-            -
                    $num = $args[0];
-            -
                    $num[1] = floor($num[1]);
-            -
-            -
                    return $num;
-            -
                }
-            -
-            -
                protected static $libCeil = array('value');
-            -
                protected function libCeil($args)
-            -
                {
-            -
                    $num = $args[0];
-            -
                    $num[1] = ceil($num[1]);
-            -
-            -
                    return $num;
-            -
                }
-            -
-            -
                protected static $libAbs = array('value');
-            -
                protected function libAbs($args)
-            -
                {
-            -
                    $num = $args[0];
-            -
                    $num[1] = abs($num[1]);
-            -
-            -
                    return $num;
-            -
                }
-            -
-            -
                protected function libMin($args)
-            -
                {
-            -
                    $numbers = $this->getNormalizedNumbers($args);
-            -
                    $min = null;
-            -
-            -
                    foreach ($numbers as $key => $number) {
-            -
                        if (null === $min || $number[1] <= $min[1]) {
-            -
                            $min = array($key, $number[1]);
-            -
                        }
-            -
                    }
-            -
-            -
                    return $args[$min[0]];
-            -
                }
-            -
-            -
                protected function libMax($args)
-            -
                {
-            -
                    $numbers = $this->getNormalizedNumbers($args);
-            -
                    $max = null;
-            -
-            -
                    foreach ($numbers as $key => $number) {
-            -
                        if (null === $max || $number[1] >= $max[1]) {
-            -
                            $max = array($key, $number[1]);
-            -
                        }
-            -
                    }
-            -
-            -
                    return $args[$max[0]];
-            -
                }
-            -
-            -
                /**
-            -
                 * Helper to normalize args containing numbers
-            -
                 *
-            -
                 * @param array $args
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function getNormalizedNumbers($args)
-            -
                {
-            -
                    $unit = null;
-            -
                    $originalUnit = null;
-            -
                    $numbers = array();
-            -
-            -
                    foreach ($args as $key => $item) {
-            -
                        if ($item[0] !== Type::T_NUMBER) {
-            -
                            $this->throwError('%s is not a number', $item[0]);
-            -
                        }
-            -
-            -
                        $number = $item->normalize();
-            -
-            -
                        if (null === $unit) {
-            -
                            $unit = $number[2];
-            -
                            $originalUnit = $item->unitStr();
-            -
                        } elseif ($unit !== $number[2]) {
-            -
                            $this->throwError('Incompatible units: "%s" and "%s".', $originalUnit, $item->unitStr());
-            -
                        }
-            -
-            -
                        $numbers[$key] = $number;
-            -
                    }
-            -
-            -
                    return $numbers;
-            -
                }
-            -
-            -
                protected static $libLength = array('list');
-            -
                protected function libLength($args)
-            -
                {
-            -
                    $list = $this->coerceList($args[0]);
-            -
-            -
                    return count($list[2]);
-            -
                }
-            -
-            -
                // TODO: need a way to declare this built-in as varargs
-            -
                //protected static $libListSeparator = array('list...');
-            -
                protected function libListSeparator($args)
-            -
                {
-            -
                    if (count($args) > 1) {
-            -
                        return 'comma';
-            -
                    }
-            -
-            -
                    $list = $this->coerceList($args[0]);
-            -
-            -
                    if (count($list[2]) <= 1) {
-            -
                        return 'space';
-            -
                    }
-            -
-            -
                    if ($list[1] === ',') {
-            -
                        return 'comma';
-            -
                    }
-            -
-            -
                    return 'space';
-            -
                }
-            -
-            -
                protected static $libNth = array('list', 'n');
-            -
                protected function libNth($args)
-            -
                {
-            -
                    $list = $this->coerceList($args[0]);
-            -
                    $n = $this->assertNumber($args[1]);
-            -
-            -
                    if ($n > 0) {
-            -
                        $n--;
-            -
                    } elseif ($n < 0) {
-            -
                        $n += count($list[2]);
-            -
                    }
-            -
-            -
                    return isset($list[2][$n]) ? $list[2][$n] : self::$defaultValue;
-            -
                }
-            -
-            -
                protected static $libSetNth = array('list', 'n', 'value');
-            -
                protected function libSetNth($args)
-            -
                {
-            -
                    $list = $this->coerceList($args[0]);
-            -
                    $n = $this->assertNumber($args[1]);
-            -
-            -
                    if ($n > 0) {
-            -
                        $n--;
-            -
                    } elseif ($n < 0) {
-            -
                        $n += count($list[2]);
-            -
                    }
-            -
-            -
                    if (! isset($list[2][$n])) {
-            -
                        $this->throwError('Invalid argument for "n"');
-            -
                    }
-            -
-            -
                    $list[2][$n] = $args[2];
-            -
-            -
                    return $list;
-            -
                }
-            -
-            -
                protected static $libMapGet = array('map', 'key');
-            -
                protected function libMapGet($args)
-            -
                {
-            -
                    $map = $this->assertMap($args[0]);
-            -
                    $key = $this->compileStringContent($this->coerceString($args[1]));
-            -
-            -
                    for ($i = count($map[1]) - 1; $i >= 0; $i--) {
-            -
                        if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) {
-            -
                            return $map[2][$i];
-            -
                        }
-            -
                    }
-            -
-            -
                    return self::$null;
-            -
                }
-            -
-            -
                protected static $libMapKeys = array('map');
-            -
                protected function libMapKeys($args)
-            -
                {
-            -
                    $map = $this->assertMap($args[0]);
-            -
                    $keys = $map[1];
-            -
-            -
                    return array(Type::T_LIST, ',', $keys);
-            -
                }
-            -
-            -
                protected static $libMapValues = array('map');
-            -
                protected function libMapValues($args)
-            -
                {
-            -
                    $map = $this->assertMap($args[0]);
-            -
                    $values = $map[2];
-            -
-            -
                    return array(Type::T_LIST, ',', $values);
-            -
                }
-            -
-            -
                protected static $libMapRemove = array('map', 'key');
-            -
                protected function libMapRemove($args)
-            -
                {
-            -
                    $map = $this->assertMap($args[0]);
-            -
                    $key = $this->compileStringContent($this->coerceString($args[1]));
-            -
-            -
                    for ($i = count($map[1]) - 1; $i >= 0; $i--) {
-            -
                        if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) {
-            -
                            array_splice($map[1], $i, 1);
-            -
                            array_splice($map[2], $i, 1);
-            -
                        }
-            -
                    }
-            -
-            -
                    return $map;
-            -
                }
-            -
-            -
                protected static $libMapHasKey = array('map', 'key');
-            -
                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--) {
-            -
                        if ($key === $this->compileStringContent($this->coerceString($map[1][$i]))) {
-            -
                            return true;
-            -
                        }
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                protected static $libMapMerge = array('map-1', 'map-2');
-            -
                protected function libMapMerge($args)
-            -
                {
-            -
                    $map1 = $this->assertMap($args[0]);
-            -
                    $map2 = $this->assertMap($args[1]);
-            -
-            -
                    return array(Type::T_MAP, array_merge($map1[1], $map2[1]), array_merge($map1[2], $map2[2]));
-            -
                }
-            -
-            -
                protected function listSeparatorForJoin($list1, $sep)
-            -
                {
-            -
                    if (! isset($sep)) {
-            -
                        return $list1[1];
-            -
                    }
-            -
-            -
                    switch ($this->compileValue($sep)) {
-            -
                        case 'comma':
-            -
                            return ',';
-            -
-            -
                        case 'space':
-            -
                            return '';
-            -
-            -
                        default:
-            -
                            return $list1[1];
-            -
                    }
-            -
                }
-            -
-            -
                protected static $libJoin = array('list1', 'list2', 'separator');
-            -
                protected function libJoin($args)
-            -
                {
-            -
                    list($list1, $list2, $sep) = $args;
-            -
-            -
                    $list1 = $this->coerceList($list1, ' ');
-            -
                    $list2 = $this->coerceList($list2, ' ');
-            -
                    $sep = $this->listSeparatorForJoin($list1, $sep);
-            -
-            -
                    return array(Type::T_LIST, $sep, array_merge($list1[2], $list2[2]));
-            -
                }
-            -
-            -
                protected static $libAppend = array('list', 'val', 'separator');
-            -
                protected function libAppend($args)
-            -
                {
-            -
                    list($list1, $value, $sep) = $args;
-            -
-            -
                    $list1 = $this->coerceList($list1, ' ');
-            -
                    $sep = $this->listSeparatorForJoin($list1, $sep);
-            -
-            -
                    return array(Type::T_LIST, $sep, array_merge($list1[2], array($value)));
-            -
                }
-            -
-            -
                protected function libZip($args)
-            -
                {
-            -
                    foreach ($args as $arg) {
-            -
                        $this->assertList($arg);
-            -
                    }
-            -
-            -
                    $lists = array();
-            -
                    $firstList = array_shift($args);
-            -
-            -
                    foreach ($firstList[2] as $key => $item) {
-            -
                        $list = array(Type::T_LIST, '', array($item));
-            -
-            -
                        foreach ($args as $arg) {
-            -
                            if (isset($arg[2][$key])) {
-            -
                                $list[2][] = $arg[2][$key];
-            -
                            } else {
-            -
                                break 2;
-            -
                            }
-            -
                        }
-            -
-            -
                        $lists[] = $list;
-            -
                    }
-            -
-            -
                    return array(Type::T_LIST, ',', $lists);
-            -
                }
-            -
-            -
                protected static $libTypeOf = array('value');
-            -
                protected function libTypeOf($args)
-            -
                {
-            -
                    $value = $args[0];
-            -
-            -
                    switch ($value[0]) {
-            -
                        case Type::T_KEYWORD:
-            -
                            if ($value === self::$true || $value === self::$false) {
-            -
                                return 'bool';
-            -
                            }
-            -
-            -
                            if ($this->coerceColor($value)) {
-            -
                                return 'color';
-            -
                            }
-            -
-            -
                            // fall-thru
-            -
                        case Type::T_FUNCTION:
-            -
                            return 'string';
-            -
-            -
                        case Type::T_LIST:
-            -
                            if (isset($value[3]) && $value[3]) {
-            -
                                return 'arglist';
-            -
                            }
-            -
-            -
                            // fall-thru
-            -
                        default:
-            -
                            return $value[0];
-            -
                    }
-            -
                }
-            -
-            -
                protected static $libUnit = array('number');
-            -
                protected function libUnit($args)
-            -
                {
-            -
                    $num = $args[0];
-            -
-            -
                    if ($num[0] === Type::T_NUMBER) {
-            -
                        return array(Type::T_STRING, '"', array($num->unitStr()));
-            -
                    }
-            -
-            -
                    return '';
-            -
                }
-            -
-            -
                protected static $libUnitless = array('number');
-            -
                protected function libUnitless($args)
-            -
                {
-            -
                    $value = $args[0];
-            -
-            -
                    return $value[0] === Type::T_NUMBER && $value->unitless();
-            -
                }
-            -
-            -
                protected static $libComparable = array('number-1', 'number-2');
-            -
                protected function libComparable($args)
-            -
                {
-            -
                    list($number1, $number2) = $args;
-            -
-            -
                    if (! isset($number1[0]) || $number1[0] !== Type::T_NUMBER ||
-            -
                        ! isset($number2[0]) || $number2[0] !== Type::T_NUMBER
-            -
                    ) {
-            -
                        $this->throwError('Invalid argument(s) for "comparable"');
-            -
                    }
-            -
-            -
                    $number1 = $number1->normalize();
-            -
                    $number2 = $number2->normalize();
-            -
-            -
                    return $number1[2] === $number2[2] || $number1->unitless() || $number2->unitless();
-            -
                }
-            -
-            -
                protected static $libStrIndex = array('string', 'substring');
-            -
                protected function libStrIndex($args)
-            -
                {
-            -
                    $string = $this->coerceString($args[0]);
-            -
                    $stringContent = $this->compileStringContent($string);
-            -
-            -
                    $substring = $this->coerceString($args[1]);
-            -
                    $substringContent = $this->compileStringContent($substring);
-            -
-            -
                    $result = strpos($stringContent, $substringContent);
-            -
-            -
                    return $result === false ? self::$null : new Node\Number($result + 1, '');
-            -
                }
-            -
-            -
                protected static $libStrInsert = array('string', 'insert', 'index');
-            -
                protected function libStrInsert($args)
-            -
                {
-            -
                    $string = $this->coerceString($args[0]);
-            -
                    $stringContent = $this->compileStringContent($string);
-            -
-            -
                    $insert = $this->coerceString($args[1]);
-            -
                    $insertContent = $this->compileStringContent($insert);
-            -
-            -
                    list(, $index) = $args[2];
-            -
-            -
                    $string[2] = array(substr_replace($stringContent, $insertContent, $index - 1, 0));
-            -
-            -
                    return $string;
-            -
                }
-            -
-            -
                protected static $libStrLength = array('string');
-            -
                protected function libStrLength($args)
-            -
                {
-            -
                    $string = $this->coerceString($args[0]);
-            -
                    $stringContent = $this->compileStringContent($string);
-            -
-            -
                    return new Node\Number(strlen($stringContent), '');
-            -
                }
-            -
-            -
                protected static $libStrSlice = array('string', 'start-at', 'end-at');
-            -
                protected function libStrSlice($args)
-            -
                {
-            -
                    if ($args[2][1] == 0) {
-            -
                        return self::$null;
-            -
                    }
-            -
-            -
                    $string = $this->coerceString($args[0]);
-            -
                    $stringContent = $this->compileStringContent($string);
-            -
-            -
                    $start = (int) $args[1][1] ?: 1;
-            -
                    $end = (int) $args[2][1];
-            -
-            -
                    $string[2] = array(substr($stringContent, $start - 1, ($end < 0 ? $end : $end - $start) + 1));
-            -
-            -
                    return $string;
-            -
                }
-            -
-            -
                protected static $libToLowerCase = array('string');
-            -
                protected function libToLowerCase($args)
-            -
                {
-            -
                    $string = $this->coerceString($args[0]);
-            -
                    $stringContent = $this->compileStringContent($string);
-            -
-            -
                    $string[2] = array(mb_strtolower($stringContent));
-            -
-            -
                    return $string;
-            -
                }
-            -
-            -
                protected static $libToUpperCase = array('string');
-            -
                protected function libToUpperCase($args)
-            -
                {
-            -
                    $string = $this->coerceString($args[0]);
-            -
                    $stringContent = $this->compileStringContent($string);
-            -
-            -
                    $string[2] = array(mb_strtoupper($stringContent));
-            -
-            -
                    return $string;
-            -
                }
-            -
-            -
                protected static $libFeatureExists = array('feature');
-            -
                protected function libFeatureExists($args)
-            -
                {
-            -
                    $string = $this->coerceString($args[0]);
-            -
                    $name = $this->compileStringContent($string);
-            -
-            -
                    return $this->toBool(
-            -
                        array_key_exists($name, $this->registeredFeatures) ? $this->registeredFeatures[$name] : false
-            -
                    );
-            -
                }
-            -
-            -
                protected static $libFunctionExists = array('name');
-            -
                protected function libFunctionExists($args)
-            -
                {
-            -
                    $string = $this->coerceString($args[0]);
-            -
                    $name = $this->compileStringContent($string);
-            -
-            -
                    // user defined functions
-            -
                    if ($this->has(self::$namespaces['function'] . $name)) {
-            -
                        return true;
-            -
                    }
-            -
-            -
                    $name = $this->normalizeName($name);
-            -
-            -
                    if (isset($this->userFunctions[$name])) {
-            -
                        return true;
-            -
                    }
-            -
-            -
                    // built-in functions
-            -
                    $f = $this->getBuiltinFunction($name);
-            -
-            -
                    return $this->toBool(is_callable($f));
-            -
                }
-            -
-            -
                protected static $libGlobalVariableExists = array('name');
-            -
                protected function libGlobalVariableExists($args)
-            -
                {
-            -
                    $string = $this->coerceString($args[0]);
-            -
                    $name = $this->compileStringContent($string);
-            -
-            -
                    return $this->has($name, $this->rootEnv);
-            -
                }
-            -
-            -
                protected static $libMixinExists = array('name');
-            -
                protected function libMixinExists($args)
-            -
                {
-            -
                    $string = $this->coerceString($args[0]);
-            -
                    $name = $this->compileStringContent($string);
-            -
-            -
                    return $this->has(self::$namespaces['mixin'] . $name);
-            -
                }
-            -
-            -
                protected static $libVariableExists = array('name');
-            -
                protected function libVariableExists($args)
-            -
                {
-            -
                    $string = $this->coerceString($args[0]);
-            -
                    $name = $this->compileStringContent($string);
-            -
-            -
                    return $this->has($name);
-            -
                }
-            -
-            -
                /**
-            -
                 * Workaround IE7's content counter bug.
-            -
                 *
-            -
                 * @param array $args
-            -
                 */
-            -
                protected function libCounter($args)
-            -
                {
-            -
                    $list = array_map(array($this, 'compileValue'), $args);
-            -
-            -
                    return array(Type::T_STRING, '', array('counter(' . implode(',', $list) . ')'));
-            -
                }
-            -
-            -
                protected function libRandom($args)
-            -
                {
-            -
                    if (isset($args[0])) {
-            -
                        $n = $this->assertNumber($args[0]);
-            -
-            -
                        if ($n < 1) {
-            -
                            $this->throwError("limit must be greater than or equal to 1");
-            -
                        }
-            -
-            -
                        return new Node\Number(mt_rand(1, $n), '');
-            -
                    }
-            -
-            -
                    return new Node\Number(mt_rand(1, mt_getrandmax()), '');
-            -
                }
-            -
-            -
                protected function libUniqueId()
-            -
                {
-            -
                    static $id;
-            -
-            -
                    if (! isset($id)) {
-            -
                        $id = mt_rand(0, pow(36, 8));
-            -
                    }
-            -
-            -
                    $id += mt_rand(0, 10) + 1;
-            -
-            -
                    return array(Type::T_STRING, '', array('u' . str_pad(base_convert($id, 10, 36), 8, '0', STR_PAD_LEFT)));
-            -
                }
-            -
            }

assets/libraries/scssphp_legacy/src/Compiler/Environment.php DELETED Viewed

@@ -1,42 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp\Compiler;
-            -
-            -
            use Leafo\ScssPhp\Block;
-            -
-            -
            /**
-            -
             * SCSS compiler environment
-            -
             *
-            -
             * @author Anthon Pang <anthon.pang@gmail.com>
-            -
             */
-            -
            class Environment
-            -
            {
-            -
                /**
-            -
                 * @var \Leafo\ScssPhp\Block
-            -
                 */
-            -
                public $block;
-            -
-            -
                /**
-            -
                 * @var \Leafo\ScssPhp\Compiler\Environment
-            -
                 */
-            -
                public $parent;
-            -
-            -
                /**
-            -
                 * @var array
-            -
                 */
-            -
                public $store;
-            -
-            -
                /**
-            -
                 * @var integer
-            -
                 */
-            -
                public $depth;
-            -
            }

assets/libraries/scssphp_legacy/src/Formatter.php DELETED Viewed

@@ -1,202 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp;
-            -
-            -
            use Leafo\ScssPhp\Formatter\OutputBlock;
-            -
-            -
            /**
-            -
             * SCSS base formatter
-            -
             *
-            -
             * @author Leaf Corcoran <leafot@gmail.com>
-            -
             */
-            -
            abstract class Formatter
-            -
            {
-            -
                /**
-            -
                 * @var integer
-            -
                 */
-            -
                public $indentLevel;
-            -
-            -
                /**
-            -
                 * @var string
-            -
                 */
-            -
                public $indentChar;
-            -
-            -
                /**
-            -
                 * @var string
-            -
                 */
-            -
                public $break;
-            -
-            -
                /**
-            -
                 * @var string
-            -
                 */
-            -
                public $open;
-            -
-            -
                /**
-            -
                 * @var string
-            -
                 */
-            -
                public $close;
-            -
-            -
                /**
-            -
                 * @var string
-            -
                 */
-            -
                public $tagSeparator;
-            -
-            -
                /**
-            -
                 * @var string
-            -
                 */
-            -
                public $assignSeparator;
-            -
-            -
                /**
-            -
                 * Initialize formatter
-            -
                 *
-            -
                 * @api
-            -
                 */
-            -
                abstract public function __construct();
-            -
-            -
                /**
-            -
                 * Return indentation (whitespace)
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                protected function indentStr()
-            -
                {
-            -
                    return '';
-            -
                }
-            -
-            -
                /**
-            -
                 * Return property assignment
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string $name
-            -
                 * @param mixed  $value
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                public function property($name, $value)
-            -
                {
-            -
                    return rtrim($name) . $this->assignSeparator . $value . ';';
-            -
                }
-            -
-            -
                /**
-            -
                 * Strip semi-colon appended by property(); it's a separator, not a terminator
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param array $lines
-            -
                 */
-            -
                public function stripSemicolon(&$lines)
-            -
                {
-            -
                }
-            -
-            -
                /**
-            -
                 * Output lines inside a block
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Formatter\OutputBlock $block
-            -
                 */
-            -
                protected function blockLines(OutputBlock $block)
-            -
                {
-            -
                    $inner = $this->indentStr();
-            -
-            -
                    $glue = $this->break . $inner;
-            -
-            -
                    echo $inner . implode($glue, $block->lines);
-            -
-            -
                    if (! empty($block->children)) {
-            -
                        echo $this->break;
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Output block selectors
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Formatter\OutputBlock $block
-            -
                 */
-            -
                protected function blockSelectors(OutputBlock $block)
-            -
                {
-            -
                    $inner = $this->indentStr();
-            -
-            -
                    echo $inner
-            -
                        . implode($this->tagSeparator, $block->selectors)
-            -
                        . $this->open . $this->break;
-            -
                }
-            -
-            -
                /**
-            -
                 * Output block children
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Formatter\OutputBlock $block
-            -
                 */
-            -
                protected function blockChildren(OutputBlock $block)
-            -
                {
-            -
                    foreach ($block->children as $child) {
-            -
                        $this->block($child);
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Output non-empty block
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Formatter\OutputBlock $block
-            -
                 */
-            -
                protected function block(OutputBlock $block)
-            -
                {
-            -
                    if (empty($block->lines) && empty($block->children)) {
-            -
                        return;
-            -
                    }
-            -
-            -
                    $pre = $this->indentStr();
-            -
-            -
                    if (! empty($block->selectors)) {
-            -
                        $this->blockSelectors($block);
-            -
-            -
                        $this->indentLevel++;
-            -
                    }
-            -
-            -
                    if (! empty($block->lines)) {
-            -
                        $this->blockLines($block);
-            -
                    }
-            -
-            -
                    if (! empty($block->children)) {
-            -
                        $this->blockChildren($block);
-            -
                    }
-            -
-            -
                    if (! empty($block->selectors)) {
-            -
                        $this->indentLevel--;
-            -
-            -
                        if (empty($block->children)) {
-            -
                            echo $this->break;
-            -
                        }
-            -
-            -
                        echo $pre . $this->close . $this->break;
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Entry point to formatting a block
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Formatter\OutputBlock $block An abstract syntax tree
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                public function format(OutputBlock $block)
-            -
                {
-            -
                    ob_start();
-            -
-            -
                    $this->block($block);
-            -
-            -
                    $out = ob_get_clean();
-            -
-            -
                    return $out;
-            -
                }
-            -
            }

assets/libraries/scssphp_legacy/src/Formatter/Compact.php DELETED Viewed

@@ -1,44 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp\Formatter;
-            -
-            -
            use Leafo\ScssPhp\Formatter;
-            -
-            -
            /**
-            -
             * SCSS compact formatter
-            -
             *
-            -
             * @author Leaf Corcoran <leafot@gmail.com>
-            -
             */
-            -
            class Compact extends Formatter
-            -
            {
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                public function __construct()
-            -
                {
-            -
                    $this->indentLevel = 0;
-            -
                    $this->indentChar = '';
-            -
                    $this->break = '';
-            -
                    $this->open = ' {';
-            -
                    $this->close = "}\n\n";
-            -
                    $this->tagSeparator = ',';
-            -
                    $this->assignSeparator = ':';
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                public function indentStr()
-            -
                {
-            -
                    return ' ';
-            -
                }
-            -
            }

assets/libraries/scssphp_legacy/src/Formatter/Compressed.php DELETED Viewed

@@ -1,84 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp\Formatter;
-            -
-            -
            use Leafo\ScssPhp\Formatter;
-            -
            use Leafo\ScssPhp\Formatter\OutputBlock;
-            -
-            -
            /**
-            -
             * SCSS compressed formatter
-            -
             *
-            -
             * @author Leaf Corcoran <leafot@gmail.com>
-            -
             */
-            -
            class Compressed extends Formatter
-            -
            {
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                public function __construct()
-            -
                {
-            -
                    $this->indentLevel = 0;
-            -
                    $this->indentChar = '  ';
-            -
                    $this->break = '';
-            -
                    $this->open = '{';
-            -
                    $this->close = '}';
-            -
                    $this->tagSeparator = ',';
-            -
                    $this->assignSeparator = ':';
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                public function stripSemicolon(&$lines)
-            -
                {
-            -
                    if (($count = count($lines))
-            -
                        && substr($lines[$count - 1], -1) === ';'
-            -
                    ) {
-            -
                        $lines[$count - 1] = substr($lines[$count - 1], 0, -1);
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                public function blockLines(OutputBlock $block)
-            -
                {
-            -
                    $inner = $this->indentStr();
-            -
-            -
                    $glue = $this->break . $inner;
-            -
-            -
                    foreach ($block->lines as $index => $line) {
-            -
                        if (substr($line, 0, 2) === '/*' && substr($line, 2, 1) !== '!') {
-            -
                            unset($block->lines[$index]);
-            -
                        } elseif (substr($line, 0, 3) === '/*!') {
-            -
                            $block->lines[$index] = '/*' . substr($line, 3);
-            -
                        }
-            -
                    }
-            -
-            -
                    echo $inner . implode($glue, $block->lines);
-            -
-            -
                    if (! empty($block->children)) {
-            -
                        echo $this->break;
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inherit}
-            -
                 */
-            -
                public function format(OutputBlock $block)
-            -
                {
-            -
                    return parent::format($block);
-            -
-            -
                    // TODO: we need to fix the 2 "compressed" tests where the "close" is applied
-            -
                    return trim(str_replace(';}', '}', parent::format($block)));
-            -
                }
-            -
            }

assets/libraries/scssphp_legacy/src/Formatter/Crunched.php DELETED Viewed

@@ -1,71 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp\Formatter;
-            -
-            -
            use Leafo\ScssPhp\Formatter;
-            -
            use Leafo\ScssPhp\Formatter\OutputBlock;
-            -
-            -
            /**
-            -
             * SCSS crunched formatter
-            -
             *
-            -
             * @author Anthon Pang <anthon.pang@gmail.com>
-            -
             */
-            -
            class Crunched extends Formatter
-            -
            {
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                public function __construct()
-            -
                {
-            -
                    $this->indentLevel = 0;
-            -
                    $this->indentChar = '  ';
-            -
                    $this->break = '';
-            -
                    $this->open = '{';
-            -
                    $this->close = '}';
-            -
                    $this->tagSeparator = ',';
-            -
                    $this->assignSeparator = ':';
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                public function stripSemicolon(&$lines)
-            -
                {
-            -
                    if (($count = count($lines))
-            -
                        && substr($lines[$count - 1], -1) === ';'
-            -
                    ) {
-            -
                        $lines[$count - 1] = substr($lines[$count - 1], 0, -1);
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                public function blockLines(OutputBlock $block)
-            -
                {
-            -
                    $inner = $this->indentStr();
-            -
-            -
                    $glue = $this->break . $inner;
-            -
-            -
                    foreach ($block->lines as $index => $line) {
-            -
                        if (substr($line, 0, 2) === '/*') {
-            -
                            unset($block->lines[$index]);
-            -
                        }
-            -
                    }
-            -
-            -
                    echo $inner . implode($glue, $block->lines);
-            -
-            -
                    if (! empty($block->children)) {
-            -
                        echo $this->break;
-            -
                    }
-            -
                }
-            -
            }

assets/libraries/scssphp_legacy/src/Formatter/Debug.php DELETED Viewed

@@ -1,118 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp\Formatter;
-            -
-            -
            use Leafo\ScssPhp\Formatter;
-            -
            use Leafo\ScssPhp\Formatter\OutputBlock;
-            -
-            -
            /**
-            -
             * SCSS debug formatter
-            -
             *
-            -
             * @author Anthon Pang <anthon.pang@gmail.com>
-            -
             */
-            -
            class Debug extends Formatter
-            -
            {
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                public function __construct()
-            -
                {
-            -
                    $this->indentLevel = 0;
-            -
                    $this->indentChar = '';
-            -
                    $this->break = "\n";
-            -
                    $this->open = ' {';
-            -
                    $this->close = ' }';
-            -
                    $this->tagSeparator = ', ';
-            -
                    $this->assignSeparator = ': ';
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                protected function indentStr()
-            -
                {
-            -
                    return str_repeat('  ', $this->indentLevel);
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                protected function blockLines(OutputBlock $block)
-            -
                {
-            -
                    $indent = $this->indentStr();
-            -
-            -
                    if (empty($block->lines)) {
-            -
                        echo "{$indent}block->lines: []\n";
-            -
-            -
                        return;
-            -
                    }
-            -
-            -
                    foreach ($block->lines as $index => $line) {
-            -
                        echo "{$indent}block->lines[{$index}]: $line\n";
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                protected function blockSelectors(OutputBlock $block)
-            -
                {
-            -
                    $indent = $this->indentStr();
-            -
-            -
                    if (empty($block->selectors)) {
-            -
                        echo "{$indent}block->selectors: []\n";
-            -
-            -
                        return;
-            -
                    }
-            -
-            -
                    foreach ($block->selectors as $index => $selector) {
-            -
                        echo "{$indent}block->selectors[{$index}]: $selector\n";
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                protected function blockChildren(OutputBlock $block)
-            -
                {
-            -
                    $indent = $this->indentStr();
-            -
-            -
                    if (empty($block->children)) {
-            -
                        echo "{$indent}block->children: []\n";
-            -
-            -
                        return;
-            -
                    }
-            -
-            -
                    $this->indentLevel++;
-            -
-            -
                    foreach ($block->children as $i => $child) {
-            -
                        $this->block($child);
-            -
                    }
-            -
-            -
                    $this->indentLevel--;
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                protected function block(OutputBlock $block)
-            -
                {
-            -
                    $indent = $this->indentStr();
-            -
-            -
                    echo "{$indent}block->type: {$block->type}\n" .
-            -
                         "{$indent}block->depth: {$block->depth}\n";
-            -
-            -
                    $this->blockSelectors($block);
-            -
                    $this->blockLines($block);
-            -
                    $this->blockChildren($block);
-            -
                }
-            -
            }

assets/libraries/scssphp_legacy/src/Formatter/Expanded.php DELETED Viewed

@@ -1,67 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp\Formatter;
-            -
-            -
            use Leafo\ScssPhp\Formatter;
-            -
            use Leafo\ScssPhp\Formatter\OutputBlock;
-            -
-            -
            /**
-            -
             * SCSS expanded formatter
-            -
             *
-            -
             * @author Leaf Corcoran <leafot@gmail.com>
-            -
             */
-            -
            class Expanded extends Formatter
-            -
            {
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                public function __construct()
-            -
                {
-            -
                    $this->indentLevel = 0;
-            -
                    $this->indentChar = '  ';
-            -
                    $this->break = "\n";
-            -
                    $this->open = ' {';
-            -
                    $this->close = '}';
-            -
                    $this->tagSeparator = ', ';
-            -
                    $this->assignSeparator = ': ';
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                protected function indentStr()
-            -
                {
-            -
                    return str_repeat($this->indentChar, $this->indentLevel);
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                protected function blockLines(OutputBlock $block)
-            -
                {
-            -
                    $inner = $this->indentStr();
-            -
-            -
                    $glue = $this->break . $inner;
-            -
-            -
                    foreach ($block->lines as $index => $line) {
-            -
                        if (substr($line, 0, 2) === '/*') {
-            -
                            $block->lines[$index] = preg_replace('/(\r|\n)+/', $glue, $line);
-            -
                        }
-            -
                    }
-            -
-            -
                    echo $inner . implode($glue, $block->lines);
-            -
-            -
                    if (empty($block->selectors) || ! empty($block->children)) {
-            -
                        echo $this->break;
-            -
                    }
-            -
                }
-            -
            }

assets/libraries/scssphp_legacy/src/Formatter/Nested.php DELETED Viewed

@@ -1,197 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp\Formatter;
-            -
-            -
            use Leafo\ScssPhp\Formatter;
-            -
            use Leafo\ScssPhp\Formatter\OutputBlock;
-            -
-            -
            /**
-            -
             * SCSS nested formatter
-            -
             *
-            -
             * @author Leaf Corcoran <leafot@gmail.com>
-            -
             */
-            -
            class Nested extends Formatter
-            -
            {
-            -
                /**
-            -
                 * @var integer
-            -
                 */
-            -
                private $depth;
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                public function __construct()
-            -
                {
-            -
                    $this->indentLevel = 0;
-            -
                    $this->indentChar = '  ';
-            -
                    $this->break = "\n";
-            -
                    $this->open = ' {';
-            -
                    $this->close = ' }';
-            -
                    $this->tagSeparator = ', ';
-            -
                    $this->assignSeparator = ': ';
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                protected function indentStr()
-            -
                {
-            -
                    $n = $this->depth - 1;
-            -
-            -
                    return str_repeat($this->indentChar, max($this->indentLevel + $n, 0));
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                protected function blockLines(OutputBlock $block)
-            -
                {
-            -
                    $inner = $this->indentStr();
-            -
-            -
                    $glue = $this->break . $inner;
-            -
-            -
                    foreach ($block->lines as $index => $line) {
-            -
                        if (substr($line, 0, 2) === '/*') {
-            -
                            $block->lines[$index] = preg_replace('/(\r|\n)+/', $glue, $line);
-            -
                        }
-            -
                    }
-            -
-            -
                    echo $inner . implode($glue, $block->lines);
-            -
-            -
                    if (! empty($block->children)) {
-            -
                        echo $this->break;
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                protected function blockSelectors(OutputBlock $block)
-            -
                {
-            -
                    $inner = $this->indentStr();
-            -
-            -
                    echo $inner
-            -
                        . implode($this->tagSeparator, $block->selectors)
-            -
                        . $this->open . $this->break;
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                protected function blockChildren(OutputBlock $block)
-            -
                {
-            -
                    foreach ($block->children as $i => $child) {
-            -
                        $this->block($child);
-            -
-            -
                        if ($i < count($block->children) - 1) {
-            -
                            echo $this->break;
-            -
-            -
                            if (isset($block->children[$i + 1])) {
-            -
                                $next = $block->children[$i + 1];
-            -
-            -
                                if ($next->depth === max($block->depth, 1) && $child->depth >= $next->depth) {
-            -
                                    echo $this->break;
-            -
                                }
-            -
                            }
-            -
                        }
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                protected function block(OutputBlock $block)
-            -
                {
-            -
                    if ($block->type === 'root') {
-            -
                        $this->adjustAllChildren($block);
-            -
                    }
-            -
-            -
                    if (empty($block->lines) && empty($block->children)) {
-            -
                        return;
-            -
                    }
-            -
-            -
                    $this->depth = $block->depth;
-            -
-            -
                    if (! empty($block->selectors)) {
-            -
                        $this->blockSelectors($block);
-            -
-            -
                        $this->indentLevel++;
-            -
                    }
-            -
-            -
                    if (! empty($block->lines)) {
-            -
                        $this->blockLines($block);
-            -
                    }
-            -
-            -
                    if (! empty($block->children)) {
-            -
                        $this->blockChildren($block);
-            -
                    }
-            -
-            -
                    if (! empty($block->selectors)) {
-            -
                        $this->indentLevel--;
-            -
-            -
                        echo $this->close;
-            -
                    }
-            -
-            -
                    if ($block->type === 'root') {
-            -
                        echo $this->break;
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Adjust the depths of all children, depth first
-            -
                 *
-            -
                 * @param \Leafo\ScssPhp\Formatter\OutputBlock $block
-            -
                 */
-            -
                private function adjustAllChildren(OutputBlock $block)
-            -
                {
-            -
                    // flatten empty nested blocks
-            -
                    $children = array();
-            -
-            -
                    foreach ($block->children as $i => $child) {
-            -
                        if (empty($child->lines) && empty($child->children)) {
-            -
                            if (isset($block->children[$i + 1])) {
-            -
                                $block->children[$i + 1]->depth = $child->depth;
-            -
                            }
-            -
-            -
                            continue;
-            -
                        }
-            -
-            -
                        $children[] = $child;
-            -
                    }
-            -
-            -
                    $count = count($children);
-            -
-            -
                    for ($i = 0; $i < $count; $i++) {
-            -
                        $depth = $children[$i]->depth;
-            -
                        $j = $i + 1;
-            -
-            -
                        if (isset($children[$j]) && $depth < $children[$j]->depth) {
-            -
                            $childDepth = $children[$j]->depth;
-            -
-            -
                            for (; $j < $count; $j++) {
-            -
                                if ($depth < $children[$j]->depth && $childDepth >= $children[$j]->depth) {
-            -
                                    $children[$j]->depth = $depth + 1;
-            -
                                }
-            -
                            }
-            -
                        }
-            -
                    }
-            -
-            -
                    $block->children = $children;
-            -
-            -
                    // make relative to parent
-            -
                    foreach ($block->children as $child) {
-            -
                        $this->adjustAllChildren($child);
-            -
-            -
                        $child->depth = $child->depth - $block->depth;
-            -
                    }
-            -
                }
-            -
            }

assets/libraries/scssphp_legacy/src/Formatter/OutputBlock.php DELETED Viewed

@@ -1,50 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp\Formatter;
-            -
-            -
            /**
-            -
             * SCSS output block
-            -
             *
-            -
             * @author Anthon Pang <anthon.pang@gmail.com>
-            -
             */
-            -
            class OutputBlock
-            -
            {
-            -
                /**
-            -
                 * @var string
-            -
                 */
-            -
                public $type;
-            -
-            -
                /**
-            -
                 * @var integer
-            -
                 */
-            -
                public $depth;
-            -
-            -
                /**
-            -
                 * @var array
-            -
                 */
-            -
                public $selectors;
-            -
-            -
                /**
-            -
                 * @var array
-            -
                 */
-            -
                public $lines;
-            -
-            -
                /**
-            -
                 * @var array
-            -
                 */
-            -
                public $children;
-            -
-            -
                /**
-            -
                 * @var \Leafo\ScssPhp\Formatter\OutputBlock
-            -
                 */
-            -
                public $parent;
-            -
            }

assets/libraries/scssphp_legacy/src/Node.php DELETED Viewed

@@ -1,35 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp;
-            -
-            -
            /**
-            -
             * SCSS node
-            -
             *
-            -
             * @author Anthon Pang <anthon.pang@gmail.com>
-            -
             */
-            -
            abstract class Node
-            -
            {
-            -
                /**
-            -
                 * @var string
-            -
                 */
-            -
                public $type;
-            -
-            -
                /**
-            -
                 * @var integer
-            -
                 */
-            -
                public $sourcePosition;
-            -
-            -
                /**
-            -
                 * @var integer
-            -
                 */
-            -
                public $sourceIndex;
-            -
            }

assets/libraries/scssphp_legacy/src/Node/Number.php DELETED Viewed

@@ -1,236 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp\Node;
-            -
-            -
            use Leafo\ScssPhp\Node;
-            -
            use Leafo\ScssPhp\Type;
-            -
-            -
            /**
-            -
             * SCSS dimension + optional units
-            -
             *
-            -
             * {@internal
-            -
             *     This is a work-in-progress.
-            -
             *
-            -
             *     The \ArrayAccess interface is temporary until the migration is complete.
-            -
             * }}
-            -
             *
-            -
             * @author Anthon Pang <anthon.pang@gmail.com>
-            -
             */
-            -
            class Number extends Node implements \ArrayAccess
-            -
            {
-            -
                /**
-            -
                 * @var integer
-            -
                 */
-            -
                static public $precision = 5;
-            -
-            -
                /**
-            -
                 * @see http://www.w3.org/TR/2012/WD-css3-values-20120308/
-            -
                 *
-            -
                 * @var array
-            -
                 */
-            -
                static protected $unitTable = array(
-            -
                    'in' => array(
-            -
                        'in' => 1,
-            -
                        'pc' => 6,
-            -
                        'pt' => 72,
-            -
                        'px' => 96,
-            -
                        'cm' => 2.54,
-            -
                        'mm' => 25.4,
-            -
                        'q'  => 101.6,
-            -
                    ),
-            -
                    'turn' => array(
-            -
                        'deg' => 180,
-            -
                        'grad' => 200,
-            -
                        'rad' => M_PI,
-            -
                        'turn' => 0.5,
-            -
                    ),
-            -
                    's' => array(
-            -
                        's' => 1,
-            -
                        'ms' => 1000,
-            -
                    ),
-            -
                    'Hz' => array(
-            -
                        'Hz' => 1,
-            -
                        'kHz' => 0.001,
-            -
                    ),
-            -
                    'dpi' => array(
-            -
                        'dpi' => 1,
-            -
                        'dpcm' => 2.54,
-            -
                        'dppx' => 96,
-            -
                    ),
-            -
                );
-            -
-            -
                /**
-            -
                 * @var integer|float
-            -
                 */
-            -
                public $dimension;
-            -
-            -
                /**
-            -
                 * @var string
-            -
                 */
-            -
                public $units;
-            -
-            -
                /**
-            -
                 * Initialize number
-            -
                 *
-            -
                 * @param mixed  $dimension
-            -
                 * @param string $initialUnit
-            -
                 */
-            -
                public function __construct($dimension, $initialUnit)
-            -
                {
-            -
                    $this->type      = Type::T_NUMBER;
-            -
                    $this->dimension = $dimension;
-            -
                    $this->units     = $initialUnit;
-            -
                }
-            -
-            -
                /**
-            -
                 * Coerce number to target units
-            -
                 *
-            -
                 * @param array $units
-            -
                 *
-            -
                 * @return \Leafo\ScssPhp\Node\Number
-            -
                 */
-            -
                public function coerce($units)
-            -
                {
-            -
                    $value = $this->dimension;
-            -
-            -
                    if (isset(self::$unitTable[$this->units][$units])) {
-            -
                        $value *= self::$unitTable[$this->units][$units];
-            -
                    }
-            -
-            -
                    return new Number($value, $units);
-            -
                }
-            -
-            -
                /**
-            -
                 * Normalize number
-            -
                 *
-            -
                 * @return \Leafo\ScssPhp\Node\Number
-            -
                 */
-            -
                public function normalize()
-            -
                {
-            -
                    if (isset(self::$unitTable['in'][$this->units])) {
-            -
                        $conv = self::$unitTable['in'][$this->units];
-            -
-            -
                        return new Number($this->dimension / $conv, 'in');
-            -
                    }
-            -
-            -
                    return new Number($this->dimension, $this->units);
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                public function offsetExists($offset)
-            -
                {
-            -
                    if ($offset === -2) {
-            -
                        return $sourceIndex !== null;
-            -
                    }
-            -
-            -
                    if ($offset === -1
-            -
                        || $offset === 0
-            -
                        || $offset === 1
-            -
                        || $offset === 2
-            -
                    ) {
-            -
                        return true;
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                public function offsetGet($offset)
-            -
                {
-            -
                    switch ($offset) {
-            -
                        case -2:
-            -
                            return $this->sourceIndex;
-            -
-            -
                        case -1:
-            -
                            return $this->sourcePosition;
-            -
-            -
                        case 0:
-            -
                            return $this->type;
-            -
-            -
                        case 1:
-            -
                            return $this->dimension;
-            -
-            -
                        case 2:
-            -
                            return $this->units;
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                public function offsetSet($offset, $value)
-            -
                {
-            -
                    if ($offset === 1) {
-            -
                        $this->dimension = $value;
-            -
                    } elseif ($offset === 2) {
-            -
                        $this->units = $value;
-            -
                    } elseif ($offset == -1) {
-            -
                        $this->sourcePosition = $value;
-            -
                    } elseif ($offset == -2) {
-            -
                        $this->sourceIndex = $value;
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                public function offsetUnset($offset)
-            -
                {
-            -
                    if ($offset === 1) {
-            -
                        $this->dimension = null;
-            -
                    } elseif ($offset === 2) {
-            -
                        $this->units = null;
-            -
                    } elseif ($offset === -1) {
-            -
                        $this->sourcePosition = null;
-            -
                    } elseif ($offset === -2) {
-            -
                        $this->sourceIndex = null;
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Returns true if the number is unitless
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                public function unitless()
-            -
                {
-            -
                    return empty($this->units);
-            -
                }
-            -
-            -
                /**
-            -
                 * Returns unit(s) as the product of numerator units divided by the product of denominator units
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                public function unitStr()
-            -
                {
-            -
                    return $this->units;
-            -
                }
-            -
-            -
                /**
-            -
                 * {@inheritdoc}
-            -
                 */
-            -
                public function __toString()
-            -
                {
-            -
                    $value = round($this->dimension, self::$precision);
-            -
-            -
                    if (empty($this->units)) {
-            -
                        return (string) $value;
-            -
                    }
-            -
-            -
                    return (string) $value . $this->units;
-            -
                }
-            -
            }

assets/libraries/scssphp_legacy/src/Parser.php DELETED Viewed

@@ -1,2377 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp;
-            -
-            -
            use Leafo\ScssPhp\Block;
-            -
            use Leafo\ScssPhp\Compiler;
-            -
            use Leafo\ScssPhp\Node;
-            -
            use Leafo\ScssPhp\Type;
-            -
-            -
            /**
-            -
             * SCSS parser
-            -
             *
-            -
             * @author Leaf Corcoran <leafot@gmail.com>
-            -
             */
-            -
            class Parser
-            -
            {
-            -
                const SOURCE_INDEX    = -1;
-            -
                const SOURCE_POSITION = -2;
-            -
-            -
                /**
-            -
                 * @var array
-            -
                 */
-            -
                protected static $precedence = array(
-            -
                    '='   => 0,
-            -
                    'or'  => 1,
-            -
                    'and' => 2,
-            -
                    '=='  => 3,
-            -
                    '!='  => 3,
-            -
                    '<=>' => 3,
-            -
                    '<='  => 4,
-            -
                    '>='  => 4,
-            -
                    '<'   => 4,
-            -
                    '>'   => 4,
-            -
                    '+'   => 5,
-            -
                    '-'   => 5,
-            -
                    '*'   => 6,
-            -
                    '/'   => 6,
-            -
                    '%'   => 6,
-            -
                );
-            -
-            -
                protected static $commentPattern;
-            -
                protected static $operatorPattern;
-            -
                protected static $whitePattern;
-            -
-            -
                private $sourceName;
-            -
                private $sourceIndex;
-            -
                private $charset;
-            -
                private $count;
-            -
                private $env;
-            -
                private $inParens;
-            -
                private $eatWhiteDefault;
-            -
                private $buffer;
-            -
-            -
                /**
-            -
                 * Constructor
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string  $sourceName
-            -
                 * @param integer $sourceIndex
-            -
                 */
-            -
                public function __construct($sourceName, $sourceIndex = 0)
-            -
                {
-            -
                    $this->sourceName  = $sourceName ?: '(stdin)';
-            -
                    $this->sourceIndex = $sourceIndex;
-            -
                    $this->charset     = null;
-            -
-            -
                    if (empty(self::$operatorPattern)) {
-            -
                        self::$operatorPattern = '([*\/%+-]|[!=]\=|\>\=?|\<\=\>|\<\=?|and|or)';
-            -
-            -
                        $commentSingle      = '\/\/';
-            -
                        $commentMultiLeft   = '\/\*';
-            -
                        $commentMultiRight  = '\*\/';
-            -
-            -
                        self::$commentPattern = $commentMultiLeft . '.*?' . $commentMultiRight;
-            -
                        self::$whitePattern = '/' . $commentSingle . '[^\n]*\s*|(' . self::$commentPattern . ')\s*|\s+/Ais';
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Get source file name
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                public function getSourceName()
-            -
                {
-            -
                    return $this->sourceName;
-            -
                }
-            -
-            -
                /**
-            -
                 * Get source line number (given character position in the buffer)
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param integer $pos
-            -
                 *
-            -
                 * @return integer
-            -
                 */
-            -
                public function getLineNo($pos)
-            -
                {
-            -
                    return 1 + substr_count(substr($this->buffer, 0, $pos), "\n");
-            -
                }
-            -
-            -
                /**
-            -
                 * Throw parser error
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string  $msg
-            -
                 * @param integer $count
-            -
                 *
-            -
                 * @throws \Exception
-            -
                 */
-            -
                public function throwParseError($msg = 'parse error', $count = null)
-            -
                {
-            -
                    $count = ! isset($count) ? $this->count : $count;
-            -
-            -
                    $line = $this->getLineNo($count);
-            -
-            -
                    if (! empty($this->sourceName)) {
-            -
                        $loc = "$this->sourceName on line $line";
-            -
                    } else {
-            -
                        $loc = "line: $line";
-            -
                    }
-            -
-            -
                    if ($this->peek("(.*?)(\n|$)", $m, $count)) {
-            -
                        throw new \Exception("$msg: failed at `$m[1]` $loc");
-            -
                    }
-            -
-            -
                    throw new \Exception("$msg: $loc");
-            -
                }
-            -
-            -
                /**
-            -
                 * Parser buffer
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string $buffer
-            -
                 *
-            -
                 * @return \Leafo\ScssPhp\Block
-            -
                 */
-            -
                public function parse($buffer)
-            -
                {
-            -
                    $this->count           = 0;
-            -
                    $this->env             = null;
-            -
                    $this->inParens        = false;
-            -
                    $this->eatWhiteDefault = true;
-            -
                    $this->buffer          = rtrim($buffer, "\x00..\x1f");
-            -
-            -
                    $this->pushBlock(null); // root block
-            -
-            -
                    $this->whitespace();
-            -
                    $this->pushBlock(null);
-            -
                    $this->popBlock();
-            -
-            -
                    while ($this->parseChunk()) {
-            -
                        ;
-            -
                    }
-            -
-            -
                    if ($this->count !== strlen($this->buffer)) {
-            -
                        $this->throwParseError();
-            -
                    }
-            -
-            -
                    if (! empty($this->env->parent)) {
-            -
                        $this->throwParseError('unclosed block');
-            -
                    }
-            -
-            -
                    if ($this->charset) {
-            -
                        array_unshift($this->env->children, $this->charset);
-            -
                    }
-            -
-            -
                    $this->env->isRoot    = true;
-            -
-            -
                    return $this->env;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse a value or value list
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string $buffer
-            -
                 * @param string $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                public function parseValue($buffer, &$out)
-            -
                {
-            -
                    $this->count           = 0;
-            -
                    $this->env             = null;
-            -
                    $this->inParens        = false;
-            -
                    $this->eatWhiteDefault = true;
-            -
                    $this->buffer          = (string) $buffer;
-            -
-            -
                    return $this->valueList($out);
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse a selector or selector list
-            -
                 *
-            -
                 * @api
-            -
                 *
-            -
                 * @param string $buffer
-            -
                 * @param string $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                public function parseSelector($buffer, &$out)
-            -
                {
-            -
                    $this->count           = 0;
-            -
                    $this->env             = null;
-            -
                    $this->inParens        = false;
-            -
                    $this->eatWhiteDefault = true;
-            -
                    $this->buffer          = (string) $buffer;
-            -
-            -
                    return $this->selectors($out);
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse a single chunk off the head of the buffer and append it to the
-            -
                 * current parse environment.
-            -
                 *
-            -
                 * Returns false when the buffer is empty, or when there is an error.
-            -
                 *
-            -
                 * This function is called repeatedly until the entire document is
-            -
                 * parsed.
-            -
                 *
-            -
                 * This parser is most similar to a recursive descent parser. Single
-            -
                 * functions represent discrete grammatical rules for the language, and
-            -
                 * they are able to capture the text that represents those rules.
-            -
                 *
-            -
                 * Consider the function Compiler::keyword(). (All parse functions are
-            -
                 * structured the same.)
-            -
                 *
-            -
                 * The function takes a single reference argument. When calling the
-            -
                 * function it will attempt to match a keyword on the head of the buffer.
-            -
                 * If it is successful, it will place the keyword in the referenced
-            -
                 * argument, advance the position in the buffer, and return true. If it
-            -
                 * fails then it won't advance the buffer and it will return false.
-            -
                 *
-            -
                 * All of these parse functions are powered by Compiler::match(), which behaves
-            -
                 * the same way, but takes a literal regular expression. Sometimes it is
-            -
                 * more convenient to use match instead of creating a new function.
-            -
                 *
-            -
                 * Because of the format of the functions, to parse an entire string of
-            -
                 * grammatical rules, you can chain them together using &&.
-            -
                 *
-            -
                 * But, if some of the rules in the chain succeed before one fails, then
-            -
                 * the buffer position will be left at an invalid state. In order to
-            -
                 * avoid this, Compiler::seek() is used to remember and set buffer positions.
-            -
                 *
-            -
                 * Before parsing a chain, use $s = $this->seek() to remember the current
-            -
                 * position into $s. Then if a chain fails, use $this->seek($s) to
-            -
                 * go back where we started.
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function parseChunk()
-            -
                {
-            -
                    $s = $this->seek();
-            -
-            -
                    // the directives
-            -
                    if (isset($this->buffer[$this->count]) && $this->buffer[$this->count] === '@') {
-            -
                        if ($this->literal('@at-root') &&
-            -
                            ($this->selectors($selector) || true) &&
-            -
                            ($this->map($with) || true) &&
-            -
                            $this->literal('{')
-            -
                        ) {
-            -
                            $atRoot = $this->pushSpecialBlock(Type::T_AT_ROOT, $s);
-            -
                            $atRoot->selector = $selector;
-            -
                            $atRoot->with = $with;
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->literal('@media') && $this->mediaQueryList($mediaQueryList) && $this->literal('{')) {
-            -
                            $media = $this->pushSpecialBlock(Type::T_MEDIA, $s);
-            -
                            $media->queryList = $mediaQueryList[2];
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->literal('@mixin') &&
-            -
                            $this->keyword($mixinName) &&
-            -
                            ($this->argumentDef($args) || true) &&
-            -
                            $this->literal('{')
-            -
                        ) {
-            -
                            $mixin = $this->pushSpecialBlock(Type::T_MIXIN, $s);
-            -
                            $mixin->name = $mixinName;
-            -
                            $mixin->args = $args;
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->literal('@include') &&
-            -
                            $this->keyword($mixinName) &&
-            -
                            ($this->literal('(') &&
-            -
                                ($this->argValues($argValues) || true) &&
-            -
                                $this->literal(')') || true) &&
-            -
                            ($this->end() ||
-            -
                                $this->literal('{') && $hasBlock = true)
-            -
                        ) {
-            -
                            $child = array(Type::T_INCLUDE,
-            -
                                $mixinName, isset($argValues) ? $argValues : null, null);
-            -
-            -
                            if (! empty($hasBlock)) {
-            -
                                $include = $this->pushSpecialBlock(Type::T_INCLUDE, $s);
-            -
                                $include->child = $child;
-            -
                            } else {
-            -
                                $this->append($child, $s);
-            -
                            }
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->literal('@import') &&
-            -
                            $this->valueList($importPath) &&
-            -
                            $this->end()
-            -
                        ) {
-            -
                            $this->append(array(Type::T_IMPORT, $importPath), $s);
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->literal('@import') &&
-            -
                            $this->url($importPath) &&
-            -
                            $this->end()
-            -
                        ) {
-            -
                            $this->append(array(Type::T_IMPORT, $importPath), $s);
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->literal('@extend') &&
-            -
                            $this->selectors($selector) &&
-            -
                            $this->end()
-            -
                        ) {
-            -
                            $this->append(array(Type::T_EXTEND, $selector), $s);
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->literal('@function') &&
-            -
                            $this->keyword($fnName) &&
-            -
                            $this->argumentDef($args) &&
-            -
                            $this->literal('{')
-            -
                        ) {
-            -
                            $func = $this->pushSpecialBlock(Type::T_FUNCTION, $s);
-            -
                            $func->name = $fnName;
-            -
                            $func->args = $args;
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->literal('@break') && $this->end()) {
-            -
                            $this->append(array(Type::T_BREAK), $s);
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->literal('@continue') && $this->end()) {
-            -
                            $this->append(array(Type::T_CONTINUE), $s);
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
-            -
                        if ($this->literal('@return') && ($this->valueList($retVal) || true) && $this->end()) {
-            -
                            $this->append(array(Type::T_RETURN, isset($retVal) ? $retVal : array(Type::T_NULL)), $s);
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->literal('@each') &&
-            -
                            $this->genericList($varNames, 'variable', ',', false) &&
-            -
                            $this->literal('in') &&
-            -
                            $this->valueList($list) &&
-            -
                            $this->literal('{')
-            -
                        ) {
-            -
                            $each = $this->pushSpecialBlock(Type::T_EACH, $s);
-            -
-            -
                            foreach ($varNames[2] as $varName) {
-            -
                                $each->vars[] = $varName[1];
-            -
                            }
-            -
-            -
                            $each->list = $list;
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->literal('@while') &&
-            -
                            $this->expression($cond) &&
-            -
                            $this->literal('{')
-            -
                        ) {
-            -
                            $while = $this->pushSpecialBlock(Type::T_WHILE, $s);
-            -
                            $while->cond = $cond;
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->literal('@for') &&
-            -
                            $this->variable($varName) &&
-            -
                            $this->literal('from') &&
-            -
                            $this->expression($start) &&
-            -
                            ($this->literal('through') ||
-            -
                                ($forUntil = true && $this->literal('to'))) &&
-            -
                            $this->expression($end) &&
-            -
                            $this->literal('{')
-            -
                        ) {
-            -
                            $for = $this->pushSpecialBlock(Type::T_FOR, $s);
-            -
                            $for->var = $varName[1];
-            -
                            $for->start = $start;
-            -
                            $for->end = $end;
-            -
                            $for->until = isset($forUntil);
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->literal('@if') && $this->valueList($cond) && $this->literal('{')) {
-            -
                            $if = $this->pushSpecialBlock(Type::T_IF, $s);
-            -
                            $if->cond = $cond;
-            -
                            $if->cases = array();
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->literal('@debug') &&
-            -
                            $this->valueList($value) &&
-            -
                            $this->end()
-            -
                        ) {
-            -
                            $this->append(array(Type::T_DEBUG, $value), $s);
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->literal('@warn') &&
-            -
                            $this->valueList($value) &&
-            -
                            $this->end()
-            -
                        ) {
-            -
                            $this->append(array(Type::T_WARN, $value), $s);
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->literal('@error') &&
-            -
                            $this->valueList($value) &&
-            -
                            $this->end()
-            -
                        ) {
-            -
                            $this->append(array(Type::T_ERROR, $value), $s);
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->literal('@content') && $this->end()) {
-            -
                            $this->append(array(Type::T_MIXIN_CONTENT), $s);
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        $last = $this->last();
-            -
-            -
                        if (isset($last) && $last[0] === Type::T_IF) {
-            -
                            list(, $if) = $last;
-            -
-            -
                            if ($this->literal('@else')) {
-            -
                                if ($this->literal('{')) {
-            -
                                    $else = $this->pushSpecialBlock(Type::T_ELSE, $s);
-            -
                                } elseif ($this->literal('if') && $this->valueList($cond) && $this->literal('{')) {
-            -
                                    $else = $this->pushSpecialBlock(Type::T_ELSEIF, $s);
-            -
                                    $else->cond = $cond;
-            -
                                }
-            -
-            -
                                if (isset($else)) {
-            -
                                    $else->dontAppend = true;
-            -
                                    $if->cases[] = $else;
-            -
-            -
                                    return true;
-            -
                                }
-            -
                            }
-            -
-            -
                            $this->seek($s);
-            -
                        }
-            -
-            -
                        // only retain the first @charset directive encountered
-            -
                        if ($this->literal('@charset') &&
-            -
                            $this->valueList($charset) &&
-            -
                            $this->end()
-            -
                        ) {
-            -
                            if (! isset($this->charset)) {
-            -
                                $statement = array(Type::T_CHARSET, $charset);
-            -
-            -
                                $statement[self::SOURCE_POSITION] = $s;
-            -
                                $statement[self::SOURCE_INDEX] = $this->sourceIndex;
-            -
-            -
                                $this->charset = $statement;
-            -
                            }
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        // doesn't match built in directive, do generic one
-            -
                        if ($this->literal('@', false) &&
-            -
                            $this->keyword($dirName) &&
-            -
                            ($this->variable($dirValue) || $this->openString('{', $dirValue) || true) &&
-            -
                            $this->literal('{')
-            -
                        ) {
-            -
                            if ($dirName === 'media') {
-            -
                                $directive = $this->pushSpecialBlock(Type::T_MEDIA, $s);
-            -
                            } else {
-            -
                                $directive = $this->pushSpecialBlock(Type::T_DIRECTIVE, $s);
-            -
                                $directive->name = $dirName;
-            -
                            }
-            -
-            -
                            if (isset($dirValue)) {
-            -
                                $directive->value = $dirValue;
-            -
                            }
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        return false;
-            -
                    }
-            -
-            -
                    // property shortcut
-            -
                    // captures most properties before having to parse a selector
-            -
                    if ($this->keyword($name, false) &&
-            -
                        $this->literal(': ') &&
-            -
                        $this->valueList($value) &&
-            -
                        $this->end()
-            -
                    ) {
-            -
                        $name = array(Type::T_STRING, '', array($name));
-            -
                        $this->append(array(Type::T_ASSIGN, $name, $value), $s);
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    $this->seek($s);
-            -
-            -
                    // variable assigns
-            -
                    if ($this->variable($name) &&
-            -
                        $this->literal(':') &&
-            -
                        $this->valueList($value) &&
-            -
                        $this->end()
-            -
                    ) {
-            -
                        // check for '!flag'
-            -
                        $assignmentFlag = $this->stripAssignmentFlag($value);
-            -
                        $this->append(array(Type::T_ASSIGN, $name, $value, $assignmentFlag), $s);
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    $this->seek($s);
-            -
-            -
                    // misc
-            -
                    if ($this->literal('-->')) {
-            -
                        return true;
-            -
                    }
-            -
-            -
                    // opening css block
-            -
                    if ($this->selectors($selectors) && $this->literal('{')) {
-            -
                        $b = $this->pushBlock($selectors, $s);
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    $this->seek($s);
-            -
-            -
                    // property assign, or nested assign
-            -
                    if ($this->propertyName($name) && $this->literal(':')) {
-            -
                        $foundSomething = false;
-            -
-            -
                        if ($this->valueList($value)) {
-            -
                            $this->append(array(Type::T_ASSIGN, $name, $value), $s);
-            -
                            $foundSomething = true;
-            -
                        }
-            -
-            -
                        if ($this->literal('{')) {
-            -
                            $propBlock = $this->pushSpecialBlock(Type::T_NESTED_PROPERTY, $s);
-            -
                            $propBlock->prefix = $name;
-            -
                            $foundSomething = true;
-            -
                        } elseif ($foundSomething) {
-            -
                            $foundSomething = $this->end();
-            -
                        }
-            -
-            -
                        if ($foundSomething) {
-            -
                            return true;
-            -
                        }
-            -
                    }
-            -
-            -
                    $this->seek($s);
-            -
-            -
                    // closing a block
-            -
                    if ($this->literal('}')) {
-            -
                        $block = $this->popBlock();
-            -
-            -
                        if (isset($block->type) && $block->type === Type::T_INCLUDE) {
-            -
                            $include = $block->child;
-            -
                            unset($block->child);
-            -
                            $include[3] = $block;
-            -
                            $this->append($include, $s);
-            -
                        } elseif (empty($block->dontAppend)) {
-            -
                            $type = isset($block->type) ? $block->type : Type::T_BLOCK;
-            -
                            $this->append(array($type, $block), $s);
-            -
                        }
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    // extra stuff
-            -
                    if ($this->literal(';') ||
-            -
                        $this->literal('<!--')
-            -
                    ) {
-            -
                        return true;
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Push block onto parse tree
-            -
                 *
-            -
                 * @param array   $selectors
-            -
                 * @param integer $pos
-            -
                 *
-            -
                 * @return \Leafo\ScssPhp\Block
-            -
                 */
-            -
                protected function pushBlock($selectors, $pos = 0)
-            -
                {
-            -
                    $b = new Block;
-            -
                    $b->parent         = $this->env;
-            -
                    $b->sourcePosition = $pos;
-            -
                    $b->sourceIndex    = $this->sourceIndex;
-            -
                    $b->selectors      = $selectors;
-            -
                    $b->comments       = array();
-            -
-            -
                    if (! $this->env) {
-            -
                        $b->children = array();
-            -
                    } elseif (empty($this->env->children)) {
-            -
                        $this->env->children = $this->env->comments;
-            -
                        $b->children = array();
-            -
                        $this->env->comments = array();
-            -
                    } else {
-            -
                        $b->children = $this->env->comments;
-            -
                        $this->env->comments = array();
-            -
                    }
-            -
-            -
                    $this->env = $b;
-            -
-            -
                    return $b;
-            -
                }
-            -
-            -
                /**
-            -
                 * Push special (named) block onto parse tree
-            -
                 *
-            -
                 * @param string  $type
-            -
                 * @param integer $pos
-            -
                 *
-            -
                 * @return \Leafo\ScssPhp\Block
-            -
                 */
-            -
                protected function pushSpecialBlock($type, $pos)
-            -
                {
-            -
                    $block = $this->pushBlock(null, $pos);
-            -
                    $block->type = $type;
-            -
-            -
                    return $block;
-            -
                }
-            -
-            -
                /**
-            -
                 * Pop scope and return last block
-            -
                 *
-            -
                 * @return \Leafo\ScssPhp\Block
-            -
                 *
-            -
                 * @throws \Exception
-            -
                 */
-            -
                protected function popBlock()
-            -
                {
-            -
                    $block = $this->env;
-            -
-            -
                    if (empty($block->parent)) {
-            -
                        $this->throwParseError('unexpected }');
-            -
                    }
-            -
-            -
                    $this->env = $block->parent;
-            -
                    unset($block->parent);
-            -
-            -
                    $comments = $block->comments;
-            -
                    if (count($comments)) {
-            -
                        $this->env->comments = $comments;
-            -
                        unset($block->comments);
-            -
                    }
-            -
-            -
                    return $block;
-            -
                }
-            -
-            -
                /**
-            -
                 * Peek input stream
-            -
                 *
-            -
                 * @param string  $regex
-            -
                 * @param array   $out
-            -
                 * @param integer $from
-            -
                 *
-            -
                 * @return integer
-            -
                 */
-            -
                protected function peek($regex, &$out, $from = null)
-            -
                {
-            -
                    if (! isset($from)) {
-            -
                        $from = $this->count;
-            -
                    }
-            -
-            -
                    $r = '/' . $regex . '/Ais';
-            -
                    $result = preg_match($r, $this->buffer, $out, null, $from);
-            -
-            -
                    return $result;
-            -
                }
-            -
-            -
                /**
-            -
                 * Seek to position in input stream (or return current position in input stream)
-            -
                 *
-            -
                 * @param integer $where
-            -
                 *
-            -
                 * @return integer
-            -
                 */
-            -
                protected function seek($where = null)
-            -
                {
-            -
                    if ($where === null) {
-            -
                        return $this->count;
-            -
                    }
-            -
-            -
                    $this->count = $where;
-            -
-            -
                    return true;
-            -
                }
-            -
-            -
                /**
-            -
                 * 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
-            -
                 *
-            -
                 * @return boolean True if match; false otherwise
-            -
                 */
-            -
                protected function matchString(&$m, $delim)
-            -
                {
-            -
                    $token = null;
-            -
-            -
                    $end = strlen($this->buffer);
-            -
-            -
                    // look for either ending delim, escape, or string interpolation
-            -
                    foreach (array('#{', '\\', $delim) as $lookahead) {
-            -
                        $pos = strpos($this->buffer, $lookahead, $this->count);
-            -
-            -
                        if ($pos !== false && $pos < $end) {
-            -
                            $end = $pos;
-            -
                            $token = $lookahead;
-            -
                        }
-            -
                    }
-            -
-            -
                    if (! isset($token)) {
-            -
                        return false;
-            -
                    }
-            -
-            -
                    $match = substr($this->buffer, $this->count, $end - $this->count);
-            -
                    $m = array(
-            -
                        $match . $token,
-            -
                        $match,
-            -
                        $token
-            -
                    );
-            -
                    $this->count = $end + strlen($token);
-            -
-            -
                    return true;
-            -
                }
-            -
-            -
                /**
-            -
                 * Try to match something on head of buffer
-            -
                 *
-            -
                 * @param string  $regex
-            -
                 * @param array   $out
-            -
                 * @param boolean $eatWhitespace
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function match($regex, &$out, $eatWhitespace = null)
-            -
                {
-            -
                    if (! isset($eatWhitespace)) {
-            -
                        $eatWhitespace = $this->eatWhiteDefault;
-            -
                    }
-            -
-            -
                    $r = '/' . $regex . '/Ais';
-            -
-            -
                    if (preg_match($r, $this->buffer, $out, null, $this->count)) {
-            -
                        $this->count += strlen($out[0]);
-            -
-            -
                        if ($eatWhitespace) {
-            -
                            $this->whitespace();
-            -
                        }
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Match literal string
-            -
                 *
-            -
                 * @param string  $what
-            -
                 * @param boolean $eatWhitespace
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function literal($what, $eatWhitespace = null)
-            -
                {
-            -
                    if (! isset($eatWhitespace)) {
-            -
                        $eatWhitespace = $this->eatWhiteDefault;
-            -
                    }
-            -
-            -
                    // shortcut on single letter
-            -
                    if (! isset($what[1]) && isset($this->buffer[$this->count])) {
-            -
                        if ($this->buffer[$this->count] === $what) {
-            -
                            if (! $eatWhitespace) {
-            -
                                $this->count++;
-            -
-            -
                                return true;
-            -
                            }
-            -
-            -
                            // goes below...
-            -
                        } else {
-            -
                            return false;
-            -
                        }
-            -
                    }
-            -
-            -
                    return $this->match($this->pregQuote($what), $m, $eatWhitespace);
-            -
                }
-            -
-            -
                /**
-            -
                 * Match some whitespace
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function whitespace()
-            -
                {
-            -
                    $gotWhite = false;
-            -
-            -
                    while (preg_match(self::$whitePattern, $this->buffer, $m, null, $this->count)) {
-            -
                        if (isset($m[1]) && empty($this->commentsSeen[$this->count])) {
-            -
                            $this->appendComment(array(Type::T_COMMENT, $m[1]));
-            -
-            -
                            $this->commentsSeen[$this->count] = true;
-            -
                        }
-            -
-            -
                        $this->count += strlen($m[0]);
-            -
                        $gotWhite = true;
-            -
                    }
-            -
-            -
                    return $gotWhite;
-            -
                }
-            -
-            -
                /**
-            -
                 * Append comment to current block
-            -
                 *
-            -
                 * @param array $comment
-            -
                 */
-            -
                protected function appendComment($comment)
-            -
                {
-            -
                    $comment[1] = substr(preg_replace(array('/^\s+/m', '/^(.)/m'), array('', ' \1'), $comment[1]), 1);
-            -
-            -
                    $this->env->comments[] = $comment;
-            -
                }
-            -
-            -
                /**
-            -
                 * Append statement to current block
-            -
                 *
-            -
                 * @param array   $statement
-            -
                 * @param integer $pos
-            -
                 */
-            -
                protected function append($statement, $pos = null)
-            -
                {
-            -
                    if ($pos !== null) {
-            -
                        $statement[self::SOURCE_POSITION] = $pos;
-            -
                        $statement[self::SOURCE_INDEX]    = $this->sourceIndex;
-            -
                    }
-            -
-            -
                    $this->env->children[] = $statement;
-            -
-            -
                    $comments = $this->env->comments;
-            -
-            -
                    if (count($comments)) {
-            -
                        $this->env->children = array_merge($this->env->children, $comments);
-            -
                        $this->env->comments = array();
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Returns last child was appended
-            -
                 *
-            -
                 * @return array|null
-            -
                 */
-            -
                protected function last()
-            -
                {
-            -
                    $i = count($this->env->children) - 1;
-            -
-            -
                    if (isset($this->env->children[$i])) {
-            -
                        return $this->env->children[$i];
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse media query list
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function mediaQueryList(&$out)
-            -
                {
-            -
                    return $this->genericList($out, 'mediaQuery', ',', false);
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse media query
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function mediaQuery(&$out)
-            -
                {
-            -
                    $s = $this->seek();
-            -
-            -
                    $expressions = null;
-            -
                    $parts = array();
-            -
-            -
                    if (($this->literal('only') && ($only = true) || $this->literal('not') && ($not = true) || true) &&
-            -
                        $this->mixedKeyword($mediaType)
-            -
                    ) {
-            -
                        $prop = array(Type::T_MEDIA_TYPE);
-            -
-            -
                        if (isset($only)) {
-            -
                            $prop[] = array(Type::T_KEYWORD, 'only');
-            -
                        }
-            -
-            -
                        if (isset($not)) {
-            -
                            $prop[] = array(Type::T_KEYWORD, 'not');
-            -
                        }
-            -
-            -
                        $media = array(Type::T_LIST, '', array());
-            -
-            -
                        foreach ((array)$mediaType as $type) {
-            -
                            if (is_array($type)) {
-            -
                                $media[2][] = $type;
-            -
                            } else {
-            -
                                $media[2][] = array(Type::T_KEYWORD, $type);
-            -
                            }
-            -
                        }
-            -
-            -
                        $prop[]  = $media;
-            -
                        $parts[] = $prop;
-            -
                    }
-            -
-            -
                    if (empty($parts) || $this->literal('and')) {
-            -
                        $this->genericList($expressions, 'mediaExpression', 'and', false);
-            -
-            -
                        if (is_array($expressions)) {
-            -
                            $parts = array_merge($parts, $expressions[2]);
-            -
                        }
-            -
                    }
-            -
-            -
                    $out = $parts;
-            -
-            -
                    return true;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse media expression
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function mediaExpression(&$out)
-            -
                {
-            -
                    $s = $this->seek();
-            -
                    $value = null;
-            -
-            -
                    if ($this->literal('(') &&
-            -
                        $this->expression($feature) &&
-            -
                        ($this->literal(':') && $this->expression($value) || true) &&
-            -
                        $this->literal(')')
-            -
                    ) {
-            -
                        $out = array(Type::T_MEDIA_EXPRESSION, $feature);
-            -
-            -
                        if ($value) {
-            -
                            $out[] = $value;
-            -
                        }
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    $this->seek($s);
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse argument values
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function argValues(&$out)
-            -
                {
-            -
                    if ($this->genericList($list, 'argValue', ',', false)) {
-            -
                        $out = $list[2];
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse argument value
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function argValue(&$out)
-            -
                {
-            -
                    $s = $this->seek();
-            -
-            -
                    $keyword = null;
-            -
-            -
                    if (! $this->variable($keyword) || ! $this->literal(':')) {
-            -
                        $this->seek($s);
-            -
                        $keyword = null;
-            -
                    }
-            -
-            -
                    if ($this->genericList($value, 'expression')) {
-            -
                        $out = array($keyword, $value, false);
-            -
                        $s = $this->seek();
-            -
-            -
                        if ($this->literal('...')) {
-            -
                            $out[2] = true;
-            -
                        } else {
-            -
                            $this->seek($s);
-            -
                        }
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse comma separated value list
-            -
                 *
-            -
                 * @param string $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function valueList(&$out)
-            -
                {
-            -
                    return $this->genericList($out, 'spaceList', ',');
-            -
                }
-            -
-            -
                /**
-            -
                 * 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->seek();
-            -
                    $items = array();
-            -
-            -
                    while ($this->$parseItem($value)) {
-            -
                        $items[] = $value;
-            -
-            -
                        if ($delim) {
-            -
                            if (! $this->literal($delim)) {
-            -
                                break;
-            -
                            }
-            -
                        }
-            -
                    }
-            -
-            -
                    if (count($items) === 0) {
-            -
                        $this->seek($s);
-            -
-            -
                        return false;
-            -
                    }
-            -
-            -
                    if ($flatten && count($items) === 1) {
-            -
                        $out = $items[0];
-            -
                    } else {
-            -
                        $out = array(Type::T_LIST, $delim, $items);
-            -
                    }
-            -
-            -
                    return true;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse expression
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function expression(&$out)
-            -
                {
-            -
                    $s = $this->seek();
-            -
-            -
                    if ($this->literal('(')) {
-            -
                        if ($this->literal(')')) {
-            -
                            $out = array(Type::T_LIST, '', array());
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        if ($this->valueList($out) && $this->literal(')') && $out[0] === Type::T_LIST) {
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        if ($this->map($out)) {
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
                    }
-            -
-            -
                    if ($this->value($lhs)) {
-            -
                        $out = $this->expHelper($lhs, 0);
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse left-hand side of subexpression
-            -
                 *
-            -
                 * @param array   $lhs
-            -
                 * @param integer $minP
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function expHelper($lhs, $minP)
-            -
                {
-            -
                    $operators = self::$operatorPattern;
-            -
-            -
                    $ss = $this->seek();
-            -
                    $whiteBefore = isset($this->buffer[$this->count - 1]) &&
-            -
                        ctype_space($this->buffer[$this->count - 1]);
-            -
-            -
                    while ($this->match($operators, $m, false) && self::$precedence[$m[1]] >= $minP) {
-            -
                        $whiteAfter = isset($this->buffer[$this->count]) &&
-            -
                            ctype_space($this->buffer[$this->count]);
-            -
                        $varAfter = isset($this->buffer[$this->count]) &&
-            -
                            $this->buffer[$this->count] === '$';
-            -
-            -
                        $this->whitespace();
-            -
-            -
                        $op = $m[1];
-            -
-            -
                        // don't turn negative numbers into expressions
-            -
                        if ($op === '-' && $whiteBefore && ! $whiteAfter && ! $varAfter) {
-            -
                            break;
-            -
                        }
-            -
-            -
                        if (! $this->value($rhs)) {
-            -
                            break;
-            -
                        }
-            -
-            -
                        // peek and see if rhs belongs to next operator
-            -
                        if ($this->peek($operators, $next) && self::$precedence[$next[1]] > self::$precedence[$op]) {
-            -
                            $rhs = $this->expHelper($rhs, self::$precedence[$next[1]]);
-            -
                        }
-            -
-            -
                        $lhs = array(Type::T_EXPRESSION, $op, $lhs, $rhs, $this->inParens, $whiteBefore, $whiteAfter);
-            -
                        $ss = $this->seek();
-            -
                        $whiteBefore = isset($this->buffer[$this->count - 1]) &&
-            -
                            ctype_space($this->buffer[$this->count - 1]);
-            -
                    }
-            -
-            -
                    $this->seek($ss);
-            -
-            -
                    return $lhs;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse value
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function value(&$out)
-            -
                {
-            -
                    $s = $this->seek();
-            -
-            -
                    if ($this->literal('not', false) && $this->whitespace() && $this->value($inner)) {
-            -
                        $out = array(Type::T_UNARY, 'not', $inner, $this->inParens);
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    $this->seek($s);
-            -
-            -
                    if ($this->literal('not', false) && $this->parenValue($inner)) {
-            -
                        $out = array(Type::T_UNARY, 'not', $inner, $this->inParens);
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    $this->seek($s);
-            -
-            -
                    if ($this->literal('+') && $this->value($inner)) {
-            -
                        $out = array(Type::T_UNARY, '+', $inner, $this->inParens);
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    $this->seek($s);
-            -
-            -
                    // negation
-            -
                    if ($this->literal('-', false) &&
-            -
                        ($this->variable($inner) ||
-            -
                        $this->unit($inner) ||
-            -
                        $this->parenValue($inner))
-            -
                    ) {
-            -
                        $out = array(Type::T_UNARY, '-', $inner, $this->inParens);
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    $this->seek($s);
-            -
-            -
                    if ($this->parenValue($out) ||
-            -
                        $this->interpolation($out) ||
-            -
                        $this->variable($out) ||
-            -
                        $this->color($out) ||
-            -
                        $this->unit($out) ||
-            -
                        $this->string($out) ||
-            -
                        $this->func($out) ||
-            -
                        $this->progid($out)
-            -
                    ) {
-            -
                        return true;
-            -
                    }
-            -
-            -
                    if ($this->keyword($keyword)) {
-            -
                        if ($keyword === 'null') {
-            -
                            $out = array(Type::T_NULL);
-            -
                        } else {
-            -
                            $out = array(Type::T_KEYWORD, $keyword);
-            -
                        }
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse parenthesized value
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function parenValue(&$out)
-            -
                {
-            -
                    $s = $this->seek();
-            -
-            -
                    $inParens = $this->inParens;
-            -
-            -
                    if ($this->literal('(')) {
-            -
                        if ($this->literal(')')) {
-            -
                            $out = array(Type::T_LIST, '', array());
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $this->inParens = true;
-            -
-            -
                        if ($this->expression($exp) && $this->literal(')')) {
-            -
                            $out = $exp;
-            -
                            $this->inParens = $inParens;
-            -
-            -
                            return true;
-            -
                        }
-            -
                    }
-            -
-            -
                    $this->inParens = $inParens;
-            -
                    $this->seek($s);
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse "progid:"
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function progid(&$out)
-            -
                {
-            -
                    $s = $this->seek();
-            -
-            -
                    if ($this->literal('progid:', false) &&
-            -
                        $this->openString('(', $fn) &&
-            -
                        $this->literal('(')
-            -
                    ) {
-            -
                        $this->openString(')', $args, '(');
-            -
-            -
                        if ($this->literal(')')) {
-            -
                            $out = array(Type::T_STRING, '', array(
-            -
                                'progid:', $fn, '(', $args, ')'
-            -
                            ));
-            -
-            -
                            return true;
-            -
                        }
-            -
                    }
-            -
-            -
                    $this->seek($s);
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse function call
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function func(&$func)
-            -
                {
-            -
                    $s = $this->seek();
-            -
-            -
                    if ($this->keyword($name, false) &&
-            -
                        $this->literal('(')
-            -
                    ) {
-            -
                        if ($name === 'alpha' && $this->argumentList($args)) {
-            -
                            $func = array(Type::T_FUNCTION, $name, array(Type::T_STRING, '', $args));
-            -
-            -
                            return true;
-            -
                        }
-            -
-            -
                        if ($name !== 'expression' && ! preg_match('/^(-[a-z]+-)?calc$/', $name)) {
-            -
                            $ss = $this->seek();
-            -
-            -
                            if ($this->argValues($args) && $this->literal(')')) {
-            -
                                $func = array(Type::T_FUNCTION_CALL, $name, $args);
-            -
-            -
                                return true;
-            -
                            }
-            -
-            -
                            $this->seek($ss);
-            -
                        }
-            -
-            -
                        if (($this->openString(')', $str, '(') || true ) &&
-            -
                            $this->literal(')')
-            -
                        ) {
-            -
                            $args = array();
-            -
-            -
                            if (! empty($str)) {
-            -
                                $args[] = array(null, array(Type::T_STRING, '', array($str)));
-            -
                            }
-            -
-            -
                            $func = array(Type::T_FUNCTION_CALL, $name, $args);
-            -
-            -
                            return true;
-            -
                        }
-            -
                    }
-            -
-            -
                    $this->seek($s);
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse function call argument list
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function argumentList(&$out)
-            -
                {
-            -
                    $s = $this->seek();
-            -
                    $this->literal('(');
-            -
-            -
                    $args = array();
-            -
-            -
                    while ($this->keyword($var)) {
-            -
                        $ss = $this->seek();
-            -
-            -
                        if ($this->literal('=') && $this->expression($exp)) {
-            -
                            $args[] = array(Type::T_STRING, '', array($var . '='));
-            -
                            $arg = $exp;
-            -
                        } else {
-            -
                            break;
-            -
                        }
-            -
-            -
                        $args[] = $arg;
-            -
-            -
                        if (! $this->literal(',')) {
-            -
                            break;
-            -
                        }
-            -
-            -
                        $args[] = array(Type::T_STRING, '', array(', '));
-            -
                    }
-            -
-            -
                    if (! $this->literal(')') || ! count($args)) {
-            -
                        $this->seek($s);
-            -
-            -
                        return false;
-            -
                    }
-            -
-            -
                    $out = $args;
-            -
-            -
                    return true;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse mixin/function definition  argument list
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function argumentDef(&$out)
-            -
                {
-            -
                    $s = $this->seek();
-            -
                    $this->literal('(');
-            -
-            -
                    $args = array();
-            -
-            -
                    while ($this->variable($var)) {
-            -
                        $arg = array($var[1], null, false);
-            -
-            -
                        $ss = $this->seek();
-            -
-            -
                        if ($this->literal(':') && $this->genericList($defaultVal, 'expression')) {
-            -
                            $arg[1] = $defaultVal;
-            -
                        } else {
-            -
                            $this->seek($ss);
-            -
                        }
-            -
-            -
                        $ss = $this->seek();
-            -
-            -
                        if ($this->literal('...')) {
-            -
                            $sss = $this->seek();
-            -
-            -
                            if (! $this->literal(')')) {
-            -
                                $this->throwParseError('... has to be after the final argument');
-            -
                            }
-            -
-            -
                            $arg[2] = true;
-            -
                            $this->seek($sss);
-            -
                        } else {
-            -
                            $this->seek($ss);
-            -
                        }
-            -
-            -
                        $args[] = $arg;
-            -
-            -
                        if (! $this->literal(',')) {
-            -
                            break;
-            -
                        }
-            -
                    }
-            -
-            -
                    if (! $this->literal(')')) {
-            -
                        $this->seek($s);
-            -
-            -
                        return false;
-            -
                    }
-            -
-            -
                    $out = $args;
-            -
-            -
                    return true;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse map
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function map(&$out)
-            -
                {
-            -
                    $s = $this->seek();
-            -
-            -
                    if (! $this->literal('(')) {
-            -
                        return false;
-            -
                    }
-            -
-            -
                    $keys = array();
-            -
                    $values = array();
-            -
-            -
                    while ($this->genericList($key, 'expression') && $this->literal(':') &&
-            -
                        $this->genericList($value, 'expression')
-            -
                    ) {
-            -
                        $keys[] = $key;
-            -
                        $values[] = $value;
-            -
-            -
                        if (! $this->literal(',')) {
-            -
                            break;
-            -
                        }
-            -
                    }
-            -
-            -
                    if (! count($keys) || ! $this->literal(')')) {
-            -
                        $this->seek($s);
-            -
-            -
                        return false;
-            -
                    }
-            -
-            -
                    $out = array(Type::T_MAP, $keys, $values);
-            -
-            -
                    return true;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse color
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function color(&$out)
-            -
                {
-            -
                    $color = array(Type::T_COLOR);
-            -
-            -
                    if ($this->match('(#([0-9a-f]{6})|#([0-9a-f]{3}))', $m)) {
-            -
                        if (isset($m[3])) {
-            -
                            $num = hexdec($m[3]);
-            -
-            -
                            foreach (array(3, 2, 1) as $i) {
-            -
                                $t = $num & 0xf;
-            -
                                $color[$i] = $t << 4 | $t;
-            -
                                $num >>= 4;
-            -
                            }
-            -
                        } else {
-            -
                            $num = hexdec($m[2]);
-            -
-            -
                            foreach (array(3, 2, 1) as $i) {
-            -
                                $color[$i] = $num & 0xff;
-            -
                                $num >>= 8;
-            -
                            }
-            -
                        }
-            -
-            -
                        $out = $color;
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse number with unit
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function unit(&$unit)
-            -
                {
-            -
                    if ($this->match('([0-9]*(\.)?[0-9]+)([%a-zA-Z]+)?', $m)) {
-            -
                        $unit = new Node\Number($m[1], empty($m[3]) ? '' : $m[3]);
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse string
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function string(&$out)
-            -
                {
-            -
                    $s = $this->seek();
-            -
-            -
                    if ($this->literal('"', false)) {
-            -
                        $delim = '"';
-            -
                    } elseif ($this->literal('\'', false)) {
-            -
                        $delim = '\'';
-            -
                    } else {
-            -
                        return false;
-            -
                    }
-            -
-            -
                    $content = array();
-            -
                    $oldWhite = $this->eatWhiteDefault;
-            -
                    $this->eatWhiteDefault = false;
-            -
-            -
                    while ($this->matchString($m, $delim)) {
-            -
                        $content[] = $m[1];
-            -
-            -
                        if ($m[2] === '#{') {
-            -
                            $this->count -= strlen($m[2]);
-            -
-            -
                            if ($this->interpolation($inter, false)) {
-            -
                                $content[] = $inter;
-            -
                            } else {
-            -
                                $this->count += strlen($m[2]);
-            -
                                $content[] = '#{'; // ignore it
-            -
                            }
-            -
                        } elseif ($m[2] === '\\') {
-            -
                            $content[] = $m[2];
-            -
-            -
                            if ($this->literal($delim, false)) {
-            -
                                $content[] = $delim;
-            -
                            }
-            -
                        } else {
-            -
                            $this->count -= strlen($delim);
-            -
                            break; // delim
-            -
                        }
-            -
                    }
-            -
-            -
                    $this->eatWhiteDefault = $oldWhite;
-            -
-            -
                    if ($this->literal($delim)) {
-            -
                        $out = array(Type::T_STRING, $delim, $content);
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    $this->seek($s);
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse keyword or interpolation
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function mixedKeyword(&$out)
-            -
                {
-            -
                    $s = $this->seek();
-            -
-            -
                    $parts = array();
-            -
-            -
                    $oldWhite = $this->eatWhiteDefault;
-            -
                    $this->eatWhiteDefault = false;
-            -
-            -
                    for (;;) {
-            -
                        if ($this->keyword($key)) {
-            -
                            $parts[] = $key;
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if ($this->interpolation($inter)) {
-            -
                            $parts[] = $inter;
-            -
                            continue;
-            -
                        }
-            -
-            -
                        break;
-            -
                    }
-            -
-            -
                    $this->eatWhiteDefault = $oldWhite;
-            -
-            -
                    if (count($parts) === 0) {
-            -
                        return false;
-            -
                    }
-            -
-            -
                    if ($this->eatWhiteDefault) {
-            -
                        $this->whitespace();
-            -
                    }
-            -
-            -
                    $out = $parts;
-            -
-            -
                    return true;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse an unbounded string stopped by $end
-            -
                 *
-            -
                 * @param string $end
-            -
                 * @param array  $out
-            -
                 * @param string $nestingOpen
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function openString($end, &$out, $nestingOpen = null)
-            -
                {
-            -
                    $oldWhite = $this->eatWhiteDefault;
-            -
                    $this->eatWhiteDefault = false;
-            -
-            -
                    $patt = '(.*?)([\'"]|#\{|' . $this->pregQuote($end) . '|' . self::$commentPattern . ')';
-            -
-            -
                    $nestingLevel = 0;
-            -
-            -
                    $content = array();
-            -
-            -
                    while ($this->match($patt, $m, false)) {
-            -
                        if (isset($m[1]) && $m[1] !== '') {
-            -
                            $content[] = $m[1];
-            -
-            -
                            if ($nestingOpen) {
-            -
                                $nestingLevel += substr_count($m[1], $nestingOpen);
-            -
                            }
-            -
                        }
-            -
-            -
                        $tok = $m[2];
-            -
-            -
                        $this->count-= strlen($tok);
-            -
-            -
                        if ($tok === $end && ! $nestingLevel--) {
-            -
                            break;
-            -
                        }
-            -
-            -
                        if (($tok === '\'' || $tok === '"') && $this->string($str)) {
-            -
                            $content[] = $str;
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if ($tok === '#{' && $this->interpolation($inter)) {
-            -
                            $content[] = $inter;
-            -
                            continue;
-            -
                        }
-            -
-            -
                        $content[] = $tok;
-            -
                        $this->count+= strlen($tok);
-            -
                    }
-            -
-            -
                    $this->eatWhiteDefault = $oldWhite;
-            -
-            -
                    if (count($content) === 0) {
-            -
                        return false;
-            -
                    }
-            -
-            -
                    // trim the end
-            -
                    if (is_string(end($content))) {
-            -
                        $content[count($content) - 1] = rtrim(end($content));
-            -
                    }
-            -
-            -
                    $out = array(Type::T_STRING, '', $content);
-            -
-            -
                    return true;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parser interpolation
-            -
                 *
-            -
                 * @param array   $out
-            -
                 * @param boolean $lookWhite save information about whitespace before and after
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function interpolation(&$out, $lookWhite = true)
-            -
                {
-            -
                    $oldWhite = $this->eatWhiteDefault;
-            -
                    $this->eatWhiteDefault = true;
-            -
-            -
                    $s = $this->seek();
-            -
-            -
                    if ($this->literal('#{') && $this->valueList($value) && $this->literal('}', false)) {
-            -
                        // TODO: don't error if out of bounds
-            -
-            -
                        if ($lookWhite) {
-            -
                            $left = preg_match('/\s/', $this->buffer[$s - 1]) ? ' ' : '';
-            -
                            $right = preg_match('/\s/', $this->buffer[$this->count]) ? ' ': '';
-            -
                        } else {
-            -
                            $left = $right = false;
-            -
                        }
-            -
-            -
                        $out = array(Type::T_INTERPOLATE, $value, $left, $right);
-            -
                        $this->eatWhiteDefault = $oldWhite;
-            -
-            -
                        if ($this->eatWhiteDefault) {
-            -
                            $this->whitespace();
-            -
                        }
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    $this->seek($s);
-            -
                    $this->eatWhiteDefault = $oldWhite;
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse property name (as an array of parts or a string)
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function propertyName(&$out)
-            -
                {
-            -
                    $s = $this->seek();
-            -
                    $parts = array();
-            -
-            -
                    $oldWhite = $this->eatWhiteDefault;
-            -
                    $this->eatWhiteDefault = false;
-            -
-            -
                    for (;;) {
-            -
                        if ($this->interpolation($inter)) {
-            -
                            $parts[] = $inter;
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if ($this->keyword($text)) {
-            -
                            $parts[] = $text;
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if (count($parts) === 0 && $this->match('[:.#]', $m, false)) {
-            -
                            // css hacks
-            -
                            $parts[] = $m[0];
-            -
                            continue;
-            -
                        }
-            -
-            -
                        break;
-            -
                    }
-            -
-            -
                    $this->eatWhiteDefault = $oldWhite;
-            -
-            -
                    if (count($parts) === 0) {
-            -
                        return false;
-            -
                    }
-            -
-            -
                    // match comment hack
-            -
                    if (preg_match(
-            -
                        self::$whitePattern,
-            -
                        $this->buffer,
-            -
                        $m,
-            -
                        null,
-            -
                        $this->count
-            -
                    )) {
-            -
                        if (! empty($m[0])) {
-            -
                            $parts[] = $m[0];
-            -
                            $this->count += strlen($m[0]);
-            -
                        }
-            -
                    }
-            -
-            -
                    $this->whitespace(); // get any extra whitespace
-            -
-            -
                    $out = array(Type::T_STRING, '', $parts);
-            -
-            -
                    return true;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse comma separated selector list
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function selectors(&$out)
-            -
                {
-            -
                    $s = $this->seek();
-            -
                    $selectors = array();
-            -
-            -
                    while ($this->selector($sel)) {
-            -
                        $selectors[] = $sel;
-            -
-            -
                        if (! $this->literal(',')) {
-            -
                            break;
-            -
                        }
-            -
-            -
                        while ($this->literal(',')) {
-            -
                            ; // ignore extra
-            -
                        }
-            -
                    }
-            -
-            -
                    if (count($selectors) === 0) {
-            -
                        $this->seek($s);
-            -
-            -
                        return false;
-            -
                    }
-            -
-            -
                    $out = $selectors;
-            -
-            -
                    return true;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse whitespace separated selector list
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function selector(&$out)
-            -
                {
-            -
                    $selector = array();
-            -
-            -
                    for (;;) {
-            -
                        if ($this->match('[>+~]+', $m)) {
-            -
                            $selector[] = array($m[0]);
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if ($this->selectorSingle($part)) {
-            -
                            $selector[] = $part;
-            -
                            $this->match('\s+', $m);
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if ($this->match('\/[^\/]+\/', $m)) {
-            -
                            $selector[] = array($m[0]);
-            -
                            continue;
-            -
                        }
-            -
-            -
                        break;
-            -
                    }
-            -
-            -
                    if (count($selector) === 0) {
-            -
                        return false;
-            -
                    }
-            -
-            -
                    $out = $selector;
-            -
                    return true;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse the parts that make up a selector
-            -
                 *
-            -
                 * {@internal
-            -
                 *     div[yes=no]#something.hello.world:nth-child(-2n+1)%placeholder
-            -
                 * }}
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function selectorSingle(&$out)
-            -
                {
-            -
                    $oldWhite = $this->eatWhiteDefault;
-            -
                    $this->eatWhiteDefault = false;
-            -
-            -
                    $parts = array();
-            -
-            -
                    if ($this->literal('*', false)) {
-            -
                        $parts[] = '*';
-            -
                    }
-            -
-            -
                    for (;;) {
-            -
                        // see if we can stop early
-            -
                        if ($this->match('\s*[{,]', $m)) {
-            -
                            $this->count--;
-            -
                            break;
-            -
                        }
-            -
-            -
                        $s = $this->seek();
-            -
-            -
                        // self
-            -
                        if ($this->literal('&', false)) {
-            -
                            $parts[] = Compiler::$selfSelector;
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if ($this->literal('.', false)) {
-            -
                            $parts[] = '.';
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if ($this->literal('|', false)) {
-            -
                            $parts[] = '|';
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if ($this->match('\\\\\S', $m)) {
-            -
                            $parts[] = $m[0];
-            -
                            continue;
-            -
                        }
-            -
-            -
                        // for keyframes
-            -
                        if ($this->unit($unit)) {
-            -
                            $parts[] = $unit;
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if ($this->keyword($name)) {
-            -
                            $parts[] = $name;
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if ($this->interpolation($inter)) {
-            -
                            $parts[] = $inter;
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if ($this->literal('%', false) && $this->placeholder($placeholder)) {
-            -
                            $parts[] = '%';
-            -
                            $parts[] = $placeholder;
-            -
                            continue;
-            -
                        }
-            -
-            -
                        if ($this->literal('#', false)) {
-            -
                            $parts[] = '#';
-            -
                            continue;
-            -
                        }
-            -
-            -
                        // a pseudo selector
-            -
                        if ($this->match('::?', $m) && $this->mixedKeyword($nameParts)) {
-            -
                            $parts[] = $m[0];
-            -
-            -
                            foreach ($nameParts as $sub) {
-            -
                                $parts[] = $sub;
-            -
                            }
-            -
-            -
                            $ss = $this->seek();
-            -
-            -
                            if ($this->literal('(') &&
-            -
                                ($this->openString(')', $str, '(') || true ) &&
-            -
                                $this->literal(')')
-            -
                            ) {
-            -
                                $parts[] = '(';
-            -
-            -
                                if (! empty($str)) {
-            -
                                    $parts[] = $str;
-            -
                                }
-            -
-            -
                                $parts[] = ')';
-            -
                            } else {
-            -
                                $this->seek($ss);
-            -
                            }
-            -
-            -
                            continue;
-            -
                        }
-            -
-            -
                        $this->seek($s);
-            -
-            -
                        // attribute selector
-            -
                        // TODO: replace with open string?
-            -
                        if ($this->literal('[', false)) {
-            -
                            $attrParts = array('[');
-            -
-            -
                            // keyword, string, operator
-            -
                            for (;;) {
-            -
                                if ($this->literal(']', false)) {
-            -
                                    $this->count--;
-            -
                                    break; // get out early
-            -
                                }
-            -
-            -
                                if ($this->match('\s+', $m)) {
-            -
                                    $attrParts[] = ' ';
-            -
                                    continue;
-            -
                                }
-            -
-            -
                                if ($this->string($str)) {
-            -
                                    $attrParts[] = $str;
-            -
                                    continue;
-            -
                                }
-            -
-            -
                                if ($this->keyword($word)) {
-            -
                                    $attrParts[] = $word;
-            -
                                    continue;
-            -
                                }
-            -
-            -
                                if ($this->interpolation($inter, false)) {
-            -
                                    $attrParts[] = $inter;
-            -
                                    continue;
-            -
                                }
-            -
-            -
                                // operator, handles attr namespace too
-            -
                                if ($this->match('[|-~\$\*\^=]+', $m)) {
-            -
                                    $attrParts[] = $m[0];
-            -
                                    continue;
-            -
                                }
-            -
-            -
                                break;
-            -
                            }
-            -
-            -
                            if ($this->literal(']', false)) {
-            -
                                $attrParts[] = ']';
-            -
-            -
                                foreach ($attrParts as $part) {
-            -
                                    $parts[] = $part;
-            -
                                }
-            -
-            -
                                continue;
-            -
                            }
-            -
-            -
                            $this->seek($s);
-            -
                            // TODO: should just break here?
-            -
                        }
-            -
-            -
                        break;
-            -
                    }
-            -
-            -
                    $this->eatWhiteDefault = $oldWhite;
-            -
-            -
                    if (count($parts) === 0) {
-            -
                        return false;
-            -
                    }
-            -
-            -
                    $out = $parts;
-            -
-            -
                    return true;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse a variable
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function variable(&$out)
-            -
                {
-            -
                    $s = $this->seek();
-            -
-            -
                    if ($this->literal('$', false) && $this->keyword($name)) {
-            -
                        $out = array(Type::T_VARIABLE, $name);
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    $this->seek($s);
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse a keyword
-            -
                 *
-            -
                 * @param string  $word
-            -
                 * @param boolean $eatWhitespace
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function keyword(&$word, $eatWhitespace = null)
-            -
                {
-            -
                    if ($this->match(
-            -
                        '(([\w_\-\*!"\']|[\\\\].)([\w\-_"\']|[\\\\].)*)',
-            -
                        $m,
-            -
                        $eatWhitespace
-            -
                    )) {
-            -
                        $word = $m[1];
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse a placeholder
-            -
                 *
-            -
                 * @param string $placeholder
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function placeholder(&$placeholder)
-            -
                {
-            -
                    if ($this->match('([\w\-_]+|#[{][$][\w\-_]+[}])', $m)) {
-            -
                        $placeholder = $m[1];
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Parse a url
-            -
                 *
-            -
                 * @param array $out
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function url(&$out)
-            -
                {
-            -
                    if ($this->match('(url\(\s*(["\']?)([^)]+)\2\s*\))', $m)) {
-            -
                        $out = array(Type::T_STRING, '', array('url(' . $m[2] . $m[3] . $m[2] . ')'));
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Consume an end of statement delimiter
-            -
                 *
-            -
                 * @return boolean
-            -
                 */
-            -
                protected function end()
-            -
                {
-            -
                    if ($this->literal(';')) {
-            -
                        return true;
-            -
                    }
-            -
-            -
                    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;
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Strip assignment flag from the list
-            -
                 *
-            -
                 * @param array $value
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                protected function stripAssignmentFlag(&$value)
-            -
                {
-            -
                    $token = &$value;
-            -
-            -
                    for ($token = &$value; $token[0] === Type::T_LIST && ($s = count($token[2])); $token = &$lastNode) {
-            -
                        $lastNode = &$token[2][$s - 1];
-            -
-            -
                        if ($lastNode[0] === Type::T_KEYWORD && in_array($lastNode[1], array('!default', '!global'))) {
-            -
                            array_pop($token[2]);
-            -
-            -
                            $token = $this->flattenList($token);
-            -
-            -
                            return $lastNode[1];
-            -
                        }
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Turn list of length 1 into value type
-            -
                 *
-            -
                 * @param array $value
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function flattenList($value)
-            -
                {
-            -
                    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
-            -
                 *
-            -
                 * @param string $what
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                private function pregQuote($what)
-            -
                {
-            -
                    return preg_quote($what, '/');
-            -
                }
-            -
            }

assets/libraries/scssphp_legacy/src/Server.php DELETED Viewed

@@ -1,459 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp;
-            -
-            -
            use Leafo\ScssPhp\Compiler;
-            -
            use Leafo\ScssPhp\Version;
-            -
-            -
            /**
-            -
             * SCSS server
-            -
             *
-            -
             * @author Leaf Corcoran <leafot@gmail.com>
-            -
             */
-            -
            class Server
-            -
            {
-            -
                /**
-            -
                 * @var boolean
-            -
                 */
-            -
                private $showErrorsAsCSS;
-            -
-            -
                /**
-            -
                 * @var string
-            -
                 */
-            -
                private $dir;
-            -
-            -
                /**
-            -
                 * @var string
-            -
                 */
-            -
                private $cacheDir;
-            -
-            -
                /**
-            -
                 * @var \Leafo\ScssPhp\Compiler
-            -
                 */
-            -
                private $scss;
-            -
-            -
                /**
-            -
                 * Join path components
-            -
                 *
-            -
                 * @param string $left  Path component, left of the directory separator
-            -
                 * @param string $right Path component, right of the directory separator
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                protected function join($left, $right)
-            -
                {
-            -
                    return rtrim($left, '/\\') . DIRECTORY_SEPARATOR . ltrim($right, '/\\');
-            -
                }
-            -
-            -
                /**
-            -
                 * Get name of requested .scss file
-            -
                 *
-            -
                 * @return string|null
-            -
                 */
-            -
                protected function inputName()
-            -
                {
-            -
                    switch (true) {
-            -
                        case isset($_GET['p']):
-            -
                            return $_GET['p'];
-            -
                        case isset($_SERVER['PATH_INFO']):
-            -
                            return $_SERVER['PATH_INFO'];
-            -
                        case isset($_SERVER['DOCUMENT_URI']):
-            -
                            return substr($_SERVER['DOCUMENT_URI'], strlen($_SERVER['SCRIPT_NAME']));
-            -
                    }
-            -
                }
-            -
-            -
                /**
-            -
                 * Get path to requested .scss file
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                protected function findInput()
-            -
                {
-            -
                    if (($input = $this->inputName())
-            -
                        && strpos($input, '..') === false
-            -
                        && substr($input, -5) === '.scss'
-            -
                    ) {
-            -
                        $name = $this->join($this->dir, $input);
-            -
-            -
                        if (is_file($name) && is_readable($name)) {
-            -
                            return $name;
-            -
                        }
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Get path to cached .css file
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                protected function cacheName($fname)
-            -
                {
-            -
                    return $this->join($this->cacheDir, md5($fname) . '.css');
-            -
                }
-            -
-            -
                /**
-            -
                 * Get path to meta data
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                protected function metadataName($out)
-            -
                {
-            -
                    return $out . '.meta';
-            -
                }
-            -
-            -
                /**
-            -
                 * Determine whether .scss file needs to be re-compiled.
-            -
                 *
-            -
                 * @param string $in   Input path
-            -
                 * @param string $out  Output path
-            -
                 * @param string $etag ETag
-            -
                 *
-            -
                 * @return boolean True if compile required.
-            -
                 */
-            -
                protected function needsCompile($in, $out, &$etag)
-            -
                {
-            -
                    if (! is_file($out)) {
-            -
                        return true;
-            -
                    }
-            -
-            -
                    $mtime = filemtime($out);
-            -
-            -
                    $metadataName = $this->metadataName($out);
-            -
-            -
                    if (is_readable($metadataName)) {
-            -
                        $metadata = unserialize(file_get_contents($metadataName));
-            -
-            -
                        foreach ($metadata['imports'] as $import => $originalMtime) {
-            -
                            $currentMtime = filemtime($import);
-            -
-            -
                            if ($currentMtime !== $originalMtime || $currentMtime > $mtime) {
-            -
                                return true;
-            -
                            }
-            -
                        }
-            -
-            -
                        $metaVars = crc32(serialize($this->scss->getVariables()));
-            -
-            -
                        if ($metaVars !== $metadata['vars']) {
-            -
                            return true;
-            -
                        }
-            -
-            -
                        $etag = $metadata['etag'];
-            -
-            -
                        return false;
-            -
                    }
-            -
-            -
                    return true;
-            -
                }
-            -
-            -
                /**
-            -
                 * Get If-Modified-Since header from client request
-            -
                 *
-            -
                 * @return string|null
-            -
                 */
-            -
                protected function getIfModifiedSinceHeader()
-            -
                {
-            -
                    $modifiedSince = null;
-            -
-            -
                    if (isset($_SERVER['HTTP_IF_MODIFIED_SINCE'])) {
-            -
                        $modifiedSince = $_SERVER['HTTP_IF_MODIFIED_SINCE'];
-            -
-            -
                        if (false !== ($semicolonPos = strpos($modifiedSince, ';'))) {
-            -
                            $modifiedSince = substr($modifiedSince, 0, $semicolonPos);
-            -
                        }
-            -
                    }
-            -
-            -
                    return $modifiedSince;
-            -
                }
-            -
-            -
                /**
-            -
                 * Get If-None-Match header from client request
-            -
                 *
-            -
                 * @return string|null
-            -
                 */
-            -
                protected function getIfNoneMatchHeader()
-            -
                {
-            -
                    $noneMatch = null;
-            -
-            -
                    if (isset($_SERVER['HTTP_IF_NONE_MATCH'])) {
-            -
                        $noneMatch = $_SERVER['HTTP_IF_NONE_MATCH'];
-            -
                    }
-            -
-            -
                    return $noneMatch;
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile .scss file
-            -
                 *
-            -
                 * @param string $in  Input path (.scss)
-            -
                 * @param string $out Output path (.css)
-            -
                 *
-            -
                 * @return array
-            -
                 */
-            -
                protected function compile($in, $out)
-            -
                {
-            -
                    $start   = microtime(true);
-            -
                    $css     = $this->scss->compile(file_get_contents($in), $in);
-            -
                    $elapsed = round((microtime(true) - $start), 4);
-            -
-            -
                    $v    = Version::VERSION;
-            -
                    $t    = @date('r');
-            -
                    $css  = "/* compiled by scssphp $v on $t (${elapsed}s) */\n\n" . $css;
-            -
                    $etag = md5($css);
-            -
-            -
                    file_put_contents($out, $css);
-            -
                    file_put_contents(
-            -
                        $this->metadataName($out),
-            -
                        serialize(array(
-            -
                            'etag'    => $etag,
-            -
                            'imports' => $this->scss->getParsedFiles(),
-            -
                            'vars'    => crc32(serialize($this->scss->getVariables())),
-            -
                        ))
-            -
                    );
-            -
-            -
                    return array($css, $etag);
-            -
                }
-            -
-            -
                /**
-            -
                 * Format error as a pseudo-element in CSS
-            -
                 *
-            -
                 * @param \Exception $error
-            -
                 *
-            -
                 * @return string
-            -
                 */
-            -
                protected function createErrorCSS($error)
-            -
                {
-            -
                    $message = str_replace(
-            -
                        array("'", "\n"),
-            -
                        array("\\'", "\\A"),
-            -
                        $error->getfile() . ":\n\n" . $error->getMessage()
-            -
                    );
-            -
-            -
                    return "body { display: none !important; }
-            -
                            html:after {
-            -
                                background: white;
-            -
                                color: black;
-            -
                                content: '$message';
-            -
                                display: block !important;
-            -
                                font-family: mono;
-            -
                                padding: 1em;
-            -
                                white-space: pre;
-            -
                            }";
-            -
                }
-            -
-            -
                /**
-            -
                 * Render errors as a pseudo-element within valid CSS, displaying the errors on any
-            -
                 * page that includes this CSS.
-            -
                 *
-            -
                 * @param boolean $show
-            -
                 */
-            -
                public function showErrorsAsCSS($show = true)
-            -
                {
-            -
                    $this->showErrorsAsCSS = $show;
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile .scss file
-            -
                 *
-            -
                 * @param string $in  Input file (.scss)
-            -
                 * @param string $out Output file (.css) optional
-            -
                 *
-            -
                 * @return string|bool
-            -
                 */
-            -
                public function compileFile($in, $out = null)
-            -
                {
-            -
                    if (! is_readable($in)) {
-            -
                        throw new \Exception('load error: failed to find ' . $in);
-            -
                    }
-            -
-            -
                    $pi = pathinfo($in);
-            -
-            -
                    $this->scss->addImportPath($pi['dirname'] . '/');
-            -
-            -
                    $compiled = $this->scss->compile(file_get_contents($in), $in);
-            -
-            -
                    if ($out !== null) {
-            -
                        return file_put_contents($out, $compiled);
-            -
                    }
-            -
-            -
                    return $compiled;
-            -
                }
-            -
-            -
                /**
-            -
                 * Check if file need compiling
-            -
                 *
-            -
                 * @param string $in  Input file (.scss)
-            -
                 * @param string $out Output file (.css)
-            -
                 *
-            -
                 * @return bool
-            -
                 */
-            -
                public function checkedCompile($in, $out)
-            -
                {
-            -
                    if (! is_file($out) || filemtime($in) > filemtime($out)) {
-            -
                        $this->compileFile($in, $out);
-            -
-            -
                        return true;
-            -
                    }
-            -
-            -
                    return false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Compile requested scss and serve css.  Outputs HTTP response.
-            -
                 *
-            -
                 * @param string $salt Prefix a string to the filename for creating the cache name hash
-            -
                 */
-            -
                public function serve($salt = '')
-            -
                {
-            -
                    $protocol = isset($_SERVER['SERVER_PROTOCOL'])
-            -
                        ? $_SERVER['SERVER_PROTOCOL']
-            -
                        : 'HTTP/1.0';
-            -
-            -
                    if ($input = $this->findInput()) {
-            -
                        $output = $this->cacheName($salt . $input);
-            -
                        $etag = $noneMatch = trim($this->getIfNoneMatchHeader(), '"');
-            -
-            -
                        if ($this->needsCompile($input, $output, $etag)) {
-            -
                            try {
-            -
                                list($css, $etag) = $this->compile($input, $output);
-            -
-            -
                                $lastModified = gmdate('D, d M Y H:i:s', filemtime($output)) . ' GMT';
-            -
-            -
                                header('Last-Modified: ' . $lastModified);
-            -
                                header('Content-type: text/css');
-            -
                                header('ETag: "' . $etag . '"');
-            -
-            -
                                echo $css;
-            -
-            -
                            } catch (\Exception $e) {
-            -
                                if ($this->showErrorsAsCSS) {
-            -
                                    header('Content-type: text/css');
-            -
-            -
                                    echo $this->createErrorCSS($e);
-            -
                                } else {
-            -
                                    header($protocol . ' 500 Internal Server Error');
-            -
                                    header('Content-type: text/plain');
-            -
-            -
                                    echo 'Parse error: ' . $e->getMessage() . "\n";
-            -
                                }
-            -
-            -
                            }
-            -
-            -
                            return;
-            -
                        }
-            -
-            -
                        header('X-SCSS-Cache: true');
-            -
                        header('Content-type: text/css');
-            -
                        header('ETag: "' . $etag . '"');
-            -
-            -
                        if ($etag === $noneMatch) {
-            -
                            header($protocol . ' 304 Not Modified');
-            -
-            -
                            return;
-            -
                        }
-            -
-            -
                        $modifiedSince = $this->getIfModifiedSinceHeader();
-            -
                        $mtime = filemtime($output);
-            -
-            -
                        if (@strtotime($modifiedSince) === $mtime) {
-            -
                            header($protocol . ' 304 Not Modified');
-            -
-            -
                            return;
-            -
                        }
-            -
-            -
                        $lastModified  = gmdate('D, d M Y H:i:s', $mtime) . ' GMT';
-            -
                        header('Last-Modified: ' . $lastModified);
-            -
-            -
                        echo file_get_contents($output);
-            -
-            -
                        return;
-            -
                    }
-            -
-            -
                    header($protocol . ' 404 Not Found');
-            -
                    header('Content-type: text/plain');
-            -
-            -
                    $v = Version::VERSION;
-            -
                    echo "/* INPUT NOT FOUND scss $v */\n";
-            -
                }
-            -
-            -
                /**
-            -
                 * Based on explicit input/output files does a full change check on cache before compiling.
-            -
                 *
-            -
                 * @param string  $in
-            -
                 * @param string  $out
-            -
                 * @param boolean $force
-            -
                 *
-            -
                 * @return string Compiled CSS results
-            -
                 *
-            -
                 * @throws \Exception
-            -
                 */
-            -
                public function checkedCachedCompile($in, $out, $force = false)
-            -
                {
-            -
                    if (! is_file($in) || ! is_readable($in)) {
-            -
                        throw new \Exception('Invalid or unreadable input file specified.');
-            -
                    }
-            -
-            -
                    if (is_dir($out) || ! is_writable(file_exists($out) ? $out : dirname($out))) {
-            -
                        throw new \Exception('Invalid or unwritable output file specified.');
-            -
                    }
-            -
-            -
                    if ($force || $this->needsCompile($in, $out, $etag)) {
-            -
                        list($css, $etag) = $this->compile($in, $out);
-            -
                    } else {
-            -
                        $css = file_get_contents($out);
-            -
                    }
-            -
-            -
                    return $css;
-            -
                }
-            -
-            -
                /**
-            -
                 * Constructor
-            -
                 *
-            -
                 * @param string                       $dir      Root directory to .scss files
-            -
                 * @param string                       $cacheDir Cache directory
-            -
                 * @param \Leafo\ScssPhp\Compiler|null $scss     SCSS compiler instance
-            -
                 */
-            -
                public function __construct($dir, $cacheDir = null, $scss = null)
-            -
                {
-            -
                    $this->dir = $dir;
-            -
-            -
                    if (! isset($cacheDir)) {
-            -
                        $cacheDir = $this->join($dir, 'scss_cache');
-            -
                    }
-            -
-            -
                    $this->cacheDir = $cacheDir;
-            -
-            -
                    if (! is_dir($this->cacheDir)) {
-            -
                        mkdir($this->cacheDir, 0755, true);
-            -
                    }
-            -
-            -
                    if (! isset($scss)) {
-            -
                        $scss = new Compiler();
-            -
                        $scss->setImportPaths($this->dir);
-            -
                    }
-            -
-            -
                    $this->scss = $scss;
-            -
                    $this->showErrorsAsCSS = false;
-            -
                }
-            -
-            -
                /**
-            -
                 * Helper method to serve compiled scss
-            -
                 *
-            -
                 * @param string $path Root path
-            -
                 */
-            -
                public static function serveFrom($path)
-            -
                {
-            -
                    $server = new self($path);
-            -
                    $server->serve();
-            -
                }
-            -
            }

assets/libraries/scssphp_legacy/src/Type.php DELETED Viewed

@@ -1,68 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp;
-            -
-            -
            /**
-            -
             * SCSS block/node types
-            -
             *
-            -
             * @author Anthon Pang <anthon.pang@gmail.com>
-            -
             */
-            -
            class Type
-            -
            {
-            -
                const T_ASSIGN = 'assign';
-            -
                const T_AT_ROOT = 'at-root';
-            -
                const T_BLOCK = 'block';
-            -
                const T_BREAK = 'break';
-            -
                const T_CHARSET = 'charset';
-            -
                const T_COLOR = 'color';
-            -
                const T_COMMENT = 'comment';
-            -
                const T_CONTINUE = 'continue';
-            -
                const T_CONTROL = 'control';
-            -
                const T_DEBUG = 'debug';
-            -
                const T_DIRECTIVE = 'directive';
-            -
                const T_EACH = 'each';
-            -
                const T_ELSE = 'else';
-            -
                const T_ELSEIF = 'elseif';
-            -
                const T_ERROR = 'error';
-            -
                const T_EXPRESSION = 'exp';
-            -
                const T_EXTEND = 'extend';
-            -
                const T_FOR = 'for';
-            -
                const T_FUNCTION = 'function';
-            -
                const T_FUNCTION_CALL = 'fncall';
-            -
                const T_HSL = 'hsl';
-            -
                const T_IF = 'if';
-            -
                const T_IMPORT = 'import';
-            -
                const T_INCLUDE = 'include';
-            -
                const T_INTERPOLATE = 'interpolate';
-            -
                const T_INTERPOLATED = 'interpolated';
-            -
                const T_KEYWORD = 'keyword';
-            -
                const T_LIST = 'list';
-            -
                const T_MAP = 'map';
-            -
                const T_MEDIA = 'media';
-            -
                const T_MEDIA_EXPRESSION = 'mediaExp';
-            -
                const T_MEDIA_TYPE = 'mediaType';
-            -
                const T_MEDIA_VALUE = 'mediaValue';
-            -
                const T_MIXIN = 'mixin';
-            -
                const T_MIXIN_CONTENT = 'mixin_content';
-            -
                const T_NESTED_PROPERTY = 'nestedprop';
-            -
                const T_NOT = 'not';
-            -
                const T_NULL = 'null';
-            -
                const T_NUMBER = 'number';
-            -
                const T_RETURN = 'return';
-            -
                const T_ROOT = 'root';
-            -
                const T_SELF = 'self';
-            -
                const T_STRING = 'string';
-            -
                const T_UNARY = 'unary';
-            -
                const T_VARIABLE = 'var';
-            -
                const T_WARN = 'warn';
-            -
                const T_WHILE = 'while';
-            -
            }

assets/libraries/scssphp_legacy/src/Util.php DELETED Viewed

@@ -1,55 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp;
-            -
-            -
            use Leafo\ScssPhp\Base\Range;
-            -
-            -
            /**
-            -
             * SCSS utilties
-            -
             *
-            -
             * @author Anthon Pang <anthon.pang@gmail.com>
-            -
             */
-            -
            class Util
-            -
            {
-            -
                /**
-            -
                 * Asserts that `value` falls within `range` (inclusive), leaving
-            -
                 * room for slight floating-point errors.
-            -
                 *
-            -
                 * @param string $name  The name of the value. Used in the error message.
-            -
                 * @param Range  $range Range of values.
-            -
                 * @param array  $value The value to check.
-            -
                 * @param string $unit  The unit of the value. Used in error reporting.
-            -
                 *
-            -
                 * @return mixed `value` adjusted to fall within range, if it was outside by a floating-point margin.
-            -
                 *
-            -
                 * @throws \Exception
-            -
                 */
-            -
                public static function checkRange($name, Range $range, $value, $unit = '')
-            -
                {
-            -
                    $val = $value[1];
-            -
                    $grace = new Range(-0.00001, 0.00001);
-            -
-            -
                    if ($range->includes($val)) {
-            -
                        return $val;
-            -
                    }
-            -
-            -
                    if ($grace->includes($val - $range->first)) {
-            -
                        return $range->first;
-            -
                    }
-            -
-            -
                    if ($grace->includes($val - $range->last)) {
-            -
                        return $range->last;
-            -
                    }
-            -
-            -
                    throw new \Exception("$name {$val} must be between {$range->first} and {$range->last}$unit");
-            -
                }
-            -
            }

assets/libraries/scssphp_legacy/src/Version.php DELETED Viewed

@@ -1,22 +0,0 @@
-            -
            <?php
-            -
            /**
-            -
             * SCSSPHP
-            -
             *
-            -
             * @copyright 2012-2015 Leaf Corcoran
-            -
             *
-            -
             * @license http://opensource.org/licenses/MIT MIT
-            -
             *
-            -
             * @link http://leafo.github.io/scssphp
-            -
             */
-            -
-            -
            namespace Leafo\ScssPhp;
-            -
-            -
            /**
-            -
             * SCSSPHP version
-            -
             *
-            -
             * @author Leaf Corcoran <leafot@gmail.com>
-            -
             */
-            -
            class Version
-            -
            {
-            -
                const VERSION = 'v0.4.0';
-            -
            }

assets/libraries/simplehtmldom/CHANGELOG.md ADDED Viewed

	@@ -0,0 +1,265 @@


1	+ # Changelog
2	+ All notable changes to this project will be documented in this file.
3	+
4	+ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
5	+
6	+ ## [1.9.1] - 2019-10-20
7	+ ### Fixed
8	+ - Fixed broken "text" selectors [#175](https://sourceforge.net/p/simplehtmldom/bugs/175/)
9	+
10	+ ## [1.9] - 2019-05-30
11	+ ### Added
12	+ - Added unit test for bug reports
13	+ - Added test for bug [#153](https://sourceforge.net/p/simplehtmldom/bugs/153/)
14	+ - Added test for bug [#163](https://sourceforge.net/p/simplehtmldom/bugs/163/)
15	+ - Added test for bug [#166](https://sourceforge.net/p/simplehtmldom/bugs/166/)
16	+ - Added test for bug [#169](https://sourceforge.net/p/simplehtmldom/bugs/169/)
17	+ - Added unit test for character sets UTF-8, CP1251 and CP1252 (#142)
18	+ - Added support for meta charset to parse_charset
19	+ - Added detection for CP1251 to parse_charset, using iconv
20	+ - Added LICENSE file (MIT) to the project root
21	+ - Added functions to `simple_html_dom_node`
22	+ - `remove`: Removes the current node recursively from the DOM tree
23	+ - `removeChild`: Removes a child node recursively from the DOM tree
24	+ - `hasClass`: Checks if the current node has the specified class name
25	+ - `addClass`: Adds one or more classes to the current node
26	+ - `removeClass`: Removes one or more classes from the current node
27	+ - `save`: Saves the current node to disk
28	+ ### Changed
29	+ - Changed manual from custom implementation to MkDocs (https://www.mkdocs.org/)
30	+ ### Fixed
31	+ - Fixed warning when trying to clear() the DOM on a null nodes list (#153)
32	+ - Fixed missing whitespace when returning plaintext (#163)
33	+ - Fixed broken detection of duplicate attributes (#166)
34	+ - Fixed broken detection of CP1252 (ISO-8859-1) documents (#142)
35	+ - Fixed error using next-sibling combinator ('E + F') on last child
36	+ - Fixed selector parsing for attribute selectors ending on "s" or "i" (#169)
37	+
38	+ ## [1.8.1] - 2019-01-13
39	+ ### Fixed
40	+ - Fixed various bugs related to parsing classes and ids
41	+
42	+ ## [1.8] - 2019-01-13
43	+ ### Added
44	+ - Added documentation for `simple_html_dom_node::find`
45	+ - Added documentation for `simple_html_dom_node::parse_selector`
46	+ - Added documentation for `simple_html_dom_node::seek`
47	+ - Added documentation for `simple_html_dom_node::match`
48	+ - Added unit tests for bug reports
49	+ - Added test for bug [#62](https://sourceforge.net/p/simplehtmldom/bugs/62/)
50	+ - Added test for bug [#79](https://sourceforge.net/p/simplehtmldom/bugs/79/)
51	+ - Added test for bug [#144](https://sourceforge.net/p/simplehtmldom/bugs/144/)
52	+ - Added unit tests for CSS selectors
53	+ - Added ability to define constants before simple_html_dom does
54	+ - 'DEFAULT_TARGET_CHARSET'
55	+ - 'DEFAULT_BR_TEXT'
56	+ - 'DEFAULT_SPAN_TEXT'
57	+ - 'MAX_FILE_SIZE'
58	+ - Added support for CSS combinators
59	+ - Added support for Child Combinator (`>`)
60	+ - Added support for Next Sibling Combinator (`+`)
61	+ - Added support for Subsequent Sibling Combinator (`~`)
62	+ - Added support for multiclass selectors (`.class.class.class`)
63	+ - Added support for multiattribute selectors (`[attr1][attr2][attribute3]`)
64	+ - Added support for attribute selectors
65	+ - Added support for pipe selectors (`\|=`)
66	+ - Added support for tilde selectors (`~=`)
67	+ - Added support for case sensitivity selectors (`i` and `s`)
68	+ - Added unit tests for PHP compatibility to PHP 5.6+
69	+ - Added coding standard using PHP_CodeSniffer
70	+ ### Changed
71	+ - Removed automatic filtering of 'tbody' selectors (#79)
72	+ > Remove 'tbody' from all selectors to maintain the previous state!
73	+ - Coding standard using PHP_CodeSniffer
74	+ ### Fixed
75	+ - Fixed broken CSS selector attributes with value "0" (#62)
76	+ - Fixed broken simple_html_dom::load_file
77	+ - Fixed forward slashes in CSS selector breaks value matching using '*=' (#144)
78	+ - Fixed Universal Selectors
79	+
80	+ ## [1.7] - 2018-12-10
81	+ ### Added
82	+ - Added code documentation to improve readability
83	+ - Added unit tests for `simple_html_dom::$self_closing_tags`
84	+ - Added unit tests for `simple_html_dom::$optional_closing_tags`
85	+ - Added unit tests for bug reports
86	+ - Added test for bug [#56](https://sourceforge.net/p/simplehtmldom/bugs/56/)
87	+ - Added test for bug [#97](https://sourceforge.net/p/simplehtmldom/bugs/97/)
88	+ - Added test for bug [#116](https://sourceforge.net/p/simplehtmldom/bugs/116/)
89	+ - Added test for bug [#121](https://sourceforge.net/p/simplehtmldom/bugs/127/)
90	+ - Added test for bug [#127](https://sourceforge.net/p/simplehtmldom/bugs/127/)
91	+ - Added test for bug [#154](https://sourceforge.net/p/simplehtmldom/bugs/154/)
92	+ - Added test for bug [#160](https://sourceforge.net/p/simplehtmldom/bugs/160/)
93	+ - Added unit tests for memory management of the parser
94	+ - Added bit flags to `simple_html_dom::load()`
95	+ - Added bit flag `HDOM_SMARTY_AS_TEXT` to optionally filter Smarty scripts (#154)\
96	+ Note: Smarty scripts are no longer filtered by default!\
97	+ - Added build script to automate releases
98	+ - Added support for attributes without whitespace to separate them
99	+ ### Changed
100	+ - Improved documentation and readability for `$self_closing_tags`
101	+ - Improved documentation and readability for `$block_tags`
102	+ - Improved documentation and readability for `$optional_closing_tags`
103	+ - Updated list of `simple_html_dom::$self_closing_tags`
104	+ - Removed 'spacer' (obsolete)
105	+ - Added 'area'
106	+ - Added 'col'
107	+ - Added 'meta'
108	+ - Added 'param'
109	+ - Added 'source'
110	+ - Added 'track'
111	+ - Added 'wbr'
112	+ - Updated list of `simple_html_dom::$optional_closing_tags`
113	+ - Removed "nobr" (obsolete)
114	+ - Added 'th' as closable element to 'td'
115	+ - Added 'td' as closable element to 'th'
116	+ - Added 'optgroup' with 'optgroup' and 'option' as closable elements
117	+ - Added 'optgroup' as closable element to 'option'
118	+ - Added 'rp' with 'rp' and 'rt' as closable elements
119	+ - Added 'rt' with 'rt' and 'rp' as closable elements
120	+ - Clarified meaning of `simple_html_dom->parent`
121	+ - Changed default `$offset` for `file_get_html()` from -1 to 0 (#161)
122	+ - Changed `simple_html_dom::load()` to remove script tags before replacing newline characters
123	+ - `simple_html_dom_node::text()` no longer adds whitespace to top level span elements (only to sub-elements)
124	+ - `simple_html_dom_node::text()` adds blank lines between paragraphs
125	+ - Normalized line endings in the repository to LF via `.gitattributes`
126	+ - Improved performance of `simple_html_dom::parse_charset()` by approximately 25%
127	+ - Improved performance of `simple_html_dom::parse()` by approximately 10%
128	+ ### Deprecated
129	+ - `str_get_html()` is deprecated and should be replaced by `new simple_html_dom()`
130	+ ### Removed
131	+ - Removed protected function `simple_html_dom::copy_until_char_escaped()`
132	+ ### Fixed
133	+ - Fixed compatibility issues with PHP 7.3
134	+ - Fixed typo (#147)
135	+ - Fixed handling of incorrectly escaped text (#160)
136	+ - Restore functionality of `$maxLen` in `file_get_html()`
137	+ - Fixed load_file breaks if an error ocurred in another script
138	+
139	+ ## [1.6] - 2014-05-28
140	+ ### Added
141	+ - Added some ability to insert and create nodes
142	+ - Add ability to search the "noise" array
143	+
144	+ ## [1.5] - 2012-09-10
145	+ ### Added
146	+ - Added flag: LOCK_EX while calling "file_put_contents()"
147	+ - Added support for detecting the source html character set. This is used to convert characters when plaintext is requested.
148	+ - Other little fixes and features, too numerous to categorize
149	+ ### Changed
150	+ - Error of "file_get_contents()" will be thrown as an exception
151	+ ### Fixed
152	+ - Fixed the typo of "token_blank_t"
153	+ - Memory leak fixed
154	+
155	+ ## [1.11] - 2008-12-14
156	+ ### Added
157	+ - Supports xpath generated from Firebug
158	+ - New method "dump" of "simple_html_dom_node"
159	+ - New attribute "xmltext" of "simple_html_dom_node"
160	+ ### Changed
161	+ - Remove preg_quote on selector match function: `[attribute*=value]`
162	+ - Element "Comment" will treat as children
163	+ ### Fixed
164	+ - Fixed the problem with `<pre>`
165	+ - Fixed bug #2207477 (does not load some pages properly)
166	+ - Fixed bug #2315853 (Error with character after < sign)
167	+
168	+ ## [1.10] - 2008-10-25
169	+ ### Changed
170	+ - Negative indexes supports of "find" method, thanks for Vadim Voituk
171	+ - Constructor with automatically load contents either text or file/url, thanks for Antcs
172	+ - Fully supports wildcard in selectors
173	+ ### Fixed
174	+ - Fixed bug of confusing by the < symbol inside the text
175	+ - Fixed bug of dash in selectors
176	+ - Fixed bug of `<nobr>`
177	+ - Fixed bug #2155883 (Nested List Parses Incorrectly)
178	+ - Fixed bug #2155113 (error with unclosed html tags)
179	+
180	+ ## [1.00] - 2008-09-05
181	+ ### Added
182	+ - New method "getAllAttributes" of "simple_html_dom_node"
183	+ - Supports full javascript string in selector: `$e->find("a[onclick=alert('hello')]")`
184	+ ### Changed
185	+ - Changed selector "*=" to case-insentive
186	+ ### Fixed
187	+ - Fixed the bug of selector in some critical conditions
188	+ - Fixed the bug of striping php tags
189	+ - Fixed the bug of remove_noise()
190	+ - Fixed the bug of noise in attributes
191	+
192	+ ## [0.99] - 2008-08-03
193	+ ### Changed
194	+ - Performance tuning (boost 10%)
195	+ - Memory requirement reduced by 25%
196	+ - Changed function name from "file_get_dom()" to "file_get_html()"
197	+ - Changed function name from "str_get_dom()" to "str_get_html()"
198	+ ### Fixed
199	+ - Fixed bug #2011286 (Error with unclosed html tags)
200	+ - Fixed bug #2012551 (Error parsing divs)
201	+ - Fixed bug #2020924 (Error for missed tag)
202	+ - Fixed bug (problem with `<body>` tag's innertext)
203	+
204	+ ## [0.98] - 2008-06-24
205	+ ### Added
206	+ - Supports "multiple class" selector feature: `<div class="a b c"></div>`
207	+ - New "callback function" feature
208	+ - New "multiple selectors" feature: $dom->find('p,a,b')
209	+ - New examples
210	+ - Supports extract contents from HTML features: $dom->plaintext
211	+ ### Changed
212	+ - Performance tuning (boost 20%)
213	+ - Changed simple_html_dom_node method name from "text()" to "makeup()"
214	+ ### Fixed
215	+ - Fixed the bug of $dom->clear()
216	+ - Fixed the bug of text nodes' innertext
217	+ - Fixed the bug of comment nodes' innertext
218	+ - Fixed the bug of decendent selector with optional tags
219	+
220	+ ## [0.97] - 2008-05-09
221	+ ### Added
222	+ - New node type "comment" (eg. $dom->find('comment'))
223	+ - Add self-closing tags: 'base', 'spacer'
224	+ - New example "simple_html_dom_utility.php"
225	+ ### Changed
226	+ - File and class name changed (html_dom_parser->simple_html_dom)
227	+ ### Removed
228	+ - ($dom->save_file) will not support anymore
229	+ - Remove example "example_customize_parser.php"
230	+ ### Fixed
231	+ - Fixed the bug of outertext (th)
232	+ - Fixed the bug of regular expression escaping chars ($dom->find)
233	+ - Fixed the bug while line-breaker and "\t" in tags
234	+
235	+ ## [0.96] - 2008-04-27
236	+ ### Added
237	+ - Reference section in manual
238	+ - Added traverse section in manual
239	+ - Added the solution while server behind proxy in FAQ (Thanks to Yousuke Shaggy)
240	+ - New method to remove attribute.
241	+ - New DOM operations(first_child, last_child, next_sibling, previous_sibling) (Request #1936000)
242	+ ### Changed
243	+ - Now file_get_dom supports full file_get_contents parameters
244	+ ### Fixed
245	+ - Fixed the bug of self-closing tags in the end of file
246	+ - Fixed the bug of blanks in the end of tag
247	+ - Fixed some typo of testcase
248	+
249	+ ## [0.95] - 2008-04-13
250	+ ### Added
251	+ - Supports tag name with namespace
252	+ ### Changed
253	+ - New attribute filters (Thanks to Yousuke Kumakura)
254	+ - Refine structure of testcase
255	+ ### Fixed
256	+ - Fix the bug of optional-closing tags
257	+ - Fix the bug of parsing the line break next to the tag's name
258	+
259	+ ## [0.94] - 2008-04-06
260	+ ### Added
261	+ - Add FAQ section in manual
262	+ ### Fixed
263	+ - Fixed infinity loop while the source content is BAD HTML
264	+ - Fixed the bug of adding new attributes to self closing tags
265	+ - Fixed the bug of customize parser without $dom->remove_noise()

assets/libraries/simplehtmldom/LICENSE ADDED Viewed

	@@ -0,0 +1,21 @@


1	+ MIT License
2	+
3	+ Copyright (c) 2019 S.C. Chen, John Schlick, logmanoriginal
4	+
5	+ Permission is hereby granted, free of charge, to any person obtaining a copy
6	+ of this software and associated documentation files (the "Software"), to deal
7	+ in the Software without restriction, including without limitation the rights
8	+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9	+ copies of the Software, and to permit persons to whom the Software is
10	+ furnished to do so, subject to the following conditions:
11	+
12	+ The above copyright notice and this permission notice shall be included in all
13	+ copies or substantial portions of the Software.
14	+
15	+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16	+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17	+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18	+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19	+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20	+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21	+ SOFTWARE.

assets/libraries/simplehtmldom/phpcompatibility.xml ADDED Viewed

	@@ -0,0 +1,11 @@


1	+ <?xml version="1.0" encoding="UTF-8"?>
2	+ <ruleset name="PHPCompatibility">
3	+ <description>Defines rules for PHPCompatibility</description>
4	+ <exclude-pattern>./app</exclude-pattern>
5	+ <exclude-pattern>./example</exclude-pattern>
6	+ <exclude-pattern>./manual</exclude-pattern>
7	+ <exclude-pattern>./testcase</exclude-pattern>
8	+ <exclude-pattern>./tests</exclude-pattern>
9	+ <config name="testVersion" value="5.6"/>
10	+ <rule ref="PHPCompatibility" />
11	+ </ruleset>

assets/libraries/simplehtmldom/phpcs.xml ADDED Viewed

	@@ -0,0 +1,48 @@


1	+ <?xml version="1.0" encoding="UTF-8"?>
2	+ <ruleset name="Ruleset">
3	+ <description>Created with the PHP Coding Standard Generator. http://edorian.github.com/php-coding-standard-generator/</description>
4	+ <exclude-pattern>./app</exclude-pattern>
5	+ <exclude-pattern>./example</exclude-pattern>
6	+ <exclude-pattern>./manual</exclude-pattern>
7	+ <exclude-pattern>./testcase</exclude-pattern>
8	+ <rule ref="Generic.WhiteSpace.DisallowSpaceIndent"/>
9	+ <rule ref="Generic.Classes.DuplicateClassName"/>
10	+ <rule ref="PSR2.Methods.MethodDeclaration" />
11	+ <rule ref="Generic.CodeAnalysis.EmptyStatement"/>
12	+ <rule ref="Generic.CodeAnalysis.UnconditionalIfStatement"/>
13	+ <rule ref="Generic.CodeAnalysis.UnnecessaryFinalModifier"/>
14	+ <rule ref="Generic.CodeAnalysis.UselessOverridingMethod"/>
15	+ <rule ref="Generic.Functions.FunctionCallArgumentSpacing"/>
16	+ <rule ref="Generic.Functions.OpeningFunctionBraceBsdAllman"/>
17	+ <rule ref="PEAR.Functions.ValidDefaultValue"/>
18	+ <rule ref="PSR2.ControlStructures.ElseIfDeclaration"/>
19	+ <rule ref="PSR2.ControlStructures.ControlStructureSpacing"/>
20	+ <rule ref="Squiz.WhiteSpace.CastSpacing"/>
21	+ <rule ref="Squiz.WhiteSpace.OperatorSpacing"/>
22	+ <rule ref="Squiz.WhiteSpace.SemicolonSpacing"/>
23	+ <rule ref="Squiz.WhiteSpace.SuperfluousWhitespace"/>
24	+ <rule ref="Squiz.Strings.ConcatenationSpacing">
25	+ <properties>
26	+ <property name="spacing" value="1"/>
27	+ <property name="ignoreNewlines" value="true"/>
28	+ </properties>
29	+ </rule>
30	+ <rule ref="Squiz.Functions.FunctionDeclarationArgumentSpacing">
31	+ <properties>
32	+ <property name="equalsSpacing" value="1"/>
33	+ </properties>
34	+ </rule>
35	+ <rule ref="Generic.Files.LineLength">
36	+ <properties>
37	+ <property name="lineLimit" value="80"/>
38	+ <property name="absoluteLineLimit" value="120"/>
39	+ </properties>
40	+ </rule>
41	+ <rule ref="Generic.NamingConventions.UpperCaseConstantName"/>
42	+ <rule ref="Generic.PHP.LowerCaseConstant"/>
43	+ <rule ref="Squiz.Strings.DoubleQuoteUsage">
44	+ <exclude name="Squiz.Strings.DoubleQuoteUsage.ContainsVar" />
45	+ </rule>
46	+ <rule ref="Generic.Strings.UnnecessaryStringConcat"/>
47	+ <rule ref="PSR2.Files.EndFileNewline"/>
48	+ </ruleset>

assets/libraries/simplehtmldom/simple_html_dom.php CHANGED Viewed

@@ -1,1749 +1,2354 @@
-            -
            <?php
-            -
            /**
-            -
             * Website: http://sourceforge.net/projects/simplehtmldom/
-            -
             * Additional projects that may be used: http://sourceforge.net/projects/debugobject/
-            -
             * Acknowledge: Jose Solorzano (https://sourceforge.net/projects/php-html/)
-            -
             * Contributions by:
-            -
             *	 Yousuke Kumakura (Attribute filters)
-            -
             *	 Vadim Voituk (Negative indexes supports of "find" method)
-            -
             *	 Antcs (Constructor with automatically load contents either text or file/url)
-            -
             *
-            -
             * all affected sections have comments starting with "PaperG"
-            -
             *
-            -
             * Paperg - Added case insensitive testing of the value of the selector.
-            -
             * Paperg - Added tag_start for the starting index of tags - NOTE: This works but not accurately.
-            -
             *  This tag_start gets counted AFTER \r\n have been crushed out, and after the remove_noice calls so it will not reflect the REAL position of the tag in the source,
-            -
             *  it will almost always be smaller by some amount.
-            -
             *  We use this to determine how far into the file the tag in question is.  This "percentage will never be accurate as the $dom->size is the "real" number of bytes the dom was created from.
-            -
             *  but for most purposes, it's a really good estimation.
-            -
             * Paperg - Added the forceTagsClosed to the dom constructor.  Forcing tags closed is great for malformed html, but it CAN lead to parsing errors.
-            -
             * Allow the user to tell us how much they trust the html.
-            -
             * Paperg add the text and plaintext to the selectors for the find syntax.  plaintext implies text in the innertext of a node.  text implies that the tag is a text node.
-            -
             * This allows for us to find tags based on the text they contain.
-            -
             * Create find_ancestor_tag to see if a tag is - at any level - inside of another specific tag.
-            -
             * Paperg: added parse_charset so that we know about the character set of the source document.
-            -
             *  NOTE:  If the user's system has a routine called get_last_retrieve_url_contents_content_type availalbe, we will assume it's returning the content-type header from the
-            -
             *  last transfer or curl_exec, and we will parse that and use it in preference to any other method of charset detection.
-            -
             *
-            -
             * Found infinite loop in the case of broken html in restore_noise.  Rewrote to protect from that.
-            -
             * PaperG (John Schlick) Added get_display_size for "IMG" tags.
-            -
             *
-            -
             * Licensed under The MIT License
-            -
             * Redistributions of files must retain the above copyright notice.
-            -
             *
-            -
             * @author S.C. Chen <me578022@gmail.com>
-            -
             * @author John Schlick
-            -
             * @author Rus Carroll
-            -
             * @version 1.5 ($Rev: 210 $)
-            -
             * @package PlaceLocalInclude
-            -
             * @subpackage simple_html_dom
-            -
             */
-            -
-            -
            /**
-            -
             * All of the Defines for the classes below.
-            -
             * @author S.C. Chen <me578022@gmail.com>
-            -
             */
-            -
-            -
-            -
            define('HDOM_TYPE_ELEMENT', 1);
-            -
            define('HDOM_TYPE_COMMENT', 2);
-            -
            define('HDOM_TYPE_TEXT',	3);
-            -
            define('HDOM_TYPE_ENDTAG',  4);
-            -
            define('HDOM_TYPE_ROOT',	5);
-            -
            define('HDOM_TYPE_UNKNOWN', 6);
-            -
            define('HDOM_QUOTE_DOUBLE', 0);
-            -
            define('HDOM_QUOTE_SINGLE', 1);
-            -
            define('HDOM_QUOTE_NO',	 3);
-            -
            define('HDOM_INFO_BEGIN',   0);
-            -
            define('HDOM_INFO_END',	 1);
-            -
            define('HDOM_INFO_QUOTE',   2);
-            -
            define('HDOM_INFO_SPACE',   3);
-            -
            define('HDOM_INFO_TEXT',	4);
-            -
            define('HDOM_INFO_INNER',   5);
-            -
            define('HDOM_INFO_OUTER',   6);
-            -
            define('HDOM_INFO_ENDSPACE',7);
-            -
            define('DEFAULT_TARGET_CHARSET', 'UTF-8');
-            -
            define('DEFAULT_BR_TEXT', "\r\n");
-            -
            define('DEFAULT_SPAN_TEXT', " ");
-            -
            define('MAX_FILE_SIZE', 600000);
-            -
-            -
-            -
            // helper functions
-            -
            // -----------------------------------------------------------------------------
-            -
            // get html dom from file
-            -
            // $maxlen is defined in the code as PHP_STREAM_COPY_ALL which is defined as -1.
-            -
            function file_get_html($url, $use_include_path = false, $context=null, $offset = -1, $maxLen=-1, $lowercase = true, $forceTagsClosed=true, $target_charset = DEFAULT_TARGET_CHARSET, $stripRN=true, $defaultBRText=DEFAULT_BR_TEXT, $defaultSpanText=DEFAULT_SPAN_TEXT)
-            -
            {
-            -
            	// We DO force the tags to be terminated.
-            -
            	$dom = new simple_html_dom(null, $lowercase, $forceTagsClosed, $target_charset, $stripRN, $defaultBRText, $defaultSpanText);
-            -
            	// For sourceforge users: uncomment the next line and comment the retreive_url_contents line 2 lines down if it is not already done.
-            -
            	$contents = file_get_contents($url, $use_include_path, $context, $offset);
-            -
            	// Paperg - use our own mechanism for getting the contents as we want to control the timeout.
-            -
            	//$contents = retrieve_url_contents($url);
-            -
            	if (empty($contents) || strlen($contents) > MAX_FILE_SIZE)
-            -
            	{
-            -
            		return false;
-            -
            	}
-            -
            	// The second parameter can force the selectors to all be lowercase.
-            -
            	$dom->load($contents, $lowercase, $stripRN);
-            -
            	return $dom;
-            -
            }
-            -
-            -
            // get html dom from string
-            -
            function str_get_html($str, $lowercase=true, $forceTagsClosed=true, $target_charset = DEFAULT_TARGET_CHARSET, $stripRN=true, $defaultBRText=DEFAULT_BR_TEXT, $defaultSpanText=DEFAULT_SPAN_TEXT)
-            -
            {
-            -
            	$dom = new simple_html_dom(null, $lowercase, $forceTagsClosed, $target_charset, $stripRN, $defaultBRText, $defaultSpanText);
-            -
            	if (empty($str) || strlen($str) > MAX_FILE_SIZE)
-            -
            	{
-            -
            		$dom->clear();
-            -
            		return false;
-            -
            	}
-            -
            	$dom->load($str, $lowercase, $stripRN);
-            -
            	return $dom;
-            -
            }
-            -
-            -
            // dump html dom tree
-            -
            function dump_html_tree($node, $show_attr=true, $deep=0)
-            -
            {
-            -
            	$node->dump($node);
-            -
            }
-            -
-            -
-            -
            /**
-            -
             * simple html dom node
-            -
             * PaperG - added ability for "find" routine to lowercase the value of the selector.
-            -
             * PaperG - added $tag_start to track the start position of the tag in the total byte index
-            -
             *
-            -
             * @package PlaceLocalInclude
-            -
             */
-            -
            class simple_html_dom_node
-            -
            {
-            -
            	public $nodetype = HDOM_TYPE_TEXT;
-            -
            	public $tag = 'text';
-            -
            	public $attr = array();
-            -
            	public $children = array();
-            -
            	public $nodes = array();
-            -
            	public $parent = null;
-            -
            	// The "info" array - see HDOM_INFO_... for what each element contains.
-            -
            	public $_ = array();
-            -
            	public $tag_start = 0;
-            -
            	private $dom = null;
-            -
-            -
            	function __construct($dom)
-            -
            	{
-            -
            		$this->dom = $dom;
-            -
            		$dom->nodes[] = $this;
-            -
            	}
-            -
-            -
            	function __destruct()
-            -
            	{
-            -
            		$this->clear();
-            -
            	}
-            -
-            -
            	function __toString()
-            -
            	{
-            -
            		return $this->outertext();
-            -
            	}
-            -
-            -
            	// clean up memory due to php5 circular references memory leak...
-            -
            	function clear()
-            -
            	{
-            -
            		$this->dom = null;
-            -
            		$this->nodes = null;
-            -
            		$this->parent = null;
-            -
            		$this->children = null;
-            -
            	}
-            -
-            -
            	// dump node's tree
-            -
            	function dump($show_attr=true, $deep=0)
-            -
            	{
-            -
            		$lead = str_repeat('	', $deep);
-            -
-            -
            		echo $lead.$this->tag;
-            -
            		if ($show_attr && count($this->attr)>0)
-            -
            		{
-            -
            			echo '(';
-            -
            			foreach ($this->attr as $k=>$v)
-            -
            				echo "[$k]=>\"".$this->$k.'", ';
-            -
            			echo ')';
-            -
            		}
-            -
            		echo "\n";
-            -
-            -
            		if ($this->nodes)
-            -
            		{
-            -
            			foreach ($this->nodes as $c)
-            -
            			{
-            -
            				$c->dump($show_attr, $deep+1);
-            -
            			}
-            -
            		}
-            -
            	}
-            -
-            -
-            -
            	// Debugging function to dump a single dom node with a bunch of information about it.
-            -
            	function dump_node($echo=true)
-            -
            	{
-            -
-            -
            		$string = $this->tag;
-            -
            		if (count($this->attr)>0)
-            -
            		{
-            -
            			$string .= '(';
-            -
            			foreach ($this->attr as $k=>$v)
-            -
            			{
-            -
            				$string .= "[$k]=>\"".$this->$k.'", ';
-            -
            			}
-            -
            			$string .= ')';
-            -
            		}
-            -
            		if (count($this->_)>0)
-            -
            		{
-            -
            			$string .= ' $_ (';
-            -
            			foreach ($this->_ as $k=>$v)
-            -
            			{
-            -
            				if (is_array($v))
-            -
            				{
-            -
            					$string .= "[$k]=>(";
-            -
            					foreach ($v as $k2=>$v2)
-            -
            					{
-            -
            						$string .= "[$k2]=>\"".$v2.'", ';
-            -
            					}
-            -
            					$string .= ")";
-            -
            				} else {
-            -
            					$string .= "[$k]=>\"".$v.'", ';
-            -
            				}
-            -
            			}
-            -
            			$string .= ")";
-            -
            		}
-            -
-            -
            		if (isset($this->text))
-            -
            		{
-            -
            			$string .= " text: (" . $this->text . ")";
-            -
            		}
-            -
-            -
            		$string .= " HDOM_INNER_INFO: '";
-            -
            		if (isset($node->_[HDOM_INFO_INNER]))
-            -
            		{
-            -
            			$string .= $node->_[HDOM_INFO_INNER] . "'";
-            -
            		}
-            -
            		else
-            -
            		{
-            -
            			$string .= ' NULL ';
-            -
            		}
-            -
-            -
            		$string .= " children: " . count($this->children);
-            -
            		$string .= " nodes: " . count($this->nodes);
-            -
            		$string .= " tag_start: " . $this->tag_start;
-            -
            		$string .= "\n";
-            -
-            -
            		if ($echo)
-            -
            		{
-            -
            			echo $string;
-            -
            			return;
-            -
            		}
-            -
            		else
-            -
            		{
-            -
            			return $string;
-            -
            		}
-            -
            	}
-            -
-            -
            	// returns the parent of node
-            -
            	// If a node is passed in, it will reset the parent of the current node to that one.
-            -
            	function parent($parent=null)
-            -
            	{
-            -
            		// I am SURE that this doesn't work properly.
-            -
            		// It fails to unset the current node from it's current parents nodes or children list first.
-            -
            		if ($parent !== null)
-            -
            		{
-            -
            			$this->parent = $parent;
-            -
            			$this->parent->nodes[] = $this;
-            -
            			$this->parent->children[] = $this;
-            -
            		}
-            -
-            -
            		return $this->parent;
-            -
            	}
-            -
-            -
            	// verify that node has children
-            -
            	function has_child()
-            -
            	{
-            -
            		return !empty($this->children);
-            -
            	}
-            -
-            -
            	// returns children of node
-            -
            	function children($idx=-1)
-            -
            	{
-            -
            		if ($idx===-1)
-            -
            		{
-            -
            			return $this->children;
-            -
            		}
-            -
            		if (isset($this->children[$idx]))
-            -
            		{
-            -
            			return $this->children[$idx];
-            -
            		}
-            -
            		return null;
-            -
            	}
-            -
-            -
            	// returns the first child of node
-            -
            	function first_child()
-            -
            	{
-            -
            		if (count($this->children)>0)
-            -
            		{
-            -
            			return $this->children[0];
-            -
            		}
-            -
            		return null;
-            -
            	}
-            -
-            -
            	// returns the last child of node
-            -
            	function last_child()
-            -
            	{
-            -
            		if (($count=count($this->children))>0)
-            -
            		{
-            -
            			return $this->children[$count-1];
-            -
            		}
-            -
            		return null;
-            -
            	}
-            -
-            -
            	// returns the next sibling of node
-            -
            	function next_sibling()
-            -
            	{
-            -
            		if ($this->parent===null)
-            -
            		{
-            -
            			return null;
-            -
            		}
-            -
-            -
            		$idx = 0;
-            -
            		$count = count($this->parent->children);
-            -
            		while ($idx<$count && $this!==$this->parent->children[$idx])
-            -
            		{
-            -
            			++$idx;
-            -
            		}
-            -
            		if (++$idx>=$count)
-            -
            		{
-            -
            			return null;
-            -
            		}
-            -
            		return $this->parent->children[$idx];
-            -
            	}
-            -
-            -
            	// returns the previous sibling of node
-            -
            	function prev_sibling()
-            -
            	{
-            -
            		if ($this->parent===null) return null;
-            -
            		$idx = 0;
-            -
            		$count = count($this->parent->children);
-            -
            		while ($idx<$count && $this!==$this->parent->children[$idx])
-            -
            			++$idx;
-            -
            		if (--$idx<0) return null;
-            -
            		return $this->parent->children[$idx];
-            -
            	}
-            -
-            -
            	// function to locate a specific ancestor tag in the path to the root.
-            -
            	function find_ancestor_tag($tag)
-            -
            	{
-            -
            		global $debug_object;
-            -
            		if (is_object($debug_object)) { $debug_object->debug_log_entry(1); }
-            -
-            -
            		// Start by including ourselves in the comparison.
-            -
            		$returnDom = $this;
-            -
-            -
            		while (!is_null($returnDom))
-            -
            		{
-            -
            			if (is_object($debug_object)) { $debug_object->debug_log(2, "Current tag is: " . $returnDom->tag); }
-            -
-            -
            			if ($returnDom->tag == $tag)
-            -
            			{
-            -
            				break;
-            -
            			}
-            -
            			$returnDom = $returnDom->parent;
-            -
            		}
-            -
            		return $returnDom;
-            -
            	}
-            -
-            -
            	// get dom node's inner html
-            -
            	function innertext()
-            -
            	{
-            -
            		if (isset($this->_[HDOM_INFO_INNER])) return $this->_[HDOM_INFO_INNER];
-            -
            		if (isset($this->_[HDOM_INFO_TEXT])) return $this->dom->restore_noise($this->_[HDOM_INFO_TEXT]);
-            -
-            -
            		$ret = '';
-            -
            		foreach ($this->nodes as $n)
-            -
            			$ret .= $n->outertext();
-            -
            		return $ret;
-            -
            	}
-            -
-            -
            	// get dom node's outer text (with tag)
-            -
            	function outertext()
-            -
            	{
-            -
            		global $debug_object;
-            -
            		if (is_object($debug_object))
-            -
            		{
-            -
            			$text = '';
-            -
            			if ($this->tag == 'text')
-            -
            			{
-            -
            				if (!empty($this->text))
-            -
            				{
-            -
            					$text = " with text: " . $this->text;
-            -
            				}
-            -
            			}
-            -
            			$debug_object->debug_log(1, 'Innertext of tag: ' . $this->tag . $text);
-            -
            		}
-            -
-            -
            		if ($this->tag==='root') return $this->innertext();
-            -
-            -
            		// trigger callback
-            -
            		if ($this->dom && $this->dom->callback!==null)
-            -
            		{
-            -
            			call_user_func_array($this->dom->callback, array($this));
-            -
            		}
-            -
-            -
            		if (isset($this->_[HDOM_INFO_OUTER])) return $this->_[HDOM_INFO_OUTER];
-            -
            		if (isset($this->_[HDOM_INFO_TEXT])) return $this->dom->restore_noise($this->_[HDOM_INFO_TEXT]);
-            -
-            -
            		// render begin tag
-            -
            		if ($this->dom && $this->dom->nodes[$this->_[HDOM_INFO_BEGIN]])
-            -
            		{
-            -
            			$ret = $this->dom->nodes[$this->_[HDOM_INFO_BEGIN]]->makeup();
-            -
            		} else {
-            -
            			$ret = "";
-            -
            		}
-            -
-            -
            		// render inner text
-            -
            		if (isset($this->_[HDOM_INFO_INNER]))
-            -
            		{
-            -
            			// If it's a br tag...  don't return the HDOM_INNER_INFO that we may or may not have added.
-            -
            			if ($this->tag != "br")
-            -
            			{
-            -
            				$ret .= $this->_[HDOM_INFO_INNER];
-            -
            			}
-            -
            		} else {
-            -
            			if ($this->nodes)
-            -
            			{
-            -
            				foreach ($this->nodes as $n)
-            -
            				{
-            -
            					$ret .= $this->convert_text($n->outertext());
-            -
            				}
-            -
            			}
-            -
            		}
-            -
-            -
            		// render end tag
-            -
            		if (isset($this->_[HDOM_INFO_END]) && $this->_[HDOM_INFO_END]!=0)
-            -
            			$ret .= '</'.$this->tag.'>';
-            -
            		return $ret;
-            -
            	}
-            -
-            -
            	// get dom node's plain text
-            -
            	function text()
-            -
            	{
-            -
            		if (isset($this->_[HDOM_INFO_INNER])) return $this->_[HDOM_INFO_INNER];
-            -
            		switch ($this->nodetype)
-            -
            		{
-            -
            			case HDOM_TYPE_TEXT: return $this->dom->restore_noise($this->_[HDOM_INFO_TEXT]);
-            -
            			case HDOM_TYPE_COMMENT: return '';
-            -
            			case HDOM_TYPE_UNKNOWN: return '';
-            -
            		}
-            -
            		if (strcasecmp($this->tag, 'script')===0) return '';
-            -
            		if (strcasecmp($this->tag, 'style')===0) return '';
-            -
-            -
            		$ret = '';
-            -
            		// In rare cases, (always node type 1 or HDOM_TYPE_ELEMENT - observed for some span tags, and some p tags) $this->nodes is set to NULL.
-            -
            		// NOTE: This indicates that there is a problem where it's set to NULL without a clear happening.
-            -
            		// WHY is this happening?
-            -
            		if (!is_null($this->nodes))
-            -
            		{
-            -
            			foreach ($this->nodes as $n)
-            -
            			{
-            -
            				$ret .= $this->convert_text($n->text());
-            -
            			}
-            -
-            -
            			// If this node is a span... add a space at the end of it so multiple spans don't run into each other.  This is plaintext after all.
-            -
            			if ($this->tag == "span")
-            -
            			{
-            -
            				$ret .= $this->dom->default_span_text;
-            -
            			}
-            -
-            -
-            -
            		}
-            -
            		return $ret;
-            -
            	}
-            -
-            -
            	function xmltext()
-            -
            	{
-            -
            		$ret = $this->innertext();
-            -
            		$ret = str_ireplace('<![CDATA[', '', $ret);
-            -
            		$ret = str_replace(']]>', '', $ret);
-            -
            		return $ret;
-            -
            	}
-            -
-            -
            	// build node's text with tag
-            -
            	function makeup()
-            -
            	{
-            -
            		// text, comment, unknown
-            -
            		if (isset($this->_[HDOM_INFO_TEXT])) return $this->dom->restore_noise($this->_[HDOM_INFO_TEXT]);
-            -
-            -
            		$ret = '<'.$this->tag;
-            -
            		$i = -1;
-            -
-            -
            		foreach ($this->attr as $key=>$val)
-            -
            		{
-            -
            			++$i;
-            -
-            -
            			// skip removed attribute
-            -
            			if ($val===null || $val===false)
-            -
            				continue;
-            -
-            -
            			$ret .= $this->_[HDOM_INFO_SPACE][$i][0];
-            -
            			//no value attr: nowrap, checked selected...
-            -
            			if ($val===true)
-            -
            				$ret .= $key;
-            -
            			else {
-            -
            				switch ($this->_[HDOM_INFO_QUOTE][$i])
-            -
            				{
-            -
            					case HDOM_QUOTE_DOUBLE: $quote = '"'; break;
-            -
            					case HDOM_QUOTE_SINGLE: $quote = '\''; break;
-            -
            					default: $quote = '';
-            -
            				}
-            -
            				$ret .= $key.$this->_[HDOM_INFO_SPACE][$i][1].'='.$this->_[HDOM_INFO_SPACE][$i][2].$quote.$val.$quote;
-            -
            			}
-            -
            		}
-            -
            		$ret = $this->dom->restore_noise($ret);
-            -
            		return $ret . $this->_[HDOM_INFO_ENDSPACE] . '>';
-            -
            	}
-            -
-            -
            	// find elements by css selector
-            -
            	//PaperG - added ability for find to lowercase the value of the selector.
-            -
            	function find($selector, $idx=null, $lowercase=false)
-            -
            	{
-            -
            		$selectors = $this->parse_selector($selector);
-            -
            		if (($count=count($selectors))===0) return array();
-            -
            		$found_keys = array();
-            -
-            -
            		// find each selector
-            -
            		for ($c=0; $c<$count; ++$c)
-            -
            		{
-            -
            			// The change on the below line was documented on the sourceforge code tracker id 2788009
-            -
            			// used to be: if (($levle=count($selectors[0]))===0) return array();
-            -
            			if (($levle=count($selectors[$c]))===0) return array();
-            -
            			if (!isset($this->_[HDOM_INFO_BEGIN])) return array();
-            -
-            -
            			$head = array($this->_[HDOM_INFO_BEGIN]=>1);
-            -
-            -
            			// handle descendant selectors, no recursive!
-            -
            			for ($l=0; $l<$levle; ++$l)
-            -
            			{
-            -
            				$ret = array();
-            -
            				foreach ($head as $k=>$v)
-            -
            				{
-            -
            					$n = ($k===-1) ? $this->dom->root : $this->dom->nodes[$k];
-            -
            					//PaperG - Pass this optional parameter on to the seek function.
-            -
            					$n->seek($selectors[$c][$l], $ret, $lowercase);
-            -
            				}
-            -
            				$head = $ret;
-            -
            			}
-            -
-            -
            			foreach ($head as $k=>$v)
-            -
            			{
-            -
            				if (!isset($found_keys[$k]))
-            -
            				{
-            -
            					$found_keys[$k] = 1;
-            -
            				}
-            -
            			}
-            -
            		}
-            -
-            -
            		// sort keys
-            -
            		ksort($found_keys);
-            -
-            -
            		$found = array();
-            -
            		foreach ($found_keys as $k=>$v)
-            -
            			$found[] = $this->dom->nodes[$k];
-            -
-            -
            		// return nth-element or array
-            -
            		if (is_null($idx)) return $found;
-            -
            		else if ($idx<0) $idx = count($found) + $idx;
-            -
            		return (isset($found[$idx])) ? $found[$idx] : null;
-            -
            	}
-            -
-            -
            	// seek for given conditions
-            -
            	// PaperG - added parameter to allow for case insensitive testing of the value of a selector.
-            -
            	protected function seek($selector, &$ret, $lowercase=false)
-            -
            	{
-            -
            		global $debug_object;
-            -
            		if (is_object($debug_object)) { $debug_object->debug_log_entry(1); }
-            -
-            -
            		list($tag, $key, $val, $exp, $no_key) = $selector;
-            -
-            -
            		// xpath index
-            -
            		if ($tag && $key && is_numeric($key))
-            -
            		{
-            -
            			$count = 0;
-            -
            			foreach ($this->children as $c)
-            -
            			{
-            -
            				if ($tag==='*' || $tag===$c->tag) {
-            -
            					if (++$count==$key) {
-            -
            						$ret[$c->_[HDOM_INFO_BEGIN]] = 1;
-            -
            						return;
-            -
            					}
-            -
            				}
-            -
            			}
-            -
            			return;
-            -
            		}
-            -
-            -
            		$end = (!empty($this->_[HDOM_INFO_END])) ? $this->_[HDOM_INFO_END] : 0;
-            -
            		if ($end==0) {
-            -
            			$parent = $this->parent;
-            -
            			while (!isset($parent->_[HDOM_INFO_END]) && $parent!==null) {
-            -
            				$end -= 1;
-            -
            				$parent = $parent->parent;
-            -
            			}
-            -
            			$end += $parent->_[HDOM_INFO_END];
-            -
            		}
-            -
-            -
            		for ($i=$this->_[HDOM_INFO_BEGIN]+1; $i<$end; ++$i) {
-            -
            			$node = $this->dom->nodes[$i];
-            -
-            -
            			$pass = true;
-            -
-            -
            			if ($tag==='*' && !$key) {
-            -
            				if (in_array($node, $this->children, true))
-            -
            					$ret[$i] = 1;
-            -
            				continue;
-            -
            			}
-            -
-            -
            			// compare tag
-            -
            			if ($tag && $tag!=$node->tag && $tag!=='*') {$pass=false;}
-            -
            			// compare key
-            -
            			if ($pass && $key) {
-            -
            				if ($no_key) {
-            -
            					if (isset($node->attr[$key])) $pass=false;
-            -
            				} else {
-            -
            					if (($key != "plaintext") && !isset($node->attr[$key])) $pass=false;
-            -
            				}
-            -
            			}
-            -
            			// compare value
-            -
            			if ($pass && $key && $val  && $val!=='*') {
-            -
            				// If they have told us that this is a "plaintext" search then we want the plaintext of the node - right?
-            -
            				if ($key == "plaintext") {
-            -
            					// $node->plaintext actually returns $node->text();
-            -
            					$nodeKeyValue = $node->text();
-            -
            				} else {
-            -
            					// this is a normal search, we want the value of that attribute of the tag.
-            -
            					$nodeKeyValue = $node->attr[$key];
-            -
            				}
-            -
            				if (is_object($debug_object)) {$debug_object->debug_log(2, "testing node: " . $node->tag . " for attribute: " . $key . $exp . $val . " where nodes value is: " . $nodeKeyValue);}
-            -
-            -
            				//PaperG - If lowercase is set, do a case insensitive test of the value of the selector.
-            -
            				if ($lowercase) {
-            -
            					$check = $this->match($exp, strtolower($val), strtolower($nodeKeyValue));
-            -
            				} else {
-            -
            					$check = $this->match($exp, $val, $nodeKeyValue);
-            -
            				}
-            -
            				if (is_object($debug_object)) {$debug_object->debug_log(2, "after match: " . ($check ? "true" : "false"));}
-            -
-            -
            				// handle multiple class
-            -
            				if (!$check && strcasecmp($key, 'class')===0) {
-            -
            					foreach (explode(' ',$node->attr[$key]) as $k) {
-            -
            						// Without this, there were cases where leading, trailing, or double spaces lead to our comparing blanks - bad form.
-            -
            						if (!empty($k)) {
-            -
            							if ($lowercase) {
-            -
            								$check = $this->match($exp, strtolower($val), strtolower($k));
-            -
            							} else {
-            -
            								$check = $this->match($exp, $val, $k);
-            -
            							}
-            -
            							if ($check) break;
-            -
            						}
-            -
            					}
-            -
            				}
-            -
            				if (!$check) $pass = false;
-            -
            			}
-            -
            			if ($pass) $ret[$i] = 1;
-            -
            			unset($node);
-            -
            		}
-            -
            		// It's passed by reference so this is actually what this function returns.
-            -
            		if (is_object($debug_object)) {$debug_object->debug_log(1, "EXIT - ret: ", $ret);}
-            -
            	}
-            -
-            -
            	protected function match($exp, $pattern, $value) {
-            -
            		global $debug_object;
-            -
            		if (is_object($debug_object)) {$debug_object->debug_log_entry(1);}
-            -
-            -
            		switch ($exp) {
-            -
            			case '=':
-            -
            				return ($value===$pattern);
-            -
            			case '!=':
-            -
            				return ($value!==$pattern);
-            -
            			case '^=':
-            -
            				return preg_match("/^".preg_quote($pattern,'/')."/", $value);
-            -
            			case '$=':
-            -
            				return preg_match("/".preg_quote($pattern,'/')."$/", $value);
-            -
            			case '*=':
-            -
            				if ($pattern[0]=='/') {
-            -
            					return preg_match($pattern, $value);
-            -
            				}
-            -
            				return preg_match("/".$pattern."/i", $value);
-            -
            		}
-            -
            		return false;
-            -
            	}
-            -
-            -
            	protected function parse_selector($selector_string) {
-            -
            		global $debug_object;
-            -
            		if (is_object($debug_object)) {$debug_object->debug_log_entry(1);}
-            -
-            -
            		// pattern of CSS selectors, modified from mootools
-            -
            		// Paperg: Add the colon to the attrbute, so that it properly finds <tag attr:ibute="something" > like google does.
-            -
            		// Note: if you try to look at this attribute, yo MUST use getAttribute since $dom->x:y will fail the php syntax check.
-            -
            // Notice the \[ starting the attbute?  and the @? following?  This implies that an attribute can begin with an @ sign that is not captured.
-            -
            // This implies that an html attribute specifier may start with an @ sign that is NOT captured by the expression.
-            -
            // farther study is required to determine of this should be documented or removed.
-            -
            //		$pattern = "/([\w-:\*]*)(?:\#([\w-]+)|\.([\w-]+))?(?:\[@?(!?[\w-]+)(?:([!*^$]?=)[\"']?(.*?)[\"']?)?\])?([\/, ]+)/is";
-            -
-            -
                // original $pattern = "/([\w-:\*]*)(?:\#([\w-]+)|\.([\w-]+))?(?:\[@?(!?[\w-:]+)(?:([!*^$]?=)[\"']?(.*?)[\"']?)?\])?([\/, ]+)/is";
-            -
            		$pattern = "/([\w\-:\*]*)(?:\#([\w-]+)|\.([\w-]+))?(?:\[@?(!?[\w\-:]+)(?:([!*^$]?=)[\"']?(.*?)[\"']?)?\])?([\/, ]+)/is";
-            -
            		preg_match_all($pattern, trim($selector_string).' ', $matches, PREG_SET_ORDER);
-            -
            		if (is_object($debug_object)) {$debug_object->debug_log(2, "Matches Array: ", $matches);}
-            -
-            -
            		$selectors = array();
-            -
            		$result = array();
-            -
-            -
-            -
            		foreach ($matches as $m) {
-            -
            			$m[0] = trim($m[0]);
-            -
            			if ($m[0]==='' || $m[0]==='/' || $m[0]==='//') continue;
-            -
            			// for browser generated xpath
-            -
            			if ($m[1]==='tbody') continue;
-            -
-            -
            			list($tag, $key, $val, $exp, $no_key) = array($m[1], null, null, '=', false);
-            -
            			if (!empty($m[2])) {$key='id'; $val=$m[2];}
-            -
            			if (!empty($m[3])) {$key='class'; $val=$m[3];}
-            -
            			if (!empty($m[4])) {$key=$m[4];}
-            -
            			if (!empty($m[5])) {$exp=$m[5];}
-            -
            			if (!empty($m[6])) {$val=$m[6];}
-            -
-            -
            			// convert to lowercase
-            -
            			if ($this->dom->lowercase) {$tag=strtolower($tag); $key=strtolower($key);}
-            -
            			//elements that do NOT have the specified attribute
-            -
            			if (isset($key[0]) && $key[0]==='!') {$key=substr($key, 1); $no_key=true;}
-            -
-            -
            			$result[] = array($tag, $key, $val, $exp, $no_key);
-            -
            			if (trim($m[7])===',') {
-            -
            				$selectors[] = $result;
-            -
            				$result = array();
-            -
            			}
-            -
            		}
-            -
            		if (count($result)>0)
-            -
            			$selectors[] = $result;
-            -
            		return $selectors;
-            -
            	}
-            -
-            -
            	function __get($name)
-            -
            	{
-            -
            		if (isset($this->attr[$name]))
-            -
            		{
-            -
            			return $this->convert_text($this->attr[$name]);
-            -
            		}
-            -
            		switch ($name)
-            -
            		{
-            -
            			case 'outertext': return $this->outertext();
-            -
            			case 'innertext': return $this->innertext();
-            -
            			case 'plaintext': return $this->text();
-            -
            			case 'xmltext': return $this->xmltext();
-            -
            			default: return array_key_exists($name, $this->attr);
-            -
            		}
-            -
            	}
-            -
-            -
            	function __set($name, $value)
-            -
            	{
-            -
            		global $debug_object;
-            -
            		if (is_object($debug_object)) {$debug_object->debug_log_entry(1);}
-            -
-            -
            		switch ($name)
-            -
            		{
-            -
            			case 'outertext': return $this->_[HDOM_INFO_OUTER] = $value;
-            -
            			case 'innertext':
-            -
            				if (isset($this->_[HDOM_INFO_TEXT])) return $this->_[HDOM_INFO_TEXT] = $value;
-            -
            				return $this->_[HDOM_INFO_INNER] = $value;
-            -
            		}
-            -
            		if (!isset($this->attr[$name]))
-            -
            		{
-            -
            			$this->_[HDOM_INFO_SPACE][] = array(' ', '', '');
-            -
            			$this->_[HDOM_INFO_QUOTE][] = HDOM_QUOTE_DOUBLE;
-            -
            		}
-            -
            		$this->attr[$name] = $value;
-            -
            	}
-            -
-            -
            	function __isset($name)
-            -
            	{
-            -
            		switch ($name)
-            -
            		{
-            -
            			case 'outertext': return true;
-            -
            			case 'innertext': return true;
-            -
            			case 'plaintext': return true;
-            -
            		}
-            -
            		//no value attr: nowrap, checked selected...
-            -
            		return (array_key_exists($name, $this->attr)) ? true : isset($this->attr[$name]);
-            -
            	}
-            -
-            -
            	function __unset($name) {
-            -
            		if (isset($this->attr[$name]))
-            -
            			unset($this->attr[$name]);
-            -
            	}
-            -
-            -
            	// PaperG - Function to convert the text from one character set to another if the two sets are not the same.
-            -
            	function convert_text($text)
-            -
            	{
-            -
            		global $debug_object;
-            -
            		if (is_object($debug_object)) {$debug_object->debug_log_entry(1);}
-            -
-            -
            		$converted_text = $text;
-            -
-            -
            		$sourceCharset = "";
-            -
            		$targetCharset = "";
-            -
-            -
            		if ($this->dom)
-            -
            		{
-            -
            			$sourceCharset = strtoupper($this->dom->_charset);
-            -
            			$targetCharset = strtoupper($this->dom->_target_charset);
-            -
            		}
-            -
            		if (is_object($debug_object)) {$debug_object->debug_log(3, "source charset: " . $sourceCharset . " target charaset: " . $targetCharset);}
-            -
-            -
            		if (!empty($sourceCharset) && !empty($targetCharset) && (strcasecmp($sourceCharset, $targetCharset) != 0))
-            -
            		{
-            -
            			// Check if the reported encoding could have been incorrect and the text is actually already UTF-8
-            -
            			if ((strcasecmp($targetCharset, 'UTF-8') == 0) && ($this->is_utf8($text)))
-            -
            			{
-            -
            				$converted_text = $text;
-            -
            			}
-            -
            			else
-            -
            			{
-            -
            				$converted_text = iconv($sourceCharset, $targetCharset, $text);
-            -
            			}
-            -
            		}
-            -
-            -
            		// Lets make sure that we don't have that silly BOM issue with any of the utf-8 text we output.
-            -
            		if ($targetCharset == 'UTF-8')
-            -
            		{
-            -
            			if (substr($converted_text, 0, 3) == "\xef\xbb\xbf")
-            -
            			{
-            -
            				$converted_text = substr($converted_text, 3);
-            -
            			}
-            -
            			if (substr($converted_text, -3) == "\xef\xbb\xbf")
-            -
            			{
-            -
            				$converted_text = substr($converted_text, 0, -3);
-            -
            			}
-            -
            		}
-            -
-            -
            		return $converted_text;
-            -
            	}
-            -
-            -
            	/**
-            -
            	* Returns true if $string is valid UTF-8 and false otherwise.
-            -
            	*
-            -
            	* @param mixed $str String to be tested
-            -
            	* @return boolean
-            -
            	*/
-            -
            	static function is_utf8($str)
-            -
            	{
-            -
            		$c=0; $b=0;
-            -
            		$bits=0;
-            -
            		$len=strlen($str);
-            -
            		for($i=0; $i<$len; $i++)
-            -
            		{
-            -
            			$c=ord($str[$i]);
-            -
            			if($c > 128)
-            -
            			{
-            -
            				if(($c >= 254)) return false;
-            -
            				elseif($c >= 252) $bits=6;
-            -
            				elseif($c >= 248) $bits=5;
-            -
            				elseif($c >= 240) $bits=4;
-            -
            				elseif($c >= 224) $bits=3;
-            -
            				elseif($c >= 192) $bits=2;
-            -
            				else return false;
-            -
            				if(($i+$bits) > $len) return false;
-            -
            				while($bits > 1)
-            -
            				{
-            -
            					$i++;
-            -
            					$b=ord($str[$i]);
-            -
            					if($b < 128 || $b > 191) return false;
-            -
            					$bits--;
-            -
            				}
-            -
            			}
-            -
            		}
-            -
            		return true;
-            -
            	}
-            -
            	/*
-            -
            	function is_utf8($string)
-            -
            	{
-            -
            		//this is buggy
-            -
            		return (utf8_encode(utf8_decode($string)) == $string);
-            -
            	}
-            -
            	*/
-            -
-            -
            	/**
-            -
            	 * Function to try a few tricks to determine the displayed size of an img on the page.
-            -
            	 * NOTE: This will ONLY work on an IMG tag. Returns FALSE on all other tag types.
-            -
            	 *
-            -
            	 * @author John Schlick
-            -
            	 * @version April 19 2012
-            -
            	 * @return array an array containing the 'height' and 'width' of the image on the page or -1 if we can't figure it out.
-            -
            	 */
-            -
            	function get_display_size()
-            -
            	{
-            -
            		global $debug_object;
-            -
-            -
            		$width = -1;
-            -
            		$height = -1;
-            -
-            -
            		if ($this->tag !== 'img')
-            -
            		{
-            -
            			return false;
-            -
            		}
-            -
-            -
            		// See if there is aheight or width attribute in the tag itself.
-            -
            		if (isset($this->attr['width']))
-            -
            		{
-            -
            			$width = $this->attr['width'];
-            -
            		}
-            -
-            -
            		if (isset($this->attr['height']))
-            -
            		{
-            -
            			$height = $this->attr['height'];
-            -
            		}
-            -
-            -
            		// Now look for an inline style.
-            -
            		if (isset($this->attr['style']))
-            -
            		{
-            -
            			// Thanks to user gnarf from stackoverflow for this regular expression.
-            -
            			$attributes = array();
-            -
            			preg_match_all("/([\w-]+)\s*:\s*([^;]+)\s*;?/", $this->attr['style'], $matches, PREG_SET_ORDER);
-            -
            			foreach ($matches as $match) {
-            -
            			  $attributes[$match[1]] = $match[2];
-            -
            			}
-            -
-            -
            			// If there is a width in the style attributes:
-            -
            			if (isset($attributes['width']) && $width == -1)
-            -
            			{
-            -
            				// check that the last two characters are px (pixels)
-            -
            				if (strtolower(substr($attributes['width'], -2)) == 'px')
-            -
            				{
-            -
            					$proposed_width = substr($attributes['width'], 0, -2);
-            -
            					// Now make sure that it's an integer and not something stupid.
-            -
            					if (filter_var($proposed_width, FILTER_VALIDATE_INT))
-            -
            					{
-            -
            						$width = $proposed_width;
-            -
            					}
-            -
            				}
-            -
            			}
-            -
-            -
            			// If there is a width in the style attributes:
-            -
            			if (isset($attributes['height']) && $height == -1)
-            -
            			{
-            -
            				// check that the last two characters are px (pixels)
-            -
            				if (strtolower(substr($attributes['height'], -2)) == 'px')
-            -
            				{
-            -
            					$proposed_height = substr($attributes['height'], 0, -2);
-            -
            					// Now make sure that it's an integer and not something stupid.
-            -
            					if (filter_var($proposed_height, FILTER_VALIDATE_INT))
-            -
            					{
-            -
            						$height = $proposed_height;
-            -
            					}
-            -
            				}
-            -
            			}
-            -
-            -
            		}
-            -
-            -
            		// Future enhancement:
-            -
            		// Look in the tag to see if there is a class or id specified that has a height or width attribute to it.
-            -
-            -
            		// Far future enhancement
-            -
            		// Look at all the parent tags of this image to see if they specify a class or id that has an img selector that specifies a height or width
-            -
            		// Note that in this case, the class or id will have the img subselector for it to apply to the image.
-            -
-            -
            		// ridiculously far future development
-            -
            		// If the class or id is specified in a SEPARATE css file thats not on the page, go get it and do what we were just doing for the ones on the page.
-            -
-            -
            		$result = array('height' => $height,
-            -
            						'width' => $width);
-            -
            		return $result;
-            -
            	}
-            -
-            -
            	// camel naming conventions
-            -
            	function getAllAttributes() {return $this->attr;}
-            -
            	function getAttribute($name) {return $this->__get($name);}
-            -
            	function setAttribute($name, $value) {$this->__set($name, $value);}
-            -
            	function hasAttribute($name) {return $this->__isset($name);}
-            -
            	function removeAttribute($name) {$this->__set($name, null);}
-            -
            	function getElementById($id) {return $this->find("#$id", 0);}
-            -
            	function getElementsById($id, $idx=null) {return $this->find("#$id", $idx);}
-            -
            	function getElementByTagName($name) {return $this->find($name, 0);}
-            -
            	function getElementsByTagName($name, $idx=null) {return $this->find($name, $idx);}
-            -
            	function parentNode() {return $this->parent();}
-            -
            	function childNodes($idx=-1) {return $this->children($idx);}
-            -
            	function firstChild() {return $this->first_child();}
-            -
            	function lastChild() {return $this->last_child();}
-            -
            	function nextSibling() {return $this->next_sibling();}
-            -
            	function previousSibling() {return $this->prev_sibling();}
-            -
            	function hasChildNodes() {return $this->has_child();}
-            -
            	function nodeName() {return $this->tag;}
-            -
            	function appendChild($node) {$node->parent($this); return $node;}
-            -
-            -
            }
-            -
-            -
            /**
-            -
             * simple html dom parser
-            -
             * Paperg - in the find routine: allow us to specify that we want case insensitive testing of the value of the selector.
-            -
             * Paperg - change $size from protected to public so we can easily access it
-            -
             * Paperg - added ForceTagsClosed in the constructor which tells us whether we trust the html or not.  Default is to NOT trust it.
-            -
             *
-            -
             * @package PlaceLocalInclude
-            -
             */
-            -
            class simple_html_dom
-            -
            {
-            -
            	public $root = null;
-            -
            	public $nodes = array();
-            -
            	public $callback = null;
-            -
            	public $lowercase = false;
-            -
            	// Used to keep track of how large the text was when we started.
-            -
            	public $original_size;
-            -
            	public $size;
-            -
            	protected $pos;
-            -
            	protected $doc;
-            -
            	protected $char;
-            -
            	protected $cursor;
-            -
            	protected $parent;
-            -
            	protected $noise = array();
-            -
            	protected $token_blank = " \t\r\n";
-            -
            	protected $token_equal = ' =/>';
-            -
            	protected $token_slash = " />\r\n\t";
-            -
            	protected $token_attr = ' >';
-            -
            	// Note that this is referenced by a child node, and so it needs to be public for that node to see this information.
-            -
            	public $_charset = '';
-            -
            	public $_target_charset = '';
-            -
            	protected $default_br_text = "";
-            -
            	public $default_span_text = "";
-            -
-            -
            	// use isset instead of in_array, performance boost about 30%...
-            -
            	protected $self_closing_tags = array('img'=>1, 'br'=>1, 'input'=>1, 'meta'=>1, 'link'=>1, 'hr'=>1, 'base'=>1, 'embed'=>1, 'spacer'=>1);
-            -
            	protected $block_tags = array('root'=>1, 'body'=>1, 'form'=>1, 'div'=>1, 'span'=>1, 'table'=>1);
-            -
            	// Known sourceforge issue #2977341
-            -
            	// B tags that are not closed cause us to return everything to the end of the document.
-            -
            	protected $optional_closing_tags = array(
-            -
            		'tr'=>array('tr'=>1, 'td'=>1, 'th'=>1),
-            -
            		'th'=>array('th'=>1),
-            -
            		'td'=>array('td'=>1),
-            -
            		'li'=>array('li'=>1),
-            -
            		'dt'=>array('dt'=>1, 'dd'=>1),
-            -
            		'dd'=>array('dd'=>1, 'dt'=>1),
-            -
            		'dl'=>array('dd'=>1, 'dt'=>1),
-            -
            		'p'=>array('p'=>1),
-            -
            		'nobr'=>array('nobr'=>1),
-            -
            		'b'=>array('b'=>1),
-            -
            		'option'=>array('option'=>1),
-            -
            	);
-            -
-            -
            	function __construct($str=null, $lowercase=true, $forceTagsClosed=true, $target_charset=DEFAULT_TARGET_CHARSET, $stripRN=true, $defaultBRText=DEFAULT_BR_TEXT, $defaultSpanText=DEFAULT_SPAN_TEXT)
-            -
            	{
-            -
            		if ($str)
-            -
            		{
-            -
            			if (preg_match("/^http:\/\//i",$str) || is_file($str))
-            -
            			{
-            -
            				$this->load_file($str);
-            -
            			}
-            -
            			else
-            -
            			{
-            -
            				$this->load($str, $lowercase, $stripRN, $defaultBRText, $defaultSpanText);
-            -
            			}
-            -
            		}
-            -
            		// Forcing tags to be closed implies that we don't trust the html, but it can lead to parsing errors if we SHOULD trust the html.
-            -
            		if (!$forceTagsClosed) {
-            -
            			$this->optional_closing_array=array();
-            -
            		}
-            -
            		$this->_target_charset = $target_charset;
-            -
            	}
-            -
-            -
            	function __destruct()
-            -
            	{
-            -
            		$this->clear();
-            -
            	}
-            -
-            -
            	// load html from string
-            -
            	function load($str, $lowercase=true, $stripRN=true, $defaultBRText=DEFAULT_BR_TEXT, $defaultSpanText=DEFAULT_SPAN_TEXT)
-            -
            	{
-            -
            		global $debug_object;
-            -
-            -
            		// prepare
-            -
            		$this->prepare($str, $lowercase, $stripRN, $defaultBRText, $defaultSpanText);
-            -
            		// strip out cdata
-            -
            		$this->remove_noise("'<!\[CDATA\[(.*?)\]\]>'is", true);
-            -
            		// strip out comments
-            -
            		$this->remove_noise("'<!--(.*?)-->'is");
-            -
            		// Per sourceforge http://sourceforge.net/tracker/?func=detail&aid=2949097&group_id=218559&atid=1044037
-            -
            		// Script tags removal now preceeds style tag removal.
-            -
            		// strip out <script> tags
-            -
            		$this->remove_noise("'<\s*script[^>]*[^/]>(.*?)<\s*/\s*script\s*>'is");
-            -
            		$this->remove_noise("'<\s*script\s*>(.*?)<\s*/\s*script\s*>'is");
-            -
            		// strip out <style> tags
-            -
            		$this->remove_noise("'<\s*style[^>]*[^/]>(.*?)<\s*/\s*style\s*>'is");
-            -
            		$this->remove_noise("'<\s*style\s*>(.*?)<\s*/\s*style\s*>'is");
-            -
            		// strip out preformatted tags
-            -
            		$this->remove_noise("'<\s*(?:code)[^>]*>(.*?)<\s*/\s*(?:code)\s*>'is");
-            -
            		// strip out server side scripts
-            -
            		$this->remove_noise("'(<\?)(.*?)(\?>)'s", true);
-            -
            		// strip smarty scripts
-            -
            		$this->remove_noise("'(\{\w)(.*?)(\})'s", true);
-            -
-            -
            		// parsing
-            -
            		while ($this->parse());
-            -
            		// end
-            -
            		$this->root->_[HDOM_INFO_END] = $this->cursor;
-            -
            		$this->parse_charset();
-            -
-            -
            		// make load function chainable
-            -
            		return $this;
-            -
-            -
            	}
-            -
-            -
            	// load html from file
-            -
            	function load_file()
-            -
            	{
-            -
            		$args = func_get_args();
-            -
            		$this->load(call_user_func_array('file_get_contents', $args), true);
-            -
            		// Throw an error if we can't properly load the dom.
-            -
            		if (($error=error_get_last())!==null) {
-            -
            			$this->clear();
-            -
            			return false;
-            -
            		}
-            -
            	}
-            -
-            -
            	// set callback function
-            -
            	function set_callback($function_name)
-            -
            	{
-            -
            		$this->callback = $function_name;
-            -
            	}
-            -
-            -
            	// remove callback function
-            -
            	function remove_callback()
-            -
            	{
-            -
            		$this->callback = null;
-            -
            	}
-            -
-            -
            	// save dom as string
-            -
            	function save($filepath='')
-            -
            	{
-            -
            		$ret = $this->root->innertext();
-            -
            		if ($filepath!=='') file_put_contents($filepath, $ret, LOCK_EX);
-            -
            		return $ret;
-            -
            	}
-            -
-            -
            	// find dom node by css selector
-            -
            	// Paperg - allow us to specify that we want case insensitive testing of the value of the selector.
-            -
            	function find($selector, $idx=null, $lowercase=false)
-            -
            	{
-            -
            		return $this->root->find($selector, $idx, $lowercase);
-            -
            	}
-            -
-            -
            	// clean up memory due to php5 circular references memory leak...
-            -
            	function clear()
-            -
            	{
-            -
            		foreach ($this->nodes as $n) {$n->clear(); $n = null;}
-            -
            		// This add next line is documented in the sourceforge repository. 2977248 as a fix for ongoing memory leaks that occur even with the use of clear.
-            -
            		if (isset($this->children)) foreach ($this->children as $n) {$n->clear(); $n = null;}
-            -
            		if (isset($this->parent)) {$this->parent->clear(); unset($this->parent);}
-            -
            		if (isset($this->root)) {$this->root->clear(); unset($this->root);}
-            -
            		unset($this->doc);
-            -
            		unset($this->noise);
-            -
            	}
-            -
-            -
            	function dump($show_attr=true)
-            -
            	{
-            -
            		$this->root->dump($show_attr);
-            -
            	}
-            -
-            -
            	// prepare HTML data and init everything
-            -
            	protected function prepare($str, $lowercase=true, $stripRN=true, $defaultBRText=DEFAULT_BR_TEXT, $defaultSpanText=DEFAULT_SPAN_TEXT)
-            -
            	{
-            -
            		$this->clear();
-            -
-            -
            		// set the length of content before we do anything to it.
-            -
            		$this->size = strlen($str);
-            -
            		// Save the original size of the html that we got in.  It might be useful to someone.
-            -
            		$this->original_size = $this->size;
-            -
-            -
            		//before we save the string as the doc...  strip out the \r \n's if we are told to.
-            -
            		if ($stripRN) {
-            -
            			$str = str_replace("\r", " ", $str);
-            -
            			$str = str_replace("\n", " ", $str);
-            -
-            -
            			// set the length of content since we have changed it.
-            -
            			$this->size = strlen($str);
-            -
            		}
-            -
-            -
            		$this->doc = $str;
-            -
            		$this->pos = 0;
-            -
            		$this->cursor = 1;
-            -
            		$this->noise = array();
-            -
            		$this->nodes = array();
-            -
            		$this->lowercase = $lowercase;
-            -
            		$this->default_br_text = $defaultBRText;
-            -
            		$this->default_span_text = $defaultSpanText;
-            -
            		$this->root = new simple_html_dom_node($this);
-            -
            		$this->root->tag = 'root';
-            -
            		$this->root->_[HDOM_INFO_BEGIN] = -1;
-            -
            		$this->root->nodetype = HDOM_TYPE_ROOT;
-            -
            		$this->parent = $this->root;
-            -
            		if ($this->size>0) $this->char = $this->doc[0];
-            -
            	}
-            -
-            -
            	// parse html content
-            -
            	protected function parse()
-            -
            	{
-            -
            		if (($s = $this->copy_until_char('<'))==='')
-            -
            		{
-            -
            			return $this->read_tag();
-            -
            		}
-            -
-            -
            		// text
-            -
            		$node = new simple_html_dom_node($this);
-            -
            		++$this->cursor;
-            -
            		$node->_[HDOM_INFO_TEXT] = $s;
-            -
            		$this->link_nodes($node, false);
-            -
            		return true;
-            -
            	}
-            -
-            -
            	// PAPERG - dkchou - added this to try to identify the character set of the page we have just parsed so we know better how to spit it out later.
-            -
            	// NOTE:  IF you provide a routine called get_last_retrieve_url_contents_content_type which returns the CURLINFO_CONTENT_TYPE from the last curl_exec
-            -
            	// (or the content_type header from the last transfer), we will parse THAT, and if a charset is specified, we will use it over any other mechanism.
-            -
            	protected function parse_charset()
-            -
            	{
-            -
            		global $debug_object;
-            -
-            -
            		$charset = null;
-            -
-            -
            		if (function_exists('get_last_retrieve_url_contents_content_type'))
-            -
            		{
-            -
            			$contentTypeHeader = get_last_retrieve_url_contents_content_type();
-            -
            			$success = preg_match('/charset=(.+)/', $contentTypeHeader, $matches);
-            -
            			if ($success)
-            -
            			{
-            -
            				$charset = $matches[1];
-            -
            				if (is_object($debug_object)) {$debug_object->debug_log(2, 'header content-type found charset of: ' . $charset);}
-            -
            			}
-            -
-            -
            		}
-            -
-            -
            		if (empty($charset))
-            -
            		{
-            -
            			$el = $this->root->find('meta[http-equiv=Content-Type]',0, true);
-            -
            			if (!empty($el))
-            -
            			{
-            -
            				$fullvalue = $el->content;
-            -
            				if (is_object($debug_object)) {$debug_object->debug_log(2, 'meta content-type tag found' . $fullvalue);}
-            -
-            -
            				if (!empty($fullvalue))
-            -
            				{
-            -
            					$success = preg_match('/charset=(.+)/i', $fullvalue, $matches);
-            -
            					if ($success)
-            -
            					{
-            -
            						$charset = $matches[1];
-            -
            					}
-            -
            					else
-            -
            					{
-            -
            						// If there is a meta tag, and they don't specify the character set, research says that it's typically ISO-8859-1
-            -
            						if (is_object($debug_object)) {$debug_object->debug_log(2, 'meta content-type tag couldn\'t be parsed. using iso-8859 default.');}
-            -
            						$charset = 'ISO-8859-1';
-            -
            					}
-            -
            				}
-            -
            			}
-            -
            		}
-            -
-            -
            		// If we couldn't find a charset above, then lets try to detect one based on the text we got...
-            -
            		if (empty($charset))
-            -
            		{
-            -
            			// Use this in case mb_detect_charset isn't installed/loaded on this machine.
-            -
            			$charset = false;
-            -
            			if (function_exists('mb_detect_encoding'))
-            -
            			{
-            -
            				// Have php try to detect the encoding from the text given to us.
-            -
            				$charset = mb_detect_encoding($this->root->plaintext . "ascii", $encoding_list = array( "UTF-8", "CP1252" ) );
-            -
            				if (is_object($debug_object)) {$debug_object->debug_log(2, 'mb_detect found: ' . $charset);}
-            -
            			}
-            -
-            -
            			// and if this doesn't work...  then we need to just wrongheadedly assume it's UTF-8 so that we can move on - cause this will usually give us most of what we need...
-            -
            			if ($charset === false)
-            -
            			{
-            -
            				if (is_object($debug_object)) {$debug_object->debug_log(2, 'since mb_detect failed - using default of utf-8');}
-            -
            				$charset = 'UTF-8';
-            -
            			}
-            -
            		}
-            -
-            -
            		// Since CP1252 is a superset, if we get one of it's subsets, we want it instead.
-            -
            		if ((strtolower($charset) == strtolower('ISO-8859-1')) || (strtolower($charset) == strtolower('Latin1')) || (strtolower($charset) == strtolower('Latin-1')))
-            -
            		{
-            -
            			if (is_object($debug_object)) {$debug_object->debug_log(2, 'replacing ' . $charset . ' with CP1252 as its a superset');}
-            -
            			$charset = 'CP1252';
-            -
            		}
-            -
-            -
            		if (is_object($debug_object)) {$debug_object->debug_log(1, 'EXIT - ' . $charset);}
-            -
-            -
            		return $this->_charset = $charset;
-            -
            	}
-            -
-            -
            	// read tag info
-            -
            	protected function read_tag()
-            -
            	{
-            -
            		if ($this->char!=='<')
-            -
            		{
-            -
            			$this->root->_[HDOM_INFO_END] = $this->cursor;
-            -
            			return false;
-            -
            		}
-            -
            		$begin_tag_pos = $this->pos;
-            -
            		$this->char = (++$this->pos<$this->size) ? $this->doc[$this->pos] : null; // next
-            -
-            -
            		// end tag
-            -
            		if ($this->char==='/')
-            -
            		{
-            -
            			$this->char = (++$this->pos<$this->size) ? $this->doc[$this->pos] : null; // next
-            -
            			// This represents the change in the simple_html_dom trunk from revision 180 to 181.
-            -
            			// $this->skip($this->token_blank_t);
-            -
            			$this->skip($this->token_blank);
-            -
            			$tag = $this->copy_until_char('>');
-            -
-            -
            			// skip attributes in end tag
-            -
            			if (($pos = strpos($tag, ' '))!==false)
-            -
            				$tag = substr($tag, 0, $pos);
-            -
-            -
            			$parent_lower = strtolower($this->parent->tag);
-            -
            			$tag_lower = strtolower($tag);
-            -
-            -
            			if ($parent_lower!==$tag_lower)
-            -
            			{
-            -
            				if (isset($this->optional_closing_tags[$parent_lower]) && isset($this->block_tags[$tag_lower]))
-            -
            				{
-            -
            					$this->parent->_[HDOM_INFO_END] = 0;
-            -
            					$org_parent = $this->parent;
-            -
-            -
            					while (($this->parent->parent) && strtolower($this->parent->tag)!==$tag_lower)
-            -
            						$this->parent = $this->parent->parent;
-            -
-            -
            					if (strtolower($this->parent->tag)!==$tag_lower) {
-            -
            						$this->parent = $org_parent; // restore origonal parent
-            -
            						if ($this->parent->parent) $this->parent = $this->parent->parent;
-            -
            						$this->parent->_[HDOM_INFO_END] = $this->cursor;
-            -
            						return $this->as_text_node($tag);
-            -
            					}
-            -
            				}
-            -
            				else if (($this->parent->parent) && isset($this->block_tags[$tag_lower]))
-            -
            				{
-            -
            					$this->parent->_[HDOM_INFO_END] = 0;
-            -
            					$org_parent = $this->parent;
-            -
-            -
            					while (($this->parent->parent) && strtolower($this->parent->tag)!==$tag_lower)
-            -
            						$this->parent = $this->parent->parent;
-            -
-            -
            					if (strtolower($this->parent->tag)!==$tag_lower)
-            -
            					{
-            -
            						$this->parent = $org_parent; // restore origonal parent
-            -
            						$this->parent->_[HDOM_INFO_END] = $this->cursor;
-            -
            						return $this->as_text_node($tag);
-            -
            					}
-            -
            				}
-            -
            				else if (($this->parent->parent) && strtolower($this->parent->parent->tag)===$tag_lower)
-            -
            				{
-            -
            					$this->parent->_[HDOM_INFO_END] = 0;
-            -
            					$this->parent = $this->parent->parent;
-            -
            				}
-            -
            				else
-            -
            					return $this->as_text_node($tag);
-            -
            			}
-            -
-            -
            			$this->parent->_[HDOM_INFO_END] = $this->cursor;
-            -
            			if ($this->parent->parent) $this->parent = $this->parent->parent;
-            -
-            -
            			$this->char = (++$this->pos<$this->size) ? $this->doc[$this->pos] : null; // next
-            -
            			return true;
-            -
            		}
-            -
-            -
            		$node = new simple_html_dom_node($this);
-            -
            		$node->_[HDOM_INFO_BEGIN] = $this->cursor;
-            -
            		++$this->cursor;
-            -
            		$tag = $this->copy_until($this->token_slash);
-            -
            		$node->tag_start = $begin_tag_pos;
-            -
-            -
            		// doctype, cdata & comments...
-            -
            		if (isset($tag[0]) && $tag[0]==='!') {
-            -
            			$node->_[HDOM_INFO_TEXT] = '<' . $tag . $this->copy_until_char('>');
-            -
-            -
            			if (isset($tag[2]) && $tag[1]==='-' && $tag[2]==='-') {
-            -
            				$node->nodetype = HDOM_TYPE_COMMENT;
-            -
            				$node->tag = 'comment';
-            -
            			} else {
-            -
            				$node->nodetype = HDOM_TYPE_UNKNOWN;
-            -
            				$node->tag = 'unknown';
-            -
            			}
-            -
            			if ($this->char==='>') $node->_[HDOM_INFO_TEXT].='>';
-            -
            			$this->link_nodes($node, true);
-            -
            			$this->char = (++$this->pos<$this->size) ? $this->doc[$this->pos] : null; // next
-            -
            			return true;
-            -
            		}
-            -
-            -
            		// text
-            -
            		if ($pos=strpos($tag, '<')!==false) {
-            -
            			$tag = '<' . substr($tag, 0, -1);
-            -
            			$node->_[HDOM_INFO_TEXT] = $tag;
-            -
            			$this->link_nodes($node, false);
-            -
            			$this->char = $this->doc[--$this->pos]; // prev
-            -
            			return true;
-            -
            		}
-            -
-            -
                // escaped hyphen here
-            -
            		if (!preg_match("/^[\w\-:]+$/", $tag)) {
-            -
            			$node->_[HDOM_INFO_TEXT] = '<' . $tag . $this->copy_until('<>');
-            -
            			if ($this->char==='<') {
-            -
            				$this->link_nodes($node, false);
-            -
            				return true;
-            -
            			}
-            -
-            -
            			if ($this->char==='>') $node->_[HDOM_INFO_TEXT].='>';
-            -
            			$this->link_nodes($node, false);
-            -
            			$this->char = (++$this->pos<$this->size) ? $this->doc[$this->pos] : null; // next
-            -
            			return true;
-            -
            		}
-            -
-            -
            		// begin tag
-            -
            		$node->nodetype = HDOM_TYPE_ELEMENT;
-            -
            		$tag_lower = strtolower($tag);
-            -
            		$node->tag = ($this->lowercase) ? $tag_lower : $tag;
-            -
-            -
            		// handle optional closing tags
-            -
            		if (isset($this->optional_closing_tags[$tag_lower]) )
-            -
            		{
-            -
            			while (isset($this->optional_closing_tags[$tag_lower][strtolower($this->parent->tag)]))
-            -
            			{
-            -
            				$this->parent->_[HDOM_INFO_END] = 0;
-            -
            				$this->parent = $this->parent->parent;
-            -
            			}
-            -
            			$node->parent = $this->parent;
-            -
            		}
-            -
-            -
            		$guard = 0; // prevent infinity loop
-            -
            		$space = array($this->copy_skip($this->token_blank), '', '');
-            -
-            -
            		// attributes
-            -
            		do
-            -
            		{
-            -
            			if ($this->char!==null && $space[0]==='')
-            -
            			{
-            -
            				break;
-            -
            			}
-            -
            			$name = $this->copy_until($this->token_equal);
-            -
            			if ($guard===$this->pos)
-            -
            			{
-            -
            				$this->char = (++$this->pos<$this->size) ? $this->doc[$this->pos] : null; // next
-            -
            				continue;
-            -
            			}
-            -
            			$guard = $this->pos;
-            -
-            -
            			// handle endless '<'
-            -
            			if ($this->pos>=$this->size-1 && $this->char!=='>') {
-            -
            				$node->nodetype = HDOM_TYPE_TEXT;
-            -
            				$node->_[HDOM_INFO_END] = 0;
-            -
            				$node->_[HDOM_INFO_TEXT] = '<'.$tag . $space[0] . $name;
-            -
            				$node->tag = 'text';
-            -
            				$this->link_nodes($node, false);
-            -
            				return true;
-            -
            			}
-            -
-            -
            			// handle mismatch '<'
-            -
            			if ($this->doc[$this->pos-1]=='<') {
-            -
            				$node->nodetype = HDOM_TYPE_TEXT;
-            -
            				$node->tag = 'text';
-            -
            				$node->attr = array();
-            -
            				$node->_[HDOM_INFO_END] = 0;
-            -
            				$node->_[HDOM_INFO_TEXT] = substr($this->doc, $begin_tag_pos, $this->pos-$begin_tag_pos-1);
-            -
            				$this->pos -= 2;
-            -
            				$this->char = (++$this->pos<$this->size) ? $this->doc[$this->pos] : null; // next
-            -
            				$this->link_nodes($node, false);
-            -
            				return true;
-            -
            			}
-            -
-            -
            			if ($name!=='/' && $name!=='') {
-            -
            				$space[1] = $this->copy_skip($this->token_blank);
-            -
            				$name = $this->restore_noise($name);
-            -
            				if ($this->lowercase) $name = strtolower($name);
-            -
            				if ($this->char==='=') {
-            -
            					$this->char = (++$this->pos<$this->size) ? $this->doc[$this->pos] : null; // next
-            -
            					$this->parse_attr($node, $name, $space);
-            -
            				}
-            -
            				else {
-            -
            					//no value attr: nowrap, checked selected...
-            -
            					$node->_[HDOM_INFO_QUOTE][] = HDOM_QUOTE_NO;
-            -
            					$node->attr[$name] = true;
-            -
            					if ($this->char!='>') $this->char = $this->doc[--$this->pos]; // prev
-            -
            				}
-            -
            				$node->_[HDOM_INFO_SPACE][] = $space;
-            -
            				$space = array($this->copy_skip($this->token_blank), '', '');
-            -
            			}
-            -
            			else
-            -
            				break;
-            -
            		} while ($this->char!=='>' && $this->char!=='/');
-            -
-            -
            		$this->link_nodes($node, true);
-            -
            		$node->_[HDOM_INFO_ENDSPACE] = $space[0];
-            -
-            -
            		// check self closing
-            -
            		if ($this->copy_until_char_escape('>')==='/')
-            -
            		{
-            -
            			$node->_[HDOM_INFO_ENDSPACE] .= '/';
-            -
            			$node->_[HDOM_INFO_END] = 0;
-            -
            		}
-            -
            		else
-            -
            		{
-            -
            			// reset parent
-            -
            			if (!isset($this->self_closing_tags[strtolower($node->tag)])) $this->parent = $node;
-            -
            		}
-            -
            		$this->char = (++$this->pos<$this->size) ? $this->doc[$this->pos] : null; // next
-            -
-            -
            		// If it's a BR tag, we need to set it's text to the default text.
-            -
            		// This way when we see it in plaintext, we can generate formatting that the user wants.
-            -
            		// since a br tag never has sub nodes, this works well.
-            -
            		if ($node->tag == "br")
-            -
            		{
-            -
            			$node->_[HDOM_INFO_INNER] = $this->default_br_text;
-            -
            		}
-            -
-            -
            		return true;
-            -
            	}
-            -
-            -
            	// parse attributes
-            -
            	protected function parse_attr($node, $name, &$space)
-            -
            	{
-            -
            		// Per sourceforge: http://sourceforge.net/tracker/?func=detail&aid=3061408&group_id=218559&atid=1044037
-            -
            		// If the attribute is already defined inside a tag, only pay atetntion to the first one as opposed to the last one.
-            -
            		if (isset($node->attr[$name]))
-            -
            		{
-            -
            			return;
-            -
            		}
-            -
-            -
            		$space[2] = $this->copy_skip($this->token_blank);
-            -
            		switch ($this->char) {
-            -
            			case '"':
-            -
            				$node->_[HDOM_INFO_QUOTE][] = HDOM_QUOTE_DOUBLE;
-            -
            				$this->char = (++$this->pos<$this->size) ? $this->doc[$this->pos] : null; // next
-            -
            				$node->attr[$name] = $this->restore_noise($this->copy_until_char_escape('"'));
-            -
            				$this->char = (++$this->pos<$this->size) ? $this->doc[$this->pos] : null; // next
-            -
            				break;
-            -
            			case '\'':
-            -
            				$node->_[HDOM_INFO_QUOTE][] = HDOM_QUOTE_SINGLE;
-            -
            				$this->char = (++$this->pos<$this->size) ? $this->doc[$this->pos] : null; // next
-            -
            				$node->attr[$name] = $this->restore_noise($this->copy_until_char_escape('\''));
-            -
            				$this->char = (++$this->pos<$this->size) ? $this->doc[$this->pos] : null; // next
-            -
            				break;
-            -
            			default:
-            -
            				$node->_[HDOM_INFO_QUOTE][] = HDOM_QUOTE_NO;
-            -
            				$node->attr[$name] = $this->restore_noise($this->copy_until($this->token_attr));
-            -
            		}
-            -
            		// PaperG: Attributes should not have \r or \n in them, that counts as html whitespace.
-            -
            		$node->attr[$name] = str_replace("\r", "", $node->attr[$name]);
-            -
            		$node->attr[$name] = str_replace("\n", "", $node->attr[$name]);
-            -
            		// PaperG: If this is a "class" selector, lets get rid of the preceeding and trailing space since some people leave it in the multi class case.
-            -
            		if ($name == "class") {
-            -
            			$node->attr[$name] = trim($node->attr[$name]);
-            -
            		}
-            -
            	}
-            -
-            -
            	// link node's parent
-            -
            	protected function link_nodes(&$node, $is_child)
-            -
            	{
-            -
            		$node->parent = $this->parent;
-            -
            		$this->parent->nodes[] = $node;
-            -
            		if ($is_child)
-            -
            		{
-            -
            			$this->parent->children[] = $node;
-            -
            		}
-            -
            	}
-            -
-            -
            	// as a text node
-            -
            	protected function as_text_node($tag)
-            -
            	{
-            -
            		$node = new simple_html_dom_node($this);
-            -
            		++$this->cursor;
-            -
            		$node->_[HDOM_INFO_TEXT] = '</' . $tag . '>';
-            -
            		$this->link_nodes($node, false);
-            -
            		$this->char = (++$this->pos<$this->size) ? $this->doc[$this->pos] : null; // next
-            -
            		return true;
-            -
            	}
-            -
-            -
            	protected function skip($chars)
-            -
            	{
-            -
            		$this->pos += strspn($this->doc, $chars, $this->pos);
-            -
            		$this->char = ($this->pos<$this->size) ? $this->doc[$this->pos] : null; // next
-            -
            	}
-            -
-            -
            	protected function copy_skip($chars)
-            -
            	{
-            -
            		$pos = $this->pos;
-            -
            		$len = strspn($this->doc, $chars, $pos);
-            -
            		$this->pos += $len;
-            -
            		$this->char = ($this->pos<$this->size) ? $this->doc[$this->pos] : null; // next
-            -
            		if ($len===0) return '';
-            -
            		return substr($this->doc, $pos, $len);
-            -
            	}
-            -
-            -
            	protected function copy_until($chars)
-            -
            	{
-            -
            		$pos = $this->pos;
-            -
            		$len = strcspn($this->doc, $chars, $pos);
-            -
            		$this->pos += $len;
-            -
            		$this->char = ($this->pos<$this->size) ? $this->doc[$this->pos] : null; // next
-            -
            		return substr($this->doc, $pos, $len);
-            -
            	}
-            -
-            -
            	protected function copy_until_char($char)
-            -
            	{
-            -
            		if ($this->char===null) return '';
-            -
-            -
            		if (($pos = strpos($this->doc, $char, $this->pos))===false) {
-            -
            			$ret = substr($this->doc, $this->pos, $this->size-$this->pos);
-            -
            			$this->char = null;
-            -
            			$this->pos = $this->size;
-            -
            			return $ret;
-            -
            		}
-            -
-            -
            		if ($pos===$this->pos) return '';
-            -
            		$pos_old = $this->pos;
-            -
            		$this->char = $this->doc[$pos];
-            -
            		$this->pos = $pos;
-            -
            		return substr($this->doc, $pos_old, $pos-$pos_old);
-            -
            	}
-            -
-            -
            	protected function copy_until_char_escape($char)
-            -
            	{
-            -
            		if ($this->char===null) return '';
-            -
-            -
            		$start = $this->pos;
-            -
            		while (1)
-            -
            		{
-            -
            			if (($pos = strpos($this->doc, $char, $start))===false)
-            -
            			{
-            -
            				$ret = substr($this->doc, $this->pos, $this->size-$this->pos);
-            -
            				$this->char = null;
-            -
            				$this->pos = $this->size;
-            -
            				return $ret;
-            -
            			}
-            -
-            -
            			if ($pos===$this->pos) return '';
-            -
-            -
            			if ($this->doc[$pos-1]==='\\') {
-            -
            				$start = $pos+1;
-            -
            				continue;
-            -
            			}
-            -
-            -
            			$pos_old = $this->pos;
-            -
            			$this->char = $this->doc[$pos];
-            -
            			$this->pos = $pos;
-            -
            			return substr($this->doc, $pos_old, $pos-$pos_old);
-            -
            		}
-            -
            	}
-            -
-            -
            	// remove noise from html content
-            -
            	// save the noise in the $this->noise array.
-            -
            	protected function remove_noise($pattern, $remove_tag=false)
-            -
            	{
-            -
            		global $debug_object;
-            -
            		if (is_object($debug_object)) { $debug_object->debug_log_entry(1); }
-            -
-            -
            		$count = preg_match_all($pattern, $this->doc, $matches, PREG_SET_ORDER|PREG_OFFSET_CAPTURE);
-            -
-            -
            		for ($i=$count-1; $i>-1; --$i)
-            -
            		{
-            -
            			$key = '___noise___'.sprintf('% 5d', count($this->noise)+1000);
-            -
            			if (is_object($debug_object)) { $debug_object->debug_log(2, 'key is: ' . $key); }
-            -
            			$idx = ($remove_tag) ? 0 : 1;
-            -
            			$this->noise[$key] = $matches[$i][$idx][0];
-            -
            			$this->doc = substr_replace($this->doc, $key, $matches[$i][$idx][1], strlen($matches[$i][$idx][0]));
-            -
            		}
-            -
-            -
            		// reset the length of content
-            -
            		$this->size = strlen($this->doc);
-            -
            		if ($this->size>0)
-            -
            		{
-            -
            			$this->char = $this->doc[0];
-            -
            		}
-            -
            	}
-            -
-            -
            	// restore noise to html content
-            -
            	function restore_noise($text)
-            -
            	{
-            -
            		global $debug_object;
-            -
            		if (is_object($debug_object)) { $debug_object->debug_log_entry(1); }
-            -
-            -
            		while (($pos=strpos($text, '___noise___'))!==false)
-            -
            		{
-            -
            			// Sometimes there is a broken piece of markup, and we don't GET the pos+11 etc... token which indicates a problem outside of us...
-            -
            			if (strlen($text) > $pos+15)
-            -
            			{
-            -
            				$key = '___noise___'.$text[$pos+11].$text[$pos+12].$text[$pos+13].$text[$pos+14].$text[$pos+15];
-            -
            				if (is_object($debug_object)) { $debug_object->debug_log(2, 'located key of: ' . $key); }
-            -
-            -
            				if (isset($this->noise[$key]))
-            -
            				{
-            -
            					$text = substr($text, 0, $pos).$this->noise[$key].substr($text, $pos+16);
-            -
            				}
-            -
            				else
-            -
            				{
-            -
            					// do this to prevent an infinite loop.
-            -
            					$text = substr($text, 0, $pos).'UNDEFINED NOISE FOR KEY: '.$key . substr($text, $pos+16);
-            -
            				}
-            -
            			}
-            -
            			else
-            -
            			{
-            -
            				// There is no valid key being given back to us... We must get rid of the ___noise___ or we will have a problem.
-            -
            				$text = substr($text, 0, $pos).'NO NUMERIC NOISE KEY' . substr($text, $pos+11);
-            -
            			}
-            -
            		}
-            -
            		return $text;
-            -
            	}
-            -
-            -
            	// Sometimes we NEED one of the noise elements.
-            -
            	function search_noise($text)
-            -
            	{
-            -
            		global $debug_object;
-            -
            		if (is_object($debug_object)) { $debug_object->debug_log_entry(1); }
-            -
-            -
            		foreach($this->noise as $noiseElement)
-            -
            		{
-            -
            			if (strpos($noiseElement, $text)!==false)
-            -
            			{
-            -
            				return $noiseElement;
-            -
            			}
-            -
            		}
-            -
            	}
-            -
            	function __toString()
-            -
            	{
-            -
            		return $this->root->innertext();
-            -
            	}
-            -
-            -
            	function __get($name)
-            -
            	{
-            -
            		switch ($name)
-            -
            		{
-            -
            			case 'outertext':
-            -
            				return $this->root->innertext();
-            -
            			case 'innertext':
-            -
            				return $this->root->innertext();
-            -
            			case 'plaintext':
-            -
            				return $this->root->text();
-            -
            			case 'charset':
-            -
            				return $this->_charset;
-            -
            			case 'target_charset':
-            -
            				return $this->_target_charset;
-            -
            		}
-            -
            	}
-            -
-            -
            	// camel naming conventions
-            -
            	function childNodes($idx=-1) {return $this->root->childNodes($idx);}
-            -
            	function firstChild() {return $this->root->first_child();}
-            -
            	function lastChild() {return $this->root->last_child();}
-            -
            	function createElement($name, $value=null) {return @str_get_html("<$name>$value</$name>")->first_child();}
-            -
            	function createTextNode($value) {return @end(str_get_html($value)->nodes);}
-            -
            	function getElementById($id) {return $this->find("#$id", 0);}
-            -
            	function getElementsById($id, $idx=null) {return $this->find("#$id", $idx);}
-            -
            	function getElementByTagName($name) {return $this->find($name, 0);}
-            -
            	function getElementsByTagName($name, $idx=-1) {return $this->find($name, $idx);}
-            -
            	function loadFile() {$args = func_get_args();$this->load_file($args);}
-            -
            }
-            -
-            -
            ?>


1	+ <?php
2	+ /** https://simplehtmldom.sourceforge.io/docs/1.9/index.html
3	+
4	+ * Website: http://sourceforge.net/projects/simplehtmldom/
5	+ * Additional projects: http://sourceforge.net/projects/debugobject/
6	+ * Acknowledge: Jose Solorzano (https://sourceforge.net/projects/php-html/)
7	+ *
8	+ * Licensed under The MIT License
9	+ * See the LICENSE file in the project root for more information.
10	+ *
11	+ * Authors:
12	+ * S.C. Chen
13	+ * John Schlick
14	+ * Rus Carroll
15	+ * logmanoriginal
16	+ *
17	+ * Contributors:
18	+ * Yousuke Kumakura
19	+ * Vadim Voituk
20	+ * Antcs
21	+ *
22	+ * Version Rev. 1.9.1 (291)
23	+ */
24	+
25	+ define('HDOM_TYPE_ELEMENT', 1);
26	+ define('HDOM_TYPE_COMMENT', 2);
27	+ define('HDOM_TYPE_TEXT', 3);
28	+ define('HDOM_TYPE_ENDTAG', 4);
29	+ define('HDOM_TYPE_ROOT', 5);
30	+ define('HDOM_TYPE_UNKNOWN', 6);
31	+ define('HDOM_QUOTE_DOUBLE', 0);
32	+ define('HDOM_QUOTE_SINGLE', 1);
33	+ define('HDOM_QUOTE_NO', 3);
34	+ define('HDOM_INFO_BEGIN', 0);
35	+ define('HDOM_INFO_END', 1);
36	+ define('HDOM_INFO_QUOTE', 2);
37	+ define('HDOM_INFO_SPACE', 3);
38	+ define('HDOM_INFO_TEXT', 4);
39	+ define('HDOM_INFO_INNER', 5);
40	+ define('HDOM_INFO_OUTER', 6);
41	+ define('HDOM_INFO_ENDSPACE', 7);
42	+
43	+ defined('DEFAULT_TARGET_CHARSET') \|\| define('DEFAULT_TARGET_CHARSET', 'UTF-8');
44	+ defined('DEFAULT_BR_TEXT') \|\| define('DEFAULT_BR_TEXT', "\r\n");
45	+ defined('DEFAULT_SPAN_TEXT') \|\| define('DEFAULT_SPAN_TEXT', ' ');
46	+ defined('MAX_FILE_SIZE') \|\| define('MAX_FILE_SIZE', 600000);
47	+ define('HDOM_SMARTY_AS_TEXT', 1);
48	+
49	+ function file_get_html(
50	+ $url,
51	+ $use_include_path = false,
52	+ $context = null,
53	+ $offset = 0,
54	+ $maxLen = -1,
55	+ $lowercase = true,
56	+ $forceTagsClosed = true,
57	+ $target_charset = DEFAULT_TARGET_CHARSET,
58	+ $stripRN = true,
59	+ $defaultBRText = DEFAULT_BR_TEXT,
60	+ $defaultSpanText = DEFAULT_SPAN_TEXT)
61	+ {
62	+ if($maxLen <= 0) { $maxLen = MAX_FILE_SIZE; }
63	+
64	+ $dom = new simple_html_dom(
65	+ null,
66	+ $lowercase,
67	+ $forceTagsClosed,
68	+ $target_charset,
69	+ $stripRN,
70	+ $defaultBRText,
71	+ $defaultSpanText
72	+ );
73	+
74	+ /**
75	+ * For sourceforge users: uncomment the next line and comment the
76	+ * retrieve_url_contents line 2 lines down if it is not already done.
77	+ */
78	+ $contents = file_get_contents(
79	+ $url,
80	+ $use_include_path,
81	+ $context,
82	+ $offset,
83	+ $maxLen
84	+ );
85	+ // $contents = retrieve_url_contents($url);
86	+
87	+ if (empty($contents) \|\| strlen($contents) > $maxLen) {
88	+ $dom->clear();
89	+ return false;
90	+ }
91	+
92	+ return $dom->load($contents, $lowercase, $stripRN);
93	+ }
94	+
95	+ function str_get_html(
96	+ $str,
97	+ $lowercase = true,
98	+ $forceTagsClosed = true,
99	+ $target_charset = DEFAULT_TARGET_CHARSET,
100	+ $stripRN = true,
101	+ $defaultBRText = DEFAULT_BR_TEXT,
102	+ $defaultSpanText = DEFAULT_SPAN_TEXT)
103	+ {
104	+ $dom = new simple_html_dom(
105	+ null,
106	+ $lowercase,
107	+ $forceTagsClosed,
108	+ $target_charset,
109	+ $stripRN,
110	+ $defaultBRText,
111	+ $defaultSpanText
112	+ );
113	+
114	+ if (empty($str) \|\| strlen($str) > MAX_FILE_SIZE) {
115	+ $dom->clear();
116	+ return false;
117	+ }
118	+
119	+ return $dom->load($str, $lowercase, $stripRN);
120	+ }
121	+
122	+ function dump_html_tree($node, $show_attr = true, $deep = 0)
123	+ {
124	+ $node->dump($node);
125	+ }
126	+
127	+ class simple_html_dom_node
128	+ {
129	+ public $nodetype = HDOM_TYPE_TEXT;
130	+ public $tag = 'text';
131	+ public $attr = array();
132	+ public $children = array();
133	+ public $nodes = array();
134	+ public $parent = null;
135	+ public $_ = array();
136	+ public $tag_start = 0;
137	+ private $dom = null;
138	+
139	+ function __construct($dom)
140	+ {
141	+ $this->dom = $dom;
142	+ $dom->nodes[] = $this;
143	+ }
144	+
145	+ function __destruct()
146	+ {
147	+ $this->clear();
148	+ }
149	+
150	+ function __toString()
151	+ {
152	+ return $this->outertext();
153	+ }
154	+
155	+ function clear()
156	+ {
157	+ $this->dom = null;
158	+ $this->nodes = null;
159	+ $this->parent = null;
160	+ $this->children = null;
161	+ }
162	+
163	+ function dump($show_attr = true, $depth = 0)
164	+ {
165	+ echo str_repeat("\t", $depth) . $this->tag;
166	+
167	+ if ($show_attr && count($this->attr) > 0) {
168	+ echo '(';
169	+ foreach ($this->attr as $k => $v) {
170	+ echo "[$k]=>\"$v\", ";
171	+ }
172	+ echo ')';
173	+ }
174	+
175	+ echo "\n";
176	+
177	+ if ($this->nodes) {
178	+ foreach ($this->nodes as $node) {
179	+ $node->dump($show_attr, $depth + 1);
180	+ }
181	+ }
182	+ }
183	+
184	+ function dump_node($echo = true)
185	+ {
186	+ $string = $this->tag;
187	+
188	+ if (count($this->attr) > 0) {
189	+ $string .= '(';
190	+ foreach ($this->attr as $k => $v) {
191	+ $string .= "[$k]=>\"$v\", ";
192	+ }
193	+ $string .= ')';
194	+ }
195	+
196	+ if (count($this->_) > 0) {
197	+ $string .= ' $_ (';
198	+ foreach ($this->_ as $k => $v) {
199	+ if (is_array($v)) {
200	+ $string .= "[$k]=>(";
201	+ foreach ($v as $k2 => $v2) {
202	+ $string .= "[$k2]=>\"$v2\", ";
203	+ }
204	+ $string .= ')';
205	+ } else {
206	+ $string .= "[$k]=>\"$v\", ";
207	+ }
208	+ }
209	+ $string .= ')';
210	+ }
211	+
212	+ if (isset($this->text)) {
213	+ $string .= " text: ({$this->text})";
214	+ }
215	+
216	+ $string .= ' HDOM_INNER_INFO: ';
217	+
218	+ if (isset($node->_[HDOM_INFO_INNER])) {
219	+ $string .= "'" . $node->_[HDOM_INFO_INNER] . "'";
220	+ } else {
221	+ $string .= ' NULL ';
222	+ }
223	+
224	+ $string .= ' children: ' . count($this->children);
225	+ $string .= ' nodes: ' . count($this->nodes);
226	+ $string .= ' tag_start: ' . $this->tag_start;
227	+ $string .= "\n";
228	+
229	+ if ($echo) {
230	+ echo $string;
231	+ return;
232	+ } else {
233	+ return $string;
234	+ }
235	+ }
236	+
237	+ function parent($parent = null)
238	+ {
239	+ // I am SURE that this doesn't work properly.
240	+ // It fails to unset the current node from it's current parents nodes or
241	+ // children list first.
242	+ if ($parent !== null) {
243	+ $this->parent = $parent;
244	+ $this->parent->nodes[] = $this;
245	+ $this->parent->children[] = $this;
246	+ }
247	+
248	+ return $this->parent;
249	+ }
250	+
251	+ function has_child()
252	+ {
253	+ return !empty($this->children);
254	+ }
255	+
256	+ function children($idx = -1)
257	+ {
258	+ if ($idx === -1) {
259	+ return $this->children;
260	+ }
261	+
262	+ if (isset($this->children[$idx])) {
263	+ return $this->children[$idx];
264	+ }
265	+
266	+ return null;
267	+ }
268	+
269	+ function first_child()
270	+ {
271	+ if (count($this->children) > 0) {
272	+ return $this->children[0];
273	+ }
274	+ return null;
275	+ }
276	+
277	+ function last_child()
278	+ {
279	+ if (count($this->children) > 0) {
280	+ return end($this->children);
281	+ }
282	+ return null;
283	+ }
284	+
285	+ function next_sibling()
286	+ {
287	+ if ($this->parent === null) {
288	+ return null;
289	+ }
290	+
291	+ $idx = array_search($this, $this->parent->children, true);
292	+
293	+ if ($idx !== false && isset($this->parent->children[$idx + 1])) {
294	+ return $this->parent->children[$idx + 1];
295	+ }
296	+
297	+ return null;
298	+ }
299	+
300	+ function prev_sibling()
301	+ {
302	+ if ($this->parent === null) {
303	+ return null;
304	+ }
305	+
306	+ $idx = array_search($this, $this->parent->children, true);
307	+
308	+ if ($idx !== false && $idx > 0) {
309	+ return $this->parent->children[$idx - 1];
310	+ }
311	+
312	+ return null;
313	+ }
314	+
315	+ function find_ancestor_tag($tag)
316	+ {
317	+ global $debug_object;
318	+ if (is_object($debug_object)) { $debug_object->debug_log_entry(1); }
319	+
320	+ if ($this->parent === null) {
321	+ return null;
322	+ }
323	+
324	+ $ancestor = $this->parent;
325	+
326	+ while (!is_null($ancestor)) {
327	+ if (is_object($debug_object)) {
328	+ $debug_object->debug_log(2, 'Current tag is: ' . $ancestor->tag);
329	+ }
330	+
331	+ if ($ancestor->tag === $tag) {
332	+ break;
333	+ }
334	+
335	+ $ancestor = $ancestor->parent;
336	+ }
337	+
338	+ return $ancestor;
339	+ }
340	+
341	+ function innertext()
342	+ {
343	+ if (isset($this->_[HDOM_INFO_INNER])) {
344	+ return $this->_[HDOM_INFO_INNER];
345	+ }
346	+
347	+ if (isset($this->_[HDOM_INFO_TEXT])) {
348	+ return $this->dom->restore_noise($this->_[HDOM_INFO_TEXT]);
349	+ }
350	+
351	+ $ret = '';
352	+
353	+ foreach ($this->nodes as $n) {
354	+ $ret .= $n->outertext();
355	+ }
356	+
357	+ return $ret;
358	+ }
359	+
360	+ function outertext()
361	+ {
362	+ global $debug_object;
363	+
364	+ if (is_object($debug_object)) {
365	+ $text = '';
366	+
367	+ if ($this->tag === 'text') {
368	+ if (!empty($this->text)) {
369	+ $text = ' with text: ' . $this->text;
370	+ }
371	+ }
372	+
373	+ $debug_object->debug_log(1, 'Innertext of tag: ' . $this->tag . $text);
374	+ }
375	+
376	+ if ($this->tag === 'root') {
377	+ return $this->innertext();
378	+ }
379	+
380	+ // todo: What is the use of this callback? Remove?
381	+ if ($this->dom && $this->dom->callback !== null) {
382	+ call_user_func_array($this->dom->callback, array($this));
383	+ }
384	+
385	+ if (isset($this->_[HDOM_INFO_OUTER])) {
386	+ return $this->_[HDOM_INFO_OUTER];
387	+ }
388	+
389	+ if (isset($this->_[HDOM_INFO_TEXT])) {
390	+ return $this->dom->restore_noise($this->_[HDOM_INFO_TEXT]);
391	+ }
392	+
393	+ $ret = '';
394	+
395	+ if ($this->dom && $this->dom->nodes[$this->_[HDOM_INFO_BEGIN]]) {
396	+ $ret = $this->dom->nodes[$this->_[HDOM_INFO_BEGIN]]->makeup();
397	+ }
398	+
399	+ if (isset($this->_[HDOM_INFO_INNER])) {
400	+ // todo: <br> should either never have HDOM_INFO_INNER or always
401	+ if ($this->tag !== 'br') {
402	+ $ret .= $this->_[HDOM_INFO_INNER];
403	+ }
404	+ } elseif ($this->nodes) {
405	+ foreach ($this->nodes as $n) {
406	+ $ret .= $this->convert_text($n->outertext());
407	+ }
408	+ }
409	+
410	+ if (isset($this->_[HDOM_INFO_END]) && $this->_[HDOM_INFO_END] != 0) {
411	+ $ret .= '</' . $this->tag . '>';
412	+ }
413	+
414	+ return $ret;
415	+ }
416	+
417	+ function text()
418	+ {
419	+ if (isset($this->_[HDOM_INFO_INNER])) {
420	+ return $this->_[HDOM_INFO_INNER];
421	+ }
422	+
423	+ switch ($this->nodetype) {
424	+ case HDOM_TYPE_TEXT: return $this->dom->restore_noise($this->_[HDOM_INFO_TEXT]);
425	+ case HDOM_TYPE_COMMENT: return '';
426	+ case HDOM_TYPE_UNKNOWN: return '';
427	+ }
428	+
429	+ if (strcasecmp($this->tag, 'script') === 0) { return ''; }
430	+ if (strcasecmp($this->tag, 'style') === 0) { return ''; }
431	+
432	+ $ret = '';
433	+
434	+ // In rare cases, (always node type 1 or HDOM_TYPE_ELEMENT - observed
435	+ // for some span tags, and some p tags) $this->nodes is set to NULL.
436	+ // NOTE: This indicates that there is a problem where it's set to NULL
437	+ // without a clear happening.
438	+ // WHY is this happening?
439	+ if (!is_null($this->nodes)) {
440	+ foreach ($this->nodes as $n) {
441	+ // Start paragraph after a blank line
442	+ if ($n->tag === 'p') {
443	+ $ret = trim($ret) . "\n\n";
444	+ }
445	+
446	+ $ret .= $this->convert_text($n->text());
447	+
448	+ // If this node is a span... add a space at the end of it so
449	+ // multiple spans don't run into each other. This is plaintext
450	+ // after all.
451	+ if ($n->tag === 'span') {
452	+ $ret .= $this->dom->default_span_text;
453	+ }
454	+ }
455	+ }
456	+ return $ret;
457	+ }
458	+
459	+ function xmltext()
460	+ {
461	+ $ret = $this->innertext();
462	+ $ret = str_ireplace('<![CDATA[', '', $ret);
463	+ $ret = str_replace(']]>', '', $ret);
464	+ return $ret;
465	+ }
466	+
467	+ function makeup()
468	+ {
469	+ // text, comment, unknown
470	+ if (isset($this->_[HDOM_INFO_TEXT])) {
471	+ return $this->dom->restore_noise($this->_[HDOM_INFO_TEXT]);
472	+ }
473	+
474	+ $ret = '<' . $this->tag;
475	+ $i = -1;
476	+
477	+ foreach ($this->attr as $key => $val) {
478	+ ++$i;
479	+
480	+ // skip removed attribute
481	+ if ($val === null \|\| $val === false) { continue; }
482	+
483	+ $ret .= $this->_[HDOM_INFO_SPACE][$i][0];
484	+
485	+ //no value attr: nowrap, checked selected...
486	+ if ($val === true) {
487	+ $ret .= $key;
488	+ } else {
489	+ switch ($this->_[HDOM_INFO_QUOTE][$i])
490	+ {
491	+ case HDOM_QUOTE_DOUBLE: $quote = '"'; break;
492	+ case HDOM_QUOTE_SINGLE: $quote = '\''; break;
493	+ default: $quote = '';
494	+ }
495	+
496	+ $ret .= $key
497	+ . $this->_[HDOM_INFO_SPACE][$i][1]
498	+ . '='
499	+ . $this->_[HDOM_INFO_SPACE][$i][2]
500	+ . $quote
501	+ . $val
502	+ . $quote;
503	+ }
504	+ }
505	+
506	+ $ret = $this->dom->restore_noise($ret);
507	+ return $ret . $this->_[HDOM_INFO_ENDSPACE] . '>';
508	+ }
509	+
510	+ function find($selector, $idx = null, $lowercase = false)
511	+ {
512	+ $selectors = $this->parse_selector($selector);
513	+ if (($count = count($selectors)) === 0) { return array(); }
514	+ $found_keys = array();
515	+
516	+ // find each selector
517	+ for ($c = 0; $c < $count; ++$c) {
518	+ // The change on the below line was documented on the sourceforge
519	+ // code tracker id 2788009
520	+ // used to be: if (($levle=count($selectors[0]))===0) return array();
521	+ if (($levle = count($selectors[$c])) === 0) { return array(); }
522	+ if (!isset($this->_[HDOM_INFO_BEGIN])) { return array(); }
523	+
524	+ $head = array($this->_[HDOM_INFO_BEGIN] => 1);
525	+ $cmd = ' '; // Combinator
526	+
527	+ // handle descendant selectors, no recursive!
528	+ for ($l = 0; $l < $levle; ++$l) {
529	+ $ret = array();
530	+
531	+ foreach ($head as $k => $v) {
532	+ $n = ($k === -1) ? $this->dom->root : $this->dom->nodes[$k];
533	+ //PaperG - Pass this optional parameter on to the seek function.
534	+ $n->seek($selectors[$c][$l], $ret, $cmd, $lowercase);
535	+ }
536	+
537	+ $head = $ret;
538	+ $cmd = $selectors[$c][$l][4]; // Next Combinator
539	+ }
540	+
541	+ foreach ($head as $k => $v) {
542	+ if (!isset($found_keys[$k])) {
543	+ $found_keys[$k] = 1;
544	+ }
545	+ }
546	+ }
547	+
548	+ // sort keys
549	+ ksort($found_keys);
550	+
551	+ $found = array();
552	+ foreach ($found_keys as $k => $v) {
553	+ $found[] = $this->dom->nodes[$k];
554	+ }
555	+
556	+ // return nth-element or array
557	+ if (is_null($idx)) { return $found; }
558	+ elseif ($idx < 0) { $idx = count($found) + $idx; }
559	+ return (isset($found[$idx])) ? $found[$idx] : null;
560	+ }
561	+
562	+ protected function seek($selector, &$ret, $parent_cmd, $lowercase = false)
563	+ {
564	+ global $debug_object;
565	+ if (is_object($debug_object)) { $debug_object->debug_log_entry(1); }
566	+
567	+ list($tag, $id, $class, $attributes, $cmb) = $selector;
568	+ $nodes = array();
569	+
570	+ if ($parent_cmd === ' ') { // Descendant Combinator
571	+ // Find parent closing tag if the current element doesn't have a closing
572	+ // tag (i.e. void element)
573	+ $end = (!empty($this->_[HDOM_INFO_END])) ? $this->_[HDOM_INFO_END] : 0;
574	+ if ($end == 0) {
575	+ $parent = $this->parent;
576	+ while (!isset($parent->_[HDOM_INFO_END]) && $parent !== null) {
577	+ $end -= 1;
578	+ $parent = $parent->parent;
579	+ }
580	+ $end += $parent->_[HDOM_INFO_END];
581	+ }
582	+
583	+ // Get list of target nodes
584	+ $nodes_start = $this->_[HDOM_INFO_BEGIN] + 1;
585	+ $nodes_count = $end - $nodes_start;
586	+ $nodes = array_slice($this->dom->nodes, $nodes_start, $nodes_count, true);
587	+ } elseif ($parent_cmd === '>') { // Child Combinator
588	+ $nodes = $this->children;
589	+ } elseif ($parent_cmd === '+'
590	+ && $this->parent
591	+ && in_array($this, $this->parent->children)) { // Next-Sibling Combinator
592	+ $index = array_search($this, $this->parent->children, true) + 1;
593	+ if ($index < count($this->parent->children))
594	+ $nodes[] = $this->parent->children[$index];
595	+ } elseif ($parent_cmd === '~'
596	+ && $this->parent
597	+ && in_array($this, $this->parent->children)) { // Subsequent Sibling Combinator
598	+ $index = array_search($this, $this->parent->children, true);
599	+ $nodes = array_slice($this->parent->children, $index);
600	+ }
601	+
602	+ // Go throgh each element starting at this element until the end tag
603	+ // Note: If this element is a void tag, any previous void element is
604	+ // skipped.
605	+ foreach($nodes as $node) {
606	+ $pass = true;
607	+
608	+ // Skip root nodes
609	+ if(!$node->parent) {
610	+ $pass = false;
611	+ }
612	+
613	+ // Handle 'text' selector
614	+ if($pass && $tag === 'text' && $node->tag === 'text') {
615	+ $ret[array_search($node, $this->dom->nodes, true)] = 1;
616	+ unset($node);
617	+ continue;
618	+ }
619	+
620	+ // Skip if node isn't a child node (i.e. text nodes)
621	+ if($pass && !in_array($node, $node->parent->children, true)) {
622	+ $pass = false;
623	+ }
624	+
625	+ // Skip if tag doesn't match
626	+ if ($pass && $tag !== '' && $tag !== $node->tag && $tag !== '*') {
627	+ $pass = false;
628	+ }
629	+
630	+ // Skip if ID doesn't exist
631	+ if ($pass && $id !== '' && !isset($node->attr['id'])) {
632	+ $pass = false;
633	+ }
634	+
635	+ // Check if ID matches
636	+ if ($pass && $id !== '' && isset($node->attr['id'])) {
637	+ // Note: Only consider the first ID (as browsers do)
638	+ $node_id = explode(' ', trim($node->attr['id']))[0];
639	+
640	+ if($id !== $node_id) { $pass = false; }
641	+ }
642	+
643	+ // Check if all class(es) exist
644	+ if ($pass && $class !== '' && is_array($class) && !empty($class)) {
645	+ if (isset($node->attr['class'])) {
646	+ $node_classes = explode(' ', $node->attr['class']);
647	+
648	+ if ($lowercase) {
649	+ $node_classes = array_map('strtolower', $node_classes);
650	+ }
651	+
652	+ foreach($class as $c) {
653	+ if(!in_array($c, $node_classes)) {
654	+ $pass = false;
655	+ break;
656	+ }
657	+ }
658	+ } else {
659	+ $pass = false;
660	+ }
661	+ }
662	+
663	+ // Check attributes
664	+ if ($pass
665	+ && $attributes !== ''
666	+ && is_array($attributes)
667	+ && !empty($attributes)) {
668	+ foreach($attributes as $a) {
669	+ list (
670	+ $att_name,
671	+ $att_expr,
672	+ $att_val,
673	+ $att_inv,
674	+ $att_case_sensitivity
675	+ ) = $a;
676	+
677	+ // Handle indexing attributes (i.e. "[2]")
678	+ /**
679	+ * Note: This is not supported by the CSS Standard but adds
680	+ * the ability to select items compatible to XPath (i.e.
681	+ * the 3rd element within it's parent).
682	+ *
683	+ * Note: This doesn't conflict with the CSS Standard which
684	+ * doesn't work on numeric attributes anyway.
685	+ */
686	+ if (is_numeric($att_name)
687	+ && $att_expr === ''
688	+ && $att_val === '') {
689	+ $count = 0;
690	+
691	+ // Find index of current element in parent
692	+ foreach ($node->parent->children as $c) {
693	+ if ($c->tag === $node->tag) ++$count;
694	+ if ($c === $node) break;
695	+ }
696	+
697	+ // If this is the correct node, continue with next
698	+ // attribute
699	+ if ($count === (int)$att_name) continue;
700	+ }
701	+
702	+ // Check attribute availability
703	+ if ($att_inv) { // Attribute should NOT be set
704	+ if (isset($node->attr[$att_name])) {
705	+ $pass = false;
706	+ break;
707	+ }
708	+ } else { // Attribute should be set
709	+ // todo: "plaintext" is not a valid CSS selector!
710	+ if ($att_name !== 'plaintext'
711	+ && !isset($node->attr[$att_name])) {
712	+ $pass = false;
713	+ break;
714	+ }
715	+ }
716	+
717	+ // Continue with next attribute if expression isn't defined
718	+ if ($att_expr === '') continue;
719	+
720	+ // If they have told us that this is a "plaintext"
721	+ // search then we want the plaintext of the node - right?
722	+ // todo "plaintext" is not a valid CSS selector!
723	+ if ($att_name === 'plaintext') {
724	+ $nodeKeyValue = $node->text();
725	+ } else {
726	+ $nodeKeyValue = $node->attr[$att_name];
727	+ }
728	+
729	+ if (is_object($debug_object)) {
730	+ $debug_object->debug_log(2,
731	+ 'testing node: '
732	+ . $node->tag
733	+ . ' for attribute: '
734	+ . $att_name
735	+ . $att_expr
736	+ . $att_val
737	+ . ' where nodes value is: '
738	+ . $nodeKeyValue
739	+ );
740	+ }
741	+
742	+ // If lowercase is set, do a case insensitive test of
743	+ // the value of the selector.
744	+ if ($lowercase) {
745	+ $check = $this->match(
746	+ $att_expr,
747	+ strtolower($att_val),
748	+ strtolower($nodeKeyValue),
749	+ $att_case_sensitivity
750	+ );
751	+ } else {
752	+ $check = $this->match(
753	+ $att_expr,
754	+ $att_val,
755	+ $nodeKeyValue,
756	+ $att_case_sensitivity
757	+ );
758	+ }
759	+
760	+ if (is_object($debug_object)) {
761	+ $debug_object->debug_log(2,
762	+ 'after match: '
763	+ . ($check ? 'true' : 'false')
764	+ );
765	+ }
766	+
767	+ if (!$check) {
768	+ $pass = false;
769	+ break;
770	+ }
771	+ }
772	+ }
773	+
774	+ // Found a match. Add to list and clear node
775	+ if ($pass) $ret[$node->_[HDOM_INFO_BEGIN]] = 1;
776	+ unset($node);
777	+ }
778	+ // It's passed by reference so this is actually what this function returns.
779	+ if (is_object($debug_object)) {
780	+ $debug_object->debug_log(1, 'EXIT - ret: ', $ret);
781	+ }
782	+ }
783	+
784	+ protected function match($exp, $pattern, $value, $case_sensitivity)
785	+ {
786	+ global $debug_object;
787	+ if (is_object($debug_object)) {$debug_object->debug_log_entry(1);}
788	+
789	+ if ($case_sensitivity === 'i') {
790	+ $pattern = strtolower($pattern);
791	+ $value = strtolower($value);
792	+ }
793	+
794	+ switch ($exp) {
795	+ case '=':
796	+ return ($value === $pattern);
797	+ case '!=':
798	+ return ($value !== $pattern);
799	+ case '^=':
800	+ return preg_match('/^' . preg_quote($pattern, '/') . '/', $value);
801	+ case '$=':
802	+ return preg_match('/' . preg_quote($pattern, '/') . '$/', $value);
803	+ case '*=':
804	+ return preg_match('/' . preg_quote($pattern, '/') . '/', $value);
805	+ case '\|=':
806	+ /**
807	+ * [att\|=val]
808	+ *
809	+ * Represents an element with the att attribute, its value
810	+ * either being exactly "val" or beginning with "val"
811	+ * immediately followed by "-" (U+002D).
812	+ */
813	+ return strpos($value, $pattern) === 0;
814	+ case '~=':
815	+ /**
816	+ * [att~=val]
817	+ *
818	+ * Represents an element with the att attribute whose value is a
819	+ * whitespace-separated list of words, one of which is exactly
820	+ * "val". If "val" contains whitespace, it will never represent
821	+ * anything (since the words are separated by spaces). Also if
822	+ * "val" is the empty string, it will never represent anything.
823	+ */
824	+ return in_array($pattern, explode(' ', trim($value)), true);
825	+ }
826	+ return false;
827	+ }
828	+
829	+ protected function parse_selector($selector_string)
830	+ {
831	+ global $debug_object;
832	+ if (is_object($debug_object)) { $debug_object->debug_log_entry(1); }
833	+
834	+ /**
835	+ * Pattern of CSS selectors, modified from mootools (https://mootools.net/)
836	+ *
837	+ * Paperg: Add the colon to the attribute, so that it properly finds
838	+ * <tag attr:ibute="something" > like google does.
839	+ *
840	+ * Note: if you try to look at this attribute, you MUST use getAttribute
841	+ * since $dom->x:y will fail the php syntax check.
842	+ *
843	+ * Notice the \[ starting the attribute? and the @? following? This
844	+ * implies that an attribute can begin with an @ sign that is not
845	+ * captured. This implies that an html attribute specifier may start
846	+ * with an @ sign that is NOT captured by the expression. Farther study
847	+ * is required to determine of this should be documented or removed.
848	+ *
849	+ * Matches selectors in this order:
850	+ *
851	+ * [0] - full match
852	+ *
853	+ * [1] - tag name
854	+ * ([\w:\-])
855	+ * Matches the tag name consisting of zero or more words, colons,
856	+ * asterisks and hyphens.
857	+ *
858	+ * [2] - id name
859	+ * (?:\#([\w-]+))
860	+ * Optionally matches a id name, consisting of an "#" followed by
861	+ * the id name (one or more words and hyphens).
862	+ *
863	+ * [3] - class names (including dots)
864	+ * (?:\.([\w\.-]+))?
865	+ * Optionally matches a list of classs, consisting of an "."
866	+ * followed by the class name (one or more words and hyphens)
867	+ * where multiple classes can be chained (i.e. ".foo.bar.baz")
868	+ *
869	+ * [4] - attributes
870	+ * ((?:\[@?(?:!?[\w:-]+)(?:(?:[!^$\|~]?=)[\"']?(?:.?)[\"']?)?(?:\s*?(?:[iIsS])?)?\])+)?
871	+ * Optionally matches the attributes list
872	+ *
873	+ * [5] - separator
874	+ * ([\/, >+~]+)
875	+ * Matches the selector list separator
876	+ */
877	+ // phpcs:ignore Generic.Files.LineLength
878	+ $pattern = "/([\w:\-])(?:\#([\w-]+))?(?:\|\.([\w\.-]+))?((?:\[@?(?:!?[\w:-]+)(?:(?:[!^$\|~]?=)[\"']?(?:.?)[\"']?)?(?:\s*?(?:[iIsS])?)?\])+)?([\/, >+~]+)/is";
879	+
880	+ preg_match_all(
881	+ $pattern,
882	+ trim($selector_string) . ' ', // Add final ' ' as pseudo separator
883	+ $matches,
884	+ PREG_SET_ORDER
885	+ );
886	+
887	+ if (is_object($debug_object)) {
888	+ $debug_object->debug_log(2, 'Matches Array: ', $matches);
889	+ }
890	+
891	+ $selectors = array();
892	+ $result = array();
893	+
894	+ foreach ($matches as $m) {
895	+ $m[0] = trim($m[0]);
896	+
897	+ // Skip NoOps
898	+ if ($m[0] === '' \|\| $m[0] === '/' \|\| $m[0] === '//') { continue; }
899	+
900	+ // Convert to lowercase
901	+ if ($this->dom->lowercase) {
902	+ $m[1] = strtolower($m[1]);
903	+ }
904	+
905	+ // Extract classes
906	+ if ($m[3] !== '') { $m[3] = explode('.', $m[3]); }
907	+
908	+ /* Extract attributes (pattern based on the pattern above!)
909	+
910	+ * [0] - full match
911	+ * [1] - attribute name
912	+ * [2] - attribute expression
913	+ * [3] - attribute value
914	+ * [4] - case sensitivity
915	+ *
916	+ * Note: Attributes can be negated with a "!" prefix to their name
917	+ */
918	+ if($m[4] !== '') {
919	+ preg_match_all(
920	+ "/\[@?(!?[\w:-]+)(?:([!^$\|~]?=)[\"']?(.?)[\"']?)?(?:\s+?([iIsS])?)?\]/is",
921	+ trim($m[4]),
922	+ $attributes,
923	+ PREG_SET_ORDER
924	+ );
925	+
926	+ // Replace element by array
927	+ $m[4] = array();
928	+
929	+ foreach($attributes as $att) {
930	+ // Skip empty matches
931	+ if(trim($att[0]) === '') { continue; }
932	+
933	+ $inverted = (isset($att[1][0]) && $att[1][0] === '!');
934	+ $m[4][] = array(
935	+ $inverted ? substr($att[1], 1) : $att[1], // Name
936	+ (isset($att[2])) ? $att[2] : '', // Expression
937	+ (isset($att[3])) ? $att[3] : '', // Value
938	+ $inverted, // Inverted Flag
939	+ (isset($att[4])) ? strtolower($att[4]) : '', // Case-Sensitivity
940	+ );
941	+ }
942	+ }
943	+
944	+ // Sanitize Separator
945	+ if ($m[5] !== '' && trim($m[5]) === '') { // Descendant Separator
946	+ $m[5] = ' ';
947	+ } else { // Other Separator
948	+ $m[5] = trim($m[5]);
949	+ }
950	+
951	+ // Clear Separator if it's a Selector List
952	+ if ($is_list = ($m[5] === ',')) { $m[5] = ''; }
953	+
954	+ // Remove full match before adding to results
955	+ array_shift($m);
956	+ $result[] = $m;
957	+
958	+ if ($is_list) { // Selector List
959	+ $selectors[] = $result;
960	+ $result = array();
961	+ }
962	+ }
963	+
964	+ if (count($result) > 0) { $selectors[] = $result; }
965	+ return $selectors;
966	+ }
967	+
968	+ function __get($name)
969	+ {
970	+ if (isset($this->attr[$name])) {
971	+ return $this->convert_text($this->attr[$name]);
972	+ }
973	+ switch ($name) {
974	+ case 'outertext': return $this->outertext();
975	+ case 'innertext': return $this->innertext();
976	+ case 'plaintext': return $this->text();
977	+ case 'xmltext': return $this->xmltext();
978	+ default: return array_key_exists($name, $this->attr);
979	+ }
980	+ }
981	+
982	+ function __set($name, $value)
983	+ {
984	+ global $debug_object;
985	+ if (is_object($debug_object)) { $debug_object->debug_log_entry(1); }
986	+
987	+ switch ($name) {
988	+ case 'outertext': return $this->_[HDOM_INFO_OUTER] = $value;
989	+ case 'innertext':
990	+ if (isset($this->_[HDOM_INFO_TEXT])) {
991	+ return $this->_[HDOM_INFO_TEXT] = $value;
992	+ }
993	+ return $this->_[HDOM_INFO_INNER] = $value;
994	+ }
995	+
996	+ if (!isset($this->attr[$name])) {
997	+ $this->_[HDOM_INFO_SPACE][] = array(' ', '', '');
998	+ $this->_[HDOM_INFO_QUOTE][] = HDOM_QUOTE_DOUBLE;
999	+ }
1000	+
1001	+ $this->attr[$name] = $value;
1002	+ }
1003	+
1004	+ function __isset($name)
1005	+ {
1006	+ switch ($name) {
1007	+ case 'outertext': return true;
1008	+ case 'innertext': return true;
1009	+ case 'plaintext': return true;
1010	+ }
1011	+ //no value attr: nowrap, checked selected...
1012	+ return (array_key_exists($name, $this->attr)) ? true : isset($this->attr[$name]);
1013	+ }
1014	+
1015	+ function __unset($name)
1016	+ {
1017	+ if (isset($this->attr[$name])) { unset($this->attr[$name]); }
1018	+ }
1019	+
1020	+ function convert_text($text)
1021	+ {
1022	+ global $debug_object;
1023	+ if (is_object($debug_object)) { $debug_object->debug_log_entry(1); }
1024	+
1025	+ $converted_text = $text;
1026	+
1027	+ $sourceCharset = '';
1028	+ $targetCharset = '';
1029	+
1030	+ if ($this->dom) {
1031	+ $sourceCharset = strtoupper($this->dom->_charset);
1032	+ $targetCharset = strtoupper($this->dom->_target_charset);
1033	+ }
1034	+
1035	+ if (is_object($debug_object)) {
1036	+ $debug_object->debug_log(3,
1037	+ 'source charset: '
1038	+ . $sourceCharset
1039	+ . ' target charaset: '
1040	+ . $targetCharset
1041	+ );
1042	+ }
1043	+
1044	+ if (!empty($sourceCharset)
1045	+ && !empty($targetCharset)
1046	+ && (strcasecmp($sourceCharset, $targetCharset) != 0)) {
1047	+ // Check if the reported encoding could have been incorrect and the text is actually already UTF-8
1048	+ if ((strcasecmp($targetCharset, 'UTF-8') == 0)
1049	+ && ($this->is_utf8($text))) {
1050	+ $converted_text = $text;
1051	+ } else {
1052	+ $converted_text = iconv($sourceCharset, $targetCharset, $text);
1053	+ }
1054	+ }
1055	+
1056	+ // Lets make sure that we don't have that silly BOM issue with any of the utf-8 text we output.
1057	+ if ($targetCharset === 'UTF-8') {
1058	+ if (substr($converted_text, 0, 3) === "\xef\xbb\xbf") {
1059	+ $converted_text = substr($converted_text, 3);
1060	+ }
1061	+
1062	+ if (substr($converted_text, -3) === "\xef\xbb\xbf") {
1063	+ $converted_text = substr($converted_text, 0, -3);
1064	+ }
1065	+ }
1066	+
1067	+ return $converted_text;
1068	+ }
1069	+
1070	+ static function is_utf8($str)
1071	+ {
1072	+ $c = 0; $b = 0;
1073	+ $bits = 0;
1074	+ $len = strlen($str);
1075	+ for($i = 0; $i < $len; $i++) {
1076	+ $c = ord($str[$i]);
1077	+ if($c > 128) {
1078	+ if(($c >= 254)) { return false; }
1079	+ elseif($c >= 252) { $bits = 6; }
1080	+ elseif($c >= 248) { $bits = 5; }
1081	+ elseif($c >= 240) { $bits = 4; }
1082	+ elseif($c >= 224) { $bits = 3; }
1083	+ elseif($c >= 192) { $bits = 2; }
1084	+ else { return false; }
1085	+ if(($i + $bits) > $len) { return false; }
1086	+ while($bits > 1) {
1087	+ $i++;
1088	+ $b = ord($str[$i]);
1089	+ if($b < 128 \|\| $b > 191) { return false; }
1090	+ $bits--;
1091	+ }
1092	+ }
1093	+ }
1094	+ return true;
1095	+ }
1096	+
1097	+ function get_display_size()
1098	+ {
1099	+ global $debug_object;
1100	+
1101	+ $width = -1;
1102	+ $height = -1;
1103	+
1104	+ if ($this->tag !== 'img') {
1105	+ return false;
1106	+ }
1107	+
1108	+ // See if there is aheight or width attribute in the tag itself.
1109	+ if (isset($this->attr['width'])) {
1110	+ $width = $this->attr['width'];
1111	+ }
1112	+
1113	+ if (isset($this->attr['height'])) {
1114	+ $height = $this->attr['height'];
1115	+ }
1116	+
1117	+ // Now look for an inline style.
1118	+ if (isset($this->attr['style'])) {
1119	+ // Thanks to user gnarf from stackoverflow for this regular expression.
1120	+ $attributes = array();
1121	+
1122	+ preg_match_all(
1123	+ '/([\w-]+)\s:\s([^;]+)\s*;?/',
1124	+ $this->attr['style'],
1125	+ $matches,
1126	+ PREG_SET_ORDER
1127	+ );
1128	+
1129	+ foreach ($matches as $match) {
1130	+ $attributes[$match[1]] = $match[2];
1131	+ }
1132	+
1133	+ // If there is a width in the style attributes:
1134	+ if (isset($attributes['width']) && $width == -1) {
1135	+ // check that the last two characters are px (pixels)
1136	+ if (strtolower(substr($attributes['width'], -2)) === 'px') {
1137	+ $proposed_width = substr($attributes['width'], 0, -2);
1138	+ // Now make sure that it's an integer and not something stupid.
1139	+ if (filter_var($proposed_width, FILTER_VALIDATE_INT)) {
1140	+ $width = $proposed_width;
1141	+ }
1142	+ }
1143	+ }
1144	+
1145	+ // If there is a width in the style attributes:
1146	+ if (isset($attributes['height']) && $height == -1) {
1147	+ // check that the last two characters are px (pixels)
1148	+ if (strtolower(substr($attributes['height'], -2)) == 'px') {
1149	+ $proposed_height = substr($attributes['height'], 0, -2);
1150	+ // Now make sure that it's an integer and not something stupid.
1151	+ if (filter_var($proposed_height, FILTER_VALIDATE_INT)) {
1152	+ $height = $proposed_height;
1153	+ }
1154	+ }
1155	+ }
1156	+
1157	+ }
1158	+
1159	+ // Future enhancement:
1160	+ // Look in the tag to see if there is a class or id specified that has
1161	+ // a height or width attribute to it.
1162	+
1163	+ // Far future enhancement
1164	+ // Look at all the parent tags of this image to see if they specify a
1165	+ // class or id that has an img selector that specifies a height or width
1166	+ // Note that in this case, the class or id will have the img subselector
1167	+ // for it to apply to the image.
1168	+
1169	+ // ridiculously far future development
1170	+ // If the class or id is specified in a SEPARATE css file thats not on
1171	+ // the page, go get it and do what we were just doing for the ones on
1172	+ // the page.
1173	+
1174	+ $result = array(
1175	+ 'height' => $height,
1176	+ 'width' => $width
1177	+ );
1178	+
1179	+ return $result;
1180	+ }
1181	+
1182	+ function save($filepath = '')
1183	+ {
1184	+ $ret = $this->outertext();
1185	+
1186	+ if ($filepath !== '') {
1187	+ file_put_contents($filepath, $ret, LOCK_EX);
1188	+ }
1189	+
1190	+ return $ret;
1191	+ }
1192	+
1193	+ function addClass($class)
1194	+ {
1195	+ if (is_string($class)) {
1196	+ $class = explode(' ', $class);
1197	+ }
1198	+
1199	+ if (is_array($class)) {
1200	+ foreach($class as $c) {
1201	+ if (isset($this->class)) {
1202	+ if ($this->hasClass($c)) {
1203	+ continue;
1204	+ } else {
1205	+ $this->class .= ' ' . $c;
1206	+ }
1207	+ } else {
1208	+ $this->class = $c;
1209	+ }
1210	+ }
1211	+ } else {
1212	+ if (is_object($debug_object)) {
1213	+ $debug_object->debug_log(2, 'Invalid type: ', gettype($class));
1214	+ }
1215	+ }
1216	+ }
1217	+
1218	+ function hasClass($class)
1219	+ {
1220	+ if (is_string($class)) {
1221	+ if (isset($this->class)) {
1222	+ return in_array($class, explode(' ', $this->class), true);
1223	+ }
1224	+ } else {
1225	+ if (is_object($debug_object)) {
1226	+ $debug_object->debug_log(2, 'Invalid type: ', gettype($class));
1227	+ }
1228	+ }
1229	+
1230	+ return false;
1231	+ }
1232	+
1233	+ function removeClass($class = null)
1234	+ {
1235	+ if (!isset($this->class)) {
1236	+ return;
1237	+ }
1238	+
1239	+ if (is_null($class)) {
1240	+ $this->removeAttribute('class');
1241	+ return;
1242	+ }
1243	+
1244	+ if (is_string($class)) {
1245	+ $class = explode(' ', $class);
1246	+ }
1247	+
1248	+ if (is_array($class)) {
1249	+ $class = array_diff(explode(' ', $this->class), $class);
1250	+ if (empty($class)) {
1251	+ $this->removeAttribute('class');
1252	+ } else {
1253	+ $this->class = implode(' ', $class);
1254	+ }
1255	+ }
1256	+ }
1257	+
1258	+ function getAllAttributes()
1259	+ {
1260	+ return $this->attr;
1261	+ }
1262	+
1263	+ function getAttribute($name)
1264	+ {
1265	+ return $this->__get($name);
1266	+ }
1267	+
1268	+ function setAttribute($name, $value)
1269	+ {
1270	+ $this->__set($name, $value);
1271	+ }
1272	+
1273	+ function hasAttribute($name)
1274	+ {
1275	+ return $this->__isset($name);
1276	+ }
1277	+
1278	+ function removeAttribute($name)
1279	+ {
1280	+ $this->__set($name, null);
1281	+ }
1282	+
1283	+ function remove()
1284	+ {
1285	+ if ($this->parent) {
1286	+ $this->parent->removeChild($this);
1287	+ }
1288	+ }
1289	+
1290	+ function removeChild($node)
1291	+ {
1292	+ $nidx = array_search($node, $this->nodes, true);
1293	+ $cidx = array_search($node, $this->children, true);
1294	+ $didx = array_search($node, $this->dom->nodes, true);
1295	+
1296	+ if ($nidx !== false && $cidx !== false && $didx !== false) {
1297	+
1298	+ foreach($node->children as $child) {
1299	+ $node->removeChild($child);
1300	+ }
1301	+
1302	+ foreach($node->nodes as $entity) {
1303	+ $enidx = array_search($entity, $node->nodes, true);
1304	+ $edidx = array_search($entity, $node->dom->nodes, true);
1305	+
1306	+ if ($enidx !== false && $edidx !== false) {
1307	+ unset($node->nodes[$enidx]);
1308	+ unset($node->dom->nodes[$edidx]);
1309	+ }
1310	+ }
1311	+
1312	+ unset($this->nodes[$nidx]);
1313	+ unset($this->children[$cidx]);
1314	+ unset($this->dom->nodes[$didx]);
1315	+
1316	+ $node->clear();
1317	+
1318	+ }
1319	+ }
1320	+
1321	+ function getElementById($id)
1322	+ {
1323	+ return $this->find("#$id", 0);
1324	+ }
1325	+
1326	+ function getElementsById($id, $idx = null)
1327	+ {
1328	+ return $this->find("#$id", $idx);
1329	+ }
1330	+
1331	+ function getElementByTagName($name)
1332	+ {
1333	+ return $this->find($name, 0);
1334	+ }
1335	+
1336	+ function getElementsByTagName($name, $idx = null)
1337	+ {
1338	+ return $this->find($name, $idx);
1339	+ }
1340	+
1341	+ function parentNode()
1342	+ {
1343	+ return $this->parent();
1344	+ }
1345	+
1346	+ function childNodes($idx = -1)
1347	+ {
1348	+ return $this->children($idx);
1349	+ }
1350	+
1351	+ function firstChild()
1352	+ {
1353	+ return $this->first_child();
1354	+ }
1355	+
1356	+ function lastChild()
1357	+ {
1358	+ return $this->last_child();
1359	+ }
1360	+
1361	+ function nextSibling()
1362	+ {
1363	+ return $this->next_sibling();
1364	+ }
1365	+
1366	+ function previousSibling()
1367	+ {
1368	+ return $this->prev_sibling();
1369	+ }
1370	+
1371	+ function hasChildNodes()
1372	+ {
1373	+ return $this->has_child();
1374	+ }
1375	+
1376	+ function nodeName()
1377	+ {
1378	+ return $this->tag;
1379	+ }
1380	+
1381	+ function appendChild($node)
1382	+ {
1383	+ $node->parent($this);
1384	+ return $node;
1385	+ }
1386	+
1387	+ }
1388	+
1389	+ class simple_html_dom
1390	+ {
1391	+ public $root = null;
1392	+ public $nodes = array();
1393	+ public $callback = null;
1394	+ public $lowercase = false;
1395	+ public $original_size;
1396	+ public $size;
1397	+
1398	+ protected $pos;
1399	+ protected $doc;
1400	+ protected $char;
1401	+
1402	+ protected $cursor;
1403	+ protected $parent;
1404	+ protected $noise = array();
1405	+ protected $token_blank = " \t\r\n";
1406	+ protected $token_equal = ' =/>';
1407	+ protected $token_slash = " />\r\n\t";
1408	+ protected $token_attr = ' >';
1409	+
1410	+ public $_charset = '';
1411	+ public $_target_charset = '';
1412	+
1413	+ protected $default_br_text = '';
1414	+
1415	+ public $default_span_text = '';
1416	+
1417	+ protected $self_closing_tags = array(
1418	+ 'area' => 1,
1419	+ 'base' => 1,
1420	+ 'br' => 1,
1421	+ 'col' => 1,
1422	+ 'embed' => 1,
1423	+ 'hr' => 1,
1424	+ 'img' => 1,
1425	+ 'input' => 1,
1426	+ 'link' => 1,
1427	+ 'meta' => 1,
1428	+ 'param' => 1,
1429	+ 'source' => 1,
1430	+ 'track' => 1,
1431	+ 'wbr' => 1
1432	+ );
1433	+ protected $block_tags = array(
1434	+ 'body' => 1,
1435	+ 'div' => 1,
1436	+ 'form' => 1,
1437	+ 'root' => 1,
1438	+ 'span' => 1,
1439	+ 'table' => 1
1440	+ );
1441	+ protected $optional_closing_tags = array(
1442	+ // Not optional, see
1443	+ // https://www.w3.org/TR/html/textlevel-semantics.html#the-b-element
1444	+ 'b' => array('b' => 1),
1445	+ 'dd' => array('dd' => 1, 'dt' => 1),
1446	+ // Not optional, see
1447	+ // https://www.w3.org/TR/html/grouping-content.html#the-dl-element
1448	+ 'dl' => array('dd' => 1, 'dt' => 1),
1449	+ 'dt' => array('dd' => 1, 'dt' => 1),
1450	+ 'li' => array('li' => 1),
1451	+ 'optgroup' => array('optgroup' => 1, 'option' => 1),
1452	+ 'option' => array('optgroup' => 1, 'option' => 1),
1453	+ 'p' => array('p' => 1),
1454	+ 'rp' => array('rp' => 1, 'rt' => 1),
1455	+ 'rt' => array('rp' => 1, 'rt' => 1),
1456	+ 'td' => array('td' => 1, 'th' => 1),
1457	+ 'th' => array('td' => 1, 'th' => 1),
1458	+ 'tr' => array('td' => 1, 'th' => 1, 'tr' => 1),
1459	+ );
1460	+
1461	+ function __construct(
1462	+ $str = null,
1463	+ $lowercase = true,
1464	+ $forceTagsClosed = true,
1465	+ $target_charset = DEFAULT_TARGET_CHARSET,
1466	+ $stripRN = true,
1467	+ $defaultBRText = DEFAULT_BR_TEXT,
1468	+ $defaultSpanText = DEFAULT_SPAN_TEXT,
1469	+ $options = 0)
1470	+ {
1471	+ if ($str) {
1472	+ if (preg_match('/^http:\/\//i', $str) \|\| is_file($str)) {
1473	+ $this->load_file($str);
1474	+ } else {
1475	+ $this->load(
1476	+ $str,
1477	+ $lowercase,
1478	+ $stripRN,
1479	+ $defaultBRText,
1480	+ $defaultSpanText,
1481	+ $options
1482	+ );
1483	+ }
1484	+ }
1485	+ // Forcing tags to be closed implies that we don't trust the html, but
1486	+ // it can lead to parsing errors if we SHOULD trust the html.
1487	+ if (!$forceTagsClosed) {
1488	+ $this->optional_closing_array = array();
1489	+ }
1490	+
1491	+ $this->_target_charset = $target_charset;
1492	+ }
1493	+
1494	+ function __destruct()
1495	+ {
1496	+ $this->clear();
1497	+ }
1498	+
1499	+ function load(
1500	+ $str,
1501	+ $lowercase = true,
1502	+ $stripRN = true,
1503	+ $defaultBRText = DEFAULT_BR_TEXT,
1504	+ $defaultSpanText = DEFAULT_SPAN_TEXT,
1505	+ $options = 0)
1506	+ {
1507	+ global $debug_object;
1508	+
1509	+ // prepare
1510	+ $this->prepare($str, $lowercase, $defaultBRText, $defaultSpanText);
1511	+
1512	+ // Per sourceforge http://sourceforge.net/tracker/?func=detail&aid=2949097&group_id=218559&atid=1044037
1513	+ // Script tags removal now preceeds style tag removal.
1514	+ // strip out <script> tags
1515	+ $this->remove_noise("'<\sscript[^>][^/]>(.?)<\s/\sscript\s>'is");
1516	+ $this->remove_noise("'<\sscript\s>(.?)<\s/\sscript\s>'is");
1517	+
1518	+ // strip out the \r \n's if we are told to.
1519	+ if ($stripRN) {
1520	+ $this->doc = str_replace("\r", ' ', $this->doc);
1521	+ $this->doc = str_replace("\n", ' ', $this->doc);
1522	+
1523	+ // set the length of content since we have changed it.
1524	+ $this->size = strlen($this->doc);
1525	+ }
1526	+
1527	+ // strip out cdata
1528	+ $this->remove_noise("'<!\[CDATA\[(.*?)\]\]>'is", true);
1529	+ // strip out comments
1530	+ $this->remove_noise("'<!--(.*?)-->'is");
1531	+ // strip out <style> tags
1532	+ $this->remove_noise("'<\sstyle[^>][^/]>(.?)<\s/\sstyle\s>'is");
1533	+ $this->remove_noise("'<\sstyle\s>(.?)<\s/\sstyle\s>'is");
1534	+ // strip out preformatted tags
1535	+ $this->remove_noise("'<\s(?:code)[^>]>(.?)<\s/\s(?:code)\s>'is");
1536	+ // strip out server side scripts
1537	+ $this->remove_noise("'(<\?)(.*?)(\?>)'s", true);
1538	+
1539	+ if($options & HDOM_SMARTY_AS_TEXT) { // Strip Smarty scripts
1540	+ $this->remove_noise("'(\{\w)(.*?)(\})'s", true);
1541	+ }
1542	+
1543	+ // parsing
1544	+ $this->parse();
1545	+ // end
1546	+ $this->root->_[HDOM_INFO_END] = $this->cursor;
1547	+ $this->parse_charset();
1548	+
1549	+ // make load function chainable
1550	+ return $this;
1551	+ }
1552	+
1553	+ function load_file()
1554	+ {
1555	+ $args = func_get_args();
1556	+
1557	+ if(($doc = call_user_func_array('file_get_contents', $args)) !== false) {
1558	+ $this->load($doc, true);
1559	+ } else {
1560	+ return false;
1561	+ }
1562	+ }
1563	+
1564	+ function set_callback($function_name)
1565	+ {
1566	+ $this->callback = $function_name;
1567	+ }
1568	+
1569	+ function remove_callback()
1570	+ {
1571	+ $this->callback = null;
1572	+ }
1573	+
1574	+ function save($filepath = '')
1575	+ {
1576	+ $ret = $this->root->innertext();
1577	+ if ($filepath !== '') { file_put_contents($filepath, $ret, LOCK_EX); }
1578	+ return $ret;
1579	+ }
1580	+
1581	+ function find($selector, $idx = null, $lowercase = false)
1582	+ {
1583	+ return $this->root->find($selector, $idx, $lowercase);
1584	+ }
1585	+
1586	+ function clear()
1587	+ {
1588	+ if (isset($this->nodes)) {
1589	+ foreach ($this->nodes as $n) {
1590	+ $n->clear();
1591	+ $n = null;
1592	+ }
1593	+ }
1594	+
1595	+ // This add next line is documented in the sourceforge repository.
1596	+ // 2977248 as a fix for ongoing memory leaks that occur even with the
1597	+ // use of clear.
1598	+ if (isset($this->children)) {
1599	+ foreach ($this->children as $n) {
1600	+ $n->clear();
1601	+ $n = null;
1602	+ }
1603	+ }
1604	+
1605	+ if (isset($this->parent)) {
1606	+ $this->parent->clear();
1607	+ unset($this->parent);
1608	+ }
1609	+
1610	+ if (isset($this->root)) {
1611	+ $this->root->clear();
1612	+ unset($this->root);
1613	+ }
1614	+
1615	+ unset($this->doc);
1616	+ unset($this->noise);
1617	+ }
1618	+
1619	+ function dump($show_attr = true)
1620	+ {
1621	+ $this->root->dump($show_attr);
1622	+ }
1623	+
1624	+ protected function prepare(
1625	+ $str, $lowercase = true,
1626	+ $defaultBRText = DEFAULT_BR_TEXT,
1627	+ $defaultSpanText = DEFAULT_SPAN_TEXT)
1628	+ {
1629	+ $this->clear();
1630	+
1631	+ $this->doc = trim($str);
1632	+ $this->size = strlen($this->doc);
1633	+ $this->original_size = $this->size; // original size of the html
1634	+ $this->pos = 0;
1635	+ $this->cursor = 1;
1636	+ $this->noise = array();
1637	+ $this->nodes = array();
1638	+ $this->lowercase = $lowercase;
1639	+ $this->default_br_text = $defaultBRText;
1640	+ $this->default_span_text = $defaultSpanText;
1641	+ $this->root = new simple_html_dom_node($this);
1642	+ $this->root->tag = 'root';
1643	+ $this->root->_[HDOM_INFO_BEGIN] = -1;
1644	+ $this->root->nodetype = HDOM_TYPE_ROOT;
1645	+ $this->parent = $this->root;
1646	+ if ($this->size > 0) { $this->char = $this->doc[0]; }
1647	+ }
1648	+
1649	+ protected function parse()
1650	+ {
1651	+ while (true) {
1652	+ // Read next tag if there is no text between current position and the
1653	+ // next opening tag.
1654	+ if (($s = $this->copy_until_char('<')) === '') {
1655	+ if($this->read_tag()) {
1656	+ continue;
1657	+ } else {
1658	+ return true;
1659	+ }
1660	+ }
1661	+
1662	+ // Add a text node for text between tags
1663	+ $node = new simple_html_dom_node($this);
1664	+ ++$this->cursor;
1665	+ $node->_[HDOM_INFO_TEXT] = $s;
1666	+ $this->link_nodes($node, false);
1667	+ }
1668	+ }
1669	+
1670	+ protected function parse_charset()
1671	+ {
1672	+ global $debug_object;
1673	+
1674	+ $charset = null;
1675	+
1676	+ if (function_exists('get_last_retrieve_url_contents_content_type')) {
1677	+ $contentTypeHeader = get_last_retrieve_url_contents_content_type();
1678	+ $success = preg_match('/charset=(.+)/', $contentTypeHeader, $matches);
1679	+ if ($success) {
1680	+ $charset = $matches[1];
1681	+ if (is_object($debug_object)) {
1682	+ $debug_object->debug_log(2,
1683	+ 'header content-type found charset of: '
1684	+ . $charset
1685	+ );
1686	+ }
1687	+ }
1688	+ }
1689	+
1690	+ if (empty($charset)) {
1691	+ // https://www.w3.org/TR/html/document-metadata.html#statedef-http-equiv-content-type
1692	+ $el = $this->root->find('meta[http-equiv=Content-Type]', 0, true);
1693	+
1694	+ if (!empty($el)) {
1695	+ $fullvalue = $el->content;
1696	+ if (is_object($debug_object)) {
1697	+ $debug_object->debug_log(2,
1698	+ 'meta content-type tag found'
1699	+ . $fullvalue
1700	+ );
1701	+ }
1702	+
1703	+ if (!empty($fullvalue)) {
1704	+ $success = preg_match(
1705	+ '/charset=(.+)/i',
1706	+ $fullvalue,
1707	+ $matches
1708	+ );
1709	+
1710	+ if ($success) {
1711	+ $charset = $matches[1];
1712	+ } else {
1713	+ // If there is a meta tag, and they don't specify the
1714	+ // character set, research says that it's typically
1715	+ // ISO-8859-1
1716	+ if (is_object($debug_object)) {
1717	+ $debug_object->debug_log(2,
1718	+ 'meta content-type tag couldn\'t be parsed. using iso-8859 default.'
1719	+ );
1720	+ }
1721	+
1722	+ $charset = 'ISO-8859-1';
1723	+ }
1724	+ }
1725	+ }
1726	+ }
1727	+
1728	+ if (empty($charset)) {
1729	+ // https://www.w3.org/TR/html/document-metadata.html#character-encoding-declaration
1730	+ if ($meta = $this->root->find('meta[charset]', 0)) {
1731	+ $charset = $meta->charset;
1732	+ if (is_object($debug_object)) {
1733	+ $debug_object->debug_log(2, 'meta charset: ' . $charset);
1734	+ }
1735	+ }
1736	+ }
1737	+
1738	+ if (empty($charset)) {
1739	+ // Try to guess the charset based on the content
1740	+ // Requires Multibyte String (mbstring) support (optional)
1741	+ if (function_exists('mb_detect_encoding')) {
1742	+ /**
1743	+ * mb_detect_encoding() is not intended to distinguish between
1744	+ * charsets, especially single-byte charsets. Its primary
1745	+ * purpose is to detect which multibyte encoding is in use,
1746	+ * i.e. UTF-8, UTF-16, shift-JIS, etc.
1747	+ *
1748	+ * -- https://bugs.php.net/bug.php?id=38138
1749	+ *
1750	+ * Adding both CP1251/ISO-8859-5 and CP1252/ISO-8859-1 will
1751	+ * always result in CP1251/ISO-8859-5 and vice versa.
1752	+ *
1753	+ * Thus, only detect if it's either UTF-8 or CP1252/ISO-8859-1
1754	+ * to stay compatible.
1755	+ */
1756	+ $encoding = mb_detect_encoding(
1757	+ $this->doc,
1758	+ array( 'UTF-8', 'CP1252', 'ISO-8859-1' )
1759	+ );
1760	+
1761	+ if ($encoding === 'CP1252' \|\| $encoding === 'ISO-8859-1') {
1762	+ // Due to a limitation of mb_detect_encoding
1763	+ // 'CP1251'/'ISO-8859-5' will be detected as
1764	+ // 'CP1252'/'ISO-8859-1'. This will cause iconv to fail, in
1765	+ // which case we can simply assume it is the other charset.
1766	+ if (!@iconv('CP1252', 'UTF-8', $this->doc)) {
1767	+ $encoding = 'CP1251';
1768	+ }
1769	+ }
1770	+
1771	+ if ($encoding !== false) {
1772	+ $charset = $encoding;
1773	+ if (is_object($debug_object)) {
1774	+ $debug_object->debug_log(2, 'mb_detect: ' . $charset);
1775	+ }
1776	+ }
1777	+ }
1778	+ }
1779	+
1780	+ if (empty($charset)) {
1781	+ // Assume it's UTF-8 as it is the most likely charset to be used
1782	+ $charset = 'UTF-8';
1783	+ if (is_object($debug_object)) {
1784	+ $debug_object->debug_log(2, 'No match found, assume ' . $charset);
1785	+ }
1786	+ }
1787	+
1788	+ // Since CP1252 is a superset, if we get one of it's subsets, we want
1789	+ // it instead.
1790	+ if ((strtolower($charset) == 'iso-8859-1')
1791	+ \|\| (strtolower($charset) == 'latin1')
1792	+ \|\| (strtolower($charset) == 'latin-1')) {
1793	+ $charset = 'CP1252';
1794	+ if (is_object($debug_object)) {
1795	+ $debug_object->debug_log(2,
1796	+ 'replacing ' . $charset . ' with CP1252 as its a superset'
1797	+ );
1798	+ }
1799	+ }
1800	+
1801	+ if (is_object($debug_object)) {
1802	+ $debug_object->debug_log(1, 'EXIT - ' . $charset);
1803	+ }
1804	+
1805	+ return $this->_charset = $charset;
1806	+ }
1807	+
1808	+ protected function read_tag()
1809	+ {
1810	+ // Set end position if no further tags found
1811	+ if ($this->char !== '<') {
1812	+ $this->root->_[HDOM_INFO_END] = $this->cursor;
1813	+ return false;
1814	+ }
1815	+
1816	+ $begin_tag_pos = $this->pos;
1817	+ $this->char = (++$this->pos < $this->size) ? $this->doc[$this->pos] : null; // next
1818	+
1819	+ // end tag
1820	+ if ($this->char === '/') {
1821	+ $this->char = (++$this->pos < $this->size) ? $this->doc[$this->pos] : null; // next
1822	+
1823	+ // Skip whitespace in end tags (i.e. in "</ html>")
1824	+ $this->skip($this->token_blank);
1825	+ $tag = $this->copy_until_char('>');
1826	+
1827	+ // Skip attributes in end tags
1828	+ if (($pos = strpos($tag, ' ')) !== false) {
1829	+ $tag = substr($tag, 0, $pos);
1830	+ }
1831	+
1832	+ $parent_lower = strtolower($this->parent->tag);
1833	+ $tag_lower = strtolower($tag);
1834	+
1835	+ // The end tag is supposed to close the parent tag. Handle situations
1836	+ // when it doesn't
1837	+ if ($parent_lower !== $tag_lower) {
1838	+ // Parent tag does not have to be closed necessarily (optional closing tag)
1839	+ // Current tag is a block tag, so it may close an ancestor
1840	+ if (isset($this->optional_closing_tags[$parent_lower])
1841	+ && isset($this->block_tags[$tag_lower])) {
1842	+
1843	+ $this->parent->_[HDOM_INFO_END] = 0;
1844	+ $org_parent = $this->parent;
1845	+
1846	+ // Traverse ancestors to find a matching opening tag
1847	+ // Stop at root node
1848	+ while (($this->parent->parent)
1849	+ && strtolower($this->parent->tag) !== $tag_lower
1850	+ ){
1851	+ $this->parent = $this->parent->parent;
1852	+ }
1853	+
1854	+ // If we don't have a match add current tag as text node
1855	+ if (strtolower($this->parent->tag) !== $tag_lower) {
1856	+ $this->parent = $org_parent; // restore origonal parent
1857	+
1858	+ if ($this->parent->parent) {
1859	+ $this->parent = $this->parent->parent;
1860	+ }
1861	+
1862	+ $this->parent->_[HDOM_INFO_END] = $this->cursor;
1863	+ return $this->as_text_node($tag);
1864	+ }
1865	+ } elseif (($this->parent->parent)
1866	+ && isset($this->block_tags[$tag_lower])
1867	+ ) {
1868	+ // Grandparent exists and current tag is a block tag, so our
1869	+ // parent doesn't have an end tag
1870	+ $this->parent->_[HDOM_INFO_END] = 0; // No end tag
1871	+ $org_parent = $this->parent;
1872	+
1873	+ // Traverse ancestors to find a matching opening tag
1874	+ // Stop at root node
1875	+ while (($this->parent->parent)
1876	+ && strtolower($this->parent->tag) !== $tag_lower
1877	+ ) {
1878	+ $this->parent = $this->parent->parent;
1879	+ }
1880	+
1881	+ // If we don't have a match add current tag as text node
1882	+ if (strtolower($this->parent->tag) !== $tag_lower) {
1883	+ $this->parent = $org_parent; // restore origonal parent
1884	+ $this->parent->_[HDOM_INFO_END] = $this->cursor;
1885	+ return $this->as_text_node($tag);
1886	+ }
1887	+ } elseif (($this->parent->parent)
1888	+ && strtolower($this->parent->parent->tag) === $tag_lower
1889	+ ) { // Grandparent exists and current tag closes it
1890	+ $this->parent->_[HDOM_INFO_END] = 0;
1891	+ $this->parent = $this->parent->parent;
1892	+ } else { // Random tag, add as text node
1893	+ return $this->as_text_node($tag);
1894	+ }
1895	+ }
1896	+
1897	+ // Set end position of parent tag to current cursor position
1898	+ $this->parent->_[HDOM_INFO_END] = $this->cursor;
1899	+
1900	+ if ($this->parent->parent) {
1901	+ $this->parent = $this->parent->parent;
1902	+ }
1903	+
1904	+ $this->char = (++$this->pos < $this->size) ? $this->doc[$this->pos] : null; // next
1905	+ return true;
1906	+ }
1907	+
1908	+ // start tag
1909	+ $node = new simple_html_dom_node($this);
1910	+ $node->_[HDOM_INFO_BEGIN] = $this->cursor;
1911	+ ++$this->cursor;
1912	+ $tag = $this->copy_until($this->token_slash); // Get tag name
1913	+ $node->tag_start = $begin_tag_pos;
1914	+
1915	+ // doctype, cdata & comments...
1916	+ // <!DOCTYPE html>
1917	+ // <![CDATA[ ... ]]>
1918	+ // <!-- Comment -->
1919	+ if (isset($tag[0]) && $tag[0] === '!') {
1920	+ $node->_[HDOM_INFO_TEXT] = '<' . $tag . $this->copy_until_char('>');
1921	+
1922	+ if (isset($tag[2]) && $tag[1] === '-' && $tag[2] === '-') { // Comment ("<!--")
1923	+ $node->nodetype = HDOM_TYPE_COMMENT;
1924	+ $node->tag = 'comment';
1925	+ } else { // Could be doctype or CDATA but we don't care
1926	+ $node->nodetype = HDOM_TYPE_UNKNOWN;
1927	+ $node->tag = 'unknown';
1928	+ }
1929	+
1930	+ if ($this->char === '>') { $node->_[HDOM_INFO_TEXT] .= '>'; }
1931	+
1932	+ $this->link_nodes($node, true);
1933	+ $this->char = (++$this->pos < $this->size) ? $this->doc[$this->pos] : null; // next
1934	+ return true;
1935	+ }
1936	+
1937	+ // The start tag cannot contain another start tag, if so add as text
1938	+ // i.e. "<<html>"
1939	+ if ($pos = strpos($tag, '<') !== false) {
1940	+ $tag = '<' . substr($tag, 0, -1);
1941	+ $node->_[HDOM_INFO_TEXT] = $tag;
1942	+ $this->link_nodes($node, false);
1943	+ $this->char = $this->doc[--$this->pos]; // prev
1944	+ return true;
1945	+ }
1946	+
1947	+ // Handle invalid tag names (i.e. "<html#doc>")
1948	+ if (!preg_match('/^\w[\w:-]*$/', $tag)) {
1949	+ $node->_[HDOM_INFO_TEXT] = '<' . $tag . $this->copy_until('<>');
1950	+
1951	+ // Next char is the beginning of a new tag, don't touch it.
1952	+ if ($this->char === '<') {
1953	+ $this->link_nodes($node, false);
1954	+ return true;
1955	+ }
1956	+
1957	+ // Next char closes current tag, add and be done with it.
1958	+ if ($this->char === '>') { $node->_[HDOM_INFO_TEXT] .= '>'; }
1959	+ $this->link_nodes($node, false);
1960	+ $this->char = (++$this->pos < $this->size) ? $this->doc[$this->pos] : null; // next
1961	+ return true;
1962	+ }
1963	+
1964	+ // begin tag, add new node
1965	+ $node->nodetype = HDOM_TYPE_ELEMENT;
1966	+ $tag_lower = strtolower($tag);
1967	+ $node->tag = ($this->lowercase) ? $tag_lower : $tag;
1968	+
1969	+ // handle optional closing tags
1970	+ if (isset($this->optional_closing_tags[$tag_lower])) {
1971	+ // Traverse ancestors to close all optional closing tags
1972	+ while (isset($this->optional_closing_tags[$tag_lower][strtolower($this->parent->tag)])) {
1973	+ $this->parent->_[HDOM_INFO_END] = 0;
1974	+ $this->parent = $this->parent->parent;
1975	+ }
1976	+ $node->parent = $this->parent;
1977	+ }
1978	+
1979	+ $guard = 0; // prevent infinity loop
1980	+
1981	+ // [0] Space between tag and first attribute
1982	+ $space = array($this->copy_skip($this->token_blank), '', '');
1983	+
1984	+ // attributes
1985	+ do {
1986	+ // Everything until the first equal sign should be the attribute name
1987	+ $name = $this->copy_until($this->token_equal);
1988	+
1989	+ if ($name === '' && $this->char !== null && $space[0] === '') {
1990	+ break;
1991	+ }
1992	+
1993	+ if ($guard === $this->pos) { // Escape infinite loop
1994	+ $this->char = (++$this->pos < $this->size) ? $this->doc[$this->pos] : null; // next
1995	+ continue;
1996	+ }
1997	+
1998	+ $guard = $this->pos;
1999	+
2000	+ // handle endless '<'
2001	+ // Out of bounds before the tag ended
2002	+ if ($this->pos >= $this->size - 1 && $this->char !== '>') {
2003	+ $node->nodetype = HDOM_TYPE_TEXT;
2004	+ $node->_[HDOM_INFO_END] = 0;
2005	+ $node->_[HDOM_INFO_TEXT] = '<' . $tag . $space[0] . $name;
2006	+ $node->tag = 'text';
2007	+ $this->link_nodes($node, false);
2008	+ return true;
2009	+ }
2010	+
2011	+ // handle mismatch '<'
2012	+ // Attributes cannot start after opening tag
2013	+ if ($this->doc[$this->pos - 1] == '<') {
2014	+ $node->nodetype = HDOM_TYPE_TEXT;
2015	+ $node->tag = 'text';
2016	+ $node->attr = array();
2017	+ $node->_[HDOM_INFO_END] = 0;
2018	+ $node->_[HDOM_INFO_TEXT] = substr(
2019	+ $this->doc,
2020	+ $begin_tag_pos,
2021	+ $this->pos - $begin_tag_pos - 1
2022	+ );
2023	+ $this->pos -= 2;
2024	+ $this->char = (++$this->pos < $this->size) ? $this->doc[$this->pos] : null; // next
2025	+ $this->link_nodes($node, false);
2026	+ return true;
2027	+ }
2028	+
2029	+ if ($name !== '/' && $name !== '') { // this is a attribute name
2030	+ // [1] Whitespace after attribute name
2031	+ $space[1] = $this->copy_skip($this->token_blank);
2032	+
2033	+ $name = $this->restore_noise($name); // might be a noisy name
2034	+
2035	+ if ($this->lowercase) { $name = strtolower($name); }
2036	+
2037	+ if ($this->char === '=') { // attribute with value
2038	+ $this->char = (++$this->pos < $this->size) ? $this->doc[$this->pos] : null; // next
2039	+ $this->parse_attr($node, $name, $space); // get attribute value
2040	+ } else {
2041	+ //no value attr: nowrap, checked selected...
2042	+ $node->_[HDOM_INFO_QUOTE][] = HDOM_QUOTE_NO;
2043	+ $node->attr[$name] = true;
2044	+ if ($this->char != '>') { $this->char = $this->doc[--$this->pos]; } // prev
2045	+ }
2046	+
2047	+ $node->_[HDOM_INFO_SPACE][] = $space;
2048	+
2049	+ // prepare for next attribute
2050	+ $space = array(
2051	+ $this->copy_skip($this->token_blank),
2052	+ '',
2053	+ ''
2054	+ );
2055	+ } else { // no more attributes
2056	+ break;
2057	+ }
2058	+ } while ($this->char !== '>' && $this->char !== '/'); // go until the tag ended
2059	+
2060	+ $this->link_nodes($node, true);
2061	+ $node->_[HDOM_INFO_ENDSPACE] = $space[0];
2062	+
2063	+ // handle empty tags (i.e. "<div/>")
2064	+ if ($this->copy_until_char('>') === '/') {
2065	+ $node->_[HDOM_INFO_ENDSPACE] .= '/';
2066	+ $node->_[HDOM_INFO_END] = 0;
2067	+ } else {
2068	+ // reset parent
2069	+ if (!isset($this->self_closing_tags[strtolower($node->tag)])) {
2070	+ $this->parent = $node;
2071	+ }
2072	+ }
2073	+
2074	+ $this->char = (++$this->pos < $this->size) ? $this->doc[$this->pos] : null; // next
2075	+
2076	+ // If it's a BR tag, we need to set it's text to the default text.
2077	+ // This way when we see it in plaintext, we can generate formatting that the user wants.
2078	+ // since a br tag never has sub nodes, this works well.
2079	+ if ($node->tag === 'br') {
2080	+ $node->_[HDOM_INFO_INNER] = $this->default_br_text;
2081	+ }
2082	+
2083	+ return true;
2084	+ }
2085	+
2086	+ protected function parse_attr($node, $name, &$space)
2087	+ {
2088	+ $is_duplicate = isset($node->attr[$name]);
2089	+
2090	+ if (!$is_duplicate) // Copy whitespace between "=" and value
2091	+ $space[2] = $this->copy_skip($this->token_blank);
2092	+
2093	+ switch ($this->char) {
2094	+ case '"':
2095	+ $quote_type = HDOM_QUOTE_DOUBLE;
2096	+ $this->char = (++$this->pos < $this->size) ? $this->doc[$this->pos] : null; // next
2097	+ $value = $this->copy_until_char('"');
2098	+ $this->char = (++$this->pos < $this->size) ? $this->doc[$this->pos] : null; // next
2099	+ break;
2100	+ case '\'':
2101	+ $quote_type = HDOM_QUOTE_SINGLE;
2102	+ $this->char = (++$this->pos < $this->size) ? $this->doc[$this->pos] : null; // next
2103	+ $value = $this->copy_until_char('\'');
2104	+ $this->char = (++$this->pos < $this->size) ? $this->doc[$this->pos] : null; // next
2105	+ break;
2106	+ default:
2107	+ $quote_type = HDOM_QUOTE_NO;
2108	+ $value = $this->copy_until($this->token_attr);
2109	+ }
2110	+
2111	+ $value = $this->restore_noise($value);
2112	+
2113	+ // PaperG: Attributes should not have \r or \n in them, that counts as
2114	+ // html whitespace.
2115	+ $value = str_replace("\r", '', $value);
2116	+ $value = str_replace("\n", '', $value);
2117	+
2118	+ // PaperG: If this is a "class" selector, lets get rid of the preceeding
2119	+ // and trailing space since some people leave it in the multi class case.
2120	+ if ($name === 'class') {
2121	+ $value = trim($value);
2122	+ }
2123	+
2124	+ if (!$is_duplicate) {
2125	+ $node->_[HDOM_INFO_QUOTE][] = $quote_type;
2126	+ $node->attr[$name] = $value;
2127	+ }
2128	+ }
2129	+
2130	+ protected function link_nodes(&$node, $is_child)
2131	+ {
2132	+ $node->parent = $this->parent;
2133	+ $this->parent->nodes[] = $node;
2134	+ if ($is_child) {
2135	+ $this->parent->children[] = $node;
2136	+ }
2137	+ }
2138	+
2139	+ protected function as_text_node($tag)
2140	+ {
2141	+ $node = new simple_html_dom_node($this);
2142	+ ++$this->cursor;
2143	+ $node->_[HDOM_INFO_TEXT] = '</' . $tag . '>';
2144	+ $this->link_nodes($node, false);
2145	+ $this->char = (++$this->pos < $this->size) ? $this->doc[$this->pos] : null; // next
2146	+ return true;
2147	+ }
2148	+
2149	+ protected function skip($chars)
2150	+ {
2151	+ $this->pos += strspn($this->doc, $chars, $this->pos);
2152	+ $this->char = ($this->pos < $this->size) ? $this->doc[$this->pos] : null; // next
2153	+ }
2154	+
2155	+ protected function copy_skip($chars)
2156	+ {
2157	+ $pos = $this->pos;
2158	+ $len = strspn($this->doc, $chars, $pos);
2159	+ $this->pos += $len;
2160	+ $this->char = ($this->pos < $this->size) ? $this->doc[$this->pos] : null; // next
2161	+ if ($len === 0) { return ''; }
2162	+ return substr($this->doc, $pos, $len);
2163	+ }
2164	+
2165	+ protected function copy_until($chars)
2166	+ {
2167	+ $pos = $this->pos;
2168	+ $len = strcspn($this->doc, $chars, $pos);
2169	+ $this->pos += $len;
2170	+ $this->char = ($this->pos < $this->size) ? $this->doc[$this->pos] : null; // next
2171	+ return substr($this->doc, $pos, $len);
2172	+ }
2173	+
2174	+ protected function copy_until_char($char)
2175	+ {
2176	+ if ($this->char === null) { return ''; }
2177	+
2178	+ if (($pos = strpos($this->doc, $char, $this->pos)) === false) {
2179	+ $ret = substr($this->doc, $this->pos, $this->size - $this->pos);
2180	+ $this->char = null;
2181	+ $this->pos = $this->size;
2182	+ return $ret;
2183	+ }
2184	+
2185	+ if ($pos === $this->pos) { return ''; }
2186	+
2187	+ $pos_old = $this->pos;
2188	+ $this->char = $this->doc[$pos];
2189	+ $this->pos = $pos;
2190	+ return substr($this->doc, $pos_old, $pos - $pos_old);
2191	+ }
2192	+
2193	+ protected function remove_noise($pattern, $remove_tag = false)
2194	+ {
2195	+ global $debug_object;
2196	+ if (is_object($debug_object)) { $debug_object->debug_log_entry(1); }
2197	+
2198	+ $count = preg_match_all(
2199	+ $pattern,
2200	+ $this->doc,
2201	+ $matches,
2202	+ PREG_SET_ORDER \| PREG_OFFSET_CAPTURE
2203	+ );
2204	+
2205	+ for ($i = $count - 1; $i > -1; --$i) {
2206	+ $key = '___noise___' . sprintf('% 5d', count($this->noise) + 1000);
2207	+
2208	+ if (is_object($debug_object)) {
2209	+ $debug_object->debug_log(2, 'key is: ' . $key);
2210	+ }
2211	+
2212	+ $idx = ($remove_tag) ? 0 : 1; // 0 = entire match, 1 = submatch
2213	+ $this->noise[$key] = $matches[$i][$idx][0];
2214	+ $this->doc = substr_replace($this->doc, $key, $matches[$i][$idx][1], strlen($matches[$i][$idx][0]));
2215	+ }
2216	+
2217	+ // reset the length of content
2218	+ $this->size = strlen($this->doc);
2219	+
2220	+ if ($this->size > 0) {
2221	+ $this->char = $this->doc[0];
2222	+ }
2223	+ }
2224	+
2225	+ function restore_noise($text)
2226	+ {
2227	+ global $debug_object;
2228	+ if (is_object($debug_object)) { $debug_object->debug_log_entry(1); }
2229	+
2230	+ while (($pos = strpos($text, '___noise___')) !== false) {
2231	+ // Sometimes there is a broken piece of markup, and we don't GET the
2232	+ // pos+11 etc... token which indicates a problem outside of us...
2233	+
2234	+ // todo: "___noise___1000" (or any number with four or more digits)
2235	+ // in the DOM causes an infinite loop which could be utilized by
2236	+ // malicious software
2237	+ if (strlen($text) > $pos + 15) {
2238	+ $key = '___noise___'
2239	+ . $text[$pos + 11]
2240	+ . $text[$pos + 12]
2241	+ . $text[$pos + 13]
2242	+ . $text[$pos + 14]
2243	+ . $text[$pos + 15];
2244	+
2245	+ if (is_object($debug_object)) {
2246	+ $debug_object->debug_log(2, 'located key of: ' . $key);
2247	+ }
2248	+
2249	+ if (isset($this->noise[$key])) {
2250	+ $text = substr($text, 0, $pos)
2251	+ . $this->noise[$key]
2252	+ . substr($text, $pos + 16);
2253	+ } else {
2254	+ // do this to prevent an infinite loop.
2255	+ $text = substr($text, 0, $pos)
2256	+ . 'UNDEFINED NOISE FOR KEY: '
2257	+ . $key
2258	+ . substr($text, $pos + 16);
2259	+ }
2260	+ } else {
2261	+ // There is no valid key being given back to us... We must get
2262	+ // rid of the ___noise___ or we will have a problem.
2263	+ $text = substr($text, 0, $pos)
2264	+ . 'NO NUMERIC NOISE KEY'
2265	+ . substr($text, $pos + 11);
2266	+ }
2267	+ }
2268	+ return $text;
2269	+ }
2270	+
2271	+ function search_noise($text)
2272	+ {
2273	+ global $debug_object;
2274	+ if (is_object($debug_object)) { $debug_object->debug_log_entry(1); }
2275	+
2276	+ foreach($this->noise as $noiseElement) {
2277	+ if (strpos($noiseElement, $text) !== false) {
2278	+ return $noiseElement;
2279	+ }
2280	+ }
2281	+ }
2282	+
2283	+ function __toString()
2284	+ {
2285	+ return $this->root->innertext();
2286	+ }
2287	+
2288	+ function __get($name)
2289	+ {
2290	+ switch ($name) {
2291	+ case 'outertext':
2292	+ return $this->root->innertext();
2293	+ case 'innertext':
2294	+ return $this->root->innertext();
2295	+ case 'plaintext':
2296	+ return $this->root->text();
2297	+ case 'charset':
2298	+ return $this->_charset;
2299	+ case 'target_charset':
2300	+ return $this->_target_charset;
2301	+ }
2302	+ }
2303	+
2304	+ function childNodes($idx = -1)
2305	+ {
2306	+ return $this->root->childNodes($idx);
2307	+ }
2308	+
2309	+ function firstChild()
2310	+ {
2311	+ return $this->root->first_child();
2312	+ }
2313	+
2314	+ function lastChild()
2315	+ {
2316	+ return $this->root->last_child();
2317	+ }
2318	+
2319	+ function createElement($name, $value = null)
2320	+ {
2321	+ return @str_get_html("<$name>$value</$name>")->firstChild();
2322	+ }
2323	+
2324	+ function createTextNode($value)
2325	+ {
2326	+ return @end(str_get_html($value)->nodes);
2327	+ }
2328	+
2329	+ function getElementById($id)
2330	+ {
2331	+ return $this->find("#$id", 0);
2332	+ }
2333	+
2334	+ function getElementsById($id, $idx = null)
2335	+ {
2336	+ return $this->find("#$id", $idx);
2337	+ }
2338	+
2339	+ function getElementByTagName($name)
2340	+ {
2341	+ return $this->find($name, 0);
2342	+ }
2343	+
2344	+ function getElementsByTagName($name, $idx = -1)
2345	+ {
2346	+ return $this->find($name, $idx);
2347	+ }
2348	+
2349	+ function loadFile()
2350	+ {
2351	+ $args = func_get_args();
2352	+ $this->load_file($args);
2353	+ }
2354	+ }

classes/maxCSSParser.php CHANGED Viewed

	@@ -55,7 +55,8 @@ class maxCSSParser
55	{
56	$this->domObj = $domObj;
57
58	- $root = $domObj->~~find(0,0)~~;

59	$struct[$root->tag] = array();
60
61	$children = $root->children();
	@@ -152,14 +153,14 @@ class maxCSSParser
152
153	public function compile($css)
154	{
155	- $scss = new \~~Leafo~~\ScssPhp\Compiler();
156	$scss->setImportPaths(MB()->get_plugin_path() . "assets/scss");
157
158	$minify = get_option("maxbuttons_minify", 1);
159
160	if ($minify == 1)
161	{
162	- $scss->setFormatter('\~~Leafo~~\ScssPhp\Formatter\Crunched');
163	}
164
165	$compile = " @import '_mixins.scss'; " . $css;
	@@ -595,13 +596,12 @@ class maxCSSParser
595	return $values;
596	}
597
598	- function outputInline($domObj, $pseudo = 'normal')
599	{
600	$domObj = $domObj->load($domObj->save());
601
602	$inline = $this->inline;
603
604	-
605	// ISSUE #43 Sometimes this breaks
606	if (! isset($inline[$pseudo]))
607	return $domObj;
	@@ -610,20 +610,24 @@ class maxCSSParser
610	if ($pseudo != 'normal') // gather all elements
611	$elements = array_merge($elements, array_keys($inline["normal"]));
612
613	- foreach($elements as $element )
614	{
615	$styles = isset($inline[$pseudo][$element]) ? $inline[$pseudo][$element] : '';
616	-
617	- if ($pseudo != 'normal') // parse all possible missing styles from pseudo el.
618	- $normstyle = $this->compile($inline['normal'][$element]);
619	-
620	$normstyle = '';
621	- if ($pseudo != 'normal') // parse all possible missing styles from pseudo el.
622	- $normstyle = $this->compile($inline['normal'][$element]);
623






624	maxUtils::addTime("CSSParser: Parse inline done");
625
626	- $styles = ~~$normstyle~~ . $this~~->compile($styles);~~




627
628	$element = trim(str_replace("."," ", $element)); // molten css class, seperator.
629
	@@ -637,6 +641,21 @@ class maxCSSParser
637
638	}
639















640
641	}
642


55	{
56	$this->domObj = $domObj;
57
58	+ $root = $domObj->root;
59	+
60	$struct[$root->tag] = array();
61
62	$children = $root->children();

153
154	public function compile($css)
155	{
156	+ $scss = new \ScssPhp\ScssPhp\Compiler();
157	$scss->setImportPaths(MB()->get_plugin_path() . "assets/scss");
158
159	$minify = get_option("maxbuttons_minify", 1);
160
161	if ($minify == 1)
162	{
163	+ $scss->setFormatter('\ScssPhp\ScssPhp\Formatter\Crunched');
164	}
165
166	$compile = " @import '_mixins.scss'; " . $css;

596	return $values;
597	}
598
599	+ public function outputInline($domObj, $pseudo = 'normal')
600	{
601	$domObj = $domObj->load($domObj->save());
602
603	$inline = $this->inline;
604

605	// ISSUE #43 Sometimes this breaks
606	if (! isset($inline[$pseudo]))
607	return $domObj;

610	if ($pseudo != 'normal') // gather all elements
611	$elements = array_merge($elements, array_keys($inline["normal"]));
612
613	+ foreach($elements as $element)
614	{
615	$styles = isset($inline[$pseudo][$element]) ? $inline[$pseudo][$element] : '';




616	$normstyle = '';


617
618	+ if ($pseudo != 'normal') // parse all possible missing styles from pseudo el
619	+ {
620	+ $tocompile = $this->dummify($inline['normal'][$element]);
621	+ $normstyle = $this->compile($tocompile);
622	+ $normstyle = $this->undummify($normstyle);
623	+ }
624	maxUtils::addTime("CSSParser: Parse inline done");
625
626	+ // add dummy {} here because new scssphp parse doesn't like styles without it. Remove it after compile, since this is inline.
627	+ $styles = $this->compile($this->dummify($normstyle . $styles));
628	+ $styles = $this->undummify($styles);
629	+
630	+ //$styles = $normstyle . $styles;
631
632	$element = trim(str_replace("."," ", $element)); // molten css class, seperator.
633

641
642	}
643
644	+ /** Dummyfi, because Scssphp compiler doesn't like CSS without {} */
645	+ private function dummify($string)
646	+ {
647	+ return 'dummy{' . $string . '}';
648	+ }
649	+
650	+ private function undummify($string)
651	+ {
652	+ $string = trim(str_replace(array('dummy','{','}'),'', $string)); // remove the dummy
653	+ if (substr($string,-1) !== ';') // the last ; might not be there, put it so we can glue more CSS there.
654	+ $string .= ';';
655	+
656	+ return $string;
657	+ }
658	+
659
660	}
661

classes/maxbuttons-admin-helper.php CHANGED Viewed

	@@ -34,8 +34,8 @@ class maxAdmin
34	{
35	self::$tabs = array(
36	"list" => array("name" => __('Buttons', 'maxbuttons'),
37	- "link" => "page=maxbuttons-~~list~~",
38	- "active" => "maxbuttons-~~list~~", ),
39	"pro" => array( "name" => __('Upgrade to Pro', 'maxbuttons'),
40	"link" => "page=maxbuttons-pro",
41	"active" => "maxbuttons-pro",


34	{
35	self::$tabs = array(
36	"list" => array("name" => __('Buttons', 'maxbuttons'),
37	+ "link" => "page=maxbuttons-controller",
38	+ "active" => "maxbuttons-controller", ),
39	"pro" => array( "name" => __('Upgrade to Pro', 'maxbuttons'),
40	"link" => "page=maxbuttons-pro",
41	"active" => "maxbuttons-pro",

classes/maxbuttons-class.php CHANGED Viewed

	@@ -402,15 +402,7 @@ class maxButtonsPlugin
402
403	if ($libname == 'scss')
404	{
405	- // external libraries
406	- if ( version_compare(PHP_VERSION, '5.4', '<' ) )
407	- {
408	- require_once($this->get_plugin_path() . "assets/libraries/scssphp_legacy/scss.inc.php");
409	- }
410	- else
411	- {
412	require_once($this->get_plugin_path() . "assets/libraries/scssphp/scss.inc.php");
413	- }
414	}
415
416	if ($libname == 'simple_template')


402
403	if ($libname == 'scss')
404	{







405	require_once($this->get_plugin_path() . "assets/libraries/scssphp/scss.inc.php");

406	}
407
408	if ($libname == 'simple_template')

maxbuttons.php CHANGED Viewed

	@@ -3,7 +3,7 @@
3	Plugin Name: MaxButtons
4	Plugin URI: http://maxbuttons.com
5	Description: The best WordPress button generator. This is the free version; the Pro version <a href="http://maxbuttons.com/?ref=mbfree">can be found here</a>.
6	- Version: 7.13.3
7	Author: Max Foundry
8	Author URI: http://maxfoundry.com
9	Text Domain: maxbuttons
	@@ -16,9 +16,9 @@ namespace MaxButtons;
16	if (! defined('MAXBUTTONS_ROOT_FILE'))
17	define("MAXBUTTONS_ROOT_FILE", __FILE__);
18	if (! defined('MAXBUTTONS_VERSION_NUM'))
19	- define('MAXBUTTONS_VERSION_NUM', '7.13.3');
20
21	- define('MAXBUTTONS_RELEASE',"11 ~~November~~ ~~2019~~");
22
23	if (! function_exists('MaxButtons\maxbutton_double_load'))
24	{
	@@ -42,23 +42,6 @@ if (function_exists("MaxButtons\MB"))
42
43	require_once( trailingslashit(dirname(MAXBUTTONS_ROOT_FILE)) . "classes/maxbuttons-class.php");
44
45	- /*
46	-
47	- // external libraries
48	- if ( version_compare(PHP_VERSION, '5.4', '<' ) )
49	- {
50	- require_once("assets/libraries/scssphp_legacy/scss.inc.php");
51	- }
52	- else
53	- {
54	- require_once("assets/libraries/scssphp/scss.inc.php");
55	- }
56	- require_once("assets/libraries/simple-template/simple_template.php");
57	-
58	- if (! class_exists('simple_html_dom_node'))
59	- require_once("assets/libraries/simplehtmldom/simple_html_dom.php");
60	- */
61	-
62	// runtime.
63	if (! function_exists("MaxButtons\MB")) {
64	function MB()


3	Plugin Name: MaxButtons
4	Plugin URI: http://maxbuttons.com
5	Description: The best WordPress button generator. This is the free version; the Pro version <a href="http://maxbuttons.com/?ref=mbfree">can be found here</a>.
6	+ Version: 7.13.4
7	Author: Max Foundry
8	Author URI: http://maxfoundry.com
9	Text Domain: maxbuttons

16	if (! defined('MAXBUTTONS_ROOT_FILE'))
17	define("MAXBUTTONS_ROOT_FILE", __FILE__);
18	if (! defined('MAXBUTTONS_VERSION_NUM'))
19	+ define('MAXBUTTONS_VERSION_NUM', '7.13.4');
20
21	+ define('MAXBUTTONS_RELEASE',"8 February 2020");
22
23	if (! function_exists('MaxButtons\maxbutton_double_load'))
24	{

42
43	require_once( trailingslashit(dirname(MAXBUTTONS_ROOT_FILE)) . "classes/maxbuttons-class.php");
44

















45	// runtime.
46	if (! function_exists("MaxButtons\MB")) {
47	function MB()

readme.txt CHANGED Viewed

	@@ -4,7 +4,7 @@ Tags: wordpress button plugin, share button, wordpress buttons, css3 button gene
4	Requires at least: 4.8
5	Tested up to: 5.3
6	Requires PHP: 5.6
7	- Stable tag: 7.13.3
8
9	WordPress button plugin so powerful and easy to use anyone can create beautiful buttons, share buttons and social icons.
10
	@@ -255,6 +255,12 @@ Secondly, please use latin only characters for button name ( Basic settings) and
255
256	== Changelog ==
257






258	= 7.13.3 =
259
260	* Fixed - relative require_once include, sometimes this crashes.


4	Requires at least: 4.8
5	Tested up to: 5.3
6	Requires PHP: 5.6
7	+ Stable tag: 7.13.4
8
9	WordPress button plugin so powerful and easy to use anyone can create beautiful buttons, share buttons and social icons.
10

255
256	== Changelog ==
257
258	+ = 7.13.4 =
259	+
260	+ * Updated ScssPhp to 1.0.7
261	+ * Updated SimpleHTMLDom to 1.9.1
262	+ * Fixed Buttons menu tab
263	+
264	= 7.13.3 =
265
266	* Fixed - relative require_once include, sometimes this crashes.

WordPress Button Plugin MaxButtons - Version 7.13.4

Version Description

Release Info

Code changes from version 7.13.3 to 7.13.4