67vc33-b1a78eb8b39a7a2f.ithost.pongsawadi.ac.th

! C99Shell v2025 !
Safe-mode: OFF (not secure) Disable Functions: None Host: Linux ns1.ithost.pongsawadi.ac.th 6.8.0-90-generic #91-Ubuntu SMP PREEMPT_DYNAMIC Tue Nov 18 14:14:30 UTC 2025 x86_64 User: ithost67s46552gwdc Software: Apache IP: 161.82.130.184 PHP: 8.2.30 CURL:ON SSH2:ON Magic Quotes:OFF MySQL:ON MSSQL:OFF PostgreSQL:ON Oracle:OFF CGI:OFF /usr/share/nodejs/json5/lib/

! C99Shell v2025 !

Safe-mode: OFF (not secure)

Disable Functions: None

Host: Linux ns1.ithost.pongsawadi.ac.th 6.8.0-90-generic #91-Ubuntu SMP PREEMPT_DYNAMIC Tue Nov 18 14:14:30 UTC 2025 x86_64

User: ithost67s46552gwdc

Software: Apache

IP: 161.82.130.184

PHP: 8.2.30

CURL:ON SSH2:ON Magic Quotes:OFF MySQL:ON MSSQL:OFF PostgreSQL:ON Oracle:OFF CGI:OFF

/usr/share/nodejs/json5/lib/

Edit File: parse.js

const util = require('./util')

let source
let parseState
let stack
let pos
let line
let column
let token
let key
let root

module.exports = function parse (text, reviver) {
    source = String(text)
    parseState = 'start'
    stack = []
    pos = 0
    line = 1
    column = 0
    token = undefined
    key = undefined
    root = undefined

do {
        token = lex()

// This code is unreachable.
        // if (!parseStates[parseState]) {
        //     throw invalidParseState()
        // }

parseStates[parseState]()
    } while (token.type !== 'eof')

if (typeof reviver === 'function') {
        return internalize({'': root}, '', reviver)
    }

return root
}

function internalize (holder, name, reviver) {
    const value = holder[name]
    if (value != null && typeof value === 'object') {
        if (Array.isArray(value)) {
            for (let i = 0; i < value.length; i++) {
                const key = String(i)
                const replacement = internalize(value, key, reviver)
                if (replacement === undefined) {
                    delete value[key]
                } else {
                    Object.defineProperty(value, key, {
                        value: replacement,
                        writable: true,
                        enumerable: true,
                        configurable: true,
                    })
                }
            }
        } else {
            for (const key in value) {
                const replacement = internalize(value, key, reviver)
                if (replacement === undefined) {
                    delete value[key]
                } else {
                    Object.defineProperty(value, key, {
                        value: replacement,
                        writable: true,
                        enumerable: true,
                        configurable: true,
                    })
                }
            }
        }
    }

return reviver.call(holder, name, value)
}

let lexState
let buffer
let doubleQuote
let sign
let c

function lex () {
    lexState = 'default'
    buffer = ''
    doubleQuote = false
    sign = 1

for (;;) {
        c = peek()

// This code is unreachable.
        // if (!lexStates[lexState]) {
        //     throw invalidLexState(lexState)
        // }

const token = lexStates[lexState]()
        if (token) {
            return token
        }
    }
}

function peek () {
    if (source[pos]) {
        return String.fromCodePoint(source.codePointAt(pos))
    }
}

function read () {
    const c = peek()

if (c === '\n') {
        line++
        column = 0
    } else if (c) {
        column += c.length
    } else {
        column++
    }

if (c) {
        pos += c.length
    }

return c
}

