Proyectos de Subversion Moodle

<?php

/**

 * SCSSPHP

 *

 * @copyright 2012-2020 Leaf Corcoran

 *

 * @license http://opensource.org/licenses/MIT MIT

 *

 * @link http://scssphp.github.io/scssphp

 */

namespace ScssPhp\ScssPhp;

use ScssPhp\ScssPhp\Block\AtRootBlock;

use ScssPhp\ScssPhp\Block\CallableBlock;

use ScssPhp\ScssPhp\Block\ContentBlock;

use ScssPhp\ScssPhp\Block\DirectiveBlock;

use ScssPhp\ScssPhp\Block\EachBlock;

use ScssPhp\ScssPhp\Block\ElseBlock;

use ScssPhp\ScssPhp\Block\ElseifBlock;

use ScssPhp\ScssPhp\Block\ForBlock;

use ScssPhp\ScssPhp\Block\IfBlock;

use ScssPhp\ScssPhp\Block\MediaBlock;

use ScssPhp\ScssPhp\Block\NestedPropertyBlock;

use ScssPhp\ScssPhp\Block\WhileBlock;

use ScssPhp\ScssPhp\Exception\ParserException;

use ScssPhp\ScssPhp\Logger\LoggerInterface;

use ScssPhp\ScssPhp\Logger\QuietLogger;

use ScssPhp\ScssPhp\Node\Number;

/**

 * Parser

 *

 * @author Leaf Corcoran <leafot@gmail.com>

 *

 * @internal

 */

class Parser

{

    const SOURCE_INDEX  = -1;

    const SOURCE_LINE   = -2;

    const SOURCE_COLUMN = -3;

    /**

     * @var array<string, int>

     */

    protected static $precedence = [

        '='   => 0,

        'or'  => 1,

        'and' => 2,

        '=='  => 3,

        '!='  => 3,

        '<='  => 4,

        '>='  => 4,

        '<'   => 4,

        '>'   => 4,

        '+'   => 5,

        '-'   => 5,

        '*'   => 6,

        '/'   => 6,

        '%'   => 6,

    ];

    /**

     * @var string

     */

    protected static $commentPattern;

    /**

     * @var string

     */

    protected static $operatorPattern;

    /**

     * @var string

     */

    protected static $whitePattern;

    /**

     * @var Cache|null

     */

    protected $cache;

    private $sourceName;

    private $sourceIndex;

    /**

     * @var array<int, int>

     */

    private $sourcePositions;

    /**

     * The current offset in the buffer

     *

     * @var int

     */

    private $count;

    /**

     * @var Block|null

     */

    private $env;

    /**

     * @var bool

     */

    private $inParens;

    /**

     * @var bool

     */

    private $eatWhiteDefault;

    /**

     * @var bool

     */

    private $discardComments;

    private $allowVars;

    /**

     * @var string

     */

    private $buffer;

    private $utf8;

    /**

     * @var string|null

     */

    private $encoding;

    private $patternModifiers;

    private $commentsSeen;

    private $cssOnly;

    /**

     * @var LoggerInterface

     */

    private $logger;

    /**

     * Constructor

     *

     * @api

     *

     * @param string|null          $sourceName

     * @param int                  $sourceIndex

     * @param string|null          $encoding

     * @param Cache|null           $cache

     * @param bool                 $cssOnly

     * @param LoggerInterface|null $logger

     */

    public function __construct($sourceName, $sourceIndex = 0, $encoding = 'utf-8', Cache $cache = null, $cssOnly = false, LoggerInterface $logger = null)

    {

        $this->sourceName       = $sourceName ?: '(stdin)';

        $this->sourceIndex      = $sourceIndex;

        $this->utf8             = ! $encoding || strtolower($encoding) === 'utf-8';

        $this->patternModifiers = $this->utf8 ? 'Aisu' : 'Ais';

        $this->commentsSeen     = [];

        $this->allowVars        = true;

        $this->cssOnly          = $cssOnly;

        $this->logger = $logger ?: new QuietLogger();

        if (empty(static::$operatorPattern)) {

            static::$operatorPattern = '([*\/%+-]|[!=]\=|\>\=?|\<\=?|and|or)';

            $commentSingle      = '\/\/';

            $commentMultiLeft   = '\/\*';

            $commentMultiRight  = '\*\/';

            static::$commentPattern = $commentMultiLeft . '.*?' . $commentMultiRight;

            static::$whitePattern = $this->utf8

                ? '/' . $commentSingle . '[^\n]*\s*|(' . static::$commentPattern . ')\s*|\s+/AisuS'

                : '/' . $commentSingle . '[^\n]*\s*|(' . static::$commentPattern . ')\s*|\s+/AisS';

        }

        $this->cache = $cache;

    }

