<h2>Editing File: /home/xaimptsg/public_html/src/vendor/symfony/css-selector/Parser/Parser.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier &lt;fabien@symfony.com&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\CssSelector\Parser;

use Symfony\Component\CssSelector\Exception\SyntaxErrorException;
use Symfony\Component\CssSelector\Node;
use Symfony\Component\CssSelector\Parser\Tokenizer\Tokenizer;

/**
 * CSS selector parser.
 *
 * This component is a port of the Python cssselect library,
 * which is copyright Ian Bicking, @see https://github.com/scrapy/cssselect.
 *
 * @author Jean-François Simon &lt;jeanfrancois.simon@sensiolabs.com&gt;
 *
 * @internal
 */
class Parser implements ParserInterface
{
    private Tokenizer $tokenizer;

    public function __construct(?Tokenizer $tokenizer = null)
    {
        $this-&gt;tokenizer = $tokenizer ?? new Tokenizer();
    }

    public function parse(string $source): array
    {
        $reader = new Reader($source);
        $stream = $this-&gt;tokenizer-&gt;tokenize($reader);

        return $this-&gt;parseSelectorList($stream);
    }

    /**
     * Parses the arguments for &quot;:nth-child()&quot; and friends.
     *
     * @param Token[] $tokens
     *
     * @throws SyntaxErrorException
     */
    public static function parseSeries(array $tokens): array
    {
        foreach ($tokens as $token) {
            if ($token-&gt;isString()) {
                throw SyntaxErrorException::stringAsFunctionArgument();
            }
        }

        $joined = trim(implode('', array_map(fn (Token $token) =&gt; $token-&gt;getValue(), $tokens)));

        $int = function ($string) {
            if (!is_numeric($string)) {
                throw SyntaxErrorException::stringAsFunctionArgument();
            }

            return (int) $string;
        };

        switch (true) {
            case 'odd' === $joined:
                return [2, 1];
            case 'even' === $joined:
                return [2, 0];
            case 'n' === $joined:
                return [1, 0];
            case !str_contains($joined, 'n'):
                return [0, $int($joined)];
        }

        $split = explode('n', $joined);
        $first = $split[0] ?? null;

        return [
            $first ? ('-' === $first || '+' === $first ? $int($first.'1') : $int($first)) : 1,
            isset($split[1]) &amp;&amp; $split[1] ? $int($split[1]) : 0,
        ];
    }

    private function parseSelectorList(TokenStream $stream): array
    {
        $stream-&gt;skipWhitespace();
        $selectors = [];

        while (true) {
            $selectors[] = $this-&gt;parserSelectorNode($stream);

            if ($stream-&gt;getPeek()-&gt;isDelimiter([','])) {
                $stream-&gt;getNext();
                $stream-&gt;skipWhitespace();
            } else {
                break;
            }
        }

        return $selectors;
    }

    private function parserSelectorNode(TokenStream $stream): Node\SelectorNode
    {
        [$result, $pseudoElement] = $this-&gt;parseSimpleSelector($stream);

        while (true) {
            $stream-&gt;skipWhitespace();
            $peek = $stream-&gt;getPeek();

            if ($peek-&gt;isFileEnd() || $peek-&gt;isDelimiter([','])) {
                break;
            }

            if (null !== $pseudoElement) {
                throw SyntaxErrorException::pseudoElementFound($pseudoElement, 'not at the end of a selector');
            }

            if ($peek-&gt;isDelimiter(['+', '&gt;', '~'])) {
                $combinator = $stream-&gt;getNext()-&gt;getValue();
                $stream-&gt;skipWhitespace();
            } else {
                $combinator = ' ';
            }

            [$nextSelector, $pseudoElement] = $this-&gt;parseSimpleSelector($stream);
            $result = new Node\CombinedSelectorNode($result, $combinator, $nextSelector);
        }

        return new Node\SelectorNode($result, $pseudoElement);
    }