const lexStates = {
    default () {
        switch (c) {
        case '\t':
        case '\v':
        case '\f':
        case ' ':
        case '\u00A0':
        case '\uFEFF':
        case '\n':
        case '\r':
        case '\u2028':
        case '\u2029':
            read()
            return

case '/':
            read()
            lexState = 'comment'
            return

case undefined:
            read()
            return newToken('eof')
        }

if (util.isSpaceSeparator(c)) {
            read()
            return
        }

// This code is unreachable.
        // if (!lexStates[parseState]) {
        //     throw invalidLexState(parseState)
        // }

return lexStates[parseState]()
    },

comment () {
        switch (c) {
        case '*':
            read()
            lexState = 'multiLineComment'
            return

case '/':
            read()
            lexState = 'singleLineComment'
            return
        }

throw invalidChar(read())
    },

multiLineComment () {
        switch (c) {
        case '*':
            read()
            lexState = 'multiLineCommentAsterisk'
            return

case undefined:
            throw invalidChar(read())
        }

read()
    },

multiLineCommentAsterisk () {
        switch (c) {
        case '*':
            read()
            return

case '/':
            read()
            lexState = 'default'
            return

case undefined:
            throw invalidChar(read())
        }

read()
        lexState = 'multiLineComment'
    },

singleLineComment () {
        switch (c) {
        case '\n':
        case '\r':
        case '\u2028':
        case '\u2029':
            read()
            lexState = 'default'
            return

case undefined:
            read()
            return newToken('eof')
        }

read()
    },

value () {
        switch (c) {
        case '{':
        case '[':
            return newToken('punctuator', read())

case 'n':
            read()
            literal('ull')
            return newToken('null', null)

case 't':
            read()
            literal('rue')
            return newToken('boolean', true)

case 'f':
            read()
            literal('alse')
            return newToken('boolean', false)

case '-':
        case '+':
            if (read() === '-') {
                sign = -1
            }

lexState = 'sign'
            return

case '.':
            buffer = read()
            lexState = 'decimalPointLeading'
            return

case '0':
            buffer = read()
            lexState = 'zero'
            return

case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            buffer = read()
            lexState = 'decimalInteger'
            return

case 'I':
            read()
            literal('nfinity')
            return newToken('numeric', Infinity)

case 'N':
            read()
            literal('aN')
            return newToken('numeric', NaN)

case '"':
        case "'":
            doubleQuote = (read() === '"')
            buffer = ''
            lexState = 'string'
            return
        }

throw invalidChar(read())
    },

identifierNameStartEscape () {
        if (c !== 'u') {
            throw invalidChar(read())
        }

read()
        const u = unicodeEscape()
        switch (u) {
        case '$':
        case '_':
            break

default:
            if (!util.isIdStartChar(u)) {
                throw invalidIdentifier()
            }

break
        }

buffer += u
        lexState = 'identifierName'
    },

identifierName () {
        switch (c) {
        case '$':
        case '_':
        case '\u200C':
        case '\u200D':
            buffer += read()
            return

case '\\':
            read()
            lexState = 'identifierNameEscape'
            return
        }

if (util.isIdContinueChar(c)) {
            buffer += read()
            return
        }

return newToken('identifier', buffer)
    },

identifierNameEscape () {
        if (c !== 'u') {
            throw invalidChar(read())
        }

read()
        const u = unicodeEscape()
        switch (u) {
        case '$':
        case '_':
        case '\u200C':
        case '\u200D':
            break

default:
            if (!util.isIdContinueChar(u)) {
                throw invalidIdentifier()
            }

break
        }

buffer += u
        lexState = 'identifierName'
    },

sign () {
        switch (c) {
        case '.':
            buffer = read()
            lexState = 'decimalPointLeading'
            return

case '0':
            buffer = read()
            lexState = 'zero'
            return

case 'I':
            read()
            literal('nfinity')
            return newToken('numeric', sign * Infinity)

case 'N':
            read()
            literal('aN')
            return newToken('numeric', NaN)
        }

throw invalidChar(read())
    },

zero () {
        switch (c) {
        case '.':
            buffer += read()
            lexState = 'decimalPoint'
            return

case 'e':
        case 'E':
            buffer += read()
            lexState = 'decimalExponent'
            return

case 'x':
        case 'X':
            buffer += read()
            lexState = 'hexadecimal'
            return
        }

return newToken('numeric', sign * 0)
    },

decimalInteger () {
        switch (c) {
        case '.':
            buffer += read()
            lexState = 'decimalPoint'
            return

case 'e':
        case 'E':
            buffer += read()
            lexState = 'decimalExponent'
            return
        }

if (util.isDigit(c)) {
            buffer += read()
            return
        }

return newToken('numeric', sign * Number(buffer))
    },

decimalPointLeading () {
        if (util.isDigit(c)) {
            buffer += read()
            lexState = 'decimalFraction'
            return
        }

throw invalidChar(read())
    },

decimalPoint () {
        switch (c) {
        case 'e':
        case 'E':
            buffer += read()
            lexState = 'decimalExponent'
            return
        }

if (util.isDigit(c)) {
            buffer += read()
            lexState = 'decimalFraction'
            return
        }

return newToken('numeric', sign * Number(buffer))
    },

decimalFraction () {
        switch (c) {
        case 'e':
        case 'E':
            buffer += read()
            lexState = 'decimalExponent'
            return
        }

if (util.isDigit(c)) {
            buffer += read()
            return
        }

return newToken('numeric', sign * Number(buffer))
    },

decimalExponent () {
        switch (c) {
        case '+':
        case '-':
            buffer += read()
            lexState = 'decimalExponentSign'
            return
        }

if (util.isDigit(c)) {
            buffer += read()
            lexState = 'decimalExponentInteger'
            return
        }

throw invalidChar(read())
    },

decimalExponentSign () {
        if (util.isDigit(c)) {
            buffer += read()
            lexState = 'decimalExponentInteger'
            return
        }

throw invalidChar(read())
    },

decimalExponentInteger () {
        if (util.isDigit(c)) {
            buffer += read()
            return
        }

return newToken('numeric', sign * Number(buffer))
    },

hexadecimal () {
        if (util.isHexDigit(c)) {
            buffer += read()
            lexState = 'hexadecimalInteger'
            return
        }

throw invalidChar(read())
    },

hexadecimalInteger () {
        if (util.isHexDigit(c)) {
            buffer += read()
            return
        }

return newToken('numeric', sign * Number(buffer))
    },

string () {
        switch (c) {
        case '\\':
            read()
            buffer += escape()
            return

case '"':
            if (doubleQuote) {
                read()
                return newToken('string', buffer)
            }

buffer += read()
            return

case "'":
            if (!doubleQuote) {
                read()
                return newToken('string', buffer)
            }

buffer += read()
            return

case '\n':
        case '\r':
            throw invalidChar(read())

case '\u2028':
        case '\u2029':
            separatorChar(c)
            break

case undefined:
            throw invalidChar(read())
        }

buffer += read()
    },

start () {
        switch (c) {
        case '{':
        case '[':
            return newToken('punctuator', read())

// This code is unreachable since the default lexState handles eof.
        // case undefined:
        //     return newToken('eof')
        }

lexState = 'value'
    },

beforePropertyName () {
        switch (c) {
        case '$':
        case '_':
            buffer = read()
            lexState = 'identifierName'
            return

case '\\':
            read()
            lexState = 'identifierNameStartEscape'
            return

case '}':
            return newToken('punctuator', read())

case '"':
        case "'":
            doubleQuote = (read() === '"')
            lexState = 'string'
            return
        }

if (util.isIdStartChar(c)) {
            buffer += read()
            lexState = 'identifierName'
            return
        }

throw invalidChar(read())
    },

afterPropertyName () {
        if (c === ':') {
            return newToken('punctuator', read())
        }

throw invalidChar(read())
    },

beforePropertyValue () {
        lexState = 'value'
    },

afterPropertyValue () {
        switch (c) {
        case ',':
        case '}':
            return newToken('punctuator', read())
        }

throw invalidChar(read())
    },

beforeArrayValue () {
        if (c === ']') {
            return newToken('punctuator', read())
        }

lexState = 'value'
    },

afterArrayValue () {
        switch (c) {
        case ',':
        case ']':
            return newToken('punctuator', read())
        }

throw invalidChar(read())
    },

end () {
        // This code is unreachable since it's handled by the default lexState.
        // if (c === undefined) {
        //     read()
        //     return newToken('eof')
        // }

throw invalidChar(read())
    },
}