    /**

     * Get source file name

     *

     * @api

     *

     * @return string

     */

    public function getSourceName()

    {

        return $this->sourceName;

    }

    /**

     * Throw parser error

     *

     * @api

     *

     * @param string $msg

     *

     * @phpstan-return never-return

     *

     * @throws ParserException

     *

     * @deprecated use "parseError" and throw the exception in the caller instead.

     */

    public function throwParseError($msg = 'parse error')

    {

        @trigger_error(

            'The method "throwParseError" is deprecated. Use "parseError" and throw the exception in the caller instead',

            E_USER_DEPRECATED

        );

        throw $this->parseError($msg);

    }

    /**

     * Creates a parser error

     *

     * @api

     *

     * @param string $msg

     *

     * @return ParserException

     */

    public function parseError($msg = 'parse error')

    {

        list($line, $column) = $this->getSourcePosition($this->count);

        $loc = empty($this->sourceName)

             ? "line: $line, column: $column"

             : "$this->sourceName on line $line, at column $column";

        if ($this->peek('(.*?)(\n|$)', $m, $this->count)) {

            $this->restoreEncoding();

            $e = new ParserException("$msg: failed at `$m[1]` $loc");

            $e->setSourcePosition([$this->sourceName, $line, $column]);

            return $e;

        }

        $this->restoreEncoding();

        $e = new ParserException("$msg: $loc");

        $e->setSourcePosition([$this->sourceName, $line, $column]);

        return $e;

    }

    /**

     * Parser buffer

     *

     * @api

     *

     * @param string $buffer

     *

     * @return Block

     */

    public function parse($buffer)

    {

        if ($this->cache) {

            $cacheKey = $this->sourceName . ':' . md5($buffer);

            $parseOptions = [

                'utf8' => $this->utf8,

            ];

            $v = $this->cache->getCache('parse', $cacheKey, $parseOptions);

            if (! \is_null($v)) {

                return $v;

            }

        }

        // strip BOM (byte order marker)

        if (substr($buffer, 0, 3) === "\xef\xbb\xbf") {

            $buffer = substr($buffer, 3);

        }

        $this->buffer          = rtrim($buffer, "\x00..\x1f");

        $this->count           = 0;

        $this->env             = null;

        $this->inParens        = false;

        $this->eatWhiteDefault = true;

        $this->saveEncoding();

        $this->extractLineNumbers($buffer);

        if ($this->utf8 && !preg_match('//u', $buffer)) {

            $message = $this->sourceName ? 'Invalid UTF-8 file: ' . $this->sourceName : 'Invalid UTF-8 file';

            throw new ParserException($message);

        }

        $this->pushBlock(null); // root block

        $this->whitespace();

        $this->pushBlock(null);

        $this->popBlock();

        while ($this->parseChunk()) {

            ;

        }

        if ($this->count !== \strlen($this->buffer)) {

            throw $this->parseError();

        }

        if (! empty($this->env->parent)) {

            throw $this->parseError('unclosed block');

        }

        $this->restoreEncoding();

        assert($this->env !== null);

        if ($this->cache) {

            $this->cache->setCache('parse', $cacheKey, $this->env, $parseOptions);

        }

        return $this->env;

    }

    /**

     * Parse a value or value list

     *

     * @api

     *

     * @param string       $buffer

     * @param string|array $out

     *

     * @return bool

     */

    public function parseValue($buffer, &$out)

    {

        $this->count           = 0;

        $this->env             = null;

        $this->inParens        = false;

        $this->eatWhiteDefault = true;

        $this->buffer          = (string) $buffer;

        $this->saveEncoding();

        $this->extractLineNumbers($this->buffer);

        $list = $this->valueList($out);

        if ($this->count !== \strlen($this->buffer)) {

            $error = $this->parseError('Expected end of value');

            $message = 'Passing trailing content after the expression when parsing a value is deprecated since Scssphp 1.12.0 and will be an error in 2.0. ' . $error->getMessage();

            @trigger_error($message, E_USER_DEPRECATED);

        }

        $this->restoreEncoding();

        return $list;

    }

