ether-code 0.9.1 → 0.9.2

package/generators/php-generator.js

@@ -5,571 +5,778 @@ class PHPGenerator {
     this.i18n = null
     this.indent = 0
     this.output = ''
-    this.translationMap = {}
-    this.functionMap = {}
-    this.supportedLanguages = ['fr', 'en', 'es', 'ru', 'zh', 'ja']
     
     if (i18nPath) {
       this.loadI18n(i18nPath)
     }
+    
+    this.buildFunctionMap()
   }
 
   loadI18n(filePath) {
     const content = fs.readFileSync(filePath, 'utf-8')
     this.i18n = JSON.parse(content)
-    this.buildTranslationMap()
-  }
-
-  buildTranslationMap() {
-    this.translationMap = {}
-    this.functionMap = {}
-    
-    if (!this.i18n) return
-
-    for (const [sectionName, section] of Object.entries(this.i18n)) {
-      if (sectionName === 'metadata' || typeof section !== 'object') continue
-      
-      for (const lang of this.supportedLanguages) {
-        if (!section[lang]) continue
-        
-        for (const [etherWord, phpCode] of Object.entries(section[lang])) {
-          const fixed = this.normalizeUTF8(etherWord)
-          const normalizedKey = fixed.toLowerCase().trim()
-          const cleanPhp = this.cleanPhpValue(phpCode)
-          
-          if (phpCode.endsWith('()')) {
-            this.functionMap[normalizedKey] = cleanPhp
-            const withoutAccents = this.removeAccents(normalizedKey)
-            if (withoutAccents !== normalizedKey) {
-              this.functionMap[withoutAccents] = cleanPhp
-            }
-          }
-          
-          this.translationMap[normalizedKey] = cleanPhp
-          
-          const withoutAccents = this.removeAccents(normalizedKey)
-          if (withoutAccents !== normalizedKey) {
-            this.translationMap[withoutAccents] = cleanPhp
-          }
-        }
-      }
-    }
   }
 