function newToken (type, value) {
    return {
        type,
        value,
        line,
        column,
    }
}

function literal (s) {
    for (const c of s) {
        const p = peek()

if (p !== c) {
            throw invalidChar(read())
        }

read()
    }
}

function escape () {
    const c = peek()
    switch (c) {
    case 'b':
        read()
        return '\b'

case 'f':
        read()
        return '\f'

case 'n':
        read()
        return '\n'

case 'r':
        read()
        return '\r'

case 't':
        read()
        return '\t'

case 'v':
        read()
        return '\v'

case '0':
        read()
        if (util.isDigit(peek())) {
            throw invalidChar(read())
        }

return '\0'

case 'x':
        read()
        return hexEscape()

case 'u':
        read()
        return unicodeEscape()

case '\n':
    case '\u2028':
    case '\u2029':
        read()
        return ''

case '\r':
        read()
        if (peek() === '\n') {
            read()
        }

return ''

case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
        throw invalidChar(read())

case undefined:
        throw invalidChar(read())
    }

return read()
}

function hexEscape () {
    let buffer = ''
    let c = peek()

if (!util.isHexDigit(c)) {
        throw invalidChar(read())
    }

buffer += read()

c = peek()
    if (!util.isHexDigit(c)) {
        throw invalidChar(read())
    }

buffer += read()

return String.fromCodePoint(parseInt(buffer, 16))
}

