ether-code 0.1.5 → 0.1.7

package/parsers/php-parser.js

@@ -1,3037 +0,0 @@
-const fs = require('fs')
-const AST = require('./ast-php')
-
-const PHP_KEYWORDS = {
-    'si': 'if', 'if': 'if', 'если': 'if', '如果': 'if', 'もし': 'if',
-    'sinon si': 'elseif', 'elseif': 'elseif', 'else if': 'elseif', 'иначе если': 'elseif', '否则如果': 'elseif', 'でなければもし': 'elseif',
-    'sinon': 'else', 'else': 'else', 'sino': 'else', 'иначе': 'else', '否则': 'else', 'そうでなければ': 'else',
-    'selon': 'switch', 'switch': 'switch', 'segun': 'switch', 'según': 'switch', 'переключатель': 'switch', '开关': 'switch', 'スイッチ': 'switch',
-    'cas': 'case', 'case': 'case', 'caso': 'case', 'случай': 'case', '情况': 'case', 'ケース': 'case',
-    'defaut': 'default', 'défaut': 'default', 'default': 'default', 'porDefecto': 'default', 'по умолчанию': 'default', '默认': 'default', 'デフォルト': 'default',
-    'correspondre': 'match', 'match': 'match', 'coincidir': 'match', 'соответствовать': 'match', '匹配': 'match', 'マッチ': 'match',
-    
-    'pour': 'for', 'for': 'for', 'para': 'for', 'для': 'for', '为': 'for', 'ため': 'for',
-    'pour chaque': 'foreach', 'foreach': 'foreach', 'para cada': 'foreach', 'для каждого': 'foreach', '对于每个': 'foreach', '各': 'foreach',
-    'tant que': 'while', 'while': 'while', 'mientras': 'while', 'пока': 'while', '当': 'while', 'の間': 'while',
-    'faire': 'do', 'do': 'do', 'hacer': 'do', 'делать': 'do', '做': 'do', 'する': 'do',
-    'continuer': 'continue', 'continue': 'continue', 'continuar': 'continue', 'продолжить': 'continue', '继续': 'continue', '続ける': 'continue',
-    'sortir': 'break', 'break': 'break', 'romper': 'break', 'прервать': 'break', '中断': 'break', 'ブレーク': 'break',
-    
-    'fonction': 'function', 'function': 'function', 'funcion': 'function', 'función': 'function', 'функция': 'function', '函数': 'function', '関数': 'function',
-    'retourner': 'return', 'return': 'return', 'retornar': 'return', 'возвращать': 'return', '返回': 'return', '戻る': 'return',
-    
-    'classe': 'class', 'class': 'class', 'clase': 'class', 'класс': 'class', '类': 'class', 'クラス': 'class',
-    'nouveau': 'new', 'new': 'new', 'nuevo': 'new', 'новый': 'new', '新建': 'new', '新規': 'new',
-    'etendre': 'extends', 'étendre': 'extends', 'extends': 'extends', 'extender': 'extends', 'расширяет': 'extends', '扩展': 'extends', '継承': 'extends',
-    'implementer': 'implements', 'implémenter': 'implements', 'implements': 'implements', 'implementar': 'implements', 'реализует': 'implements', '实现': 'implements', '実装': 'implements',
-    'interface': 'interface', 'interfaz': 'interface', 'интерфейс': 'interface', '接口': 'interface', 'インターフェース': 'interface',
-    'trait': 'trait', 'rasgo': 'trait', 'трейт': 'trait', '特性': 'trait', 'トレイト': 'trait',
-    'abstrait': 'abstract', 'abstract': 'abstract', 'abstracto': 'abstract', 'абстрактный': 'abstract', '抽象': 'abstract',
-    'final': 'final', 'финальный': 'final', '最终': 'final', 'ファイナル': 'final',
-    'lecture seule': 'readonly', 'readonly': 'readonly', 'soloLectura': 'readonly', 'только чтение': 'readonly', '只读': 'readonly', '読み取り専用': 'readonly',
-    
-    'public': 'public', 'publico': 'public', 'público': 'public', 'публичный': 'public', '公共': 'public', 'パブリック': 'public',
-    'protege': 'protected', 'protégé': 'protected', 'protected': 'protected', 'protegido': 'protected', 'защищённый': 'protected', '受保护': 'protected', 'プロテクト': 'protected',
-    'prive': 'private', 'privé': 'private', 'private': 'private', 'privado': 'private', 'приватный': 'private', '私有': 'private', 'プライベート': 'private',
-    'statique': 'static', 'static': 'static', 'estatico': 'static', 'estático': 'static', 'статический': 'static', '静态': 'static', 'スタティック': 'static',
-    
-    'enumeration': 'enum', 'énumération': 'enum', 'enum': 'enum', 'enumeracion': 'enum', 'enumeración': 'enum', 'перечисление': 'enum', '枚举': 'enum', '列挙': 'enum',
-    
-    'espace de noms': 'namespace', 'namespace': 'namespace', 'espacio de nombres': 'namespace', 'пространство имён': 'namespace', '命名空间': 'namespace', '名前空間': 'namespace',
-    'utiliser': 'use', 'use': 'use', 'usar': 'use', 'использовать': 'use', '使用': 'use', '使う': 'use',
-    'comme': 'as', 'as': 'as', 'como': 'as', 'как': 'as', '作为': 'as', 'として': 'as',
-    
-    'inclure': 'include', 'include': 'include', 'incluir': 'include', 'включить': 'include', '包含': 'include', 'インクルード': 'include',
-    'inclure une fois': 'include_once', 'include_once': 'include_once', 'incluir una vez': 'include_once', 'включить один раз': 'include_once', '包含一次': 'include_once',
-    'exiger': 'require', 'require': 'require', 'requerir': 'require', 'требовать': 'require', '需要': 'require', '要求': 'require',
-    'exiger une fois': 'require_once', 'require_once': 'require_once', 'requerir una vez': 'require_once', 'требовать один раз': 'require_once', '需要一次': 'require_once',
-    
-    'essayer': 'try', 'try': 'try', 'intentar': 'try', 'попробовать': 'try', '尝试': 'try', 'トライ': 'try',
-    'attraper': 'catch', 'catch': 'catch', 'capturar': 'catch', 'поймать': 'catch', '捕获': 'catch', 'キャッチ': 'catch',
-    'enfin': 'finally', 'finally': 'finally', 'finalmente': 'finally', 'наконец': 'finally', '最终': 'finally', 'ファイナリー': 'finally',
-    'lancer': 'throw', 'throw': 'throw', 'lanzar': 'throw', 'бросить': 'throw', '抛出': 'throw', 'スロー': 'throw',
-    
-    'echo': 'echo', 'écho': 'echo', 'eco': 'echo', 'вывод': 'echo', '回显': 'echo', 'エコー': 'echo',
-    'imprimer': 'print', 'print': 'print', 'imprimir': 'print', 'печать': 'print', '打印': 'print', '印刷': 'print',
-    
-    'vrai': 'true', 'true': 'true', 'verdadero': 'true', 'истина': 'true', '真': 'true', '真実': 'true',
-    'faux': 'false', 'false': 'false', 'falso': 'false', 'ложь': 'false', '假': 'false', '偽': 'false',
-    'nul': 'null', 'null': 'null', 'nulo': 'null', 'ноль': 'null', '空值': 'null', 'ヌル': 'null',
-    
-    'global': 'global', 'глобальный': 'global', '全局': 'global', 'グローバル': 'global',
-    'const': 'const', 'constante': 'const', 'константа': 'const', '常量': 'const', '定数': 'const',
-    'var': 'var', 'variable': 'var', 'переменная': 'var', '变量': 'var', '変数': 'var',
-    
-    'et': 'and', 'and': 'and', 'y': 'and', 'и': 'and', '且': 'and', 'かつ': 'and',
-    'ou': 'or', 'or': 'or', 'o': 'or', 'или': 'or', '或': 'or', 'または': 'or',
-    'non': 'not', 'not': 'not', 'no': 'not', 'не': 'not', '非': 'not', 'ではない': 'not',
-    'ou exclusif': 'xor', 'xor': 'xor', 'o exclusivo': 'xor', 'исключающее или': 'xor', '异或': 'xor', '排他的論理和': 'xor',
-    
-    'instance de': 'instanceof', 'instanceof': 'instanceof', 'instancia de': 'instanceof', 'экземпляр': 'instanceof', '实例': 'instanceof', 'インスタンス': 'instanceof',
-    'cloner': 'clone', 'clone': 'clone', 'clonar': 'clone', 'клонировать': 'clone', '克隆': 'clone', 'クローン': 'clone',
-    
-    'soi': 'self', 'self': 'self', 'себя': 'self', '自身': 'self', '自己': 'self',
-    'parent': 'parent', 'padre': 'parent', 'родитель': 'parent', '父类': 'parent', '親': 'parent',
-    'ceci': '$this', 'esto': '$this', 'это': '$this', '这': '$this', 'これ': '$this',
-    
-    'aller a': 'goto', 'aller à': 'goto', 'goto': 'goto', 'ir a': 'goto', 'перейти': 'goto', '跳转': 'goto', 'ゴートゥ': 'goto',
-    'declarer': 'declare', 'déclarer': 'declare', 'declare': 'declare', 'declarar': 'declare', 'объявить': 'declare', '声明': 'declare', '宣言': 'declare',
-    
-    'liste': 'list', 'list': 'list', 'lista': 'list', 'список': 'list', '列表': 'list', 'リスト': 'list',
-    'vide': 'empty', 'empty': 'empty', 'vacio': 'empty', 'vacío': 'empty', 'пусто': 'empty', '空': 'empty', '空か': 'empty',
-    'existant': 'isset', 'isset': 'isset', 'existe': 'isset', 'существует': 'isset', '已设置': 'isset', '設定済み': 'isset',
-    'supprimer': 'unset', 'unset': 'unset', 'eliminar': 'unset', 'удалить': 'unset', '取消设置': 'unset', '解除': 'unset',
-    'evaluer': 'eval', 'évaluer': 'eval', 'eval': 'eval', 'evaluar': 'eval', 'выполнить': 'eval', '评估': 'eval', '評価': 'eval',
-    'sortie': 'exit', 'exit': 'exit', 'salir': 'exit', 'выход': 'exit', '退出': 'exit', '終了': 'exit',
-    'mourir': 'die', 'die': 'die', 'morir': 'die', 'умереть': 'die', '死': 'die', '終わる': 'die',
-    
-    'produire': 'yield', 'yield': 'yield', 'producir': 'yield', 'генерировать': 'yield', '产出': 'yield', '譲る': 'yield',
-    'produire de': 'yield from', 'yield from': 'yield from', 'producir de': 'yield from', 'генерировать из': 'yield from', '产出从': 'yield from'
-}
-
-const PHP_TYPES = {
-    'chaine': 'string', 'chaîne': 'string', 'string': 'string', 'cadena': 'string', 'строка': 'string', '字符串': 'string', '文字列': 'string',
-    'entier': 'int', 'int': 'int', 'integer': 'int', 'entero': 'int', 'целое число': 'int', '整数': 'int',
-    'flottant': 'float', 'float': 'float', 'double': 'float', 'flotante': 'float', 'число с плавающей точкой': 'float', '浮点数': 'float', '浮動小数点': 'float',
-    'booleen': 'bool', 'booléen': 'bool', 'bool': 'bool', 'boolean': 'bool', 'booleano': 'bool', 'логический': 'bool', '布尔': 'bool', 'ブール': 'bool',
-    'tableau': 'array', 'array': 'array', 'arreglo': 'array', 'массив': 'array', '数组': 'array', '配列': 'array',
-    'objet': 'object', 'object': 'object', 'objeto': 'object', 'объект': 'object', '对象': 'object', 'オブジェクト': 'object',
-    'appelable': 'callable', 'callable': 'callable', 'llamable': 'callable', 'вызываемый': 'callable', '可调用': 'callable', '呼び出し可能': 'callable',
-    'iterable': 'iterable', 'itérable': 'iterable', 'итерируемый': 'iterable', '可迭代': 'iterable', 'イテラブル': 'iterable',
-    'mixte': 'mixed', 'mixed': 'mixed', 'mixto': 'mixed', 'смешанный': 'mixed', '混合': 'mixed', 'ミックス': 'mixed',
-    'void': 'void', 'vide': 'void', 'vacío': 'void', 'пустой': 'void', '空': 'void', 'ボイド': 'void',
-    'jamais': 'never', 'never': 'never', 'nunca': 'never', 'никогда': 'never', '从不': 'never', 'ネバー': 'never',
-    'ressource': 'resource', 'resource': 'resource', 'recurso': 'resource', 'ресурс': 'resource', '资源': 'resource', 'リソース': 'resource'
-}
-
-class PHPLexer {
-    constructor(source, i18n = {}) {
-        this.source = source
-        this.pos = 0
-        this.line = 1
-        this.column = 1
-        this.tokens = []
-        this.i18n = i18n
-        this.inPHP = false
-    }
-
-    peek(offset = 0) {
-        return this.source[this.pos + offset] || ''
-    }
-
-    advance() {
-        const char = this.source[this.pos]
-        this.pos++
-        if (char === '\n') {
-            this.line++
-            this.column = 1
-        } else {
-            this.column++
-        }
-        return char
-    }
-
-    skipWhitespace() {
-        while (this.pos < this.source.length && /\s/.test(this.peek())) {
-            this.advance()
-        }
-    }
-
-    skipComment() {
-        if (this.peek() === '/' && this.peek(1) === '/') {
-            while (this.pos < this.source.length && this.peek() !== '\n') {
-                this.advance()
-            }
-            return true
-        }
-        if (this.peek() === '#' && this.peek(1) !== '[') {
-            while (this.pos < this.source.length && this.peek() !== '\n') {
-                this.advance()
-            }
-            return true
-        }
-        if (this.peek() === '/' && this.peek(1) === '*') {
-            this.advance()
-            this.advance()
-            while (this.pos < this.source.length) {
-                if (this.peek() === '*' && this.peek(1) === '/') {
-                    this.advance()
-                    this.advance()
-                    break
-                }
-                this.advance()
-            }
-            return true
-        }
-        return false
-    }
-
-    tokenize() {
-        while (this.pos < this.source.length) {
-            this.skipWhitespace()
-            while (this.skipComment()) {
-                this.skipWhitespace()
-            }
-            if (this.pos >= this.source.length) break
-
-            const loc = { line: this.line, column: this.column }
-
-            if (!this.inPHP) {
-                if (this.source.slice(this.pos, this.pos + 5) === '<?php') {
-                    this.tokens.push({ type: 'PHP_OPEN', loc })
-                    this.pos += 5
-                    this.inPHP = true
-                    continue
-                }
-                if (this.source.slice(this.pos, this.pos + 3) === '<?=') {
-                    this.tokens.push({ type: 'PHP_ECHO_OPEN', loc })
-                    this.pos += 3
-                    this.inPHP = true
-                    continue
-                }
-                if (this.source.slice(this.pos, this.pos + 2) === '<?') {
-                    this.tokens.push({ type: 'PHP_SHORT_OPEN', loc })
-                    this.pos += 2
-                    this.inPHP = true
-                    continue
-                }
-                let html = ''
-                while (this.pos < this.source.length) {
-                    if (this.source.slice(this.pos, this.pos + 2) === '<?') break
-                    html += this.advance()
-                }
-                if (html) {
-                    this.tokens.push({ type: 'HTML', value: html, loc })
-                }
-                continue
-            }
-
-            if (this.source.slice(this.pos, this.pos + 2) === '?>') {
-                this.tokens.push({ type: 'PHP_CLOSE', loc })
-                this.pos += 2
-                this.inPHP = false
-                continue
-            }
-
-            const char = this.peek()
-
-            if (char === '$') {
-                this.tokens.push(this.readVariable())
-                continue
-            }
-
-            if (char === '"' || char === "'") {
-                this.tokens.push(this.readString(char))
-                continue
-            }
-
-            if (char === '`') {
-                this.tokens.push(this.readShellExec())
-                continue
-            }
-
-            if (/[0-9]/.test(char) || (char === '.' && /[0-9]/.test(this.peek(1)))) {
-                this.tokens.push(this.readNumber())
-                continue
-            }
-
-            if (/[a-zA-ZÀ-ÿА-яぁ-ゟァ-ヿ一-龯_]/.test(char)) {
-                const { word, loc: wordLoc } = this.readWord()
-                const tokenType = this.classifyWord(word)
-                this.tokens.push({ type: tokenType, value: word, loc: wordLoc })
-                continue
-            }
-
-            if (char === '#' && this.peek(1) === '[') {
-                this.tokens.push(this.readAttribute())
-                continue
-            }
-
-            const token = this.readOperator()
-            if (token) {
-                this.tokens.push(token)
-                continue
-            }
-
-            this.advance()
-        }
-
-        this.tokens.push({ type: 'EOF', loc: { line: this.line, column: this.column } })
-        return this.tokens
-    }
-
-    readVariable() {
-        const loc = { line: this.line, column: this.column }
-        this.advance()
-        
-        if (this.peek() === '$') {
-            this.advance()
-            if (this.peek() === '{') {
-                this.advance()
-                let expr = ''
-                let braceCount = 1
-                while (braceCount > 0 && this.pos < this.source.length) {
-                    const c = this.peek()
-                    if (c === '{') braceCount++
-                    if (c === '}') braceCount--
-                    if (braceCount > 0) expr += this.advance()
-                    else this.advance()
-                }
-                return { type: 'VARIABLE_VARIABLE', value: expr, loc }
-            }
-            const name = this.readIdentifier()
-            return { type: 'VARIABLE_VARIABLE', value: name, loc }
-        }
-
-        if (this.peek() === '{') {
-            this.advance()
-            let expr = ''
-            let braceCount = 1
-            while (braceCount > 0 && this.pos < this.source.length) {
-                const c = this.peek()
-                if (c === '{') braceCount++
-                if (c === '}') braceCount--
-                if (braceCount > 0) expr += this.advance()
-                else this.advance()
-            }
-            return { type: 'VARIABLE_EXPR', value: expr, loc }
-        }
-
-        const name = this.readIdentifier()
-        return { type: 'VARIABLE', value: name, loc }
-    }
-
-    readIdentifier() {
-        let name = ''
-        while (this.pos < this.source.length && /[a-zA-Z0-9À-ÿА-яぁ-ゟァ-ヿ一-龯_]/.test(this.peek())) {
-            name += this.advance()
-        }
-        return name
-    }
-
-    readWord() {
-        const loc = { line: this.line, column: this.column }
-        let word = ''
-        
-        while (this.pos < this.source.length && /[a-zA-Z0-9À-ÿА-яぁ-ゟァ-ヿ一-龯_ ]/.test(this.peek())) {
-            const nextChar = this.peek()
-            if (nextChar === ' ') {
-                const testWord = word + ' ' + this.lookAheadWord()
-                if (PHP_KEYWORDS[testWord.toLowerCase()]) {
-                    this.advance()
-                    word = testWord
-                    continue
-                }
-                break
-            }
-            word += this.advance()
-        }
-        
-        return { word: word.trim(), loc }
-    }
-
-    lookAheadWord() {
-        let result = ''
-        let i = this.pos
-        while (i < this.source.length && /[a-zA-Z0-9À-ÿА-яぁ-ゟァ-ヿ一-龯_]/.test(this.source[i])) {
-            result += this.source[i]
-            i++
-        }
-        return result
-    }
-
-    readString(quote) {
-        const loc = { line: this.line, column: this.column }
-        this.advance()
-        let value = ''
-        let raw = quote
-        
-        while (this.pos < this.source.length && this.peek() !== quote) {
-            if (this.peek() === '\\') {
-                raw += this.advance()
-                if (this.pos < this.source.length) {
-                    const escaped = this.advance()
-                    raw += escaped
-                    switch (escaped) {
-                        case 'n': value += '\n'; break
-                        case 'r': value += '\r'; break
-                        case 't': value += '\t'; break
-                        case '\\': value += '\\'; break
-                        case quote: value += quote; break
-                        case '$': value += '$'; break
-                        default: value += '\\' + escaped
-                    }
-                }
-            } else {
-                const c = this.advance()
-                value += c
-                raw += c
-            }
-        }
-        
-        if (this.peek() === quote) {
-            raw += this.advance()
-        }
-        
-        const isInterpolated = quote === '"' && value.includes('$')
-        return { 
-            type: isInterpolated ? 'INTERPOLATED_STRING' : 'STRING', 
-            value, 
-            raw, 
-            loc 
-        }
-    }
-
-    readShellExec() {
-        const loc = { line: this.line, column: this.column }
-        this.advance()
-        let command = ''
-        
-        while (this.pos < this.source.length && this.peek() !== '`') {
-            if (this.peek() === '\\' && this.peek(1) === '`') {
-                this.advance()
-                command += this.advance()
-            } else {
-                command += this.advance()
-            }
-        }
-        
-        if (this.peek() === '`') this.advance()
-        
-        return { type: 'SHELL_EXEC', value: command, loc }
-    }
-
-    readNumber() {
-        const loc = { line: this.line, column: this.column }
-        let value = ''
-        
-        if (this.peek() === '0' && (this.peek(1) === 'x' || this.peek(1) === 'X')) {
-            value += this.advance() + this.advance()
-            while (/[0-9a-fA-F_]/.test(this.peek())) {
-                value += this.advance()
-            }
-            return { type: 'NUMBER', value: parseInt(value.replace(/_/g, ''), 16), raw: value, loc }
-        }
-        
-        if (this.peek() === '0' && (this.peek(1) === 'b' || this.peek(1) === 'B')) {
-            value += this.advance() + this.advance()
-            while (/[01_]/.test(this.peek())) {
-                value += this.advance()
-            }
-            return { type: 'NUMBER', value: parseInt(value.replace(/_/g, '').slice(2), 2), raw: value, loc }
-        }
-        
-        if (this.peek() === '0' && (this.peek(1) === 'o' || this.peek(1) === 'O')) {
-            value += this.advance() + this.advance()
-            while (/[0-7_]/.test(this.peek())) {
-                value += this.advance()
-            }
-            return { type: 'NUMBER', value: parseInt(value.replace(/_/g, '').slice(2), 8), raw: value, loc }
-        }
-        
-        while (/[0-9_]/.test(this.peek())) {
-            value += this.advance()
-        }
-        
-        if (this.peek() === '.' && /[0-9]/.test(this.peek(1))) {
-            value += this.advance()
-            while (/[0-9_]/.test(this.peek())) {
-                value += this.advance()
-            }
-        }
-        
-        if (this.peek() === 'e' || this.peek() === 'E') {
-            value += this.advance()
-            if (this.peek() === '+' || this.peek() === '-') {
-                value += this.advance()
-            }
-            while (/[0-9_]/.test(this.peek())) {
-                value += this.advance()
-            }
-        }
-        
-        const cleanValue = value.replace(/_/g, '')
-        return { 
-            type: 'NUMBER', 
-            value: cleanValue.includes('.') || cleanValue.includes('e') || cleanValue.includes('E') 
-                ? parseFloat(cleanValue) 
-                : parseInt(cleanValue, 10), 
-            raw: value, 
-            loc 
-        }
-    }
-
-    readAttribute() {
-        const loc = { line: this.line, column: this.column }
-        this.advance()
-        this.advance()
-        
-        let content = ''
-        let bracketCount = 1
-        
-        while (bracketCount > 0 && this.pos < this.source.length) {
-            const c = this.peek()
-            if (c === '[') bracketCount++
-            if (c === ']') bracketCount--
-            if (bracketCount > 0) content += this.advance()
-            else this.advance()
-        }
-        
-        return { type: 'ATTRIBUTE', value: content, loc }
-    }
-
-    readOperator() {
-        const loc = { line: this.line, column: this.column }
-        
-        const threeChar = this.source.slice(this.pos, this.pos + 3)
-        const twoChar = this.source.slice(this.pos, this.pos + 2)
-        const oneChar = this.peek()
-        
-        const threeCharOps = {
-            '===': 'IDENTICAL', '!==': 'NOT_IDENTICAL', '<=>': 'SPACESHIP',
-            '**=': 'POW_ASSIGN', '??=': 'NULL_COALESCE_ASSIGN', '...': 'SPREAD',
-            '?->': 'NULLSAFE_ARROW'
-        }
-        
-        const twoCharOps = {
-            '==': 'EQUAL', '!=': 'NOT_EQUAL', '<>': 'NOT_EQUAL',
-            '<=': 'LTE', '>=': 'GTE', '&&': 'AND', '||': 'OR',
-            '++': 'INCREMENT', '--': 'DECREMENT', '**': 'POW',
-            '+=': 'PLUS_ASSIGN', '-=': 'MINUS_ASSIGN', '*=': 'TIMES_ASSIGN',
-            '/=': 'DIV_ASSIGN', '%=': 'MOD_ASSIGN', '.=': 'CONCAT_ASSIGN',
-            '&=': 'AND_ASSIGN', '|=': 'OR_ASSIGN', '^=': 'XOR_ASSIGN',
-            '<<': 'SHL', '>>': 'SHR', '->': 'ARROW', '::': 'DOUBLE_COLON',
-            '??': 'NULL_COALESCE', '=>': 'DOUBLE_ARROW', 'fn': 'FN'
-        }
-        
-        const oneCharOps = {
-            '+': 'PLUS', '-': 'MINUS', '*': 'TIMES', '/': 'DIV', '%': 'MOD',
-            '=': 'ASSIGN', '<': 'LT', '>': 'GT', '!': 'NOT', '~': 'TILDE',
-            '&': 'AMPERSAND', '|': 'PIPE', '^': 'CARET', '@': 'AT',
-            '(': 'LPAREN', ')': 'RPAREN', '[': 'LBRACKET', ']': 'RBRACKET',
-            '{': 'LBRACE', '}': 'RBRACE', ';': 'SEMICOLON', ':': 'COLON',
-            ',': 'COMMA', '.': 'DOT', '?': 'QUESTION', '\\': 'BACKSLASH'
-        }
-        
-        if (threeCharOps[threeChar]) {
-            this.advance(); this.advance(); this.advance()
-            return { type: threeCharOps[threeChar], value: threeChar, loc }
-        }
-        
-        if (twoCharOps[twoChar]) {
-            this.advance(); this.advance()
-            return { type: twoCharOps[twoChar], value: twoChar, loc }
-        }
-        
-        if (oneCharOps[oneChar]) {
-            this.advance()
-            return { type: oneCharOps[oneChar], value: oneChar, loc }
-        }
-        
-        return null
-    }
-
-    classifyWord(word) {
-        const lowerWord = word.toLowerCase()
-        
-        if (PHP_KEYWORDS[lowerWord] || PHP_KEYWORDS[word]) {
-            return 'KEYWORD'
-        }
-        
-        if (PHP_TYPES[lowerWord] || PHP_TYPES[word]) {
-            return 'TYPE'
-        }
-        
-        return 'IDENTIFIER'
-    }
-}
-
-class PHPParser {
-    constructor(i18nPath = null) {
-        this.tokens = []
-        this.pos = 0
-        this.i18n = {}
-        
-        if (i18nPath) {
-            this.loadI18n(i18nPath)
-        }
-    }
-
-    loadI18n(filePath) {
-        try {
-            const content = fs.readFileSync(filePath, 'utf-8')
-            this.i18n = JSON.parse(content)
-        } catch (e) {
-            console.error(`Erreur chargement i18n: ${e.message}`)
-            this.i18n = {}
-        }
-    }
-
-    setI18n(i18nData) {
-        this.i18n = i18nData
-    }
-
-    parse(source) {
-        const lexer = new PHPLexer(source, this.i18n)
-        this.tokens = lexer.tokenize()
-        this.pos = 0
-        return this.parseProgram()
-    }
-
-    peek(offset = 0) {
-        return this.tokens[this.pos + offset] || { type: 'EOF' }
-    }
-
-    advance() {
-        return this.tokens[this.pos++]
-    }
-
-    match(...types) {
-        return types.includes(this.peek().type)
-    }
-
-    expect(type) {
-        const token = this.peek()
-        if (token.type !== type) {
-            throw new Error(`Attendu ${type}, reçu ${token.type} à ligne ${token.loc?.line}`)
-        }
-        return this.advance()
-    }
-
-    parseProgram() {
-        const body = []
-        
-        while (!this.match('EOF')) {
-            const stmt = this.parseTopLevel()
-            if (stmt) body.push(stmt)
-        }
-        
-        return new AST.Program(body)
-    }
-
-    parseTopLevel() {
-        const token = this.peek()
-        
-        if (token.type === 'HTML') {
-            this.advance()
-            return new AST.HTMLBlock(token.value, token.loc)
-        }
-        
-        if (token.type === 'PHP_OPEN' || token.type === 'PHP_SHORT_OPEN') {
-            this.advance()
-            return this.parsePHPBlock()
-        }
-        
-        if (token.type === 'PHP_ECHO_OPEN') {
-            this.advance()
-            const expr = this.parseExpression()
-            if (this.match('PHP_CLOSE')) this.advance()
-            return new AST.EchoStatement([expr], token.loc)
-        }
-        
-        return this.parseStatement()
-    }
-
-    parsePHPBlock() {
-        const body = []
-        
-        while (!this.match('PHP_CLOSE', 'EOF')) {
-            const stmt = this.parseStatement()
-            if (stmt) body.push(stmt)
-        }
-        
-        if (this.match('PHP_CLOSE')) this.advance()
-        
-        return new AST.PHPBlock(body)
-    }
-
-    parseStatement() {
-        const token = this.peek()
-        
-        if (token.type === 'KEYWORD') {
-            const keyword = this.translateKeyword(token.value)
-            
-            switch (keyword) {
-                case 'if': return this.parseIfStatement()
-                case 'switch': return this.parseSwitchStatement()
-                case 'match': return this.parseMatchExpression()
-                case 'for': return this.parseForStatement()
-                case 'foreach': return this.parseForeachStatement()
-                case 'while': return this.parseWhileStatement()
-                case 'do': return this.parseDoWhileStatement()
-                case 'function': return this.parseFunctionDeclaration()
-                case 'class': return this.parseClassDeclaration()
-                case 'interface': return this.parseInterfaceDeclaration()
-                case 'trait': return this.parseTraitDeclaration()
-                case 'enum': return this.parseEnumDeclaration()
-                case 'namespace': return this.parseNamespaceDeclaration()
-                case 'use': return this.parseUseDeclaration()
-                case 'try': return this.parseTryStatement()
-                case 'throw': return this.parseThrowStatement()
-                case 'return': return this.parseReturnStatement()
-                case 'break': return this.parseBreakStatement()
-                case 'continue': return this.parseContinueStatement()
-                case 'echo': return this.parseEchoStatement()
-                case 'print': return this.parsePrintStatement()
-                case 'global': return this.parseGlobalStatement()
-                case 'static': return this.parseStaticStatement()
-                case 'declare': return this.parseDeclareStatement()
-                case 'goto': return this.parseGotoStatement()
-                case 'unset': return this.parseUnsetStatement()
-                case 'const': return this.parseConstDeclaration()
-                case 'abstract':
-                case 'final':
-                    return this.parseClassDeclaration()
-            }
-        }
-        
-        if (token.type === 'ATTRIBUTE') {
-            return this.parseAttributedDeclaration()
-        }
-        
-        if (token.type === 'IDENTIFIER' && this.peek(1).type === 'COLON') {
-            return this.parseLabelStatement()
-        }
-        
-        if (this.match('LBRACE')) {
-            return this.parseBlockStatement()
-        }
-        
-        if (this.match('SEMICOLON')) {
-            this.advance()
-            return new AST.EmptyStatement(token.loc)
-        }
-        
-        const expr = this.parseExpression()
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.ExpressionStatement(expr, token.loc)
-    }
-
-    parseIfStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        this.expect('LPAREN')
-        const test = this.parseExpression()
-        this.expect('RPAREN')
-        
-        const consequent = this.parseStatementOrBlock()
-        
-        let alternate = null
-        if (this.match('KEYWORD')) {
-            const kw = this.translateKeyword(this.peek().value)
-            if (kw === 'elseif') {
-                alternate = this.parseIfStatement()
-            } else if (kw === 'else') {
-                this.advance()
-                alternate = this.parseStatementOrBlock()
-            }
-        }
-        
-        return new AST.IfStatement(test, consequent, alternate, loc)
-    }
-
-    parseSwitchStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        this.expect('LPAREN')
-        const discriminant = this.parseExpression()
-        this.expect('RPAREN')
-        
-        this.expect('LBRACE')
-        const cases = []
-        
-        while (!this.match('RBRACE', 'EOF')) {
-            const caseToken = this.peek()
-            if (caseToken.type === 'KEYWORD') {
-                const kw = this.translateKeyword(caseToken.value)
-                if (kw === 'case') {
-                    this.advance()
-                    const test = this.parseExpression()
-                    this.expect('COLON')
-                    const consequent = []
-                    while (!this.match('RBRACE', 'EOF')) {
-                        const nextKw = this.peek().type === 'KEYWORD' ? this.translateKeyword(this.peek().value) : null
-                        if (nextKw === 'case' || nextKw === 'default') break
-                        consequent.push(this.parseStatement())
-                    }
-                    cases.push(new AST.SwitchCase(test, consequent, caseToken.loc))
-                } else if (kw === 'default') {
-                    this.advance()
-                    this.expect('COLON')
-                    const consequent = []
-                    while (!this.match('RBRACE', 'EOF')) {
-                        const nextKw = this.peek().type === 'KEYWORD' ? this.translateKeyword(this.peek().value) : null
-                        if (nextKw === 'case' || nextKw === 'default') break
-                        consequent.push(this.parseStatement())
-                    }
-                    cases.push(new AST.SwitchCase(null, consequent, caseToken.loc))
-                } else {
-                    break
-                }
-            } else {
-                break
-            }
-        }
-        
-        this.expect('RBRACE')
-        return new AST.SwitchStatement(discriminant, cases, loc)
-    }
-
-    parseMatchExpression() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        this.expect('LPAREN')
-        const condition = this.parseExpression()
-        this.expect('RPAREN')
-        
-        this.expect('LBRACE')
-        const arms = []
-        
-        while (!this.match('RBRACE', 'EOF')) {
-            const armLoc = this.peek().loc
-            let conditions = []
-            let isDefault = false
-            
-            if (this.peek().type === 'KEYWORD' && this.translateKeyword(this.peek().value) === 'default') {
-                this.advance()
-                isDefault = true
-            } else {
-                conditions.push(this.parseExpression())
-                while (this.match('COMMA')) {
-                    this.advance()
-                    if (this.match('DOUBLE_ARROW')) break
-                    conditions.push(this.parseExpression())
-                }
-            }
-            
-            this.expect('DOUBLE_ARROW')
-            const body = this.parseExpression()
-            
-            arms.push(new AST.MatchArm(conditions, body, isDefault, armLoc))
-            
-            if (this.match('COMMA')) this.advance()
-        }
-        
-        this.expect('RBRACE')
-        return new AST.MatchExpression(condition, arms, loc)
-    }
-
-    parseForStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        this.expect('LPAREN')
-        
-        const init = this.match('SEMICOLON') ? null : this.parseExpressionList()
-        this.expect('SEMICOLON')
-        
-        const test = this.match('SEMICOLON') ? null : this.parseExpressionList()
-        this.expect('SEMICOLON')
-        
-        const update = this.match('RPAREN') ? null : this.parseExpressionList()
-        this.expect('RPAREN')
-        
-        const body = this.parseStatementOrBlock()
-        
-        return new AST.ForStatement(init, test, update, body, loc)
-    }
-
-    parseForeachStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        this.expect('LPAREN')
-        const source = this.parseExpression()
-        
-        this.expect('KEYWORD')
-        
-        let key = null
-        let value = null
-        let byRef = false
-        
-        if (this.match('AMPERSAND')) {
-            this.advance()
-            byRef = true
-        }
-        
-        value = this.parseVariable()
-        
-        if (this.match('DOUBLE_ARROW')) {
-            this.advance()
-            key = value
-            byRef = false
-            
-            if (this.match('AMPERSAND')) {
-                this.advance()
-                byRef = true
-            }
-            value = this.parseVariable()
-        }
-        
-        this.expect('RPAREN')
-        const body = this.parseStatementOrBlock()
-        
-        return new AST.ForeachStatement(source, key, value, body, byRef, loc)
-    }
-
-    parseWhileStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        this.expect('LPAREN')
-        const test = this.parseExpression()
-        this.expect('RPAREN')
-        
-        const body = this.parseStatementOrBlock()
-        
-        return new AST.WhileStatement(test, body, loc)
-    }
-
-    parseDoWhileStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const body = this.parseStatementOrBlock()
-        
-        this.expect('KEYWORD')
-        this.expect('LPAREN')
-        const test = this.parseExpression()
-        this.expect('RPAREN')
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.DoWhileStatement(body, test, loc)
-    }
-
-    parseFunctionDeclaration() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let byRef = false
-        if (this.match('AMPERSAND')) {
-            this.advance()
-            byRef = true
-        }
-        
-        const name = this.expect('IDENTIFIER').value
-        
-        this.expect('LPAREN')
-        const params = this.parseParameterList()
-        this.expect('RPAREN')
-        
-        let returnType = null
-        if (this.match('COLON')) {
-            this.advance()
-            returnType = this.parseTypeReference()
-        }
-        
-        const body = this.parseBlockStatement()
-        
-        return new AST.FunctionDeclaration(name, params, body, returnType, byRef, loc)
-    }
-
-    parseParameterList() {
-        const params = []
-        
-        while (!this.match('RPAREN', 'EOF')) {
-            params.push(this.parseParameter())
-            if (!this.match('RPAREN')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        return params
-    }
-
-    parseParameter() {
-        const loc = this.peek().loc
-        let visibility = null
-        let readonly = false
-        let type = null
-        let byRef = false
-        let variadic = false
-        
-        if (this.match('KEYWORD')) {
-            const kw = this.translateKeyword(this.peek().value)
-            if (['public', 'protected', 'private'].includes(kw)) {
-                visibility = kw
-                this.advance()
-            }
-        }
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'readonly') {
-            readonly = true
-            this.advance()
-        }
-        
-        if (this.match('TYPE', 'IDENTIFIER', 'QUESTION')) {
-            type = this.parseTypeReference()
-        }
-        
-        if (this.match('AMPERSAND')) {
-            this.advance()
-            byRef = true
-        }
-        
-        if (this.match('SPREAD')) {
-            this.advance()
-            variadic = true
-        }
-        
-        const nameToken = this.expect('VARIABLE')
-        const name = nameToken.value
-        
-        let defaultValue = null
-        if (this.match('ASSIGN')) {
-            this.advance()
-            defaultValue = this.parseExpression()
-        }
-        
-        return new AST.Parameter(name, type, defaultValue, byRef, variadic, visibility, readonly, loc)
-    }
-
-    parseTypeReference() {
-        let nullable = false
-        
-        if (this.match('QUESTION')) {
-            this.advance()
-            nullable = true
-        }
-        
-        const types = [this.parseSingleType()]
-        
-        while (this.match('PIPE')) {
-            this.advance()
-            types.push(this.parseSingleType())
-        }
-        
-        if (types.length === 1) {
-            types[0].nullable = nullable
-            return types[0]
-        }
-        
-        return new AST.UnionType(types)
-    }
-
-    parseSingleType() {
-        const loc = this.peek().loc
-        let name = ''
-        
-        if (this.match('BACKSLASH')) {
-            name += this.advance().value
-        }
-        
-        while (this.match('IDENTIFIER', 'TYPE')) {
-            name += this.advance().value
-            if (this.match('BACKSLASH')) {
-                name += this.advance().value
-            } else {
-                break
-            }
-        }
-        
-        return new AST.TypeReference(this.translateType(name) || name, false, loc)
-    }
-
-    parseClassDeclaration() {
-        const loc = this.peek().loc
-        const modifiers = []
-        const attributes = []
-        
-        while (this.match('KEYWORD')) {
-            const kw = this.translateKeyword(this.peek().value)
-            if (['abstract', 'final', 'readonly'].includes(kw)) {
-                modifiers.push(kw)
-                this.advance()
-            } else if (kw === 'class') {
-                this.advance()
-                break
-            } else {
-                break
-            }
-        }
-        
-        const name = this.expect('IDENTIFIER').value
-        
-        let superClass = null
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'extends') {
-            this.advance()
-            superClass = this.parseNamespaceName()
-        }
-        
-        const interfaces = []
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'implements') {
-            this.advance()
-            interfaces.push(this.parseNamespaceName())
-            while (this.match('COMMA')) {
-                this.advance()
-                interfaces.push(this.parseNamespaceName())
-            }
-        }
-        
-        const body = this.parseClassBody()
-        
-        return new AST.ClassDeclaration(name, body, superClass, interfaces, modifiers, attributes, loc)
-    }
-
-    parseClassBody() {
-        this.expect('LBRACE')
-        const members = []
-        
-        while (!this.match('RBRACE', 'EOF')) {
-            const member = this.parseClassMember()
-            if (member) members.push(member)
-        }
-        
-        this.expect('RBRACE')
-        return new AST.ClassBody(members)
-    }
-
-    parseClassMember() {
-        const loc = this.peek().loc
-        const modifiers = []
-        const attributes = []
-        
-        while (this.match('ATTRIBUTE')) {
-            attributes.push(this.parseAttributeGroup())
-        }
-        
-        while (this.match('KEYWORD')) {
-            const kw = this.translateKeyword(this.peek().value)
-            if (['public', 'protected', 'private', 'static', 'abstract', 'final', 'readonly'].includes(kw)) {
-                modifiers.push(kw)
-                this.advance()
-            } else {
-                break
-            }
-        }
-        
-        if (this.match('KEYWORD')) {
-            const kw = this.translateKeyword(this.peek().value)
-            
-            if (kw === 'function') {
-                this.advance()
-                return this.parseMethodDefinition(modifiers, attributes, loc)
-            }
-            
-            if (kw === 'const') {
-                this.advance()
-                return this.parseClassConstant(modifiers, loc)
-            }
-            
-            if (kw === 'use') {
-                this.advance()
-                return this.parseTraitUse()
-            }
-        }
-        
-        return this.parsePropertyDeclaration(modifiers, attributes, loc)
-    }
-
-    parseMethodDefinition(modifiers, attributes, loc) {
-        let byRef = false
-        if (this.match('AMPERSAND')) {
-            this.advance()
-            byRef = true
-        }
-        
-        const name = this.expect('IDENTIFIER').value
-        
-        this.expect('LPAREN')
-        const params = this.parseParameterList()
-        this.expect('RPAREN')
-        
-        let returnType = null
-        if (this.match('COLON')) {
-            this.advance()
-            returnType = this.parseTypeReference()
-        }
-        
-        let body = null
-        if (this.match('LBRACE')) {
-            body = this.parseBlockStatement()
-        } else {
-            this.expect('SEMICOLON')
-        }
-        
-        return new AST.MethodDefinition(name, params, body, returnType, modifiers, byRef, attributes, loc)
-    }
-
-    parsePropertyDeclaration(modifiers, attributes, loc) {
-        let type = null
-        
-        if (this.match('TYPE', 'IDENTIFIER', 'QUESTION')) {
-            type = this.parseTypeReference()
-        }
-        
-        const nameToken = this.expect('VARIABLE')
-        const name = nameToken.value
-        
-        let value = null
-        if (this.match('ASSIGN')) {
-            this.advance()
-            value = this.parseExpression()
-        }
-        
-        this.expect('SEMICOLON')
-        
-        return new AST.PropertyDeclaration(name, value, type, modifiers, attributes, loc)
-    }
-
-    parseClassConstant(modifiers, loc) {
-        let type = null
-        
-        if (this.match('TYPE', 'IDENTIFIER', 'QUESTION') && this.peek(1).type === 'IDENTIFIER') {
-            type = this.parseTypeReference()
-        }
-        
-        const name = this.expect('IDENTIFIER').value
-        this.expect('ASSIGN')
-        const value = this.parseExpression()
-        
-        this.expect('SEMICOLON')
-        
-        return new AST.ClassConstant(name, value, modifiers, type, loc)
-    }
-
-    parseInterfaceDeclaration() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const name = this.expect('IDENTIFIER').value
-        
-        const extends_ = []
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'extends') {
-            this.advance()
-            extends_.push(this.parseNamespaceName())
-            while (this.match('COMMA')) {
-                this.advance()
-                extends_.push(this.parseNamespaceName())
-            }
-        }
-        
-        const body = this.parseClassBody()
-        
-        return new AST.InterfaceDeclaration(name, body, extends_, [], loc)
-    }
-
-    parseTraitDeclaration() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const name = this.expect('IDENTIFIER').value
-        const body = this.parseClassBody()
-        
-        return new AST.TraitDeclaration(name, body, [], loc)
-    }
-
-    parseTraitUse() {
-        const traits = [this.parseNamespaceName()]
-        
-        while (this.match('COMMA')) {
-            this.advance()
-            traits.push(this.parseNamespaceName())
-        }
-        
-        const adaptations = []
-        
-        if (this.match('LBRACE')) {
-            this.advance()
-            while (!this.match('RBRACE', 'EOF')) {
-                this.advance()
-            }
-            this.expect('RBRACE')
-        } else {
-            this.expect('SEMICOLON')
-        }
-        
-        return new AST.TraitUse(traits, adaptations)
-    }
-
-    parseEnumDeclaration() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const name = this.expect('IDENTIFIER').value
-        
-        let backingType = null
-        if (this.match('COLON')) {
-            this.advance()
-            backingType = this.parseTypeReference()
-        }
-        
-        const interfaces = []
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'implements') {
-            this.advance()
-            interfaces.push(this.parseNamespaceName())
-            while (this.match('COMMA')) {
-                this.advance()
-                interfaces.push(this.parseNamespaceName())
-            }
-        }
-        
-        this.expect('LBRACE')
-        const body = []
-        
-        while (!this.match('RBRACE', 'EOF')) {
-            if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'case') {
-                this.advance()
-                const caseName = this.expect('IDENTIFIER').value
-                let caseValue = null
-                if (this.match('ASSIGN')) {
-                    this.advance()
-                    caseValue = this.parseExpression()
-                }
-                this.expect('SEMICOLON')
-                body.push(new AST.EnumCase(caseName, caseValue))
-            } else {
-                body.push(this.parseClassMember())
-            }
-        }
-        
-        this.expect('RBRACE')
-        
-        return new AST.EnumDeclaration(name, body, backingType, interfaces, [], loc)
-    }
-
-    parseNamespaceDeclaration() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let name = null
-        if (this.match('IDENTIFIER', 'BACKSLASH')) {
-            name = this.parseNamespaceName()
-        }
-        
-        if (this.match('LBRACE')) {
-            this.advance()
-            const body = []
-            while (!this.match('RBRACE', 'EOF')) {
-                body.push(this.parseStatement())
-            }
-            this.expect('RBRACE')
-            return new AST.NamespaceDeclaration(name, body, loc)
-        }
-        
-        this.expect('SEMICOLON')
-        return new AST.NamespaceDeclaration(name, null, loc)
-    }
-
-    parseUseDeclaration() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let useType = null
-        if (this.match('KEYWORD')) {
-            const kw = this.translateKeyword(this.peek().value)
-            if (kw === 'function' || kw === 'const') {
-                useType = kw
-                this.advance()
-            }
-        }
-        
-        const declarations = []
-        declarations.push(this.parseUseClause())
-        
-        while (this.match('COMMA')) {
-            this.advance()
-            declarations.push(this.parseUseClause())
-        }
-        
-        this.expect('SEMICOLON')
-        
-        return new AST.UseDeclaration(declarations, useType, loc)
-    }
-
-    parseUseClause() {
-        const name = this.parseNamespaceName()
-        
-        let alias = null
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'as') {
-            this.advance()
-            alias = this.expect('IDENTIFIER').value
-        }
-        
-        return new AST.UseClause(name, alias)
-    }
-
-    parseNamespaceName() {
-        const parts = []
-        let absolute = false
-        
-        if (this.match('BACKSLASH')) {
-            absolute = true
-            this.advance()
-        }
-        
-        parts.push(this.expect('IDENTIFIER').value)
-        
-        while (this.match('BACKSLASH')) {
-            this.advance()
-            parts.push(this.expect('IDENTIFIER').value)
-        }
-        
-        return new AST.NamespaceName(parts, absolute)
-    }
-
-    parseTryStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const block = this.parseBlockStatement()
-        const catches = []
-        let finalizer = null
-        
-        while (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'catch') {
-            this.advance()
-            this.expect('LPAREN')
-            
-            const types = [this.parseNamespaceName()]
-            while (this.match('PIPE')) {
-                this.advance()
-                types.push(this.parseNamespaceName())
-            }
-            
-            let param = null
-            if (this.match('VARIABLE')) {
-                param = this.advance().value
-            }
-            
-            this.expect('RPAREN')
-            const catchBody = this.parseBlockStatement()
-            catches.push(new AST.CatchClause(types, param, catchBody))
-        }
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'finally') {
-            this.advance()
-            finalizer = new AST.FinallyClause(this.parseBlockStatement())
-        }
-        
-        return new AST.TryStatement(block, catches, finalizer, loc)
-    }
-
-    parseThrowStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const argument = this.parseExpression()
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.ThrowStatement(argument, loc)
-    }
-
-    parseReturnStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let argument = null
-        if (!this.match('SEMICOLON', 'PHP_CLOSE', 'EOF')) {
-            argument = this.parseExpression()
-        }
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.ReturnStatement(argument, loc)
-    }
-
-    parseBreakStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let level = null
-        if (this.match('NUMBER')) {
-            level = this.advance().value
-        }
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.BreakStatement(level, loc)
-    }
-
-    parseContinueStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let level = null
-        if (this.match('NUMBER')) {
-            level = this.advance().value
-        }
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.ContinueStatement(level, loc)
-    }
-
-    parseEchoStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const expressions = [this.parseExpression()]
-        while (this.match('COMMA')) {
-            this.advance()
-            expressions.push(this.parseExpression())
-        }
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.EchoStatement(expressions, loc)
-    }
-
-    parsePrintStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const expression = this.parseExpression()
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.PrintStatement(expression, loc)
-    }
-
-    parseGlobalStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const variables = [this.parseVariable()]
-        while (this.match('COMMA')) {
-            this.advance()
-            variables.push(this.parseVariable())
-        }
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.GlobalStatement(variables, loc)
-    }
-
-    parseStaticStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        if (this.match('KEYWORD')) {
-            return this.parseClassDeclaration()
-        }
-        
-        const declarations = []
-        
-        do {
-            if (this.match('COMMA')) this.advance()
-            const varToken = this.expect('VARIABLE')
-            let value = null
-            if (this.match('ASSIGN')) {
-                this.advance()
-                value = this.parseExpression()
-            }
-            declarations.push(new AST.StaticVariable(varToken.value, value))
-        } while (this.match('COMMA'))
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.StaticStatement(declarations, loc)
-    }
-
-    parseDeclareStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        this.expect('LPAREN')
-        const directives = []
-        
-        do {
-            if (this.match('COMMA')) this.advance()
-            const name = this.expect('IDENTIFIER').value
-            this.expect('ASSIGN')
-            const value = this.parseExpression()
-            directives.push(new AST.DeclareDirective(name, value))
-        } while (this.match('COMMA'))
-        
-        this.expect('RPAREN')
-        
-        let body = null
-        if (this.match('LBRACE')) {
-            body = this.parseBlockStatement()
-        } else if (!this.match('SEMICOLON')) {
-            body = this.parseStatement()
-        }
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.DeclareStatement(directives, body, loc)
-    }
-
-    parseGotoStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const label = this.expect('IDENTIFIER').value
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.GotoStatement(label, loc)
-    }
-
-    parseUnsetStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        this.expect('LPAREN')
-        const args = [this.parseExpression()]
-        while (this.match('COMMA')) {
-            this.advance()
-            args.push(this.parseExpression())
-        }
-        this.expect('RPAREN')
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.UnsetStatement(args, loc)
-    }
-
-    parseConstDeclaration() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const name = this.expect('IDENTIFIER').value
-        this.expect('ASSIGN')
-        const value = this.parseExpression()
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.ConstantDeclaration(name, value, loc)
-    }
-
-    parseLabelStatement() {
-        const loc = this.peek().loc
-        const name = this.advance().value
-        this.expect('COLON')
-        
-        return new AST.LabelStatement(name, loc)
-    }
-
-    parseAttributeGroup() {
-        const token = this.advance()
-        const attributes = []
-        
-        const parts = token.value.split(',')
-        for (const part of parts) {
-            const trimmed = part.trim()
-            if (trimmed) {
-                const match = trimmed.match(/^([^(]+)(?:\((.*)\))?$/)
-                if (match) {
-                    attributes.push(new AST.Attribute(match[1].trim(), []))
-                }
-            }
-        }
-        
-        return new AST.AttributeGroup(attributes)
-    }
-
-    parseAttributedDeclaration() {
-        const attributes = [this.parseAttributeGroup()]
-        
-        while (this.match('ATTRIBUTE')) {
-            attributes.push(this.parseAttributeGroup())
-        }
-        
-        return this.parseStatement()
-    }
-
-    parseBlockStatement() {
-        const loc = this.peek().loc
-        this.expect('LBRACE')
-        const body = []
-        
-        while (!this.match('RBRACE', 'EOF')) {
-            body.push(this.parseStatement())
-        }
-        
-        this.expect('RBRACE')
-        return new AST.BlockStatement(body, loc)
-    }
-
-    parseStatementOrBlock() {
-        if (this.match('LBRACE')) {
-            return this.parseBlockStatement()
-        }
-        return this.parseStatement()
-    }
-
-    parseExpressionList() {
-        const expressions = [this.parseExpression()]
-        while (this.match('COMMA')) {
-            this.advance()
-            expressions.push(this.parseExpression())
-        }
-        return expressions.length === 1 ? expressions[0] : expressions
-    }
-
-    parseExpression() {
-        return this.parseAssignmentExpression()
-    }
-
-    parseAssignmentExpression() {
-        const left = this.parseConditionalExpression()
-        
-        if (this.match('ASSIGN', 'PLUS_ASSIGN', 'MINUS_ASSIGN', 'TIMES_ASSIGN', 'DIV_ASSIGN', 
-            'MOD_ASSIGN', 'CONCAT_ASSIGN', 'AND_ASSIGN', 'OR_ASSIGN', 'XOR_ASSIGN',
-            'POW_ASSIGN', 'NULL_COALESCE_ASSIGN')) {
-            const op = this.advance()
-            const right = this.parseAssignmentExpression()
-            return new AST.AssignmentExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseConditionalExpression() {
-        const test = this.parseNullCoalescingExpression()
-        
-        if (this.match('QUESTION')) {
-            this.advance()
-            const consequent = this.match('COLON') ? null : this.parseExpression()
-            this.expect('COLON')
-            const alternate = this.parseConditionalExpression()
-            return new AST.ConditionalExpression(test, consequent, alternate, test.loc)
-        }
-        
-        return test
-    }
-
-    parseNullCoalescingExpression() {
-        let left = this.parseLogicalOrExpression()
-        
-        while (this.match('NULL_COALESCE')) {
-            this.advance()
-            const right = this.parseLogicalOrExpression()
-            left = new AST.NullCoalescingExpression(left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseLogicalOrExpression() {
-        let left = this.parseLogicalAndExpression()
-        
-        while (this.match('OR') || (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'or')) {
-            this.advance()
-            const right = this.parseLogicalAndExpression()
-            left = new AST.BinaryExpression('||', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseLogicalAndExpression() {
-        let left = this.parseBitwiseOrExpression()
-        
-        while (this.match('AND') || (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'and')) {
-            this.advance()
-            const right = this.parseBitwiseOrExpression()
-            left = new AST.BinaryExpression('&&', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseBitwiseOrExpression() {
-        let left = this.parseBitwiseXorExpression()
-        
-        while (this.match('PIPE')) {
-            this.advance()
-            const right = this.parseBitwiseXorExpression()
-            left = new AST.BinaryExpression('|', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseBitwiseXorExpression() {
-        let left = this.parseBitwiseAndExpression()
-        
-        while (this.match('CARET') || (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'xor')) {
-            this.advance()
-            const right = this.parseBitwiseAndExpression()
-            left = new AST.BinaryExpression('^', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseBitwiseAndExpression() {
-        let left = this.parseEqualityExpression()
-        
-        while (this.match('AMPERSAND') && !this.match('AND')) {
-            this.advance()
-            const right = this.parseEqualityExpression()
-            left = new AST.BinaryExpression('&', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseEqualityExpression() {
-        let left = this.parseComparisonExpression()
-        
-        while (this.match('EQUAL', 'NOT_EQUAL', 'IDENTICAL', 'NOT_IDENTICAL', 'SPACESHIP')) {
-            const op = this.advance()
-            const right = this.parseComparisonExpression()
-            
-            if (op.type === 'SPACESHIP') {
-                left = new AST.SpaceshipExpression(left, right, left.loc)
-            } else {
-                left = new AST.BinaryExpression(op.value, left, right, left.loc)
-            }
-        }
-        
-        return left
-    }
-
-    parseComparisonExpression() {
-        let left = this.parseShiftExpression()
-        
-        while (this.match('LT', 'GT', 'LTE', 'GTE')) {
-            const op = this.advance()
-            const right = this.parseShiftExpression()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'instanceof') {
-            this.advance()
-            const right = this.parseUnaryExpression()
-            left = new AST.InstanceofExpression(left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseShiftExpression() {
-        let left = this.parseAdditiveExpression()
-        
-        while (this.match('SHL', 'SHR')) {
-            const op = this.advance()
-            const right = this.parseAdditiveExpression()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseAdditiveExpression() {
-        let left = this.parseMultiplicativeExpression()
-        
-        while (this.match('PLUS', 'MINUS', 'DOT')) {
-            const op = this.advance()
-            const right = this.parseMultiplicativeExpression()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseMultiplicativeExpression() {
-        let left = this.parsePowExpression()
-        
-        while (this.match('TIMES', 'DIV', 'MOD')) {
-            const op = this.advance()
-            const right = this.parsePowExpression()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parsePowExpression() {
-        const left = this.parseUnaryExpression()
-        
-        if (this.match('POW')) {
-            this.advance()
-            const right = this.parsePowExpression()
-            return new AST.BinaryExpression('**', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseUnaryExpression() {
-        const loc = this.peek().loc
-        
-        if (this.match('NOT')) {
-            this.advance()
-            return new AST.UnaryExpression('!', this.parseUnaryExpression(), true, loc)
-        }
-        
-        if (this.match('TILDE')) {
-            this.advance()
-            return new AST.UnaryExpression('~', this.parseUnaryExpression(), true, loc)
-        }
-        
-        if (this.match('AT')) {
-            this.advance()
-            return new AST.ErrorSuppressExpression(this.parseUnaryExpression(), loc)
-        }
-        
-        if (this.match('INCREMENT', 'DECREMENT')) {
-            const op = this.advance()
-            return new AST.UpdateExpression(op.value, this.parseUnaryExpression(), true, loc)
-        }
-        
-        if (this.match('PLUS', 'MINUS')) {
-            const op = this.advance()
-            return new AST.UnaryExpression(op.value, this.parseUnaryExpression(), true, loc)
-        }
-        
-        if (this.match('LPAREN')) {
-            const next = this.peek(1)
-            if (next.type === 'TYPE' || next.type === 'IDENTIFIER') {
-                const castType = this.lookAheadCast()
-                if (castType) {
-                    this.advance()
-                    this.advance()
-                    this.expect('RPAREN')
-                    return new AST.CastExpression(castType, this.parseUnaryExpression(), loc)
-                }
-            }
-        }
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'clone') {
-            this.advance()
-            return new AST.CloneExpression(this.parseUnaryExpression(), loc)
-        }
-        
-        return this.parsePostfixExpression()
-    }
-
-    lookAheadCast() {
-        const types = ['int', 'integer', 'float', 'double', 'real', 'string', 'binary', 
-                       'array', 'object', 'bool', 'boolean', 'unset']
-        const token = this.peek(1)
-        if (token.type === 'TYPE' || token.type === 'IDENTIFIER') {
-            const val = token.value.toLowerCase()
-            if (types.includes(val) && this.peek(2).type === 'RPAREN') {
-                return this.translateType(val) || val
-            }
-        }
-        return null
-    }
-
-    parsePostfixExpression() {
-        let expr = this.parsePrimaryExpression()
-        
-        while (true) {
-            if (this.match('INCREMENT', 'DECREMENT')) {
-                const op = this.advance()
-                expr = new AST.UpdateExpression(op.value, expr, false, expr.loc)
-            } else if (this.match('LBRACKET')) {
-                this.advance()
-                const index = this.match('RBRACKET') ? null : this.parseExpression()
-                this.expect('RBRACKET')
-                expr = new AST.ArrayAccess(expr, index, expr.loc)
-            } else if (this.match('ARROW', 'NULLSAFE_ARROW')) {
-                const nullsafe = this.peek().type === 'NULLSAFE_ARROW'
-                this.advance()
-                if (this.match('LBRACE')) {
-                    this.advance()
-                    const property = this.parseExpression()
-                    this.expect('RBRACE')
-                    expr = new AST.MemberExpression(expr, property, nullsafe, expr.loc)
-                } else {
-                    const property = this.parsePropertyName()
-                    expr = new AST.MemberExpression(expr, property, nullsafe, expr.loc)
-                }
-                if (this.match('LPAREN')) {
-                    expr = this.parseCallArguments(expr)
-                }
-            } else if (this.match('DOUBLE_COLON')) {
-                this.advance()
-                const property = this.parsePropertyName()
-                expr = new AST.StaticMemberExpression(expr, property, expr.loc)
-                if (this.match('LPAREN')) {
-                    expr = this.parseCallArguments(expr)
-                }
-            } else if (this.match('LPAREN')) {
-                expr = this.parseCallArguments(expr)
-            } else {
-                break
-            }
-        }
-        
-        return expr
-    }
-
-    parseCallArguments(callee) {
-        this.expect('LPAREN')
-        const args = []
-        
-        while (!this.match('RPAREN', 'EOF')) {
-            if (this.match('IDENTIFIER') && this.peek(1).type === 'COLON') {
-                const name = this.advance().value
-                this.expect('COLON')
-                const value = this.parseExpression()
-                args.push(new AST.NamedArgument(name, value))
-            } else if (this.match('SPREAD')) {
-                this.advance()
-                const value = this.parseExpression()
-                args.push(new AST.ArrayElement(value, null, false, true))
-            } else {
-                args.push(this.parseExpression())
-            }
-            
-            if (!this.match('RPAREN')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        this.expect('RPAREN')
-        return new AST.CallExpression(callee, args, callee.loc)
-    }
-
-    parsePropertyName() {
-        if (this.match('VARIABLE')) {
-            return this.parseVariable()
-        }
-        if (this.match('IDENTIFIER', 'KEYWORD')) {
-            return new AST.Identifier(this.advance().value)
-        }
-        throw new Error(`Attendu nom de propriété à ligne ${this.peek().loc?.line}`)
-    }
-
-    parsePrimaryExpression() {
-        const token = this.peek()
-        
-        if (token.type === 'VARIABLE') {
-            return this.parseVariable()
-        }
-        
-        if (token.type === 'VARIABLE_VARIABLE') {
-            this.advance()
-            return new AST.VariableVariable(token.value, token.loc)
-        }
-        
-        if (token.type === 'NUMBER') {
-            this.advance()
-            return new AST.NumericLiteral(token.value, token.raw, token.loc)
-        }
-        
-        if (token.type === 'STRING') {
-            this.advance()
-            return new AST.StringLiteral(token.value, token.raw, token.loc)
-        }
-        
-        if (token.type === 'INTERPOLATED_STRING') {
-            this.advance()
-            return new AST.InterpolatedString([token.value], token.loc)
-        }
-        
-        if (token.type === 'SHELL_EXEC') {
-            this.advance()
-            return new AST.ShellExecExpression(token.value, token.loc)
-        }
-        
-        if (token.type === 'KEYWORD') {
-            const kw = this.translateKeyword(token.value)
-            
-            if (kw === 'true') {
-                this.advance()
-                return new AST.BooleanLiteral(true, token.loc)
-            }
-            if (kw === 'false') {
-                this.advance()
-                return new AST.BooleanLiteral(false, token.loc)
-            }
-            if (kw === 'null') {
-                this.advance()
-                return new AST.NullLiteral(token.loc)
-            }
-            
-            if (kw === 'new') {
-                return this.parseNewExpression()
-            }
-            
-            if (kw === 'array') {
-                return this.parseArrayExpression(false)
-            }
-            
-            if (kw === 'list') {
-                return this.parseListExpression()
-            }
-            
-            if (kw === 'function') {
-                return this.parseClosureExpression()
-            }
-            
-            if (kw === 'static' && this.peek(1).type === 'KEYWORD') {
-                this.advance()
-                return this.parseClosureExpression(true)
-            }
-            
-            if (kw === 'fn') {
-                return this.parseArrowFunction()
-            }
-            
-            if (kw === 'yield') {
-                return this.parseYieldExpression()
-            }
-            
-            if (kw === 'throw') {
-                this.advance()
-                return new AST.ThrowExpression(this.parseExpression(), token.loc)
-            }
-            
-            if (kw === 'empty') {
-                this.advance()
-                this.expect('LPAREN')
-                const arg = this.parseExpression()
-                this.expect('RPAREN')
-                return new AST.EmptyExpression(arg, token.loc)
-            }
-            
-            if (kw === 'isset') {
-                this.advance()
-                this.expect('LPAREN')
-                const args = [this.parseExpression()]
-                while (this.match('COMMA')) {
-                    this.advance()
-                    args.push(this.parseExpression())
-                }
-                this.expect('RPAREN')
-                return new AST.IssetExpression(args, token.loc)
-            }
-            
-            if (kw === 'eval') {
-                this.advance()
-                this.expect('LPAREN')
-                const code = this.parseExpression()
-                this.expect('RPAREN')
-                return new AST.EvalExpression(code, token.loc)
-            }
-            
-            if (kw === 'exit' || kw === 'die') {
-                this.advance()
-                let arg = null
-                if (this.match('LPAREN')) {
-                    this.advance()
-                    if (!this.match('RPAREN')) {
-                        arg = this.parseExpression()
-                    }
-                    this.expect('RPAREN')
-                }
-                return new AST.ExitExpression(arg, kw === 'die', token.loc)
-            }
-            
-            if (kw === 'print') {
-                this.advance()
-                return new AST.PrintExpression(this.parseExpression(), token.loc)
-            }
-            
-            if (kw === 'include' || kw === 'include_once' || kw === 'require' || kw === 'require_once') {
-                this.advance()
-                const path = this.parseExpression()
-                return new AST.IncludeExpression(path, kw.includes('once'), kw.includes('require'), token.loc)
-            }
-            
-            if (kw === 'self' || kw === 'parent' || kw === 'static') {
-                this.advance()
-                return new AST.Identifier(kw, token.loc)
-            }
-            
-            if (kw === 'match') {
-                return this.parseMatchExpression()
-            }
-        }
-        
-        if (token.type === 'FN') {
-            return this.parseArrowFunction()
-        }
-        
-        if (token.type === 'LBRACKET') {
-            return this.parseArrayExpression(true)
-        }
-        
-        if (token.type === 'LPAREN') {
-            this.advance()
-            const expr = this.parseExpression()
-            this.expect('RPAREN')
-            return expr
-        }
-        
-        if (token.type === 'IDENTIFIER' || token.type === 'BACKSLASH') {
-            return this.parseNameOrCall()
-        }
-        
-        throw new Error(`Token inattendu ${token.type} à ligne ${token.loc?.line}`)
-    }
-
-    parseVariable() {
-        const token = this.expect('VARIABLE')
-        return new AST.Variable(token.value, token.loc)
-    }
-
-    parseNewExpression() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'class') {
-            this.advance()
-            return this.parseAnonymousClass(loc)
-        }
-        
-        const callee = this.parseNameOrCall()
-        
-        let args = []
-        if (this.match('LPAREN')) {
-            this.advance()
-            while (!this.match('RPAREN', 'EOF')) {
-                args.push(this.parseExpression())
-                if (!this.match('RPAREN')) {
-                    this.expect('COMMA')
-                }
-            }
-            this.expect('RPAREN')
-        }
-        
-        return new AST.NewExpression(callee, args, loc)
-    }
-
-    parseAnonymousClass(loc) {
-        let args = []
-        if (this.match('LPAREN')) {
-            this.advance()
-            while (!this.match('RPAREN', 'EOF')) {
-                args.push(this.parseExpression())
-                if (!this.match('RPAREN')) {
-                    this.expect('COMMA')
-                }
-            }
-            this.expect('RPAREN')
-        }
-        
-        let superClass = null
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'extends') {
-            this.advance()
-            superClass = this.parseNamespaceName()
-        }
-        
-        const interfaces = []
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'implements') {
-            this.advance()
-            interfaces.push(this.parseNamespaceName())
-            while (this.match('COMMA')) {
-                this.advance()
-                interfaces.push(this.parseNamespaceName())
-            }
-        }
-        
-        const body = this.parseClassBody()
-        
-        return new AST.AnonymousClass(args, superClass, interfaces, body, loc)
-    }
-
-    parseArrayExpression(shortSyntax) {
-        const loc = this.peek().loc
-        
-        if (shortSyntax) {
-            this.expect('LBRACKET')
-        } else {
-            this.advance()
-            this.expect('LPAREN')
-        }
-        
-        const elements = []
-        const closeToken = shortSyntax ? 'RBRACKET' : 'RPAREN'
-        
-        while (!this.match(closeToken, 'EOF')) {
-            if (this.match('SPREAD')) {
-                this.advance()
-                const value = this.parseExpression()
-                elements.push(new AST.ArrayElement(value, null, false, true))
-            } else {
-                let key = null
-                let value = this.parseExpression()
-                let byRef = false
-                
-                if (this.match('DOUBLE_ARROW')) {
-                    this.advance()
-                    key = value
-                    
-                    if (this.match('AMPERSAND')) {
-                        this.advance()
-                        byRef = true
-                    }
-                    
-                    value = this.parseExpression()
-                }
-                
-                elements.push(new AST.ArrayElement(value, key, byRef, false))
-            }
-            
-            if (!this.match(closeToken)) {
-                this.expect('COMMA')
-                if (this.match(closeToken)) break
-            }
-        }
-        
-        this.expect(closeToken)
-        return new AST.ArrayExpression(elements, shortSyntax, loc)
-    }
-
-    parseListExpression() {
-        const loc = this.peek().loc
-        this.advance()
-        this.expect('LPAREN')
-        
-        const elements = []
-        
-        while (!this.match('RPAREN', 'EOF')) {
-            if (this.match('COMMA')) {
-                elements.push(null)
-            } else {
-                let key = null
-                let value = this.parseExpression()
-                
-                if (this.match('DOUBLE_ARROW')) {
-                    this.advance()
-                    key = value
-                    value = this.parseExpression()
-                }
-                
-                elements.push(new AST.ArrayElement(value, key, false, false))
-            }
-            
-            if (!this.match('RPAREN')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        this.expect('RPAREN')
-        return new AST.ListExpression(elements, loc)
-    }
-
-    parseClosureExpression(isStatic = false) {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let byRef = false
-        if (this.match('AMPERSAND')) {
-            this.advance()
-            byRef = true
-        }
-        
-        this.expect('LPAREN')
-        const params = this.parseParameterList()
-        this.expect('RPAREN')
-        
-        const uses = []
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'use') {
-            this.advance()
-            this.expect('LPAREN')
-            
-            while (!this.match('RPAREN', 'EOF')) {
-                let useByRef = false
-                if (this.match('AMPERSAND')) {
-                    this.advance()
-                    useByRef = true
-                }
-                const useVar = this.expect('VARIABLE').value
-                uses.push(new AST.ClosureUse(useVar, useByRef))
-                
-                if (!this.match('RPAREN')) {
-                    this.expect('COMMA')
-                }
-            }
-            
-            this.expect('RPAREN')
-        }
-        
-        let returnType = null
-        if (this.match('COLON')) {
-            this.advance()
-            returnType = this.parseTypeReference()
-        }
-        
-        const body = this.parseBlockStatement()
-        
-        return new AST.ClosureExpression(params, uses, body, returnType, isStatic, loc)
-    }
-
-    parseArrowFunction() {
-        const loc = this.peek().loc
-        let isStatic = false
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'static') {
-            isStatic = true
-            this.advance()
-        }
-        
-        this.advance()
-        
-        this.expect('LPAREN')
-        const params = this.parseParameterList()
-        this.expect('RPAREN')
-        
-        let returnType = null
-        if (this.match('COLON')) {
-            this.advance()
-            returnType = this.parseTypeReference()
-        }
-        
-        this.expect('DOUBLE_ARROW')
-        const body = this.parseExpression()
-        
-        return new AST.ArrowFunction(params, body, returnType, isStatic, loc)
-    }
-
-    parseYieldExpression() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'from') {
-            this.advance()
-            return new AST.YieldFromExpression(this.parseExpression(), loc)
-        }
-        
-        if (this.match('SEMICOLON', 'RPAREN', 'RBRACKET', 'COMMA')) {
-            return new AST.YieldExpression(null, null, loc)
-        }
-        
-        const first = this.parseExpression()
-        
-        if (this.match('DOUBLE_ARROW')) {
-            this.advance()
-            const value = this.parseExpression()
-            return new AST.YieldExpression(first, value, loc)
-        }
-        
-        return new AST.YieldExpression(null, first, loc)
-    }
-
-    parseNameOrCall() {
-        const name = this.parseNamespaceName()
-        
-        if (this.match('LPAREN')) {
-            return this.parseCallArguments(name)
-        }
-        
-        if (this.match('DOUBLE_COLON')) {
-            this.advance()
-            const property = this.parsePropertyName()
-            const expr = new AST.StaticMemberExpression(name, property, name.loc)
-            
-            if (this.match('LPAREN')) {
-                return this.parseCallArguments(expr)
-            }
-            return expr
-        }
-        
-        if (name.parts.length === 1 && !name.absolute) {
-            return new AST.Identifier(name.parts[0], name.loc)
-        }
-        
-        return name
-    }
-
-    translateKeyword(word) {
-        const lowerWord = word.toLowerCase()
-        return PHP_KEYWORDS[lowerWord] || PHP_KEYWORDS[word] || word
-    }
-
-    translateType(word) {
-        const lowerWord = word.toLowerCase()
-        return PHP_TYPES[lowerWord] || PHP_TYPES[word] || null
-    }
-}
-
-class PHPCodeGenerator {
-    constructor(options = {}) {
-        this.indentStr = options.indentStr || '    '
-        this.indentLevel = 0
-    }
-
-    indent() {
-        return this.indentStr.repeat(this.indentLevel)
-    }
-
-    generate(ast) {
-        if (!ast) return ''
-        
-        const method = `generate${ast.type}`
-        if (this[method]) {
-            return this[method](ast)
-        }
-        
-        return ''
-    }
-
-    generateProgram(node) {
-        return node.body.map(stmt => this.generate(stmt)).join('\n')
-    }
-
-    generatePHPBlock(node) {
-        return '<?php\n' + node.body.map(stmt => this.generate(stmt)).join('\n') + '\n?>'
-    }
-
-    generateHTMLBlock(node) {
-        return node.content
-    }
-
-    generateEchoStatement(node) {
-        const exprs = node.expressions.map(e => this.generate(e)).join(', ')
-        return `${this.indent()}echo ${exprs};`
-    }
-
-    generatePrintStatement(node) {
-        return `${this.indent()}print ${this.generate(node.expression)};`
-    }
-
-    generateIdentifier(node) {
-        return node.name
-    }
-
-    generateVariable(node) {
-        return '$' + node.name
-    }
-
-    generateVariableVariable(node) {
-        return '$$' + node.expression
-    }
-
-    generateConstantDeclaration(node) {
-        return `${this.indent()}const ${node.name} = ${this.generate(node.value)};`
-    }
-
-    generateStringLiteral(node) {
-        return node.raw || `"${node.value}"`
-    }
-
-    generateNumericLiteral(node) {
-        return node.raw || String(node.value)
-    }
-
-    generateBooleanLiteral(node) {
-        return node.value ? 'true' : 'false'
-    }
-
-    generateNullLiteral() {
-        return 'null'
-    }
-
-    generateArrayExpression(node) {
-        const elements = node.elements.map(e => this.generate(e)).join(', ')
-        return node.shortSyntax ? `[${elements}]` : `array(${elements})`
-    }
-
-    generateArrayElement(node) {
-        let result = ''
-        if (node.unpack) result += '...'
-        if (node.key) result += this.generate(node.key) + ' => '
-        if (node.byRef) result += '&'
-        result += this.generate(node.value)
-        return result
-    }
-
-    generateBinaryExpression(node) {
-        return `${this.generate(node.left)} ${node.operator} ${this.generate(node.right)}`
-    }
-
-    generateUnaryExpression(node) {
-        if (node.prefix) {
-            return `${node.operator}${this.generate(node.argument)}`
-        }
-        return `${this.generate(node.argument)}${node.operator}`
-    }
-
-    generateUpdateExpression(node) {
-        if (node.prefix) {
-            return `${node.operator}${this.generate(node.argument)}`
-        }
-        return `${this.generate(node.argument)}${node.operator}`
-    }
-
-    generateAssignmentExpression(node) {
-        return `${this.generate(node.left)} ${node.operator} ${this.generate(node.right)}`
-    }
-
-    generateConditionalExpression(node) {
-        const test = this.generate(node.test)
-        const consequent = node.consequent ? this.generate(node.consequent) : ''
-        const alternate = this.generate(node.alternate)
-        return `${test} ? ${consequent} : ${alternate}`
-    }
-
-    generateNullCoalescingExpression(node) {
-        return `${this.generate(node.left)} ?? ${this.generate(node.right)}`
-    }
-
-    generateSpaceshipExpression(node) {
-        return `${this.generate(node.left)} <=> ${this.generate(node.right)}`
-    }
-
-    generateInstanceofExpression(node) {
-        return `${this.generate(node.left)} instanceof ${this.generate(node.right)}`
-    }
-
-    generateCastExpression(node) {
-        return `(${node.castType})${this.generate(node.expression)}`
-    }
-
-    generateCloneExpression(node) {
-        return `clone ${this.generate(node.expression)}`
-    }
-
-    generateErrorSuppressExpression(node) {
-        return `@${this.generate(node.expression)}`
-    }
-
-    generateIfStatement(node) {
-        let result = `${this.indent()}if (${this.generate(node.test)}) `
-        result += this.generateBlock(node.consequent)
-        
-        if (node.alternate) {
-            if (node.alternate.type === 'IfStatement') {
-                result += ` else${this.generate(node.alternate).trim().slice(this.indent().length)}`
-            } else {
-                result += ` else ${this.generateBlock(node.alternate)}`
-            }
-        }
-        
-        return result
-    }
-
-    generateBlock(node) {
-        if (node.type === 'BlockStatement') {
-            return this.generate(node)
-        }
-        this.indentLevel++
-        const result = `{\n${this.generate(node)}\n${this.indent().slice(this.indentStr.length)}}`
-        this.indentLevel--
-        return result
-    }
-
-    generateBlockStatement(node) {
-        this.indentLevel++
-        const body = node.body.map(stmt => this.generate(stmt)).join('\n')
-        this.indentLevel--
-        return `{\n${body}\n${this.indent()}}`
-    }
-
-    generateSwitchStatement(node) {
-        let result = `${this.indent()}switch (${this.generate(node.discriminant)}) {\n`
-        this.indentLevel++
-        for (const c of node.cases) {
-            result += this.generate(c) + '\n'
-        }
-        this.indentLevel--
-        result += `${this.indent()}}`
-        return result
-    }
-
-    generateSwitchCase(node) {
-        let result = node.test 
-            ? `${this.indent()}case ${this.generate(node.test)}:\n`
-            : `${this.indent()}default:\n`
-        this.indentLevel++
-        for (const stmt of node.consequent) {
-            result += this.generate(stmt) + '\n'
-        }
-        this.indentLevel--
-        return result.trimEnd()
-    }
-
-    generateMatchExpression(node) {
-        let result = `match (${this.generate(node.condition)}) {\n`
-        this.indentLevel++
-        for (const arm of node.arms) {
-            result += this.generate(arm) + ',\n'
-        }
-        this.indentLevel--
-        result += `${this.indent()}}`
-        return result
-    }
-
-    generateMatchArm(node) {
-        const conditions = node.isDefault 
-            ? 'default'
-            : node.conditions.map(c => this.generate(c)).join(', ')
-        return `${this.indent()}${conditions} => ${this.generate(node.body)}`
-    }
-
-    generateForStatement(node) {
-        const init = node.init ? (Array.isArray(node.init) ? node.init.map(e => this.generate(e)).join(', ') : this.generate(node.init)) : ''
-        const test = node.test ? (Array.isArray(node.test) ? node.test.map(e => this.generate(e)).join(', ') : this.generate(node.test)) : ''
-        const update = node.update ? (Array.isArray(node.update) ? node.update.map(e => this.generate(e)).join(', ') : this.generate(node.update)) : ''
-        return `${this.indent()}for (${init}; ${test}; ${update}) ${this.generateBlock(node.body)}`
-    }
-
-    generateForeachStatement(node) {
-        let result = `${this.indent()}foreach (${this.generate(node.source)} as `
-        if (node.key) {
-            result += `${this.generate(node.key)} => `
-        }
-        if (node.byRef) result += '&'
-        result += `${this.generate(node.value)}) ${this.generateBlock(node.body)}`
-        return result
-    }
-
-    generateWhileStatement(node) {
-        return `${this.indent()}while (${this.generate(node.test)}) ${this.generateBlock(node.body)}`
-    }
-
-    generateDoWhileStatement(node) {
-        return `${this.indent()}do ${this.generateBlock(node.body)} while (${this.generate(node.test)});`
-    }
-
-    generateBreakStatement(node) {
-        return `${this.indent()}break${node.level ? ' ' + node.level : ''};`
-    }
-
-    generateContinueStatement(node) {
-        return `${this.indent()}continue${node.level ? ' ' + node.level : ''};`
-    }
-
-    generateReturnStatement(node) {
-        return `${this.indent()}return${node.argument ? ' ' + this.generate(node.argument) : ''};`
-    }
-
-    generateThrowStatement(node) {
-        return `${this.indent()}throw ${this.generate(node.argument)};`
-    }
-
-    generateTryStatement(node) {
-        let result = `${this.indent()}try ${this.generate(node.block)}`
-        for (const c of node.catches) {
-            result += ' ' + this.generate(c)
-        }
-        if (node.finalizer) {
-            result += ' ' + this.generate(node.finalizer)
-        }
-        return result
-    }
-
-    generateCatchClause(node) {
-        const types = node.types.map(t => this.generate(t)).join('|')
-        const param = node.param ? ' $' + node.param : ''
-        return `catch (${types}${param}) ${this.generate(node.body)}`
-    }
-
-    generateFinallyClause(node) {
-        return `finally ${this.generate(node.body)}`
-    }
-
-    generateFunctionDeclaration(node) {
-        let result = `${this.indent()}function `
-        if (node.byRef) result += '&'
-        result += `${node.name}(`
-        result += node.params.map(p => this.generate(p)).join(', ')
-        result += ')'
-        if (node.returnType) result += ': ' + this.generate(node.returnType)
-        result += ' ' + this.generate(node.body)
-        return result
-    }
-
-    generateParameter(node) {
-        let result = ''
-        if (node.visibility) result += node.visibility + ' '
-        if (node.readonly) result += 'readonly '
-        if (node.paramType) result += this.generate(node.paramType) + ' '
-        if (node.byRef) result += '&'
-        if (node.variadic) result += '...'
-        result += '$' + node.name
-        if (node.default) result += ' = ' + this.generate(node.default)
-        return result
-    }
-
-    generateTypeReference(node) {
-        return (node.nullable ? '?' : '') + node.name
-    }
-
-    generateUnionType(node) {
-        return node.types.map(t => this.generate(t)).join('|')
-    }
-
-    generateCallExpression(node) {
-        const callee = this.generate(node.callee)
-        const args = node.arguments.map(a => this.generate(a)).join(', ')
-        return `${callee}(${args})`
-    }
-
-    generateNamedArgument(node) {
-        return `${node.name}: ${this.generate(node.value)}`
-    }
-
-    generateNewExpression(node) {
-        const callee = this.generate(node.callee)
-        const args = node.arguments.length ? '(' + node.arguments.map(a => this.generate(a)).join(', ') + ')' : ''
-        return `new ${callee}${args}`
-    }
-
-    generateMemberExpression(node) {
-        const op = node.nullsafe ? '?->' : '->'
-        return `${this.generate(node.object)}${op}${this.generate(node.property)}`
-    }
-
-    generateStaticMemberExpression(node) {
-        return `${this.generate(node.object)}::${this.generate(node.property)}`
-    }
-
-    generateArrayAccess(node) {
-        const index = node.index ? this.generate(node.index) : ''
-        return `${this.generate(node.array)}[${index}]`
-    }
-
-    generateClassDeclaration(node) {
-        let result = this.indent()
-        if (node.modifiers.length) result += node.modifiers.join(' ') + ' '
-        result += `class ${node.name}`
-        if (node.superClass) result += ` extends ${this.generate(node.superClass)}`
-        if (node.interfaces.length) result += ` implements ${node.interfaces.map(i => this.generate(i)).join(', ')}`
-        result += ' ' + this.generate(node.body)
-        return result
-    }
-
-    generateClassBody(node) {
-        this.indentLevel++
-        const members = node.members.map(m => this.generate(m)).join('\n\n')
-        this.indentLevel--
-        return `{\n${members}\n${this.indent()}}`
-    }
-
-    generateMethodDefinition(node) {
-        let result = this.indent()
-        if (node.modifiers.length) result += node.modifiers.join(' ') + ' '
-        result += 'function '
-        if (node.byRef) result += '&'
-        result += `${node.name}(`
-        result += node.params.map(p => this.generate(p)).join(', ')
-        result += ')'
-        if (node.returnType) result += ': ' + this.generate(node.returnType)
-        if (node.body) {
-            result += ' ' + this.generate(node.body)
-        } else {
-            result += ';'
-        }
-        return result
-    }
-
-    generatePropertyDeclaration(node) {
-        let result = this.indent()
-        if (node.modifiers.length) result += node.modifiers.join(' ') + ' '
-        if (node.propertyType) result += this.generate(node.propertyType) + ' '
-        result += '$' + node.name
-        if (node.value) result += ' = ' + this.generate(node.value)
-        result += ';'
-        return result
-    }
-
-    generateClassConstant(node) {
-        let result = this.indent()
-        if (node.modifiers.length) result += node.modifiers.join(' ') + ' '
-        result += 'const '
-        if (node.constType) result += this.generate(node.constType) + ' '
-        result += `${node.name} = ${this.generate(node.value)};`
-        return result
-    }
-
-    generateInterfaceDeclaration(node) {
-        let result = `${this.indent()}interface ${node.name}`
-        if (node.extends.length) result += ` extends ${node.extends.map(e => this.generate(e)).join(', ')}`
-        result += ' ' + this.generate(node.body)
-        return result
-    }
-
-    generateTraitDeclaration(node) {
-        return `${this.indent()}trait ${node.name} ${this.generate(node.body)}`
-    }
-
-    generateTraitUse(node) {
-        return `${this.indent()}use ${node.traits.map(t => this.generate(t)).join(', ')};`
-    }
-
-    generateEnumDeclaration(node) {
-        let result = `${this.indent()}enum ${node.name}`
-        if (node.backingType) result += ': ' + this.generate(node.backingType)
-        if (node.interfaces.length) result += ` implements ${node.interfaces.map(i => this.generate(i)).join(', ')}`
-        result += ' {\n'
-        this.indentLevel++
-        for (const item of node.body) {
-            result += this.generate(item) + '\n'
-        }
-        this.indentLevel--
-        result += `${this.indent()}}`
-        return result
-    }
-
-    generateEnumCase(node) {
-        let result = `${this.indent()}case ${node.name}`
-        if (node.value) result += ' = ' + this.generate(node.value)
-        result += ';'
-        return result
-    }
-
-    generateNamespaceDeclaration(node) {
-        let result = `${this.indent()}namespace`
-        if (node.name) result += ' ' + this.generate(node.name)
-        if (node.body) {
-            result += ' {\n'
-            this.indentLevel++
-            result += node.body.map(s => this.generate(s)).join('\n')
-            this.indentLevel--
-            result += `\n${this.indent()}}`
-        } else {
-            result += ';'
-        }
-        return result
-    }
-
-    generateUseDeclaration(node) {
-        let result = `${this.indent()}use `
-        if (node.useType) result += node.useType + ' '
-        result += node.declarations.map(d => this.generate(d)).join(', ')
-        result += ';'
-        return result
-    }
-
-    generateUseClause(node) {
-        let result = this.generate(node.name)
-        if (node.alias) result += ' as ' + node.alias
-        return result
-    }
-
-    generateNamespaceName(node) {
-        return (node.absolute ? '\\' : '') + node.parts.join('\\')
-    }
-
-    generateIncludeExpression(node) {
-        const keyword = node.require 
-            ? (node.once ? 'require_once' : 'require')
-            : (node.once ? 'include_once' : 'include')
-        return `${keyword} ${this.generate(node.path)}`
-    }
-
-    generateExpressionStatement(node) {
-        return `${this.indent()}${this.generate(node.expression)};`
-    }
-
-    generateEmptyStatement() {
-        return `${this.indent()};`
-    }
-
-    generateGlobalStatement(node) {
-        return `${this.indent()}global ${node.variables.map(v => this.generate(v)).join(', ')};`
-    }
-
-    generateStaticStatement(node) {
-        const decls = node.declarations.map(d => {
-            let result = '$' + d.name
-            if (d.value) result += ' = ' + this.generate(d.value)
-            return result
-        }).join(', ')
-        return `${this.indent()}static ${decls};`
-    }
-
-    generateClosureExpression(node) {
-        let result = node.static ? 'static ' : ''
-        result += 'function ('
-        result += node.params.map(p => this.generate(p)).join(', ')
-        result += ')'
-        if (node.uses.length) {
-            result += ' use ('
-            result += node.uses.map(u => (u.byRef ? '&$' : '$') + u.variable).join(', ')
-            result += ')'
-        }
-        if (node.returnType) result += ': ' + this.generate(node.returnType)
-        result += ' ' + this.generate(node.body)
-        return result
-    }
-
-    generateArrowFunction(node) {
-        let result = node.static ? 'static ' : ''
-        result += 'fn('
-        result += node.params.map(p => this.generate(p)).join(', ')
-        result += ')'
-        if (node.returnType) result += ': ' + this.generate(node.returnType)
-        result += ' => ' + this.generate(node.body)
-        return result
-    }
-
-    generateListExpression(node) {
-        const elements = node.elements.map(e => e ? this.generate(e) : '').join(', ')
-        return `list(${elements})`
-    }
-
-    generateYieldExpression(node) {
-        if (node.key) {
-            return `yield ${this.generate(node.key)} => ${this.generate(node.value)}`
-        }
-        if (node.value) {
-            return `yield ${this.generate(node.value)}`
-        }
-        return 'yield'
-    }
-
-    generateYieldFromExpression(node) {
-        return `yield from ${this.generate(node.expression)}`
-    }
-
-    generateThrowExpression(node) {
-        return `throw ${this.generate(node.argument)}`
-    }
-
-    generateExitExpression(node) {
-        const keyword = node.isDie ? 'die' : 'exit'
-        if (node.argument) {
-            return `${keyword}(${this.generate(node.argument)})`
-        }
-        return keyword
-    }
-
-    generateEmptyExpression(node) {
-        return `empty(${this.generate(node.argument)})`
-    }
-
-    generateIssetExpression(node) {
-        return `isset(${node.arguments.map(a => this.generate(a)).join(', ')})`
-    }
-
-    generateUnsetStatement(node) {
-        return `${this.indent()}unset(${node.arguments.map(a => this.generate(a)).join(', ')});`
-    }
-
-    generateEvalExpression(node) {
-        return `eval(${this.generate(node.code)})`
-    }
-
-    generatePrintExpression(node) {
-        return `print ${this.generate(node.argument)}`
-    }
-
-    generateShellExecExpression(node) {
-        return '`' + node.command + '`'
-    }
-
-    generateAnonymousClass(node) {
-        let result = 'new class'
-        if (node.arguments.length) {
-            result += '(' + node.arguments.map(a => this.generate(a)).join(', ') + ')'
-        }
-        if (node.superClass) result += ` extends ${this.generate(node.superClass)}`
-        if (node.interfaces.length) result += ` implements ${node.interfaces.map(i => this.generate(i)).join(', ')}`
-        result += ' ' + this.generate(node.body)
-        return result
-    }
-
-    generateLabelStatement(node) {
-        return `${node.name}:`
-    }
-
-    generateGotoStatement(node) {
-        return `${this.indent()}goto ${node.label};`
-    }
-}
-
-module.exports = {
-    PHPLexer,
-    PHPParser,
-    PHPCodeGenerator,
-    PHP_KEYWORDS,
-    PHP_TYPES
-}