ULTRA [ resource.optimyar.com ]

Linux uranus.pws-dns.net 5.14.0-427.42.1.el9_4.x86_64 #1 SMP PREEMPT_DYNAMIC Fri Nov 1 14:58:02 EDT 2024 x86_64

LiteSpeed

31.214.174.197 | Your IP: 216.73.216.187

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ home / freeclou / .nvm / versions / node / v12.22.1 / lib / node_modules / pm2 / node_modules / yamljs / src /

Home Upload Mass Deface Mass Delete Back Connect Notify

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

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	freeclou/freeclou	drwxr-xr-x	2025-01-27 08:08:25
..	dir	-	freeclou/freeclou	drwxr-xr-x	2025-01-27 08:08:25
Exception	dir	-	freeclou/freeclou	drwxr-xr-x	2025-01-27 08:08:25
Dumper.coffee	text/x-Algol68	2.38 KB	freeclou/freeclou	-rw-r--r--	2016-06-22 09:42:09
Escaper.coffee	text/plain	3.24 KB	freeclou/freeclou	-rw-r--r--	2016-06-22 09:42:09
Inline.coffee	text/plain	18.34 KB	freeclou/freeclou	-rw-r--r--	2017-04-02 02:37:27
Parser.coffee	text/plain	24.97 KB	freeclou/freeclou	-rw-r--r--	2017-04-02 02:37:27
Pattern.coffee	text/plain	4.67 KB	freeclou/freeclou	-rw-r--r--	2017-04-02 02:37:27
Unescaper.coffee	text/plain	2.69 KB	freeclou/freeclou	-rw-r--r--	2016-06-22 09:42:09
Utils.coffee	text/x-Algol68	10.68 KB	freeclou/freeclou	-rw-r--r--	2017-04-20 03:50:22
Yaml.coffee	text/x-Algol68	3.95 KB	freeclou/freeclou	-rw-r--r--	2017-06-24 11:36:32