function unicodeEscape () {
    let buffer = ''
    let count = 4

while (count-- > 0) {
        const c = peek()
        if (!util.isHexDigit(c)) {
            throw invalidChar(read())
        }

buffer += read()
    }

return String.fromCodePoint(parseInt(buffer, 16))
}

const parseStates = {
    start () {
        if (token.type === 'eof') {
            throw invalidEOF()
        }

push()
    },

beforePropertyName () {
        switch (token.type) {
        case 'identifier':
        case 'string':
            key = token.value
            parseState = 'afterPropertyName'
            return

case 'punctuator':
            // This code is unreachable since it's handled by the lexState.
            // if (token.value !== '}') {
            //     throw invalidToken()
            // }

pop()
            return

case 'eof':
            throw invalidEOF()
        }

// This code is unreachable since it's handled by the lexState.
        // throw invalidToken()
    },

afterPropertyName () {
        // This code is unreachable since it's handled by the lexState.
        // if (token.type !== 'punctuator' || token.value !== ':') {
        //     throw invalidToken()
        // }

if (token.type === 'eof') {
            throw invalidEOF()
        }

parseState = 'beforePropertyValue'
    },

beforePropertyValue () {
        if (token.type === 'eof') {
            throw invalidEOF()
        }

push()
    },

beforeArrayValue () {
        if (token.type === 'eof') {
            throw invalidEOF()
        }

if (token.type === 'punctuator' && token.value === ']') {
            pop()
            return
        }

push()
    },

afterPropertyValue () {
        // This code is unreachable since it's handled by the lexState.
        // if (token.type !== 'punctuator') {
        //     throw invalidToken()
        // }

if (token.type === 'eof') {
            throw invalidEOF()
        }

switch (token.value) {
        case ',':
            parseState = 'beforePropertyName'
            return

case '}':
            pop()
        }

// This code is unreachable since it's handled by the lexState.
        // throw invalidToken()
    },

afterArrayValue () {
        // This code is unreachable since it's handled by the lexState.
        // if (token.type !== 'punctuator') {
        //     throw invalidToken()
        // }

if (token.type === 'eof') {
            throw invalidEOF()
        }

switch (token.value) {
        case ',':
            parseState = 'beforeArrayValue'
            return

case ']':
            pop()
        }

// This code is unreachable since it's handled by the lexState.
        // throw invalidToken()
    },

end () {
        // This code is unreachable since it's handled by the lexState.
        // if (token.type !== 'eof') {
        //     throw invalidToken()
        // }
    },
}

function push () {
    let value

switch (token.type) {
    case 'punctuator':
        switch (token.value) {
        case '{':
            value = {}
            break

case '[':
            value = []
            break
        }

break

case 'null':
    case 'boolean':
    case 'numeric':
    case 'string':
        value = token.value
        break

// This code is unreachable.
    // default:
    //     throw invalidToken()
    }

if (root === undefined) {
        root = value
    } else {
        const parent = stack[stack.length - 1]
        if (Array.isArray(parent)) {
            parent.push(value)
        } else {
            Object.defineProperty(parent, key, {
                value,
                writable: true,
                enumerable: true,
                configurable: true,
            })
        }
    }

if (value !== null && typeof value === 'object') {
        stack.push(value)

if (Array.isArray(value)) {
            parseState = 'beforeArrayValue'
        } else {
            parseState = 'beforePropertyName'
        }
    } else {
        const current = stack[stack.length - 1]
        if (current == null) {
            parseState = 'end'
        } else if (Array.isArray(current)) {
            parseState = 'afterArrayValue'
        } else {
            parseState = 'afterPropertyValue'
        }
    }
}

