ether-code 0.1.0

package/generators/js-generator.js

@@ -0,0 +1,909 @@
+const fs = require('fs')
+
+class JSGenerator {
+  constructor(i18nPath = null) {
+    this.i18n = null
+    this.indent = 0
+    this.output = ''
+    this.keywordMap = {}
+    this.methodMap = {}
+    this.operatorMap = {}
+    
+    this.buildGenericMaps()
+    
+    if (i18nPath) {
+      this.loadI18n(i18nPath)
+    }
+  }
+
+  buildGenericMaps() {
+    this.keywordMap = {
+      'variable': 'let', 'constante': 'const', 'var': 'var',
+      'fonction': 'function', 'retourner': 'return',
+      'si': 'if', 'sinon': 'else', 'sinon si': 'else if',
+      'pour': 'for', 'tant que': 'while', 'faire': 'do',
+      'selon': 'switch', 'cas': 'case', 'défaut': 'default',
+      'sortir': 'break', 'continuer': 'continue',
+      'essayer': 'try', 'attraper': 'catch', 'finalement': 'finally',
+      'lancer': 'throw', 'nouveau': 'new',
+      'classe': 'class', 'étend': 'extends', 'super': 'super',
+      'statique': 'static', 'obtenir': 'get', 'définir': 'set',
+      'importer': 'import', 'exporter': 'export', 'depuis': 'from',
+      'asynchrone': 'asynchrone', 'attendre': 'await',
+      'vrai': 'true', 'faux': 'false', 'nul': 'null', 'indefini': 'undefined',
+      'typeof': 'typeof', 'instanceof': 'instanceof', 'dans': 'in', 'de': 'of'
+    }
+    
+    this.methodMap = {
+      'afficher': 'console.log',
+      'ajouter': 'push', 'retirer': 'pop', 'insérer': 'unshift',
+      'filtrer': 'filter', 'mapper': 'map', 'réduire': 'reduce',
+      'trouver': 'find', 'certains': 'some', 'tous': 'every',
+      'joindre': 'join', 'diviser': 'split',
+      'longueur': 'length', 'taille': 'length',
+      'majuscules': 'toUpperCase', 'minuscules': 'toLowerCase',
+      'inclut': 'includes', 'indice de': 'indexOf',
+      'tableau': 'Array', 'objet': 'Object', 'chaîne': 'String', 'nombre': 'Number'
+    }
+    
+    this.operatorMap = {
+      'et': '&&', 'ou': '||', 'non': '!',
+      'egal': '===', 'different': '!==',
+      'plus': '+', 'moins': '-', 'fois': '*', 'divise': '/'
+    }
+  }
+
+  loadI18n(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8')
+    this.i18n = JSON.parse(content)
+    this.buildMaps()
+  }
+
+  buildMaps() {
+    this.keywordMap = {}
+    this.methodMap = {}
+    this.builtinMap = {}
+    
+    if (!this.i18n) return
+
+    const addToMap = (map, section) => {
+      if (!section) return
+      for (const [key, translations] of Object.entries(section)) {
+        if (translations && translations.fr && translations.js) {
+          map[translations.fr.toLowerCase()] = translations.js
+        }
+      }
+    }
+
+    addToMap(this.keywordMap, this.i18n.variables)
+    addToMap(this.keywordMap, this.i18n.typesPrimitifs)
+    addToMap(this.keywordMap, this.i18n.typesComposites)
+    addToMap(this.keywordMap, this.i18n.valeursSpeciales)
+    addToMap(this.keywordMap, this.i18n.operateursArithmetiques)
+    addToMap(this.keywordMap, this.i18n.operateursComparaison)
+    addToMap(this.keywordMap, this.i18n.operateursLogiques)
+    addToMap(this.keywordMap, this.i18n.structuresControle)
+    addToMap(this.keywordMap, this.i18n.fonctions)
+    addToMap(this.keywordMap, this.i18n.asynchrone)
+    addToMap(this.keywordMap, this.i18n.classes)
+    addToMap(this.keywordMap, this.i18n.modules)
+    addToMap(this.keywordMap, this.i18n.erreurs)
+    addToMap(this.keywordMap, this.i18n.generateurs)
+
+    addToMap(this.methodMap, this.i18n.methodesTableau)
+    addToMap(this.methodMap, this.i18n.methodesChaine)
+    addToMap(this.methodMap, this.i18n.methodesObjet)
+    addToMap(this.methodMap, this.i18n.methodesJSON)
+    addToMap(this.methodMap, this.i18n.methodesMath)
+    addToMap(this.methodMap, this.i18n.dom)
+    addToMap(this.methodMap, this.i18n.evenements)
+    addToMap(this.methodMap, this.i18n.fetch)
+    addToMap(this.methodMap, this.i18n.console)
+    addToMap(this.methodMap, this.i18n.stockage)
+    addToMap(this.methodMap, this.i18n.timers)
+  }
+
+  translate(word) {
+    const lower = word.toLowerCase()
+    return this.keywordMap[lower] || this.methodMap[lower] || this.translateGeneric(word)
+  }
+
+  translateGeneric(word) {
+    const translations = {
+      'variable': 'let',
+      'constante': 'const',
+      'fonction': 'function',
+      'retourner': 'return',
+      'si': 'if',
+      'sinon': 'else',
+      'sinon si': 'else if',
+      'pour': 'for',
+      'tant que': 'while',
+      'faire': 'do',
+      'selon': 'switch',
+      'cas': 'case',
+      'défaut': 'default',
+      'sortir': 'break',
+      'continuer': 'continue',
+      'essayer': 'try',
+      'attraper': 'catch',
+      'finalement': 'finally',
+      'lancer': 'throw',
+      'nouveau': 'new',
+      'supprimer': 'delete',
+      'typeof': 'typeof',
+      'type de': 'typeof',
+      'instanceof': 'instanceof',
+      'instance de': 'instanceof',
+      'dans': 'in',
+      'de': 'of',
+      'vrai': 'true',
+      'faux': 'false',
+      'nul': 'null',
+      'indefini': 'undefined',
+      'ceci': 'this',
+      'classe': 'class',
+      'étend': 'extends',
+      'super': 'super',
+      'constructeur': 'constructor',
+      'statique': 'static',
+      'obtenir': 'get',
+      'définir': 'set',
+      'asynchrone': 'asynchrone',
+      'attendre': 'await',
+      'produire': 'yield',
+      'importer': 'import',
+      'exporter': 'export',
+      'depuis': 'from',
+      'comme': 'as',
+      'par défaut': 'default',
+      'et': '&&',
+      'ou': '||',
+      'non': '!',
+      'egal': '===',
+      'different': '!==',
+      'inferieur': '<',
+      'superieur': '>',
+      'inferieur ou egal': '<=',
+      'superieur ou egal': '>=',
+      'plus': '+',
+      'moins': '-',
+      'fois': '*',
+      'divise': '/',
+      'modulo': '%',
+      'puissance': '**',
+      'longueur': 'length',
+      'ajouter': 'push',
+      'retirer': 'pop',
+      'decaler': 'shift',
+      'insérer début': 'unshift',
+      'trancher': 'slice',
+      'epiisser': 'splice',
+      'concatener': 'concat',
+      'joindre': 'join',
+      'inverser': 'reverse',
+      'trier': 'sort',
+      'filtrer': 'filter',
+      'mapper': 'map',
+      'réduire': 'reduce',
+      'trouver': 'find',
+      'trouver index': 'findIndex',
+      'chaque': 'forEach',
+      'certains': 'some',
+      'tous': 'every',
+      'inclut': 'includes',
+      'index de': 'indexOf',
+      'majuscules': 'toUpperCase',
+      'minuscules': 'toLowerCase',
+      'diviser': 'split',
+      'remplacer': 'replace',
+      'supprimer espaces': 'trim',
+      'commence par': 'startsWith',
+      'finit par': 'endsWith',
+      'sous chaîne': 'substring',
+      'afficher': 'console.log',
+      'alerte': 'alert',
+      'confirmer': 'confirm',
+      'demander': 'prompt',
+      'document': 'document',
+      'fenetre': 'window',
+      'élément par id': 'getElementById',
+      'éléments par classe': 'getElementsByClassName',
+      'éléments par tag': 'getElementsByTagName',
+      'sélecteur': 'querySelector',
+      'selecteurs': 'querySelectorAll',
+      'créer élément': 'createElement',
+      'ajouter enfant': 'appendChild',
+      'supprimer enfant': 'removeChild',
+      'attribut': 'getAttribute',
+      'définir attribut': 'setAttribute',
+      'écouter': 'addEventListener',
+      'stopper ecoute': 'removeEventListener',
+      'empêcher défaut': 'preventDefault',
+      'stopper propagation': 'stopPropagation',
+      'stockage local': 'localStorage',
+      'stockage session': 'sessionStorage',
+      'obtenir item': 'getItem',
+      'définir item': 'setItem',
+      'supprimer item': 'removeItem',
+      'vider': 'clear',
+      'temporisation': 'setTimeout',
+      'intervalle': 'setInterval',
+      'annuler temporisation': 'clearTimeout',
+      'annuler intervalle': 'clearInterval',
+      'promesse': 'Promise',
+      'résoudre': 'resolve',
+      'rejeter': 'reject',
+      'alors': 'then',
+      'capturer': 'catch',
+      'tout': 'all',
+      'course': 'race',
+      'récupérer': 'fetch',
+      'json': 'json',
+      'texte': 'text',
+      'réponse': 'response',
+      'requête': 'request',
+      'entêtes': 'headers',
+      'corps': 'body',
+      'méthode': 'method',
+      'analyser': 'JSON.parse',
+      'convertir': 'JSON.stringify',
+      'nombre': 'Number',
+      'chaîne': 'String',
+      'booléen': 'Boolean',
+      'tableau': 'Array',
+      'objet': 'Object',
+      'date': 'Date',
+      'regex': 'RegExp',
+      'expression reguliere': 'RegExp',
+      'erreur': 'Error',
+      'erreur type': 'TypeError',
+      'erreur référence': 'ReferenceError',
+      'erreur syntaxe': 'SyntaxError',
+      'erreur plage': 'RangeError',
+      'math': 'Math',
+      'aléatoire': 'random',
+      'plancher': 'floor',
+      'plafond': 'ceil',
+      'arrondi': 'round',
+      'absolu': 'abs',
+      'minimum': 'min',
+      'maximum': 'max',
+      'puissance math': 'pow',
+      'racine': 'sqrt',
+      'sinus': 'sin',
+      'cosinus': 'cos',
+      'tangente': 'tan',
+      'pi': 'PI',
+      'maintenant': 'Date.now',
+      'heure actuelle': 'Date.now'
+    }
+
+    const lower = word.toLowerCase()
+    return translations[lower] || word
+  }
+
+  generate(ast) {
+    this.output = ''
+    this.indent = 0
+
+    if (Array.isArray(ast)) {
+      for (const node of ast) {
+        const result = this.generateNode(node)
+        if (result !== undefined && this.output === '') {
+          this.output = result
+        }
+      }
+    } else if (ast && ast.type) {
+      const result = this.generateNode(ast)
+      if (result !== undefined && this.output === '') {
+        this.output = result
+      }
+    } else if (ast && ast.body) {
+      for (const node of ast.body) {
+        const result = this.generateNode(node)
+        if (result !== undefined && this.output === '') {
+          this.output = result
+        }
+      }
+    }
+
+    return this.output.trim()
+  }
+
+  generateNode(node) {
+    if (!node) return
+
+    switch (node.type) {
+      case 'Program':
+        this.generateProgram(node)
+        break
+      case 'VariableDeclaration':
+        this.generateVariableDeclaration(node)
+        break
+      case 'FunctionDeclaration':
+        this.generateFunctionDeclaration(node)
+        break
+      case 'ClassDeclaration':
+        this.generateClassDeclaration(node)
+        break
+      case 'IfStatement':
+        this.generateIfStatement(node)
+        break
+      case 'ForStatement':
+        this.generateForStatement(node)
+        break
+      case 'ForOfStatement':
+      case 'ForInStatement':
+        this.generateForOfStatement(node)
+        break
+      case 'WhileStatement':
+        this.generateWhileStatement(node)
+        break
+      case 'DoWhileStatement':
+        this.generateDoWhileStatement(node)
+        break
+      case 'SwitchStatement':
+        this.generateSwitchStatement(node)
+        break
+      case 'TryStatement':
+        this.generateTryStatement(node)
+        break
+      case 'ReturnStatement':
+        this.generateReturnStatement(node)
+        break
+      case 'ThrowStatement':
+        this.generateThrowStatement(node)
+        break
+      case 'BreakStatement':
+        this.writeLine('break;')
+        break
+      case 'ContinueStatement':
+        this.writeLine('continue;')
+        break
+      case 'ExpressionStatement':
+        this.generateExpressionStatement(node)
+        break
+      case 'BlockStatement':
+        this.generateBlockStatement(node)
+        break
+      case 'ImportDeclaration':
+        this.generateImportDeclaration(node)
+        break
+      case 'ExportDeclaration':
+      case 'ExportNamedDeclaration':
+      case 'ExportDefaultDeclaration':
+        this.generateExportDeclaration(node)
+        break
+      case 'ArrowFunctionExpression':
+        return this.generateArrowFunction(node)
+      case 'CallExpression':
+        return this.generateCallExpression(node)
+      case 'MemberExpression':
+        return this.generateMemberExpression(node)
+      case 'BinaryExpression':
+      case 'LogicalExpression':
+        return this.generateBinaryExpression(node)
+      case 'UnaryExpression':
+        return this.generateUnaryExpression(node)
+      case 'AssignmentExpression':
+        return this.generateAssignmentExpression(node)
+      case 'ConditionalExpression':
+        return this.generateConditionalExpression(node)
+      case 'ObjectExpression':
+        return this.generateObjectExpression(node)
+      case 'ArrayExpression':
+        return this.generateArrayExpression(node)
+      case 'Identifier':
+        return this.translate(node.name)
+      case 'Literal':
+        return this.generateLiteral(node)
+      case 'TemplateLiteral':
+        return this.generateTemplateLiteral(node)
+      case 'NewExpression':
+        return this.generateNewExpression(node)
+      case 'AwaitExpression':
+        return this.generateAwaitExpression(node)
+      case 'UpdateExpression':
+        return this.generateUpdateExpression(node)
+      default:
+        if (node.expression) {
+          return this.generateNode(node.expression)
+        }
+        return ''
+    }
+  }
+
+  generateUpdateExpression(node) {
+    const arg = this.generateNode(node.argument)
+    const op = node.operator
+    if (node.prefix) {
+      return `${op}${arg}`
+    }
+    return `${arg}${op}`
+  }
+
+  generateProgram(node) {
+    for (const statement of node.body || []) {
+      this.generateNode(statement)
+    }
+  }
+
+  generateVariableDeclaration(node) {
+    const kind = this.translate(node.kind || 'let')
+    const declarations = node.declarations || []
+
+    for (const decl of declarations) {
+      let name
+      if (decl.id) {
+        if (typeof decl.id === 'string') {
+          name = this.translate(decl.id)
+        } else if (decl.id.name) {
+          name = this.translate(decl.id.name)
+        } else {
+          name = this.generateNode(decl.id)
+        }
+      } else if (decl.name) {
+        name = this.translate(typeof decl.name === 'string' ? decl.name : decl.name.name)
+      }
+      
+      if (decl.init) {
+        const init = this.generateNode(decl.init)
+        this.writeLine(`${kind} ${name} = ${init};`)
+      } else {
+        this.writeLine(`${kind} ${name};`)
+      }
+    }
+  }
+
+  generateFunctionDeclaration(node) {
+    const async = node.async ? 'async ' : ''
+    const generator = node.generator ? '*' : ''
+    const name = this.translate(node.id?.name || node.name || '')
+    const params = (node.params || []).map(p => this.generateNode(p)).join(', ')
+
+    this.writeLine(`${async}function${generator} ${name}(${params}) {`)
+    this.indent++
+    this.generateNode(node.body)
+    this.indent--
+    this.writeLine('}')
+    this.writeLine('')
+  }
+
+  generateClassDeclaration(node) {
+    const name = this.translate(node.id?.name || node.name || '')
+    const extend = node.superClass ? ` extends ${this.generateNode(node.superClass)}` : ''
+
+    this.writeLine(`class ${name}${extend} {`)
+    this.indent++
+
+    const body = node.body?.body || node.body || []
+    for (const member of body) {
+      this.generateClassMember(member)
+    }
+
+    this.indent--
+    this.writeLine('}')
+    this.writeLine('')
+  }
+
+  generateClassMember(node) {
+    const isStatic = node.static ? 'static ' : ''
+    const kind = node.kind || 'method'
+    const name = this.translate(node.key?.name || node.name || '')
+    const params = (node.value?.params || node.params || []).map(p => this.generateNode(p)).join(', ')
+
+    if (kind === 'constructor' || name === 'constructor' || name === 'constructeur') {
+      this.writeLine(`constructor(${params}) {`)
+    } else if (kind === 'get') {
+      this.writeLine(`${isStatic}get ${name}() {`)
+    } else if (kind === 'set') {
+      this.writeLine(`${isStatic}set ${name}(${params}) {`)
+    } else {
+      const async = node.value?.async || node.async ? 'async ' : ''
+      this.writeLine(`${isStatic}${async}${name}(${params}) {`)
+    }
+
+    this.indent++
+    this.generateNode(node.value?.body || node.body)
+    this.indent--
+    this.writeLine('}')
+    this.writeLine('')
+  }
+
+  generateIfStatement(node) {
+    const test = this.generateNode(node.test)
+    this.writeLine(`if (${test}) {`)
+    this.indent++
+    this.generateNode(node.consequent)
+    this.indent--
+
+    if (node.alternate) {
+      if (node.alternate.type === 'IfStatement') {
+        this.output = this.output.trimEnd() + '\n' + this.getIndent() + '} else '
+        const altTest = this.generateNode(node.alternate.test)
+        this.output += `if (${altTest}) {\n`
+        this.indent++
+        this.generateNode(node.alternate.consequent)
+        this.indent--
+        if (node.alternate.alternate) {
+          if (node.alternate.alternate.type === 'IfStatement') {
+            this.generateIfStatement({ ...node.alternate, test: node.alternate.alternate.test, consequent: node.alternate.alternate.consequent, alternate: node.alternate.alternate.alternate })
+          } else {
+            this.writeLine('} else {')
+            this.indent++
+            this.generateNode(node.alternate.alternate)
+            this.indent--
+            this.writeLine('}')
+          }
+        } else {
+          this.writeLine('}')
+        }
+      } else {
+        this.writeLine('} else {')
+        this.indent++
+        this.generateNode(node.alternate)
+        this.indent--
+        this.writeLine('}')
+      }
+    } else {
+      this.writeLine('}')
+    }
+  }
+
+  generateForStatement(node) {
+    let init = ''
+    if (node.init) {
+      const saved = this.output
+      this.output = ''
+      this.generateNode(node.init)
+      init = this.output.trim().replace(/;$/, '')
+      this.output = saved
+    }
+    const test = node.test ? (this.generateNode(node.test) || '') : ''
+    const update = node.update ? (this.generateNode(node.update) || '') : ''
+
+    this.writeLine(`for (${init}; ${test}; ${update}) {`)
+    this.indent++
+    this.generateNode(node.body)
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generateForOfStatement(node) {
+    let left = ''
+    if (node.left?.type === 'VariableDeclaration') {
+      const kind = this.translate(node.left.kind || 'const')
+      const decl = node.left.declarations?.[0]
+      let name = ''
+      if (decl?.id?.name) {
+        name = this.translate(decl.id.name)
+      } else if (decl?.name) {
+        name = this.translate(typeof decl.name === 'string' ? decl.name : decl.name.name)
+      }
+      left = `${kind} ${name}`
+    } else {
+      left = this.generateNode(node.left) || ''
+    }
+    const right = this.generateNode(node.right) || ''
+    const keyword = node.type === 'ForInStatement' ? 'in' : 'of'
+
+    this.writeLine(`for (${left} ${keyword} ${right}) {`)
+    this.indent++
+    this.generateNode(node.body)
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generateWhileStatement(node) {
+    const test = this.generateNode(node.test)
+    this.writeLine(`while (${test}) {`)
+    this.indent++
+    this.generateNode(node.body)
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generateDoWhileStatement(node) {
+    this.writeLine('do {')
+    this.indent++
+    this.generateNode(node.body)
+    this.indent--
+    const test = this.generateNode(node.test)
+    this.writeLine(`} while (${test});`)
+  }
+
+  generateSwitchStatement(node) {
+    const discriminant = this.generateNode(node.discriminant)
+    this.writeLine(`switch (${discriminant}) {`)
+    this.indent++
+
+    for (const caseNode of node.cases || []) {
+      if (caseNode.test) {
+        const test = this.generateNode(caseNode.test)
+        this.writeLine(`case ${test}:`)
+      } else {
+        this.writeLine('default:')
+      }
+      this.indent++
+      for (const stmt of caseNode.consequent || []) {
+        this.generateNode(stmt)
+      }
+      this.indent--
+    }
+
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generateTryStatement(node) {
+    this.writeLine('try {')
+    this.indent++
+    this.generateNode(node.block)
+    this.indent--
+
+    if (node.handler) {
+      const param = node.handler.param ? this.generateNode(node.handler.param) : 'e'
+      this.writeLine(`} catch (${param}) {`)
+      this.indent++
+      this.generateNode(node.handler.body)
+      this.indent--
+    }
+
+    if (node.finalizer) {
+      this.writeLine('} finally {')
+      this.indent++
+      this.generateNode(node.finalizer)
+      this.indent--
+    }
+
+    this.writeLine('}')
+  }
+
+  generateReturnStatement(node) {
+    if (node.argument) {
+      const arg = this.generateNode(node.argument)
+      this.writeLine(`return ${arg};`)
+    } else {
+      this.writeLine('return;')
+    }
+  }
+
+  generateThrowStatement(node) {
+    const arg = this.generateNode(node.argument)
+    this.writeLine(`throw ${arg};`)
+  }
+
+  generateExpressionStatement(node) {
+    const expr = this.generateNode(node.expression)
+    this.writeLine(`${expr};`)
+  }
+
+  generateBlockStatement(node) {
+    for (const stmt of node.body || []) {
+      this.generateNode(stmt)
+    }
+  }
+
+  generateImportDeclaration(node) {
+    const source = this.generateLiteral(node.source)
+    const specifiers = node.specifiers || []
+
+    if (specifiers.length === 0) {
+      this.writeLine(`import ${source};`)
+      return
+    }
+
+    const defaultSpec = specifiers.find(s => s.type === 'ImportDefaultSpecifier')
+    const namespaceSpec = specifiers.find(s => s.type === 'ImportNamespaceSpecifier')
+    const namedSpecs = specifiers.filter(s => s.type === 'ImportSpecifier')
+
+    let importParts = []
+
+    if (defaultSpec) {
+      importParts.push(this.generateNode(defaultSpec.local))
+    }
+
+    if (namespaceSpec) {
+      importParts.push(`* as ${this.generateNode(namespaceSpec.local)}`)
+    }
+
+    if (namedSpecs.length > 0) {
+      const named = namedSpecs.map(s => {
+        const imported = this.generateNode(s.imported)
+        const local = this.generateNode(s.local)
+        return imported === local ? imported : `${imported} as ${local}`
+      }).join(', ')
+      importParts.push(`{ ${named} }`)
+    }
+
+    this.writeLine(`import ${importParts.join(', ')} from ${source};`)
+  }
+
+  generateExportDeclaration(node) {
+    if (node.default || node.type === 'ExportDefaultDeclaration') {
+      const decl = this.generateNode(node.declaration)
+      this.writeLine(`export default ${decl};`)
+    } else if (node.declaration) {
+      this.output += 'export '
+      this.generateNode(node.declaration)
+    } else if (node.specifiers) {
+      const specs = node.specifiers.map(s => {
+        const local = this.generateNode(s.local)
+        const exported = this.generateNode(s.exported)
+        return local === exported ? local : `${local} as ${exported}`
+      }).join(', ')
+      this.writeLine(`export { ${specs} };`)
+    }
+  }
+
+  generateArrowFunction(node) {
+    const async = node.async ? 'async ' : ''
+    const params = (node.params || []).map(p => this.generateNode(p)).join(', ')
+    const paramsStr = node.params?.length === 1 ? params : `(${params})`
+
+    if (node.body?.type === 'BlockStatement') {
+      let body = ''
+      const savedOutput = this.output
+      this.output = ''
+      this.indent++
+      this.generateNode(node.body)
+      this.indent--
+      body = this.output.trim()
+      this.output = savedOutput
+      return `${async}${paramsStr} => {\n${body}\n${this.getIndent()}}`
+    } else {
+      const body = this.generateNode(node.body)
+      return `${async}${paramsStr} => ${body}`
+    }
+  }
+
+  generateCallExpression(node) {
+    const callee = this.generateNode(node.callee)
+    const args = (node.arguments || []).map(a => this.generateNode(a)).join(', ')
+    return `${callee}(${args})`
+  }
+
+  generateMemberExpression(node) {
+    const object = this.generateNode(node.object)
+    const property = this.generateNode(node.property)
+    
+    if (node.computed) {
+      return `${object}[${property}]`
+    }
+    return `${object}.${property}`
+  }
+
+  generateBinaryExpression(node) {
+    const left = this.generateNode(node.left)
+    const right = this.generateNode(node.right)
+    const op = this.translateOperator(node.operator)
+    return `${left} ${op} ${right}`
+  }
+
+  generateUnaryExpression(node) {
+    const arg = this.generateNode(node.argument)
+    const op = this.translateOperator(node.operator)
+    
+    if (node.prefix) {
+      return op === 'typeof' || op === 'delete' || op === 'void' 
+        ? `${op} ${arg}` 
+        : `${op}${arg}`
+    }
+    return `${arg}${op}`
+  }
+
+  generateAssignmentExpression(node) {
+    const left = this.generateNode(node.left)
+    const right = this.generateNode(node.right)
+    const op = node.operator || '='
+    return `${left} ${op} ${right}`
+  }
+
+  generateConditionalExpression(node) {
+    const test = this.generateNode(node.test)
+    const consequent = this.generateNode(node.consequent)
+    const alternate = this.generateNode(node.alternate)
+    return `${test} ? ${consequent} : ${alternate}`
+  }
+
+  generateObjectExpression(node) {
+    const props = (node.properties || []).map(p => {
+      const key = p.computed ? `[${this.generateNode(p.key)}]` : this.generateNode(p.key)
+      const value = this.generateNode(p.value)
+      
+      if (p.shorthand || key === value) {
+        return key
+      }
+      if (p.method) {
+        const params = (p.value.params || []).map(param => this.generateNode(param)).join(', ')
+        return `${key}(${params}) { ... }`
+      }
+      return `${key}: ${value}`
+    })
+    
+    if (props.length === 0) return '{}'
+    if (props.length <= 3 && !props.some(p => p.includes('\n'))) {
+      return `{ ${props.join(', ')} }`
+    }
+    return `{\n${this.getIndent()}  ${props.join(',\n' + this.getIndent() + '  ')}\n${this.getIndent()}}`
+  }
+
+  generateArrayExpression(node) {
+    const elements = (node.elements || []).map(e => e ? this.generateNode(e) : '')
+    
+    if (elements.length === 0) return '[]'
+    if (elements.length <= 5 && !elements.some(e => e.includes('\n'))) {
+      return `[${elements.join(', ')}]`
+    }
+    return `[\n${this.getIndent()}  ${elements.join(',\n' + this.getIndent() + '  ')}\n${this.getIndent()}]`
+  }
+
+  generateLiteral(node) {
+    if (node.raw) return node.raw
+    if (node.regex) {
+      return `/${node.regex.pattern}/${node.regex.flags || ''}`
+    }
+    if (typeof node.value === 'string') {
+      return `"${node.value.replace(/"/g, '\\"')}"`
+    }
+    if (node.value === null) return 'null'
+    if (node.value === undefined) return 'undefined'
+    return String(node.value)
+  }
+
+  generateTemplateLiteral(node) {
+    let result = '`'
+    const quasis = node.quasis || []
+    const expressions = node.expressions || []
+    
+    for (let i = 0; i < quasis.length; i++) {
+      result += quasis[i].value?.raw || quasis[i].raw || ''
+      if (i < expressions.length) {
+        result += '${' + this.generateNode(expressions[i]) + '}'
+      }
+    }
+    
+    return result + '`'
+  }
+
+  generateNewExpression(node) {
+    const callee = this.generateNode(node.callee)
+    const args = (node.arguments || []).map(a => this.generateNode(a)).join(', ')
+    return `new ${callee}(${args})`
+  }
+
+  generateAwaitExpression(node) {
+    const arg = this.generateNode(node.argument)
+    return `await ${arg}`
+  }
+
+  translateOperator(op) {
+    const operators = {
+      'et': '&&',
+      'ou': '||',
+      'non': '!',
+      'egal': '===',
+      'different': '!==',
+      'plus': '+',
+      'moins': '-',
+      'fois': '*',
+      'divise': '/',
+      'modulo': '%',
+      'puissance': '**'
+    }
+    return operators[op] || op
+  }
+
+  writeLine(text) {
+    this.output += this.getIndent() + text + '\n'
+  }
+
+  getIndent() {
+    return '  '.repeat(this.indent)
+  }
+}
+
+module.exports = {
+  JSGenerator
+}