!C99Shell v. 2.5 [PHP 8 Update] [24.05.2025]!

Software: Apache. PHP/8.1.30 

uname -a: Linux server1.tuhinhossain.com 5.15.0-151-generic #161-Ubuntu SMP Tue Jul 22 14:25:40 UTC
2025 x86_64
 

uid=1002(picotech) gid=1003(picotech) groups=1003(picotech),0(root)  

Safe-mode: OFF (not secure)

/home/picotech/domains/sms.picotech.app/public_html_v5_6/vendor/sabberworm/php-css-parser/src/Value/   drwxr-xr-x
Free 28.78 GB of 117.98 GB (24.39%)
Home    Back    Forward    UPDIR    Refresh    Search    Buffer    Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Self remove    Logout    


Viewing file:     Value.php (7.22 KB)      -rw-r--r--
Select action/file-type:
(+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
<?php

namespace Sabberworm\CSS\Value;

use 
Sabberworm\CSS\Parsing\ParserState;
use 
Sabberworm\CSS\Parsing\SourceException;
use 
Sabberworm\CSS\Parsing\UnexpectedEOFException;
use 
Sabberworm\CSS\Parsing\UnexpectedTokenException;
use 
Sabberworm\CSS\Renderable;

/**
 * Abstract base class for specific classes of CSS values: `Size`, `Color`, `CSSString` and `URL`, and another
 * abstract subclass `ValueList`.
 */
abstract class Value implements Renderable
{
    
/**
     * @var int
     */
    
protected $iLineNo;

    
/**
     * @param int $iLineNo
     */
    
public function __construct($iLineNo 0)
    {
        
$this->iLineNo $iLineNo;
    }

    
/**
     * @param array<array-key, string> $aListDelimiters
     *
     * @return RuleValueList|CSSFunction|CSSString|LineName|Size|URL|string
     *
     * @throws UnexpectedTokenException
     * @throws UnexpectedEOFException
     */
    
public static function parseValue(ParserState $oParserState, array $aListDelimiters = [])
    {
        
/** @var array<int, RuleValueList|CSSFunction|CSSString|LineName|Size|URL|string> $aStack */
        
$aStack = [];
        
$oParserState->consumeWhiteSpace();
        
//Build a list of delimiters and parsed values
        
while (
            !(
$oParserState->comes('}') || $oParserState->comes(';') || $oParserState->comes('!')
                || 
$oParserState->comes(')')
                || 
$oParserState->comes('\\')
                || 
$oParserState->isEnd())
        ) {
            if (
count($aStack) > 0) {
                
$bFoundDelimiter false;
                foreach (
$aListDelimiters as $sDelimiter) {
                    if (
$oParserState->comes($sDelimiter)) {
                        
array_push($aStack$oParserState->consume($sDelimiter));
                        
$oParserState->consumeWhiteSpace();
                        
$bFoundDelimiter true;
                        break;
                    }
                }
                if (!
$bFoundDelimiter) {
                    
//Whitespace was the list delimiter
                    
array_push($aStack' ');
                }
            }
            
array_push($aStackself::parsePrimitiveValue($oParserState));
            
$oParserState->consumeWhiteSpace();
        }
        
// Convert the list to list objects
        
foreach ($aListDelimiters as $sDelimiter) {
            if (
count($aStack) === 1) {
                return 
$aStack[0];
            }
            
$iStartPosition null;
            while ((
$iStartPosition array_search($sDelimiter$aStacktrue)) !== false) {
                
$iLength 2//Number of elements to be joined
                
for ($i $iStartPosition 2$i count($aStack); $i += 2, ++$iLength) {
                    if (
$sDelimiter !== $aStack[$i]) {
                        break;
                    }
                }
                
$oList = new RuleValueList($sDelimiter$oParserState->currentLine());
                for (
$i $iStartPosition 1$i $iStartPosition $iLength 2$i += 2) {
                    
$oList->addListComponent($aStack[$i]);
                }
                
array_splice($aStack$iStartPosition 1$iLength 1, [$oList]);
            }
        }
        if (!isset(
$aStack[0])) {
            throw new 
UnexpectedTokenException(
                
{$oParserState->peek()} ",
                
$oParserState->peek(1, -1) . $oParserState->peek(2),
                
'literal',
                
$oParserState->currentLine()
            );
        }
        return 
$aStack[0];
    }

    
/**
     * @param bool $bIgnoreCase
     *
     * @return CSSFunction|string
     *
     * @throws UnexpectedEOFException
     * @throws UnexpectedTokenException
     */
    
public static function parseIdentifierOrFunction(ParserState $oParserState$bIgnoreCase false)
    {
        
$oAnchor $oParserState->anchor();
        
$mResult $oParserState->parseIdentifier($bIgnoreCase);

        if (
$oParserState->comes('(')) {
            
$oAnchor->backtrack();
            if (
$oParserState->streql('url'$mResult)) {
                
$mResult URL::parse($oParserState);
            } elseif (
                
$oParserState->streql('calc'$mResult)
                || 
$oParserState->streql('-webkit-calc'$mResult)
                || 
$oParserState->streql('-moz-calc'$mResult)
            ) {
                
$mResult CalcFunction::parse($oParserState);
            } else {
                
$mResult CSSFunction::parse($oParserState$bIgnoreCase);
            }
        }

        return 
$mResult;
    }

    
/**
     * @return CSSFunction|CSSString|LineName|Size|URL|string
     *
     * @throws UnexpectedEOFException
     * @throws UnexpectedTokenException
     * @throws SourceException
     */
    
public static function parsePrimitiveValue(ParserState $oParserState)
    {
        
$oValue null;
        
$oParserState->consumeWhiteSpace();
        if (
            
is_numeric($oParserState->peek())
            || (
$oParserState->comes('-.')
                && 
is_numeric($oParserState->peek(12)))
            || ((
$oParserState->comes('-') || $oParserState->comes('.')) && is_numeric($oParserState->peek(11)))
        ) {
            
$oValue Size::parse($oParserState);
        } elseif (
$oParserState->comes('#') || $oParserState->comes('rgb'true) || $oParserState->comes('hsl'true)) {
            
$oValue Color::parse($oParserState);
        } elseif (
$oParserState->comes("'") || $oParserState->comes('"')) {
            
$oValue CSSString::parse($oParserState);
        } elseif (
$oParserState->comes("progid:") && $oParserState->getSettings()->bLenientParsing) {
            
$oValue self::parseMicrosoftFilter($oParserState);
        } elseif (
$oParserState->comes("[")) {
            
$oValue LineName::parse($oParserState);
        } elseif (
$oParserState->comes("U+")) {
            
$oValue self::parseUnicodeRangeValue($oParserState);
        } else {
            
$oValue self::parseIdentifierOrFunction($oParserState);
        }
        
$oParserState->consumeWhiteSpace();
        return 
$oValue;
    }

    
/**
     * @return CSSFunction
     *
     * @throws UnexpectedEOFException
     * @throws UnexpectedTokenException
     */
    
private static function parseMicrosoftFilter(ParserState $oParserState)
    {
        
$sFunction $oParserState->consumeUntil('('falsetrue);
        
$aArguments Value::parseValue($oParserState, [',''=']);
        return new 
CSSFunction($sFunction$aArguments','$oParserState->currentLine());
    }

    
/**
     * @return string
     *
     * @throws UnexpectedEOFException
     * @throws UnexpectedTokenException
     */
    
private static function parseUnicodeRangeValue(ParserState $oParserState)
    {
        
$iCodepointMaxLength 6// Code points outside BMP can use up to six digits
        
$sRange "";
        
$oParserState->consume("U+");
        do {
            if (
$oParserState->comes('-')) {
                
$iCodepointMaxLength 13// Max length is 2 six digit code points + the dash(-) between them
            
}
            
$sRange .= $oParserState->consume(1);
        } while (
strlen($sRange) < $iCodepointMaxLength && preg_match("/[A-Fa-f0-9\?-]/"$oParserState->peek()));
        return 
"U+{$sRange}";
    }

    
/**
     * @return int
     */
    
public function getLineNo()
    {
        return 
$this->iLineNo;
    }
}

:: Command execute ::

Enter:
 
Select:
 

:: Search ::
  - regexp 

:: Upload ::
 
[ ok ]

:: Make Dir ::
 
[ ok ]
:: Make File ::
 
[ ok ]

:: Go Dir ::
 
:: Go File ::
 

--[ c99shell v. 2.5 [PHP 8 Update] [24.05.2025] | Generation time: 0.0042 ]--