    /**

     * Parse a selector or selector list

     *

     * @api

     *

     * @param string       $buffer

     * @param string|array $out

     * @param bool         $shouldValidate

     *

     * @return bool

     */

    public function parseSelector($buffer, &$out, $shouldValidate = true)

    {

        $this->count           = 0;

        $this->env             = null;

        $this->inParens        = false;

        $this->eatWhiteDefault = true;

        $this->buffer          = (string) $buffer;

        $this->saveEncoding();

        $this->extractLineNumbers($this->buffer);

        // discard space/comments at the start

        $this->discardComments = true;

        $this->whitespace();

        $this->discardComments = false;

        $selector = $this->selectors($out);

        $this->restoreEncoding();

        if ($shouldValidate && $this->count !== strlen($buffer)) {

            throw $this->parseError("`" . substr($buffer, $this->count) . "` is not a valid Selector in `$buffer`");

        }

        return $selector;

    }

    /**

     * Parse a media Query

     *

     * @api

     *

     * @param string $buffer

     * @param array  $out

     *

     * @return bool

     */

    public function parseMediaQueryList($buffer, &$out)

    {

        $this->count           = 0;

        $this->env             = null;

        $this->inParens        = false;

        $this->eatWhiteDefault = true;

        $this->buffer          = (string) $buffer;

        $this->discardComments = true;

        $this->saveEncoding();

        $this->extractLineNumbers($this->buffer);

        $this->whitespace();

        $isMediaQuery = $this->mediaQueryList($out);

        $this->restoreEncoding();

        return $isMediaQuery;

    }

    /**

     * Parse a single chunk off the head of the buffer and append it to the

     * current parse environment.

     *

     * Returns false when the buffer is empty, or when there is an error.

     *

     * This function is called repeatedly until the entire document is

     * parsed.

     *

     * This parser is most similar to a recursive descent parser. Single

     * functions represent discrete grammatical rules for the language, and

     * they are able to capture the text that represents those rules.

     *

     * Consider the function Compiler::keyword(). (All parse functions are

     * structured the same.)

     *

     * The function takes a single reference argument. When calling the

     * function it will attempt to match a keyword on the head of the buffer.

     * If it is successful, it will place the keyword in the referenced

     * argument, advance the position in the buffer, and return true. If it

     * fails then it won't advance the buffer and it will return false.

     *

     * All of these parse functions are powered by Compiler::match(), which behaves

     * the same way, but takes a literal regular expression. Sometimes it is

     * more convenient to use match instead of creating a new function.

     *

     * Because of the format of the functions, to parse an entire string of

     * grammatical rules, you can chain them together using &&.

     *

     * But, if some of the rules in the chain succeed before one fails, then

     * the buffer position will be left at an invalid state. In order to

     * avoid this, Compiler::seek() is used to remember and set buffer positions.

     *

     * Before parsing a chain, use $s = $this->count to remember the current

     * position into $s. Then if a chain fails, use $this->seek($s) to

     * go back where we started.

     *

     * @return bool

     */

    protected function parseChunk()

    {

        $s = $this->count;

        // the directives

        if (isset($this->buffer[$this->count]) && $this->buffer[$this->count] === '@') {

            if (

                $this->literal('@at-root', 8) &&

                ($this->selectors($selector) || true) &&

                ($this->map($with) || true) &&

                (($this->matchChar('(') &&

                    $this->interpolation($with) &&

                    $this->matchChar(')')) || true) &&

                $this->matchChar('{', false)

            ) {

                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);

                $atRoot = new AtRootBlock();

                $this->registerPushedBlock($atRoot, $s);

                $atRoot->selector = $selector;

                $atRoot->with     = $with;

                return true;

            }

            $this->seek($s);

            if (

                $this->literal('@media', 6) &&

                $this->mediaQueryList($mediaQueryList) &&

                $this->matchChar('{', false)

            ) {

                $media = new MediaBlock();

                $this->registerPushedBlock($media, $s);

                $media->queryList = $mediaQueryList[2];

                return true;

            }

            $this->seek($s);

            if (

                $this->literal('@mixin', 6) &&

                $this->keyword($mixinName) &&

                ($this->argumentDef($args) || true) &&

                $this->matchChar('{', false)

            ) {

                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);

                $mixin = new CallableBlock(Type::T_MIXIN);

                $this->registerPushedBlock($mixin, $s);

                $mixin->name = $mixinName;

                $mixin->args = $args;

                return true;

            }

