sendwp / vendor / scssphp / scssphp / src / Parser.php

Parser.php in SendWP 1.4.4, at vendor/scssphp/scssphp/src/Parser.php

4,206 lines 112.1 KB

Raw Download Zip

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