    /**
     * Parses next simple node (hash, class, pseudo, negation).
     *
     * @throws SyntaxErrorException
     */
    private function parseSimpleSelector(TokenStream $stream, bool $insideNegation = false): array
    {
        $stream-&gt;skipWhitespace();

        $selectorStart = \count($stream-&gt;getUsed());
        $result = $this-&gt;parseElementNode($stream);
        $pseudoElement = null;

        while (true) {
            $peek = $stream-&gt;getPeek();
            if ($peek-&gt;isWhitespace()
                || $peek-&gt;isFileEnd()
                || $peek-&gt;isDelimiter([',', '+', '&gt;', '~'])
                || ($insideNegation &amp;&amp; $peek-&gt;isDelimiter([')']))
            ) {
                break;
            }

            if (null !== $pseudoElement) {
                throw SyntaxErrorException::pseudoElementFound($pseudoElement, 'not at the end of a selector');
            }

            if ($peek-&gt;isHash()) {
                $result = new Node\HashNode($result, $stream-&gt;getNext()-&gt;getValue());
            } elseif ($peek-&gt;isDelimiter(['.'])) {
                $stream-&gt;getNext();
                $result = new Node\ClassNode($result, $stream-&gt;getNextIdentifier());
            } elseif ($peek-&gt;isDelimiter(['['])) {
                $stream-&gt;getNext();
                $result = $this-&gt;parseAttributeNode($result, $stream);
            } elseif ($peek-&gt;isDelimiter([':'])) {
                $stream-&gt;getNext();

                if ($stream-&gt;getPeek()-&gt;isDelimiter([':'])) {
                    $stream-&gt;getNext();
                    $pseudoElement = $stream-&gt;getNextIdentifier();

                    continue;
                }

                $identifier = $stream-&gt;getNextIdentifier();
                if (\in_array(strtolower($identifier), ['first-line', 'first-letter', 'before', 'after'])) {
                    // Special case: CSS 2.1 pseudo-elements can have a single ':'.
                    // Any new pseudo-element must have two.
                    $pseudoElement = $identifier;

                    continue;
                }

                if (!$stream-&gt;getPeek()-&gt;isDelimiter(['('])) {
                    $result = new Node\PseudoNode($result, $identifier);
                    if ('Pseudo[Element[*]:scope]' === $result-&gt;__toString()) {
                        $used = \count($stream-&gt;getUsed());
                        if (!(2 === $used
                           || 3 === $used &amp;&amp; $stream-&gt;getUsed()[0]-&gt;isWhiteSpace()
                           || $used &gt;= 3 &amp;&amp; $stream-&gt;getUsed()[$used - 3]-&gt;isDelimiter([','])
                           || $used &gt;= 4
                                &amp;&amp; $stream-&gt;getUsed()[$used - 3]-&gt;isWhiteSpace()
                                &amp;&amp; $stream-&gt;getUsed()[$used - 4]-&gt;isDelimiter([','])
                        )) {
                            throw SyntaxErrorException::notAtTheStartOfASelector('scope');
                        }
                    }
                    continue;
                }

                $stream-&gt;getNext();
                $stream-&gt;skipWhitespace();

                if ('not' === strtolower($identifier)) {
                    if ($insideNegation) {
                        throw SyntaxErrorException::nestedNot();
                    }

                    [$argument, $argumentPseudoElement] = $this-&gt;parseSimpleSelector($stream, true);
                    $next = $stream-&gt;getNext();

                    if (null !== $argumentPseudoElement) {
                        throw SyntaxErrorException::pseudoElementFound($argumentPseudoElement, 'inside ::not()');
                    }

                    if (!$next-&gt;isDelimiter([')'])) {
                        throw SyntaxErrorException::unexpectedToken('&quot;)&quot;', $next);
                    }

                    $result = new Node\NegationNode($result, $argument);
                } else {
                    $arguments = [];
                    $next = null;

                    while (true) {
                        $stream-&gt;skipWhitespace();
                        $next = $stream-&gt;getNext();

                        if ($next-&gt;isIdentifier()
                            || $next-&gt;isString()
                            || $next-&gt;isNumber()
                            || $next-&gt;isDelimiter(['+', '-'])
                        ) {
                            $arguments[] = $next;
                        } elseif ($next-&gt;isDelimiter([')'])) {
                            break;
                        } else {
                            throw SyntaxErrorException::unexpectedToken('an argument', $next);
                        }
                    }

                    if (!$arguments) {
                        throw SyntaxErrorException::unexpectedToken('at least one argument', $next);
                    }

                    $result = new Node\FunctionNode($result, $identifier, $arguments);
                }
            } else {
                throw SyntaxErrorException::unexpectedToken('selector', $peek);
            }
        }

        if (\count($stream-&gt;getUsed()) === $selectorStart) {
            throw SyntaxErrorException::unexpectedToken('selector', $stream-&gt;getPeek());
        }

        return [$result, $pseudoElement];
    }