            $this->seek($s);

            if (

                ($this->literal('@include', 8) &&

                    $this->keyword($mixinName) &&

                    ($this->matchChar('(') &&

                    ($this->argValues($argValues) || true) &&

                    $this->matchChar(')') || true) &&

                    ($this->end()) ||

                ($this->literal('using', 5) &&

                    $this->argumentDef($argUsing) &&

                    ($this->end() || $this->matchChar('{') && $hasBlock = true)) ||

                $this->matchChar('{') && $hasBlock = true)

            ) {

                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);

                $child = [

                    Type::T_INCLUDE,

                    $mixinName,

                    isset($argValues) ? $argValues : null,

                    null,

                    isset($argUsing) ? $argUsing : null

                ];

                if (! empty($hasBlock)) {

                    $include = new ContentBlock();

                    $this->registerPushedBlock($include, $s);

                    $include->child = $child;

                } else {

                    $this->append($child, $s);

                }

                return true;

            }

            $this->seek($s);

            if (

                $this->literal('@scssphp-import-once', 20) &&

                $this->valueList($importPath) &&

                $this->end()

            ) {

                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);

                list($line, $column) = $this->getSourcePosition($s);

                $file = $this->sourceName;

                $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);

                $this->append([Type::T_SCSSPHP_IMPORT_ONCE, $importPath], $s);

                return true;

            }

            $this->seek($s);

            if (

                $this->literal('@import', 7) &&

                $this->valueList($importPath) &&

                $importPath[0] !== Type::T_FUNCTION_CALL &&

                $this->end()

            ) {

                if ($this->cssOnly) {

                    $this->assertPlainCssValid([Type::T_IMPORT, $importPath], $s);

                    $this->append([Type::T_COMMENT, rtrim(substr($this->buffer, $s, $this->count - $s))]);

                    return true;

                }

                $this->append([Type::T_IMPORT, $importPath], $s);

                return true;

            }

            $this->seek($s);

            if (

                $this->literal('@import', 7) &&

                $this->url($importPath) &&

                $this->end()

            ) {

                if ($this->cssOnly) {

                    $this->assertPlainCssValid([Type::T_IMPORT, $importPath], $s);

                    $this->append([Type::T_COMMENT, rtrim(substr($this->buffer, $s, $this->count - $s))]);

                    return true;

                }

                $this->append([Type::T_IMPORT, $importPath], $s);

                return true;

            }

            $this->seek($s);

            if (

                $this->literal('@extend', 7) &&

                $this->selectors($selectors) &&

                $this->end()

            ) {

                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);

                // check for '!flag'

                $optional = $this->stripOptionalFlag($selectors);

                $this->append([Type::T_EXTEND, $selectors, $optional], $s);

                return true;

            }

            $this->seek($s);

            if (

                $this->literal('@function', 9) &&

                $this->keyword($fnName) &&

                $this->argumentDef($args) &&

                $this->matchChar('{', false)

            ) {

                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);

                $func = new CallableBlock(Type::T_FUNCTION);

                $this->registerPushedBlock($func, $s);

                $func->name = $fnName;

                $func->args = $args;

                return true;

            }

            $this->seek($s);

            if (

                $this->literal('@return', 7) &&

                ($this->valueList($retVal) || true) &&

                $this->end()

            ) {

                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);

                $this->append([Type::T_RETURN, isset($retVal) ? $retVal : [Type::T_NULL]], $s);

                return true;

            }

            $this->seek($s);

            if (

                $this->literal('@each', 5) &&

                $this->genericList($varNames, 'variable', ',', false) &&

                $this->literal('in', 2) &&

                $this->valueList($list) &&

                $this->matchChar('{', false)

            ) {

                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);

                $each = new EachBlock();

                $this->registerPushedBlock($each, $s);

                foreach ($varNames[2] as $varName) {

                    $each->vars[] = $varName[1];

                }

                $each->list = $list;

                return true;

            }

            $this->seek($s);

            if (

                $this->literal('@while', 6) &&

                $this->expression($cond) &&

                $this->matchChar('{', false)

            ) {

                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);

                while (

                    $cond[0] === Type::T_LIST &&

                    ! empty($cond['enclosing']) &&

                    $cond['enclosing'] === 'parent' &&

                    \count($cond[2]) == 1

                ) {

                    $cond = reset($cond[2]);

                }

                $while = new WhileBlock();

                $this->registerPushedBlock($while, $s);

                $while->cond = $cond;

                return true;

            }

            $this->seek($s);

            if (

                $this->literal('@for', 4) &&

                $this->variable($varName) &&

                $this->literal('from', 4) &&

                $this->expression($start) &&

                ($this->literal('through', 7) ||

                    ($forUntil = true && $this->literal('to', 2))) &&

                $this->expression($end) &&

                $this->matchChar('{', false)

            ) {

                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);

                $for = new ForBlock();

                $this->registerPushedBlock($for, $s);

                $for->var   = $varName[1];

                $for->start = $start;

                $for->end   = $end;

                $for->until = isset($forUntil);

                return true;

            }

            $this->seek($s);

            if (

                $this->literal('@if', 3) &&

                $this->functionCallArgumentsList($cond, false, '{', false)

            ) {

                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);

                $if = new IfBlock();

                $this->registerPushedBlock($if, $s);

                while (

                    $cond[0] === Type::T_LIST &&

                    ! empty($cond['enclosing']) &&

                    $cond['enclosing'] === 'parent' &&

                    \count($cond[2]) == 1

                ) {

                    $cond = reset($cond[2]);

                }

                $if->cond  = $cond;

                $if->cases = [];

                return true;

            }

            $this->seek($s);

            if (

                $this->literal('@debug', 6) &&

                $this->functionCallArgumentsList($value, false)

            ) {

                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);

                $this->append([Type::T_DEBUG, $value], $s);

                return true;

            }

            $this->seek($s);

            if (

                $this->literal('@warn', 5) &&

                $this->functionCallArgumentsList($value, false)

            ) {

                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);

                $this->append([Type::T_WARN, $value], $s);

                return true;

            }

            $this->seek($s);

            if (

                $this->literal('@error', 6) &&

                $this->functionCallArgumentsList($value, false)

            ) {

                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);

                $this->append([Type::T_ERROR, $value], $s);

                return true;

            }

            $this->seek($s);

            if (

                $this->literal('@content', 8) &&

                ($this->end() ||

                    $this->matchChar('(') &&

                    $this->argValues($argContent) &&

                    $this->matchChar(')') &&

                    $this->end())

            ) {

                ! $this->cssOnly || $this->assertPlainCssValid(false, $s);

                $this->append([Type::T_MIXIN_CONTENT, isset($argContent) ? $argContent : null], $s);

                return true;

            }

            $this->seek($s);

            $last = $this->last();

            if (isset($last) && $last[0] === Type::T_IF) {

                list(, $if) = $last;

                assert($if instanceof IfBlock);

                if ($this->literal('@else', 5)) {

                    if ($this->matchChar('{', false)) {

                        $else = new ElseBlock();

                    } elseif (

                        $this->literal('if', 2) &&

                        $this->functionCallArgumentsList($cond, false, '{', false)

                    ) {

                        $else = new ElseifBlock();

                        $else->cond = $cond;

                    }

                    if (isset($else)) {

                        $this->registerPushedBlock($else, $s);

                        $if->cases[] = $else;

                        return true;

                    }

                }

                $this->seek($s);

            }

            // only retain the first @charset directive encountered

            if (

                $this->literal('@charset', 8) &&

                $this->valueList($charset) &&

                $this->end()

            ) {

                return true;

            }

            $this->seek($s);

            if (

                $this->literal('@supports', 9) &&

                ($t1 = $this->supportsQuery($supportQuery)) &&

                ($t2 = $this->matchChar('{', false))

            ) {

                $directive = new DirectiveBlock();

                $this->registerPushedBlock($directive, $s);

                $directive->name  = 'supports';

                $directive->value = $supportQuery;

                return true;

            }

            $this->seek($s);

            // doesn't match built in directive, do generic one

            if (

                $this->matchChar('@', false) &&

                $this->mixedKeyword($dirName) &&

                $this->directiveValue($dirValue, '{')

            ) {

                if (count($dirName) === 1 && is_string(reset($dirName))) {

                    $dirName = reset($dirName);

                } else {

                    $dirName = [Type::T_STRING, '', $dirName];

                }

                if ($dirName === 'media') {

                    $directive = new MediaBlock();

                } else {

                    $directive = new DirectiveBlock();

                    $directive->name = $dirName;

                }

                $this->registerPushedBlock($directive, $s);

                if (isset($dirValue)) {

                    ! $this->cssOnly || ($dirValue = $this->assertPlainCssValid($dirValue));

                    $directive->value = $dirValue;

                }

                return true;

            }

            $this->seek($s);

            // maybe it's a generic blockless directive

            if (

                $this->matchChar('@', false) &&

                $this->mixedKeyword($dirName) &&

                ! $this->isKnownGenericDirective($dirName) &&

                ($this->end(false) || ($this->directiveValue($dirValue, '') && $this->end(false)))

            ) {

                if (\count($dirName) === 1 && \is_string(\reset($dirName))) {

                    $dirName = \reset($dirName);

                } else {

                    $dirName = [Type::T_STRING, '', $dirName];

                }

                if (

                    ! empty($this->env->parent) &&

                    $this->env->type &&

                    ! \in_array($this->env->type, [Type::T_DIRECTIVE, Type::T_MEDIA])

                ) {

                    $plain = \trim(\substr($this->buffer, $s, $this->count - $s));

                    throw $this->parseError(

                        "Unknown directive `{$plain}` not allowed in `" . $this->env->type . "` block"

                    );

                }

                // blockless directives with a blank line after keeps their blank lines after

                // sass-spec compliance purpose

                $s = $this->count;

                $hasBlankLine = false;

                if ($this->match('\s*?\n\s*\n', $out, false)) {

                    $hasBlankLine = true;

                    $this->seek($s);

                }

                $isNotRoot = ! empty($this->env->parent);

                $this->append([Type::T_DIRECTIVE, [$dirName, $dirValue, $hasBlankLine, $isNotRoot]], $s);

                $this->whitespace();

                return true;

            }

            $this->seek($s);

            return false;

        }

        $inCssSelector = null;

        if ($this->cssOnly) {

            $inCssSelector = (! empty($this->env->parent) &&

                ! in_array($this->env->type, [Type::T_DIRECTIVE, Type::T_MEDIA]));

        }

        // custom properties : right part is static

        if (($this->customProperty($name) ) && $this->matchChar(':', false)) {

            $start = $this->count;

            // but can be complex and finish with ; or }

            foreach ([';','}'] as $ending) {

                if (

                    $this->openString($ending, $stringValue, '(', ')', false) &&

                    $this->end()

                ) {

                    $end = $this->count;

                    $value = $stringValue;

                    // check if we have only a partial value due to nested [] or { } to take in account

                    $nestingPairs = [['[', ']'], ['{', '}']];

                    foreach ($nestingPairs as $nestingPair) {

                        $p = strpos($this->buffer, $nestingPair[0], $start);

                        if ($p && $p < $end) {

                            $this->seek($start);

                            if (

                                $this->openString($ending, $stringValue, $nestingPair[0], $nestingPair[1], false) &&

                                $this->end() &&

                                $this->count > $end

                            ) {

                                $end = $this->count;

                                $value = $stringValue;

                            }

                        }

                    }

                    $this->seek($end);

                    $this->append([Type::T_CUSTOM_PROPERTY, $name, $value], $s);

                    return true;

                }

            }

            // TODO: output an error here if nothing found according to sass spec

        }

        $this->seek($s);

        // property shortcut

        // captures most properties before having to parse a selector

        if (

            $this->keyword($name, false) &&

            $this->literal(': ', 2) &&

            $this->valueList($value) &&

            $this->end()

        ) {

            $name = [Type::T_STRING, '', [$name]];

            $this->append([Type::T_ASSIGN, $name, $value], $s);

            return true;

        }

        $this->seek($s);

        // variable assigns

        if (

            $this->variable($name) &&

            $this->matchChar(':') &&

            $this->valueList($value) &&

            $this->end()

        ) {

            ! $this->cssOnly || $this->assertPlainCssValid(false, $s);

            // check for '!flag'

            $assignmentFlags = $this->stripAssignmentFlags($value);

            $this->append([Type::T_ASSIGN, $name, $value, $assignmentFlags], $s);

            return true;

        }

        $this->seek($s);