function pop () {
    stack.pop()

const current = stack[stack.length - 1]
    if (current == null) {
        parseState = 'end'
    } else if (Array.isArray(current)) {
        parseState = 'afterArrayValue'
    } else {
        parseState = 'afterPropertyValue'
    }
}

// This code is unreachable.
// function invalidParseState () {
//     return new Error(`JSON5: invalid parse state '${parseState}'`)
// }

// This code is unreachable.
// function invalidLexState (state) {
//     return new Error(`JSON5: invalid lex state '${state}'`)
// }

function invalidChar (c) {
    if (c === undefined) {
        return syntaxError(`JSON5: invalid end of input at ${line}:${column}`)
    }

return syntaxError(`JSON5: invalid character '${formatChar(c)}' at ${line}:${column}`)
}

function invalidEOF () {
    return syntaxError(`JSON5: invalid end of input at ${line}:${column}`)
}

// This code is unreachable.
// function invalidToken () {
//     if (token.type === 'eof') {
//         return syntaxError(`JSON5: invalid end of input at ${line}:${column}`)
//     }

//     const c = String.fromCodePoint(token.value.codePointAt(0))
//     return syntaxError(`JSON5: invalid character '${formatChar(c)}' at ${line}:${column}`)
// }

function invalidIdentifier () {
    column -= 5
    return syntaxError(`JSON5: invalid identifier character at ${line}:${column}`)
}

function separatorChar (c) {
    console.warn(`JSON5: '${formatChar(c)}' in strings is not valid ECMAScript; consider escaping`)
}

function formatChar (c) {
    const replacements = {
        "'": "\\'",
        '"': '\\"',
        '\\': '\\\\',
        '\b': '\\b',
        '\f': '\\f',
        '\n': '\\n',
        '\r': '\\r',
        '\t': '\\t',
        '\v': '\\v',
        '\0': '\\0',
        '\u2028': '\\u2028',
        '\u2029': '\\u2029',
    }

if (replacements[c]) {
        return replacements[c]
    }

if (c < ' ') {
        const hexString = c.charCodeAt(0).toString(16)
        return '\\x' + ('00' + hexString).substring(hexString.length)
    }

return c
}

function syntaxError (message) {
    const err = new SyntaxError(message)
    err.lineNumber = line
    err.columnNumber = column
    return err
}

Cancel

Listing directory:

Name	Size	Modify	Owner/Group	Perms	Action	Select
cli.js	3.51 KB	25.01.2023 01:13:17	0/0	-rwxr-xr-x	Edit Rename Download
index.d.ts	1.79 KB	24.01.2023 00:31:50	0/0	-rw-r--r--	Edit Rename Download
index.js	143 B	25.01.2023 01:13:17	0/0	-rw-r--r--	Edit Rename Download
parse.d.ts	533 B	25.01.2023 01:13:17	0/0	-rw-r--r--	Edit Rename Download
parse.js	21.88 KB	25.01.2023 01:13:17	0/0	-rw-r--r--	Edit Rename Download
register.js	374 B	25.01.2023 01:13:17	0/0	-rw-r--r--	Edit Rename Download
require.js	163 B	25.01.2023 01:13:17	0/0	-rw-r--r--	Edit Rename Download
stringify.d.ts	4.06 KB	25.01.2023 01:13:17	0/0	-rw-r--r--	Edit Rename Download
stringify.js	6.82 KB	25.01.2023 01:13:17	0/0	-rw-r--r--	Edit Rename Download
unicode.d.ts	124 B	25.01.2023 01:13:17	0/0	-rw-r--r--	Edit Rename Download
unicode.js	17.43 KB	25.01.2023 01:13:17	0/0	-rw-r--r--	Edit Rename Download
util.d.ts	292 B	25.01.2023 01:13:17	0/0	-rw-r--r--	Edit Rename Download
util.js	885 B	25.01.2023 01:13:17	0/0	-rw-r--r--	Edit Rename Download

:: Command Execute ::
Enter Command:	Select Command:

:: Search ::

:: Upload ::

:: Make Dir ::

:: Make File ::

--[ C99Shell v2025 (01.07.2025) powered by V4NTA | https://privdayz.com | Generation time: 1774404215.6467 ]--

Explain