    private function parseElementNode(TokenStream $stream): Node\ElementNode
    {
        $peek = $stream-&gt;getPeek();

        if ($peek-&gt;isIdentifier() || $peek-&gt;isDelimiter(['*'])) {
            if ($peek-&gt;isIdentifier()) {
                $namespace = $stream-&gt;getNext()-&gt;getValue();
            } else {
                $stream-&gt;getNext();
                $namespace = null;
            }

            if ($stream-&gt;getPeek()-&gt;isDelimiter(['|'])) {
                $stream-&gt;getNext();
                $element = $stream-&gt;getNextIdentifierOrStar();
            } else {
                $element = $namespace;
                $namespace = null;
            }
        } else {
            $element = $namespace = null;
        }

        return new Node\ElementNode($namespace, $element);
    }

    private function parseAttributeNode(Node\NodeInterface $selector, TokenStream $stream): Node\AttributeNode
    {
        $stream-&gt;skipWhitespace();
        $attribute = $stream-&gt;getNextIdentifierOrStar();

        if (null === $attribute &amp;&amp; !$stream-&gt;getPeek()-&gt;isDelimiter(['|'])) {
            throw SyntaxErrorException::unexpectedToken('&quot;|&quot;', $stream-&gt;getPeek());
        }

        if ($stream-&gt;getPeek()-&gt;isDelimiter(['|'])) {
            $stream-&gt;getNext();

            if ($stream-&gt;getPeek()-&gt;isDelimiter(['='])) {
                $namespace = null;
                $stream-&gt;getNext();
                $operator = '|=';
            } else {
                $namespace = $attribute;
                $attribute = $stream-&gt;getNextIdentifier();
                $operator = null;
            }
        } else {
            $namespace = $operator = null;
        }

        if (null === $operator) {
            $stream-&gt;skipWhitespace();
            $next = $stream-&gt;getNext();

            if ($next-&gt;isDelimiter([']'])) {
                return new Node\AttributeNode($selector, $namespace, $attribute, 'exists', null);
            } elseif ($next-&gt;isDelimiter(['='])) {
                $operator = '=';
            } elseif ($next-&gt;isDelimiter(['^', '$', '*', '~', '|', '!'])
                &amp;&amp; $stream-&gt;getPeek()-&gt;isDelimiter(['='])
            ) {
                $operator = $next-&gt;getValue().'=';
                $stream-&gt;getNext();
            } else {
                throw SyntaxErrorException::unexpectedToken('operator', $next);
            }
        }

        $stream-&gt;skipWhitespace();
        $value = $stream-&gt;getNext();

        if ($value-&gt;isNumber()) {
            // if the value is a number, it's casted into a string
            $value = new Token(Token::TYPE_STRING, (string) $value-&gt;getValue(), $value-&gt;getPosition());
        }

        if (!($value-&gt;isIdentifier() || $value-&gt;isString())) {
            throw SyntaxErrorException::unexpectedToken('string or identifier', $value);
        }

        $stream-&gt;skipWhitespace();
        $next = $stream-&gt;getNext();

        if (!$next-&gt;isDelimiter([']'])) {
            throw SyntaxErrorException::unexpectedToken('&quot;]&quot;', $next);
        }

        return new Node\AttributeNode($selector, $namespace, $attribute, $operator, $value-&gt;getValue());
    }
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fhome%2Fxaimptsg%2Fpublic_html%2Fsrc%2Fvendor%2Fsymfony%2Fcss-selector%2FParser'>Back to Directory</a>