-  normalizeUTF8(str) {
+  normalizeAccents(str) {
     if (typeof str !== 'string') return String(str)
-    try {
-      const bytes = new Uint8Array(str.length)
-      for (let i = 0; i < str.length; i++) {
-        bytes[i] = str.charCodeAt(i)
-      }
-      const decoder = new TextDecoder('utf-8')
-      return decoder.decode(bytes)
-    } catch (e) {
-      return str
+    return str.toLowerCase()
+      .normalize('NFD')
+      .replace(/[\u0300-\u036f]/g, '')
+      .replace(/-/g, ' ')
+      .replace(/_/g, ' ')
+  }
+
+  buildFunctionMap() {
+    this.functionMap = {
+      'est chaine': 'is_string',
+      'est entier': 'is_int',
+      'est flottant': 'is_float',
+      'est tableau': 'is_array',
+      'est booleen': 'is_bool',
+      'est nul': 'is_null',
+      'est null': 'is_null',
+      'est objet': 'is_object',
+      'est numerique': 'is_numeric',
+      'est callable': 'is_callable',
+      'est appelable': 'is_callable',
+      'est ressource': 'is_resource',
+      'est scalaire': 'is_scalar',
+      'est vide': 'empty',
+      'est iterable': 'is_iterable',
+      'est comptable': 'is_countable',
+      'obtenir type': 'gettype',
+      'definir type': 'settype',
+      'valeur entier': 'intval',
+      'valeur entiere': 'intval',
+      'valeur flottant': 'floatval',
+      'valeur chaine': 'strval',
+      'valeur booleen': 'boolval',
+      'longueur': 'strlen',
+      'sous chaine': 'substr',
+      'sous-chaine': 'substr',
+      'position': 'strpos',
+      'remplacer': 'str_replace',
+      'exploser': 'explode',
+      'imploser': 'implode',
+      'majuscules': 'strtoupper',
+      'minuscules': 'strtolower',
+      'couper espaces': 'trim',
+      'rogner': 'trim',
+      'rogner gauche': 'ltrim',
+      'rogner droite': 'rtrim',
+      'repeter': 'str_repeat',
+      'inverser chaine': 'strrev',
+      'remplir': 'str_pad',
+      'remplir gauche': 'str_pad',
+      'compter': 'count',
+      'trier': 'sort',
+      'trier inverse': 'rsort',
+      'trier associatif': 'asort',
+      'trier cles': 'ksort',
+      'inverser': 'array_reverse',
+      'fusionner': 'array_merge',
+      'fusionner tableaux': 'array_merge',
+      'filtrer': 'array_filter',
+      'filtrer tableau': 'array_filter',
+      'mapper': 'array_map',
+      'mapper tableau': 'array_map',
+      'transformer': 'array_map',
+      'reduire': 'array_reduce',
+      'reduire tableau': 'array_reduce',
+      'cles': 'array_keys',
+      'tableau cles': 'array_keys',
+      'valeurs': 'array_values',
+      'tableau valeurs': 'array_values',
+      'pousser': 'array_push',
+      'ajouter': 'array_push',
+      'retirer': 'array_pop',
+      'rechercher': 'array_search',
+      'existe': 'array_key_exists',
+      'cle existe': 'array_key_exists',
+      'dans tableau': 'in_array',
+      'somme': 'array_sum',
+      'somme tableau': 'array_sum',
+      'unique': 'array_unique',
+      'decouper': 'array_slice',
+      'epissure': 'array_splice',
+      'combiner': 'array_combine',
+      'remplir tableau': 'array_fill',
+      'colonne': 'array_column',
+      'compter valeurs': 'array_count_values',
+      'difference': 'array_diff',
+      'intersection': 'array_intersect',
+      'premier': 'reset',
+      'dernier': 'end',
+      'suivant': 'next',
+      'precedent': 'prev',
+      'courant': 'current',
+      'cle courante': 'key',
+      'melanger': 'shuffle',
+      'absolu': 'abs',
+      'plafond': 'ceil',
+      'plancher': 'floor',
+      'arrondir': 'round',
+      'arrondi': 'round',
+      'racine carree': 'sqrt',
+      'puissance': 'pow',
+      'aleatoire': 'rand',
+      'aleatoire entier': 'random_int',
+      'maximum': 'max',
+      'minimum': 'min',
+      'pi': 'pi',
+      'exponentielle': 'exp',
+      'logarithme': 'log',
+      'logarithme10': 'log10',
+      'sinus': 'sin',
+      'cosinus': 'cos',
+      'tangente': 'tan',
+      'formater nombre': 'number_format',
+      'date': 'date',
+      'temps': 'time',
+      'maintenant': 'time',
+      'creer date': 'mktime',
+      'date vers temps': 'strtotime',
+      'formater date': 'date_format',
+      'fichier existe': 'file_exists',
+      'lire fichier': 'file_get_contents',
+      'ecrire fichier': 'file_put_contents',
+      'ouvrir fichier': 'fopen',
+      'fermer fichier': 'fclose',
+      'lire ligne': 'fgets',
+      'ecrire ligne': 'fputs',
+      'est fichier': 'is_file',
+      'est repertoire': 'is_dir',
+      'creer repertoire': 'mkdir',
+      'supprimer fichier': 'unlink',
+      'renommer': 'rename',
+      'copier': 'copy',
+      'taille fichier': 'filesize',
+      'encoder json': 'json_encode',
+      'decoder json': 'json_decode',
+      'json encoder': 'json_encode',
+      'json decoder': 'json_decode',
+      'correspondre': 'preg_match',
+      'regex correspondance': 'preg_match',
+      'regex toutes': 'preg_match_all',
+      'regex remplacer': 'preg_replace',
+      'demarrer session': 'session_start',
+      'detruire session': 'session_destroy',
+      'definir cookie': 'setcookie',
+      'hacher': 'hash',
+      'hacher mot de passe': 'password_hash',
+      'verifier mot de passe': 'password_verify',
+      'md5': 'md5',
+      'sha1': 'sha1',
+      'base64 encoder': 'base64_encode',
+      'base64 decoder': 'base64_decode',
+      'url encoder': 'urlencode',
+      'url decoder': 'urldecode',
+      'htmlentites': 'htmlentities',
+      'html special': 'htmlspecialchars',
+      'enlever balises': 'strip_tags',
+      'echapper': 'addslashes',
+      'preparer': 'prepare',
+      'executer': 'execute',
+      'recuperer': 'fetch',
+      'recuperer tout': 'fetchAll',
+      'nombre lignes': 'rowCount',
+      'dernier id': 'lastInsertId',
+      'afficher info': 'var_dump',
+      'imprimer r': 'print_r',
+      'exporter': 'var_export',
+      'vide': 'empty',
+      'defini': 'isset',
+      'supprimer': 'unset',
+      'sortie': 'exit',
+      'mourir': 'die',
+      'dormir': 'sleep',
+      'micro dormir': 'usleep',
+      'entete': 'header',
+      'en tete': 'header',
+      'rediriger': 'header',
+      'serialiser': 'serialize',
+      'deserialiser': 'unserialize',
+      'formater': 'format',
+      'getmessage': 'getMessage'
     }
-  }
 
-  cleanPhpValue(value) {
-    if (typeof value !== 'string') return value
-    let cleaned = value.replace(/\(\)$/, '')
-    return cleaned
+    this.keywordMap = {
+      'variable': '',
+      'constante': 'const',
+      'fonction': 'function',
+      'retourner': 'return',
+      'si': 'if',
+      'sinon': 'else',
+      'sinon si': 'elseif',
+      'pour': 'for',
+      'pour chaque': 'foreach',
+      'tant que': 'while',
+      'faire': 'do',
+      'selon': 'switch',
+      'cas': 'case',
+      'defaut': 'default',
+      'sortir': 'break',
+      'continuer': 'continue',
+      'essayer': 'try',
+      'attraper': 'catch',
+      'finalement': 'finally',
+      'lancer': 'throw',
+      'nouveau': 'new',
+      'nouvelle': 'new',
+      'classe': 'class',
+      'interface': 'interface',
+      'trait': 'trait',
+      'etend': 'extends',
+      'etendre': 'extends',
+      'implemente': 'implements',
+      'implementer': 'implements',
+      'utiliser': 'use',
+      'public': 'public',
+      'publique': 'public',
+      'prive': 'private',
+      'privee': 'private',
+      'protege': 'protected',
+      'protegee': 'protected',
+      'statique': 'static',
+      'final': 'final',
+      'finale': 'final',
+      'abstrait': 'abstract',
+      'abstraite': 'abstract',
+      'constructeur': '__construct',
+      'destructeur': '__destruct',
+      'obtenir': '__get',
+      'definir': '__set',
+      'appeler': '__call',
+      'vers chaine': '__toString',
+      'espace de noms': 'namespace',
+      'comme': 'as',
+      'vrai': 'true',
+      'faux': 'false',
+      'nul': 'null',
+      'rien': 'null',
+      'ceci': '$this',
+      'parent': 'parent',
+      'self': 'self',
+      'soi': 'self',
+      'et': '&&',
+      'ou': '||',
+      'non': '!',
+      'egal': '===',
+      'different': '!==',
+      'concatener': '.',
+      'tableau': 'array',
+      'chaine': 'string',
+      'entier': 'int',
+      'flottant': 'float',
+      'booleen': 'bool',
+      'objet': 'object',
+      'vide type': 'void',
+      'void': 'void',
+      'mixte': 'mixed',
+      'afficher': 'echo',
+      'imprimer': 'print',
+      'inclure': 'include',
+      'inclure une fois': 'include_once',
+      'requiert': 'require',
+      'requerir': 'require',
+      'requiert une fois': 'require_once',
+      'requerir une fois': 'require_once',
+      'rendement': 'yield',
+      'rendement de': 'yield from'
+    }
   }
 
   translate(word) {
-    if (!word || typeof word !== 'string') return word
-    
-    const normalized = word.toLowerCase().trim()
-    
-    if (this.translationMap[normalized]) {
-      return this.translationMap[normalized]
-    }
-    
-    const withoutAccents = this.removeAccents(normalized)
-    if (this.translationMap[withoutAccents]) {
-      return this.translationMap[withoutAccents]
-    }
-    
-    return word
+    if (!word) return word
+    const normalized = this.normalizeAccents(word)
+    return this.functionMap[normalized] || this.keywordMap[normalized] || word
   }
 
   translateFunction(word) {
-    if (!word || typeof word !== 'string') return word
-    
-    const normalized = word.toLowerCase().trim()
-    const withoutAccents = this.removeAccents(normalized)
-    
-    if (this.functionMap[normalized]) {
-      return this.functionMap[normalized]
-    }
-    
-    if (this.functionMap[withoutAccents]) {
-      return this.functionMap[withoutAccents]
-    }
-    
-    if (this.translationMap[normalized]) {
-      return this.translationMap[normalized]
-    }
-    
-    if (this.translationMap[withoutAccents]) {
-      return this.translationMap[withoutAccents]
-    }
-    
-    return word
+    if (!word) return word
+    const normalized = this.normalizeAccents(word)
+    return this.functionMap[normalized] || word
   }
 
-  removeAccents(str) {
-    return str.normalize('NFD').replace(/[\u0300-\u036f]/g, '')
+  translateKeyword(word) {
+    if (!word) return word
+    const normalized = this.normalizeAccents(word)
+    return this.keywordMap[normalized] || word
+  }
+
+  extractTypeName(typeNode) {
+    if (!typeNode) return ''
+    if (typeof typeNode === 'string') return this.translateKeyword(typeNode)
+    if (typeNode.name) return this.translateKeyword(typeNode.name)
+    if (typeNode.type === 'Identifier') return this.translateKeyword(typeNode.name || typeNode.value || '')
+    if (typeNode.value) return this.translateKeyword(typeNode.value)
+    return ''
   }
 
   generate(ast) {
-    this.output = '<?php\n'
+    this.output = ''
     this.indent = 0
-    
-    if (ast.strict) {
-      this.writeLine("declare(strict_types=1);")
-      this.writeLine('')
+
+    if (ast.phpTag !== false) {
+      this.output = '<?php\n'
     }
 
-    if (Array.isArray(ast.body)) {
-      for (const node of ast.body) {
+    if (Array.isArray(ast)) {
+      for (const node of ast) {
         this.generateNode(node)
       }
-    } else if (ast.body) {
-      this.generateNode(ast.body)
-    } else {
+    } else if (ast && ast.type === 'Program') {
+      for (const node of ast.body || []) {
+        this.generateNode(node)
+      }
+    } else if (ast && ast.type) {
       this.generateNode(ast)
+    } else if (ast && ast.body) {
+      for (const node of ast.body) {
+        this.generateNode(node)
+      }
     }
 
-    return this.output
+    return this.output.trim()
   }
 
   generateNode(node) {
     if (!node) return ''
 
-    if (Array.isArray(node)) {
-      return node.map(n => this.generateNode(n)).join('')
+    switch (node.type) {
+      case 'Program':
+        for (const stmt of node.body || []) {
+          this.generateNode(stmt)
+        }
+        return ''
+      case 'DeclareStatement':
+        return this.generateDeclareStatement(node)
+      case 'NamespaceDeclaration':
+        return this.generateNamespace(node)
+      case 'UseStatement':
+        return this.generateUseStatement(node)
+      case 'ConstantDeclaration':
+        return this.generateConstantDeclaration(node)
+      case 'VariableDeclaration':
+        return this.generateVariableDeclaration(node)
+      case 'FunctionDeclaration':
+        return this.generateFunctionDeclaration(node)
+      case 'ClassDeclaration':
+        return this.generateClassDeclaration(node)
+      case 'InterfaceDeclaration':
+        return this.generateInterfaceDeclaration(node)
+      case 'TraitDeclaration':
+        return this.generateTraitDeclaration(node)
+      case 'EnumDeclaration':
+        return this.generateEnumDeclaration(node)
+      case 'IfStatement':
+        return this.generateIfStatement(node)
+      case 'ForStatement':
+        return this.generateForStatement(node)
+      case 'ForEachStatement':
+        return this.generateForEachStatement(node)
+      case 'WhileStatement':
+        return this.generateWhileStatement(node)
+      case 'DoWhileStatement':
+        return this.generateDoWhileStatement(node)
+      case 'SwitchStatement':
+        return this.generateSwitchStatement(node)
+      case 'TryStatement':
+        return this.generateTryStatement(node)
+      case 'ReturnStatement':
+        return this.generateReturnStatement(node)
+      case 'ThrowStatement':
+        return this.generateThrowStatement(node)
+      case 'BreakStatement':
+        this.writeLine('break;')
+        return ''
+      case 'ContinueStatement':
+        this.writeLine('continue;')
+        return ''
+      case 'ExpressionStatement':
+        return this.generateExpressionStatement(node)
+      case 'EchoStatement':
+        return this.generateEchoStatement(node)
+      case 'BlockStatement':
+        return this.generateBlockStatement(node)
+      case 'CallExpression':
+        return this.generateCallExpression(node)
+      case 'MemberExpression':
+        return this.generateMemberExpression(node)
+      case 'StaticMemberExpression':
+        return this.generateStaticMemberExpression(node)
+      case 'BinaryExpression':
+        return this.generateBinaryExpression(node)
+      case 'LogicalExpression':
+        return this.generateBinaryExpression(node)
+      case 'AssignmentExpression':
+        return this.generateAssignmentExpression(node)
+      case 'UnaryExpression':
+        return this.generateUnaryExpression(node)
+      case 'UpdateExpression':
+        return this.generateUpdateExpression(node)
+      case 'ConditionalExpression':
+        return this.generateConditionalExpression(node)
+      case 'ArrayExpression':
+        return this.generateArrayExpression(node)
+      case 'ObjectExpression':
+        return this.generateObjectExpression(node)
+      case 'Identifier':
+        return this.generateIdentifier(node)
+      case 'Variable':
+        return this.generateVariable(node)
+      case 'Literal':
+        return this.generateLiteral(node)
+      case 'StringLiteral':
+        return this.generateStringLiteral(node)
+      case 'NewExpression':
+        return this.generateNewExpression(node)
+      case 'ThisExpression':
+        return '$this'
+      case 'FunctionExpression':
+        return this.generateFunctionExpression(node)
+      case 'ArrowFunctionExpression':
+        return this.generateArrowFunctionExpression(node)
+      case 'IndexExpression':
+        return this.generateIndexExpression(node)
+      case 'NullCoalesceExpression':
+        return this.generateNullCoalesceExpression(node)
+      case 'YieldExpression':
+        return this.generateYieldExpression(node)
+      default:
+        return ''
     }
+  }
 
-    const type = node.type || node.nodeType
-
-    const generators = {
-      'Program': () => this.generateProgram(node),
-      'FunctionDeclaration': () => this.generateFunctionDeclaration(node),
-      'ClassDeclaration': () => this.generateClassDeclaration(node),
-      'InterfaceDeclaration': () => this.generateInterfaceDeclaration(node),
-      'TraitDeclaration': () => this.generateTraitDeclaration(node),
-      'EnumDeclaration': () => this.generateEnumDeclaration(node),
-      'MethodDefinition': () => this.generateMethodDefinition(node),
-      'MethodDeclaration': () => this.generateMethodDefinition(node),
-      'PropertyDeclaration': () => this.generatePropertyDeclaration(node),
-      'VariableDeclaration': () => this.generateVariableDeclaration(node),
-      'ConstantDeclaration': () => this.generateConstantDeclaration(node),
-      'IfStatement': () => this.generateIfStatement(node),
-      'ForStatement': () => this.generateForStatement(node),
-      'ForEachStatement': () => this.generateForEachStatement(node),
-      'ForeachStatement': () => this.generateForEachStatement(node),
-      'WhileStatement': () => this.generateWhileStatement(node),
-      'DoWhileStatement': () => this.generateDoWhileStatement(node),
-      'SwitchStatement': () => this.generateSwitchStatement(node),
-      'MatchExpression': () => this.generateMatchExpression(node),
-      'TryStatement': () => this.generateTryStatement(node),
-      'ReturnStatement': () => this.generateReturnStatement(node),
-      'YieldExpression': () => this.generateYieldExpression(node),
-      'ThrowStatement': () => this.generateThrowStatement(node),
-      'BreakStatement': () => this.writeLine('break;'),
-      'ContinueStatement': () => this.writeLine('continue;'),
-      'ExpressionStatement': () => this.generateExpressionStatement(node),
-      'EchoStatement': () => this.generateEchoStatement(node),
-      'PrintStatement': () => this.generatePrintStatement(node),
-      'Namespace': () => this.generateNamespace(node),
-      'UseStatement': () => this.generateUseStatement(node),
-      'DeclareStatement': () => this.generateDeclareStatement(node),
-      'IncludeStatement': () => this.generateIncludeStatement(node),
-      'Include': () => this.generateInclude(node),
-      'CallExpression': () => this.generateCallExpression(node),
-      'MemberExpression': () => this.generateMemberExpression(node),
-      'StaticMemberExpression': () => this.generateStaticMemberExpression(node),
-      'IndexExpression': () => this.generateIndexExpression(node),
-      'BinaryExpression': () => this.generateBinaryExpression(node),
-      'LogicalExpression': () => this.generateBinaryExpression(node),
-      'UnaryExpression': () => this.generateUnaryExpression(node),
-      'AssignmentExpression': () => this.generateAssignmentExpression(node),
-      'UpdateExpression': () => this.generateUpdateExpression(node),
-      'ConditionalExpression': () => this.generateConditionalExpression(node),
-      'NullCoalescing': () => this.generateNullCoalescing(node),
-      'ArrayExpression': () => this.generateArrayExpression(node),
-      'ObjectExpression': () => this.generateObjectExpression(node),
-      'ArrowFunction': () => this.generateArrowFunction(node),
-      'ArrowFunctionExpression': () => this.generateArrowFunction(node),
-      'FunctionExpression': () => this.generateFunctionExpression(node),
-      'Closure': () => this.generateClosure(node),
-      'Identifier': () => this.generateIdentifier(node),
-      'ThisExpression': () => '$this',
-      'Literal': () => this.generateLiteral(node),
-      'StringLiteral': () => this.generateLiteral(node),
-      'NumericLiteral': () => this.generateLiteral(node),
-      'BooleanLiteral': () => this.generateLiteral(node),
-      'NullLiteral': () => 'null',
-      'NewExpression': () => this.generateNewExpression(node),
-      'InstanceOf': () => this.generateInstanceOf(node),
-      'BlockStatement': () => this.generateBlockStatement(node),
-      'NamespaceDeclaration': () => this.generateNamespace(node),
-      'EmptyStatement': () => '',
-      'Comment': () => ''
+  generateDeclareStatement(node) {
+    const directives = []
+    if (node.strictTypes) {
+      directives.push('strict_types=1')
     }
-
-    if (generators[type]) {
-      return generators[type]()
+    if (node.ticks) {
+      directives.push(`ticks=${node.ticks}`)
     }
-
-    if (node.expression) {
-      return this.generateNode(node.expression)
+    if (node.encoding) {
+      directives.push(`encoding='${node.encoding}'`)
+    }
+    if (directives.length > 0) {
+      this.writeLine(`declare(${directives.join(', ')});`)
     }
+    return ''
+  }
 
+  generateNamespace(node) {
+    const name = node.name || node.path
+    this.writeLine(`namespace ${name};`)
+    this.writeLine('')
     return ''
   }
 
-  generateProgram(node) {
-    for (const stmt of node.body || []) {
-      this.generateNode(stmt)
+  generateUseStatement(node) {
+    const name = node.name || node.source
+    const alias = node.alias ? ` as ${node.alias}` : ''
+    this.writeLine(`use ${name}${alias};`)
+    return ''
+  }
+
+  generateConstantDeclaration(node) {
+    const name = node.name || node.id?.name
+    const value = this.generateNode(node.value || node.init)
+    this.writeLine(`define('${name}', ${value});`)
+    return ''
+  }
+
+  generateVariableDeclaration(node) {
+    const declarations = node.declarations || [node]
+    
+    for (const decl of declarations) {
+      const name = this.generateVariable(decl.id || decl)
+      if (decl.init) {
+        const init = this.generateNode(decl.init)
+        this.writeLine(`${name} = ${init};`)
+      }
     }
+    return ''
   }
 
   generateFunctionDeclaration(node) {
-    const name = node.name || node.id?.name || 'anonymous'
-    const params = this.generateParams(node.params || [])
-    const returnType = node.returnType ? ': ' + this.translateType(node.returnType) : ''
+    const name = node.name || node.id?.name || ''
+    const params = (node.params || []).map(p => this.generateParam(p)).join(', ')
+    let returnType = ''
     
+    if (node.returnType) {
+      const type = this.extractTypeName(node.returnType)
+      if (type) returnType = ': ' + type
+    }
+
     this.writeLine(`function ${name}(${params})${returnType} {`)
     this.indent++
-    this.generateNode(node.body)
+    
+    if (node.body) {
+      this.generateBody(node.body)
+    }
+    
     this.indent--
     this.writeLine('}')
     this.writeLine('')
+    return ''
   }
 
-  generateParams(params) {
-    return params.map(p => {
-      let result = ''
-      
-      if (p.visibility) {
-        result += this.translate(p.visibility) + ' '
-      }
-      
-      if (p.typeHint) {
-        result += this.translateType(p.typeHint) + ' '
-      }
-      
-      if (p.variadic) {
-        result += '...'
-      }
-      
-      if (p.reference || p.byReference) {
-        result += '&'
-      }
-      
-      const name = p.name || p.id?.name || p
-      result += '$' + (typeof name === 'string' ? name : name.name || 'param')
-      
-      if (p.default !== undefined && p.default !== null) {
-        result += ' = ' + this.generateNode(p.default)
-      }
-      
-      return result
-    }).join(', ')
-  }
-
-  translateType(type) {
-    if (!type) return ''
+  generateParam(param) {
+    let result = ''
     
-    if (typeof type === 'string') {
-      const translated = this.translate(type)
-      const typeMap = {
-        'chaîne': 'string', 'chaine': 'string', 'string': 'string',
-        'entier': 'int', 'integer': 'int', 'int': 'int',
-        'flottant': 'float', 'float': 'float',
-        'booléen': 'bool', 'booleen': 'bool', 'boolean': 'bool', 'bool': 'bool',
-        'tableau': 'array', 'array': 'array',
-        'objet': 'object', 'object': 'object',
-        'nul': 'null', 'null': 'null',
-        'vide': 'void', 'void': 'void',
-        'mixte': 'mixed', 'mixed': 'mixed',
-        'appelable': 'callable', 'callable': 'callable',
-        'itérable': 'iterable', 'iterable': 'iterable',
-        'jamais': 'never', 'never': 'never'
+    if (param.typeHint || (param.type && param.type !== 'Parameter' && param.type !== 'Identifier')) {
+      const type = param.typeHint || param.type
+      if (typeof type === 'string' && type !== 'Parameter' && type !== 'Identifier') {
+        result += this.translateKeyword(type) + ' '
+      } else if (type && type.name) {
+        result += this.translateKeyword(type.name) + ' '
       }
-      return typeMap[translated.toLowerCase()] || typeMap[type.toLowerCase()] || type
     }
     
-    if (type.type === 'TypeHint' && type.types && type.types.length > 0) {
-      const prefix = type.nullable ? '?' : ''
-      if (type.union || type.types.length > 1) {
-        return prefix + type.types.map(t => this.translateType(t)).join('|')
-      }
-      return prefix + this.translateType(type.types[0])
+    if (param.reference) {
+      result += '&'
     }
     
-    if (type.union) {
-      return type.types.map(t => this.translateType(t)).join('|')
+    if (param.variadic) {
+      result += '...'
     }
     
-    if (type.intersection) {
-      return type.types.map(t => this.translateType(t)).join('&')
-    }
+    result += this.generateVariable(param)
     
-    if (type.nullable) {
-      return '?' + this.translateType(type.type)
+    if (param.default !== undefined && param.default !== null) {
+      result += ' = ' + this.generateNode(param.default)
     }
     
-    return type.name || type
+    return result
+  }
+
+  generateBody(body) {
+    if (Array.isArray(body)) {
+      for (const stmt of body) {
+        this.generateNode(stmt)
+      }
+    } else if (body && body.body) {
+      for (const stmt of body.body) {
+        this.generateNode(stmt)
+      }
+    } else if (body) {
+      this.generateNode(body)
+    }
   }
 
   generateClassDeclaration(node) {
     let declaration = ''
     
-    const modifiers = node.modifiers || []
-    if (modifiers.includes('abstract') || node.abstract) declaration += 'abstract '
-    if (modifiers.includes('final') || node.final) declaration += 'final '
-    if (modifiers.includes('readonly') || node.readonly) declaration += 'readonly '
-    
-    declaration += 'class ' + (node.name || node.id?.name)
+    if (node.abstract) declaration += 'abstract '
+    if (node.final) declaration += 'final '
+    if (node.readonly) declaration += 'readonly '
     
-    if (node.superClass) {
-      const superName = typeof node.superClass === 'string' ? node.superClass : node.superClass.name
-      declaration += ' extends ' + superName
-    } else if (node.extends) {
-      declaration += ' extends ' + (typeof node.extends === 'string' ? node.extends : node.extends.name)
+    declaration += 'class ' + (node.name || node.id?.name || '')
+
+    if (node.extends || node.superClass) {
+      declaration += ' extends ' + (node.extends || node.superClass)
     }
-    
-    if (node.interfaces && node.interfaces.length > 0) {
-      declaration += ' implements ' + node.interfaces.map(i => typeof i === 'string' ? i : i.name).join(', ')
-    } else if (node.implements && node.implements.length > 0) {
-      declaration += ' implements ' + node.implements.map(i => typeof i === 'string' ? i : i.name).join(', ')
+
+    if (node.implements && node.implements.length > 0) {
+      declaration += ' implements ' + node.implements.join(', ')
     }
-    
+
     this.writeLine(declaration + ' {')
     this.indent++
-    
-    for (const member of node.body || node.members || []) {
-      this.generateNode(member)
+
+    const members = node.body?.body || node.members || node.body || []
+    for (const member of members) {
+      this.generateClassMember(member)
     }
-    
+
     this.indent--
     this.writeLine('}')
     this.writeLine('')
+    return ''
   }
 
-  generateInterfaceDeclaration(node) {
-    let declaration = 'interface ' + this.translate(node.name || node.id?.name)
+  generateClassMember(node) {
+    if (!node) return
+
+    if (node.type === 'UseTraitStatement') {
+      this.writeLine(`use ${node.traits.join(', ')};`)
+      return
+    }
+
+    const visibility = node.visibility || 'public'
+    const isStatic = node.static ? 'static ' : ''
+    const isReadonly = node.readonly ? 'readonly ' : ''
     
+    if (node.type === 'Property' || node.kind === 'property' || node.type === 'PropertyDeclaration') {
+      const name = '$' + (node.name || node.key?.name || node.id?.name || '')
+      let typeHint = ''
+      if (node.typeHint) {
+        typeHint = this.translateKeyword(node.typeHint) + ' '
+      }
+      const value = node.value ? ' = ' + this.generateNode(node.value) : ''
+      this.writeLine(`${visibility} ${isStatic}${isReadonly}${typeHint}${name}${value};`)
+    } else if (node.type === 'Method' || node.kind === 'method' || node.type === 'MethodDeclaration') {
+      const name = node.name || node.key?.name || ''
+      const translatedName = this.translateKeyword(name)
+      const params = (node.params || []).map(p => this.generateParam(p)).join(', ')
+      let returnType = ''
+      
+      if (node.returnType) {
+        const type = this.extractTypeName(node.returnType)
+        if (type) returnType = ': ' + type
+      }
+      
+      const abstractMod = node.abstract ? 'abstract ' : ''
+      
+      if (node.abstract) {
+        this.writeLine(`${abstractMod}${visibility} ${isStatic}function ${translatedName}(${params})${returnType};`)
+      } else {
+        this.writeLine(`${visibility} ${isStatic}function ${translatedName}(${params})${returnType} {`)
+        this.indent++
+        
+        if (node.body) {
+          this.generateBody(node.body)
+        }
+        
+        this.indent--
+        this.writeLine('}')
+      }
+      this.writeLine('')
+    }
+  }
+
+  generateInterfaceDeclaration(node) {
+    let declaration = 'interface ' + (node.name || '')
+
     if (node.extends && node.extends.length > 0) {
-      declaration += ' extends ' + node.extends.map(e => this.translate(e)).join(', ')
+      declaration += ' extends ' + node.extends.join(', ')
     }
-    
+
     this.writeLine(declaration + ' {')
     this.indent++
-    
-    for (const member of node.body || node.members || []) {
-      this.generateNode(member)
+
+    const members = node.body?.body || node.members || node.body || []
+    for (const member of members) {
+      this.generateInterfaceMember(member)
     }
-    
+
     this.indent--
     this.writeLine('}')
     this.writeLine('')
+    return ''
   }
 
-  generateTraitDeclaration(node) {
-    this.writeLine('trait ' + this.translate(node.name || node.id?.name) + ' {')
-    this.indent++
+  generateInterfaceMember(node) {
+    if (!node) return
+
+    const visibility = 'public'
+    const name = node.name || node.key?.name || ''
+    const translatedName = this.translateKeyword(name)
+    const params = (node.params || []).map(p => this.generateParam(p)).join(', ')
+    let returnType = ''
     
-    for (const member of node.body || node.members || []) {
-      this.generateNode(member)
+    if (node.returnType) {
+      const type = this.extractTypeName(node.returnType)
+      if (type) returnType = ': ' + type
     }
     
-    this.indent--
-    this.writeLine('}')
+    this.writeLine(`${visibility} function ${translatedName}(${params})${returnType};`)
     this.writeLine('')
   }
 
-  generateEnumDeclaration(node) {
-    let declaration = 'enum ' + this.translate(node.name || node.id?.name)
-    
-    if (node.backingType) {
-      declaration += ': ' + this.translateType(node.backingType)
-    }
-    
-    this.writeLine(declaration + ' {')
+  generateTraitDeclaration(node) {
+    this.writeLine('trait ' + (node.name || '') + ' {')
     this.indent++
-    
-    for (const member of node.cases || node.members || []) {
-      if (member.value !== undefined) {
-        this.writeLine(`case ${member.name} = ${this.generateNode(member.value)};`)
-      } else {
-        this.writeLine(`case ${member.name};`)
-      }
-    }
-    
-    for (const method of node.methods || []) {
-      this.generateNode(method)
+
+    const members = node.body?.body || node.members || node.body || []
+    for (const member of members) {
+      this.generateClassMember(member)
     }
-    
+
     this.indent--
     this.writeLine('}')
     this.writeLine('')
+    return ''
   }
 
-  generateMethodDefinition(node) {
-    let declaration = ''
-    
-    const visibility = node.visibility || node.access || 'public'
-    declaration += this.translate(visibility) + ' '
-    
-    if (node.static) declaration += 'static '
-    if (node.final) declaration += 'final '
-    if (node.abstract) declaration += 'abstract '
-    
-    const name = this.translateMethodName(node.name || node.key?.name)
-    const params = this.generateParams(node.params || node.value?.params || [])
-    const returnType = node.returnType ? ': ' + this.translateType(node.returnType) : ''
-    
-    const body = node.body || node.value?.body
-    const hasEmptyBody = !body || (body.type === 'BlockStatement' && (!body.body || body.body.length === 0))
-    
-    if (node.abstract || hasEmptyBody) {
-      this.writeLine(`${declaration}function ${name}(${params})${returnType};`)
-    } else {
-      this.writeLine(`${declaration}function ${name}(${params})${returnType} {`)
-      this.indent++
-      this.generateNode(body)
-      this.indent--
-      this.writeLine('}')
-    }
-    this.writeLine('')
-  }
-
-  translateMethodName(name) {
-    if (!name) return 'method'
+  generateEnumDeclaration(node) {
+    let declaration = 'enum ' + (node.name || '')
     
-    const magicMethods = {
-      'constructeur': '__construct',
-      'constructor': '__construct',
-      'destructeur': '__destruct',
-      'destructor': '__destruct',
-      'obtenir': '__get',
-      'get': '__get',
-      'définir': '__set',
-      'definir': '__set',
-      'set': '__set',
-      'appeler': '__call',
-      'call': '__call',
-      'appeler statique': '__callStatic',
-      'call static': '__callStatic',
-      'vers chaîne': '__toString',
-      'vers chaine': '__toString',
-      'to string': '__toString',
-      'invoquer': '__invoke',
-      'invoke': '__invoke',
-      'cloner': '__clone',
-      'clone': '__clone',
-      'dormir': '__sleep',
-      'sleep': '__sleep',
-      'réveiller': '__wakeup',
-      'reveiller': '__wakeup',
-      'wakeup': '__wakeup',
-      'sérialiser': '__serialize',
-      'serialiser': '__serialize',
-      'serialize': '__serialize',
-      'désérialiser': '__unserialize',
-      'deserialiser': '__unserialize',
-      'unserialize': '__unserialize',
-      'isset': '__isset',
-      'existe propriété': '__isset',
-      'existe propriete': '__isset',
-      'unset': '__unset',
-      'détruire propriété': '__unset',
-      'detruire propriete': '__unset',
-      'déboguer info': '__debugInfo',
-      'deboguer info': '__debugInfo',
-      'debug info': '__debugInfo'
+    if (node.backingType) {
+      declaration += ': ' + this.translateKeyword(node.backingType)
     }
-    
-    const normalized = name.toLowerCase().trim()
-    return magicMethods[normalized] || name
-  }
 
-  generatePropertyDeclaration(node) {
-    let declaration = ''
-    
-    const visibility = node.visibility || node.access || 'public'
-    declaration += this.translate(visibility) + ' '
-    
-    if (node.static) declaration += 'static '
-    if (node.readonly) declaration += 'readonly '
-    
-    if (node.typeHint) {
-      declaration += this.translateType(node.typeHint) + ' '
-    }
-    
-    const name = node.name || node.key?.name
-    declaration += '$' + name
-    
-    if (node.default !== undefined && node.default !== null) {
-      declaration += ' = ' + this.generateNode(node.default)
-    } else if (node.value !== undefined && node.value !== null) {
-      declaration += ' = ' + this.generateNode(node.value)
-    }
-    
-    this.writeLine(declaration + ';')
-  }
+    this.writeLine(declaration + ' {')
+    this.indent++
 
-  generateVariableDeclaration(node) {
-    for (const decl of node.declarations || [node]) {
-      const name = decl.name || decl.id?.name || decl.id
-      const varName = '$' + (typeof name === 'string' ? name : name.name || 'var')
-      
-      if (decl.init !== undefined) {
-        const value = this.generateNode(decl.init)
-        this.writeLine(`${varName} = ${value};`)
+    const cases = node.cases || node.members || []
+    for (const caseNode of cases) {
+      if (caseNode.value !== undefined) {
+        this.writeLine(`case ${caseNode.name} = ${this.generateNode(caseNode.value)};`)
       } else {
-        this.writeLine(`${varName} = null;`)
+        this.writeLine(`case ${caseNode.name};`)
       }
     }
-  }
 
-  generateConstantDeclaration(node) {
-    const name = node.name || node.id?.name
-    const value = this.generateNode(node.value || node.init)
-    
-    if (node.classLevel) {
-      const visibility = node.visibility ? this.translate(node.visibility) + ' ' : ''
-      this.writeLine(`${visibility}const ${name.toUpperCase()} = ${value};`)
-    } else {
-      this.writeLine(`define('${name.toUpperCase()}', ${value});`)
-    }
+    this.indent--
+    this.writeLine('}')
+    this.writeLine('')
+    return ''
   }
 
   generateIfStatement(node) {
-    const test = this.generateNode(node.test || node.condition)
+    const test = this.generateNode(node.test)
     this.writeLine(`if (${test}) {`)
     this.indent++
-    this.generateNode(node.consequent)
+    this.generateBody(node.consequent)
     this.indent--
-    
+
     if (node.alternate) {
-      if (node.alternate.type === 'IfStatement' || node.alternate.type === 'ElseIfStatement') {
-        this.write('} else')
-        this.generateIfStatement({ ...node.alternate, isElseIf: true })
+      if (node.alternate.type === 'IfStatement') {
+        const altTest = this.generateNode(node.alternate.test)
+        this.writeLine(`} elseif (${altTest}) {`)
+        this.indent++
+        this.generateBody(node.alternate.consequent)
+        this.indent--
+        if (node.alternate.alternate) {
+          this.generateElse(node.alternate.alternate)
+        } else {
+          this.writeLine('}')
+        }
       } else {
         this.writeLine('} else {')
         this.indent++
-        this.generateNode(node.alternate)
+        this.generateBody(node.alternate)
         this.indent--
         this.writeLine('}')
       }
     } else {
       this.writeLine('}')
     }
+    return ''
+  }
+
+  generateElse(node) {
+    if (node.type === 'IfStatement') {
+      const altTest = this.generateNode(node.test)
+      this.writeLine(`} elseif (${altTest}) {`)
+      this.indent++
+      this.generateBody(node.consequent)
+      this.indent--
+      if (node.alternate) {
+        this.generateElse(node.alternate)
+      } else {
+        this.writeLine('}')
+      }
+    } else {
+      this.writeLine('} else {')
+      this.indent++
+      this.generateBody(node)
+      this.indent--
+      this.writeLine('}')
+    }
   }
 
   generateForStatement(node) {
@@ -579,48 +786,43 @@ class PHPGenerator {
 
     this.writeLine(`for (${init}; ${test}; ${update}) {`)
     this.indent++
-    this.generateNode(node.body)
+    this.generateBody(node.body)
     this.indent--
     this.writeLine('}')
+    return ''
   }
 
   generateForEachStatement(node) {
-    const array = this.generateNode(node.array || node.right || node.iterable)
-    
-    const valueNode = node.value || node.left || node.valueVar
-    const value = typeof valueNode === 'string' 
-      ? '$' + valueNode 
-      : this.generateIdentifier(valueNode)
-    
-    let key = ''
-    const keyNode = node.key || node.keyVar
-    if (keyNode) {
-      key = (typeof keyNode === 'string' ? '$' + keyNode : this.generateIdentifier(keyNode)) + ' => '
-    }
+    const array = this.generateNode(node.array || node.right)
+    const value = this.generateVariable(node.value || node.left)
+    const key = node.key ? this.generateVariable(node.key) + ' => ' : ''
 
     this.writeLine(`foreach (${array} as ${key}${value}) {`)
     this.indent++
-    this.generateNode(node.body)
+    this.generateBody(node.body)
     this.indent--
     this.writeLine('}')
+    return ''
   }
 
   generateWhileStatement(node) {
-    const test = this.generateNode(node.test || node.condition)
+    const test = this.generateNode(node.test)
     this.writeLine(`while (${test}) {`)
     this.indent++
-    this.generateNode(node.body)
+    this.generateBody(node.body)
     this.indent--
     this.writeLine('}')
+    return ''
   }
 
   generateDoWhileStatement(node) {
     this.writeLine('do {')
     this.indent++
-    this.generateNode(node.body)
+    this.generateBody(node.body)
     this.indent--
-    const test = this.generateNode(node.test || node.condition)
+    const test = this.generateNode(node.test)
     this.writeLine(`} while (${test});`)
+    return ''
   }
 
   generateSwitchStatement(node) {
@@ -644,56 +846,35 @@ class PHPGenerator {
 
     this.indent--
     this.writeLine('}')
-  }
-
-  generateMatchExpression(node) {
-    const subject = this.generateNode(node.subject || node.discriminant)
-    let result = `match (${subject}) {\n`
-    
-    for (const arm of node.arms || node.cases || []) {
-      this.indent++
-      if (arm.conditions) {
-        const conditions = arm.conditions.map(c => this.generateNode(c)).join(', ')
-        result += this.getIndent() + `${conditions} => ${this.generateNode(arm.body)},\n`
-      } else if (arm.default) {
-        result += this.getIndent() + `default => ${this.generateNode(arm.body)},\n`
-      }
-      this.indent--
-    }
-    
-    result += this.getIndent() + '}'
-    return result
+    return ''
   }
 
   generateTryStatement(node) {
     this.writeLine('try {')
     this.indent++
-    this.generateNode(node.block)
+    this.generateBody(node.block)
     this.indent--
 
-    const handlers = node.catches || node.handlers || (node.handler ? [node.handler] : [])
-    for (const handler of handlers) {
-      const types = handler.types && handler.types.length > 0 
-        ? handler.types.join(' | ') 
-        : (handler.type || 'Exception')
-      const param = handler.param 
-        ? (typeof handler.param === 'string' ? '$' + handler.param : this.generateIdentifier(handler.param))
+    if (node.handler) {
+      const exceptionType = node.handler.exceptionType || node.handler.type || 'Exception'
+      const param = node.handler.param 
+        ? this.generateVariable(node.handler.param) 
         : '$e'
-      this.writeLine(`} catch (${types} ${param}) {`)
+      this.writeLine(`} catch (${exceptionType} ${param}) {`)
       this.indent++
-      this.generateNode(handler.body)
+      this.generateBody(node.handler.body)
       this.indent--
     }
 
-    const finallyBlock = node.finally || node.finalizer
-    if (finallyBlock) {
+    if (node.finalizer) {
       this.writeLine('} finally {')
       this.indent++
-      this.generateNode(finallyBlock)
+      this.generateBody(node.finalizer)
       this.indent--
     }
 
     this.writeLine('}')
+    return ''
   }
 
   generateReturnStatement(node) {
@@ -703,80 +884,34 @@ class PHPGenerator {
     } else {
       this.writeLine('return;')
     }
-  }
-
-  generateYieldExpression(node) {
-    const arg = node.argument ? this.generateNode(node.argument) : ''
-    if (node.delegate) {
-      return `yield from ${arg}`
-    }
-    return `yield ${arg}`
+    return ''
   }
 
   generateThrowStatement(node) {
     const arg = this.generateNode(node.argument)
     this.writeLine(`throw ${arg};`)
+    return ''
   }
 
   generateExpressionStatement(node) {
     const expr = this.generateNode(node.expression)
-    this.writeLine(`${expr};`)
+    if (expr) {
+      this.writeLine(`${expr};`)
+    }
+    return ''
   }
 
   generateEchoStatement(node) {
-    const exprs = node.expressions || node.arguments || [node.argument]
-    const args = exprs.filter(Boolean).map(a => this.generateNode(a)).join(', ')
+    const args = (node.expressions || node.arguments || [node.argument]).filter(Boolean).map(a => this.generateNode(a)).join(', ')
     this.writeLine(`echo ${args};`)
+    return ''
   }
 
-  generatePrintStatement(node) {
-    const arg = this.generateNode(node.argument)
-    this.writeLine(`print ${arg};`)
-  }
-
-  generateNamespace(node) {
-    this.writeLine(`namespace ${node.name};`)
-    this.writeLine('')
-  }
-
-  generateUseStatement(node) {
-    const typePrefix = node.useType === 'function' ? 'function ' : (node.useType === 'const' ? 'const ' : '')
-    
-    if (node.imports && node.imports.length > 0) {
-      for (const imp of node.imports) {
-        const path = imp.path || imp.name || imp
-        const alias = imp.alias ? ' as ' + imp.alias : ''
-        this.writeLine(`use ${typePrefix}${path}${alias};`)
-      }
-    } else {
-      const name = node.name || node.source || 'undefined'
-      const alias = node.alias ? ' as ' + node.alias : ''
-      this.writeLine(`use ${typePrefix}${name}${alias};`)
-    }
-  }
-
-  generateDeclareStatement(node) {
-    const directives = (node.directives || []).map(d => {
-      const value = typeof d.value === 'object' ? this.generateNode(d.value) : d.value
-      return `${d.name}=${value}`
-    }).join(', ')
-    this.writeLine(`declare(${directives});`)
-  }
-
-  generateIncludeStatement(node) {
-    const type = node.once 
-      ? (node.required ? 'require_once' : 'include_once') 
-      : (node.required ? 'require' : 'include')
-    const path = typeof node.path === 'string' ? `'${node.path}'` : this.generateNode(node.path)
-    this.writeLine(`${type} ${path};`)
-  }
-
-  generateInclude(node) {
-    if (node.resolved && node.children) {
-      for (const child of node.children) {
-        this.generateNode(child)
-      }
+  generateBlockStatement(node) {
+    for (const stmt of node.body || []) {
+      this.generateNode(stmt)
     }
+    return ''
   }
 
   generateCallExpression(node) {
@@ -784,34 +919,15 @@ class PHPGenerator {
     
     if (typeof node.callee === 'string') {
       callee = this.translateFunction(node.callee)
-    } else if (node.callee.type === 'MemberExpression') {
-      callee = this.generateMemberExpression(node.callee)
-    } else if (node.callee.type === 'StaticMemberExpression') {
-      callee = this.generateStaticMemberExpression(node.callee)
     } else if (node.callee.type === 'Identifier') {
-      const name = node.callee.name
-      const translated = this.translateFunction(name)
-      if (translated !== name) {
-        callee = translated
-      } else if (name.includes(' ')) {
-        callee = name.replace(/ /g, '_')
-      } else {
-        callee = name
-      }
+      callee = this.translateFunction(node.callee.name)
+    } else if (node.callee.type === 'MemberExpression' || node.callee.type === 'StaticMemberExpression') {
+      callee = this.generateNode(node.callee)
     } else {
       callee = this.generateNode(node.callee)
     }
     
-    const args = (node.arguments || []).map(a => {
-      if (a.spread) {
-        return '...' + this.generateNode(a.argument || a)
-      }
-      if (a.name && a.value) {
-        return `${a.name}: ${this.generateNode(a.value)}`
-      }
-      return this.generateNode(a)
-    }).join(', ')
-    
+    const args = (node.arguments || []).map(a => this.generateNode(a)).join(', ')
     return `${callee}(${args})`
   }
 
@@ -822,53 +938,24 @@ class PHPGenerator {
     if (typeof node.property === 'string') {
       property = node.property
     } else if (node.property.type === 'Identifier') {
-      let propName = node.property.name
-      let translated = this.translateFunction(propName)
-      if (translated.includes('->')) {
-        translated = translated.split('->').pop()
-      } else if (translated.includes('::')) {
-        translated = translated.split('::').pop()
-      } else if (translated !== propName && !translated.includes('(')) {
-        translated = propName
-      }
-      property = translated
+      property = this.translateFunction(node.property.name)
     } else {
       property = this.generateNode(node.property)
     }
     
-    if (node.static) {
-      return `${object}::${property}`
-    }
+    const operator = node.nullsafe ? '?->' : '->'
+    
     if (node.computed) {
       return `${object}[${property}]`
     }
-    if (node.nullSafe) {
-      return `${object}?->${property}`
-    }
-    return `${object}->${property}`
+    return `${object}${operator}${property}`
   }
 
   generateStaticMemberExpression(node) {
-    const classNode = node.class || node.object
-    const className = classNode.type === 'Identifier' ? classNode.name : this.generateNode(classNode)
-    
-    const memberNode = node.member || node.property
-    let memberName
-    if (typeof memberNode === 'string') {
-      memberName = memberNode
-    } else if (memberNode.type === 'Identifier') {
-      memberName = this.translateMethodName(memberNode.name)
-    } else {
-      memberName = this.generateNode(memberNode)
-    }
-    
-    return `${className}::${memberName}`
-  }
-
-  generateIndexExpression(node) {
-    const object = this.generateNode(node.object)
-    const index = this.generateNode(node.index)
-    return `${object}[${index}]`
+    const cls = node.class?.name || this.generateNode(node.class)
+    let member = node.member?.name || this.generateNode(node.member)
+    member = this.translateKeyword(member)
+    return `${cls}::${member}`
   }
 
   generateBinaryExpression(node) {
@@ -877,47 +964,41 @@ class PHPGenerator {
     let op = node.operator
 
     const opMap = {
-      'et': '&&', 'and': '&&',
-      'ou': '||', 'or': '||',
-      'non': '!', 'not': '!',
-      'égal': '===', 'egal': '===', 'equal': '===',
-      'différent': '!==', 'different': '!==', 'not equal': '!==',
-      'concaténer': '.', 'concatener': '.', 'concatenate': '.',
-      'vaisseau spatial': '<=>', 'spaceship': '<=>',
-      'fusion null': '??', 'null coalescing': '??'
+      'et': '&&',
+      'ou': '||',
+      'concatener': '.',
+      'concat': '.'
     }
-    
-    op = opMap[op?.toLowerCase()] || op
+    op = opMap[this.normalizeAccents(op)] || op
+
+    return `${left} ${op} ${right}`
+  }
 
-    const result = `${left} ${op} ${right}`
-    return node.parenthesized ? `(${result})` : result
+  generateAssignmentExpression(node) {
+    const left = this.generateNode(node.left)
+    const right = this.generateNode(node.right)
+    const op = node.operator || '='
+    return `${left} ${op} ${right}`
   }
 
   generateUnaryExpression(node) {
-    const argument = this.generateNode(node.argument || node.operand)
-    const op = node.operator === 'non' || node.operator === 'not' ? '!' : node.operator
+    const operand = this.generateNode(node.operand || node.argument)
+    const op = node.operator === 'non' ? '!' : node.operator
     
     if (node.prefix !== false) {
-      return `${op}${argument}`
+      return `${op}${operand}`
     }
-    return `${argument}${op}`
+    return `${operand}${op}`
   }
 
   generateUpdateExpression(node) {
-    const argument = this.generateNode(node.argument || node.operand)
+    const operand = this.generateNode(node.operand || node.argument)
     const op = node.operator
     
     if (node.prefix) {
-      return `${op}${argument}`
+      return `${op}${operand}`
     }
-    return `${argument}${op}`
-  }
-
-  generateAssignmentExpression(node) {
-    const left = this.generateNode(node.left)
-    const right = this.generateNode(node.right)
-    const op = node.operator || '='
-    return `${left} ${op} ${right}`
+    return `${operand}${op}`
   }
 
   generateConditionalExpression(node) {
@@ -927,31 +1008,24 @@ class PHPGenerator {
     return `${test} ? ${consequent} : ${alternate}`
   }
 
-  generateNullCoalescing(node) {
-    const left = this.generateNode(node.left)
-    const right = this.generateNode(node.right)
-    return `${left} ?? ${right}`
-  }
-
   generateArrayExpression(node) {
     const elements = (node.elements || []).map(e => {
-      if (!e) return 'null'
       if (e.type === 'ArrayElement') {
-        if (e.key !== null && e.key !== undefined) {
+        if (e.key) {
           const key = this.generateNode(e.key)
           const value = this.generateNode(e.value)
           return `${key} => ${value}`
         }
         return this.generateNode(e.value)
       }
-      if (e.key !== undefined && e.key !== null) {
+      if (e.type === 'SpreadElement') {
+        return '...' + this.generateNode(e.argument)
+      }
+      if (e.key) {
         const key = this.generateNode(e.key)
         const value = this.generateNode(e.value || e)
         return `${key} => ${value}`
       }
-      if (e.spread) {
-        return '...' + this.generateNode(e.argument || e)
-      }
       return this.generateNode(e)
     })
     
@@ -966,112 +1040,44 @@ class PHPGenerator {
     return this.generateArrayExpression(node)
   }
 
-  generateArrowFunction(node) {
-    const params = this.generateParams(node.params || [])
-    const body = this.generateNode(node.body)
-    return `fn(${params}) => ${body}`
-  }
-
-  generateFunctionExpression(node) {
-    const params = this.generateParams(node.params || [])
-    const uses = node.uses || node.use || []
-    const useVars = uses.length > 0 
-      ? ` use (${uses.map(u => (u.byReference || u.byRef ? '&' : '') + '$' + (u.name || u)).join(', ')})` 
-      : ''
-    const returnType = node.returnType ? ': ' + this.translateType(node.returnType) : ''
-    
-    let result = `function(${params})${useVars}${returnType} {\n`
+  generateIdentifier(node) {
+    const name = node.name || node
+    if (typeof name !== 'string') return '$var'
     
-    const savedOutput = this.output
-    const savedIndent = this.indent
-    this.output = ''
-    this.indent++
+    const normalized = this.normalizeAccents(name)
     
-    const body = node.body
-    if (body && body.type === 'BlockStatement' && body.body) {
-      for (const stmt of body.body) {
-        this.generateNode(stmt)
-      }
-    } else if (body) {
-      this.writeLine('return ' + this.generateNode(body) + ';')
+    if (this.functionMap[normalized]) {
+      return this.functionMap[normalized]
     }
     
-    const bodyOutput = this.output
-    this.output = savedOutput
-    this.indent = savedIndent
-    
-    result += bodyOutput
-    result += this.getIndent() + '}'
-    return result
-  }
-
-  generateClosure(node) {
-    const params = this.generateParams(node.params || [])
-    const useVars = node.use && node.use.length > 0 
-      ? ` use (${node.use.map(u => (u.byRef ? '&' : '') + '$' + this.translate(u.name || u)).join(', ')})` 
-      : ''
-    const returnType = node.returnType ? ': ' + this.translateType(node.returnType) : ''
-    
-    let result = `function(${params})${useVars}${returnType} {\n`
-    this.indent++
+    const translated = this.translateKeyword(name)
     
-    if (Array.isArray(node.body)) {
-      for (const stmt of node.body) {
-        result += this.getIndent() + this.generateNode(stmt)
-      }
-    } else {
-      result += this.getIndent() + 'return ' + this.generateNode(node.body) + ';\n'
+    if (translated.startsWith('$')) return translated
+    if (['true', 'false', 'null', 'self', 'parent', 'static'].includes(translated)) {
+      return translated
+    }
+    if (/^[A-Z]/.test(translated)) return translated
+    if (translated === name && !name.startsWith('$')) {
+      return '$' + name
     }
     
-    this.indent--
-    result += this.getIndent() + '}'
-    return result
+    return translated.startsWith('$') ? translated : '$' + translated
   }
 
-  generateIdentifier(node) {
+  generateVariable(node) {
+    if (!node) return '$var'
+    
     const name = node.name || node.id?.name || node
     if (typeof name !== 'string') return '$var'
     
-    const keywords = [
-      'true', 'false', 'null', 
-      'self', 'parent', 'static',
-      'this', '$this', 'vrai', 'faux', 'nul', 'ceci'
-    ]
-    const lowerName = name.toLowerCase()
-    
-    if (lowerName === 'vrai') return 'true'
-    if (lowerName === 'faux') return 'false'
-    if (lowerName === 'nul') return 'null'
-    if (lowerName === 'ceci' || lowerName === 'this') return '$this'
-    
-    if (keywords.includes(lowerName)) {
-      return name
-    }
-    
     if (name.startsWith('$')) return name
-    
-    if (/^[A-Z]/.test(name)) return name
-    
-    if (name.includes('(') || name.includes('::') || name.includes('->')) return name
-    
-    const superglobals = ['_GET', '_POST', '_SERVER', '_SESSION', '_COOKIE', '_FILES', '_REQUEST', '_ENV', 'GLOBALS']
-    if (superglobals.includes(name) || superglobals.includes(name.toUpperCase())) {
-      return '$' + name.toUpperCase()
-    }
-    
     return '$' + name
   }
 
   generateLiteral(node) {
-    if (node.raw !== undefined) return node.raw
+    if (node.raw) return node.raw
     if (typeof node.value === 'string') {
-      const escaped = node.value
-        .replace(/\\/g, '\\\\')
-        .replace(/"/g, '\\"')
-        .replace(/\n/g, '\\n')
-        .replace(/\r/g, '\\r')
-        .replace(/\t/g, '\\t')
-      return `"${escaped}"`
+      return `"${node.value.replace(/"/g, '\\"')}"`
     }
     if (node.value === null) return 'null'
     if (node.value === true) return 'true'
@@ -1079,28 +1085,83 @@ class PHPGenerator {
     return String(node.value)
   }
 
+  generateStringLiteral(node) {
+    const quote = node.doubleQuoted ? '"' : "'"
+    const value = node.value.replace(new RegExp(quote, 'g'), '\\' + quote)
+    return `${quote}${value}${quote}`
+  }
+
   generateNewExpression(node) {
-    const callee = typeof node.callee === 'string'
-      ? this.translate(node.callee)
-      : this.generateNode(node.callee)
+    let callee
+    if (typeof node.callee === 'string') {
+      callee = node.callee
+    } else if (node.callee.type === 'Identifier') {
+      callee = node.callee.name
+    } else {
+      callee = this.generateNode(node.callee)
+    }
     const args = (node.arguments || []).map(a => this.generateNode(a)).join(', ')
     return `new ${callee}(${args})`
   }
 
-  generateInstanceOf(node) {
+  generateFunctionExpression(node) {
+    const params = (node.params || []).map(p => this.generateParam(p)).join(', ')
+    
+    let uses = ''
+    if (node.uses && node.uses.length > 0) {
+      const useVars = node.uses.map(u => {
+        const ref = u.byRef ? '&' : ''
+        return ref + this.generateVariable(u)
+      }).join(', ')
+      uses = ` use (${useVars})`
+    }
+    
+    let returnType = ''
+    if (node.returnType) {
+      returnType = ': ' + this.translateKeyword(node.returnType)
+    }
+    
+    let body = ''
+    if (node.body) {
+      const savedOutput = this.output
+      const savedIndent = this.indent
+      this.output = ''
+      this.indent = 0
+      this.generateBody(node.body)
+      body = this.output
+      this.output = savedOutput
+      this.indent = savedIndent
+    }
+    
+    return `function(${params})${uses}${returnType} {\n${body}}`
+  }
+
+  generateArrowFunctionExpression(node) {
+    const params = (node.params || []).map(p => this.generateParam(p)).join(', ')
+    const body = this.generateNode(node.body)
+    return `fn(${params}) => ${body}`
+  }
+
+  generateIndexExpression(node) {
+    const object = this.generateNode(node.object)
+    const index = node.index ? this.generateNode(node.index) : ''
+    return `${object}[${index}]`
+  }
+
+  generateNullCoalesceExpression(node) {
     const left = this.generateNode(node.left)
     const right = this.generateNode(node.right)
-    return `${left} instanceof ${right}`
+    return `${left} ?? ${right}`
   }
 
-  generateBlockStatement(node) {
-    for (const stmt of node.body || []) {
-      this.generateNode(stmt)
+  generateYieldExpression(node) {
+    if (node.delegate) {
+      return `yield from ${this.generateNode(node.argument)}`
     }
-  }
-
-  write(text) {
-    this.output += text
+    if (node.argument) {
+      return `yield ${this.generateNode(node.argument)}`
+    }
+    return 'yield'
   }
 
   writeLine(text) {
@@ -1112,4 +1173,6 @@ class PHPGenerator {
   }
 }
 
-module.exports = { PHPGenerator }
+module.exports = {
+  PHPGenerator
+}