ether-code 0.6.6 → 0.6.8

package/generators/js-generator.js

@@ -5,12 +5,18 @@ class JSGenerator {
     this.i18n = null
     this.indent = 0
     this.output = ''
+    this.context = []
+    
     this.keywordMap = {}
+    this.contextualMap = {}
+    this.operatorMap = {}
     this.methodMap = {}
     this.builtinMap = {}
     
     if (i18nPath) {
       this.loadI18n(i18nPath)
+    } else {
+      this.buildDefaultMaps()
     }
   }
 
@@ -21,228 +27,818 @@ class JSGenerator {
   }
 
   buildMaps() {
-    if (!this.i18n) return
+    if (!this.i18n) {
+      this.buildDefaultMaps()
+      return
+    }
 
-    const addToMap = (map, section) => {
+    const addToMap = (map, section, prefix = '') => {
       if (!section) return
       for (const [key, translations] of Object.entries(section)) {
-        if (translations && translations.fr && translations.js) {
-          map[translations.fr.toLowerCase()] = translations.js
+        if (translations && translations.fr && translations.en) {
+          const frKey = translations.fr.toLowerCase()
+          const enValue = translations.en
+          if (prefix) {
+            if (!this.contextualMap[frKey]) {
+              this.contextualMap[frKey] = {}
+            }
+            this.contextualMap[frKey][prefix] = enValue
+          }
+          if (!map[frKey]) {
+            map[frKey] = enValue
+          }
         }
       }
     }
 
     addToMap(this.keywordMap, this.i18n.variables)
+    addToMap(this.keywordMap, this.i18n.portee)
     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.boucles)
     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.gestionErreurs)
+    addToMap(this.keywordMap, this.i18n.asynchrone)
+    addToMap(this.keywordMap, this.i18n.promesses)
     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)
+    addToMap(this.keywordMap, this.i18n.iterateurs)
+    addToMap(this.keywordMap, this.i18n.modeStrict)
+    addToMap(this.keywordMap, this.i18n.gabarits)
+    addToMap(this.keywordMap, this.i18n.synonymes)
+
+    addToMap(this.operatorMap, this.i18n.operateursArithmetiques)
+    addToMap(this.operatorMap, this.i18n.operateursComparaison)
+    addToMap(this.operatorMap, this.i18n.operateursLogiques)
+    addToMap(this.operatorMap, this.i18n.operateursBinaires)
+    addToMap(this.operatorMap, this.i18n.operateursUnaires)
+    addToMap(this.operatorMap, this.i18n.operateursAutres)
+
+    addToMap(this.methodMap, this.i18n.methodesTableau, 'array')
+    addToMap(this.methodMap, this.i18n.methodesChaine, 'string')
+    addToMap(this.methodMap, this.i18n.methodesObjet, 'object')
+    addToMap(this.methodMap, this.i18n.json, 'json')
+    addToMap(this.methodMap, this.i18n.math, 'math')
+    addToMap(this.methodMap, this.i18n.number, 'number')
+    addToMap(this.methodMap, this.i18n.bigint, 'bigint')
+    addToMap(this.methodMap, this.i18n.symbol, 'symbol')
+    addToMap(this.methodMap, this.i18n.console, 'console')
+    addToMap(this.methodMap, this.i18n.dom, 'dom')
+    addToMap(this.methodMap, this.i18n.evenements, 'event')
+    addToMap(this.methodMap, this.i18n.fetch, 'fetch')
+    addToMap(this.methodMap, this.i18n.stockage, 'storage')
+    addToMap(this.methodMap, this.i18n.minuteries, 'timer')
+    addToMap(this.methodMap, this.i18n.proxy, 'proxy')
+    addToMap(this.methodMap, this.i18n.reflect, 'reflect')
+    addToMap(this.methodMap, this.i18n.collections, 'collection')
+    addToMap(this.methodMap, this.i18n.date, 'date')
+    addToMap(this.methodMap, this.i18n.regexp, 'regexp')
+    addToMap(this.methodMap, this.i18n.typedArrays, 'typedarray')
+    addToMap(this.methodMap, this.i18n.gestionMemoire, 'memory')
+    addToMap(this.methodMap, this.i18n.intl, 'intl')
+    addToMap(this.methodMap, this.i18n.fonctionsGlobales, 'global')
+
+    this.buildConflictResolution()
   }
 
-  translate(word) {
-    const lower = word.toLowerCase()
-    return this.keywordMap[lower] || this.methodMap[lower] || this.translateGeneric(word)
+  buildConflictResolution() {
+    this.conflicts = {
+      'obtenir': {
+        'class': 'get',
+        'object': 'Object.get',
+        'map': 'get',
+        'storage': 'getItem',
+        'default': 'get'
+      },
+      'définir': {
+        'class': 'set',
+        'object': 'Object.set',
+        'map': 'set',
+        'storage': 'setItem',
+        'default': 'set'
+      },
+      'ajouter': {
+        'array': 'push',
+        'set': 'add',
+        'dom': 'append',
+        'class': 'classList.add',
+        'default': 'push'
+      },
+      'supprimer': {
+        'array': 'pop',
+        'object': 'delete',
+        'dom': 'remove',
+        'storage': 'removeItem',
+        'set': 'delete',
+        'map': 'delete',
+        'default': 'delete'
+      },
+      'retirer': {
+        'array': 'pop',
+        'stack': 'pop',
+        'default': 'pop'
+      },
+      'depuis': {
+        'module': 'from',
+        'array': 'Array.from',
+        'default': 'from'
+      },
+      'de': {
+        'loop': 'of',
+        'array': 'Array.of',
+        'iterator': 'Iterator.from',
+        'default': 'of'
+      },
+      'valeurs': {
+        'array': 'values',
+        'object': 'Object.values',
+        'map': 'values',
+        'set': 'values',
+        'default': 'values'
+      },
+      'clés': {
+        'array': 'keys',
+        'object': 'Object.keys',
+        'map': 'keys',
+        'default': 'keys'
+      },
+      'entrées': {
+        'array': 'entries',
+        'object': 'Object.entries',
+        'map': 'entries',
+        'set': 'entries',
+        'default': 'entries'
+      },
+      'taille': {
+        'array': 'length',
+        'string': 'length',
+        'set': 'size',
+        'map': 'size',
+        'default': 'length'
+      },
+      'longueur': {
+        'array': 'length',
+        'string': 'length',
+        'buffer': 'byteLength',
+        'default': 'length'
+      },
+      'effacer': {
+        'console': 'console.clear',
+        'set': 'clear',
+        'map': 'clear',
+        'storage': 'clear',
+        'default': 'clear'
+      },
+      'créer': {
+        'object': 'Object.create',
+        'dom': 'createElement',
+        'default': 'create'
+      },
+      'a': {
+        'array': 'at',
+        'set': 'has',
+        'map': 'has',
+        'object': 'Object.hasOwn',
+        'default': 'has'
+      },
+      'suivant': {
+        'iterator': 'next',
+        'dom': 'nextSibling',
+        'default': 'next'
+      },
+      'formater': {
+        'intl': 'format',
+        'date': 'toLocaleString',
+        'default': 'format'
+      },
+      'analyser': {
+        'json': 'JSON.parse',
+        'number': 'parseFloat',
+        'date': 'Date.parse',
+        'default': 'JSON.parse'
+      },
+      'convertir': {
+        'json': 'JSON.stringify',
+        'string': 'toString',
+        'default': 'JSON.stringify'
+      },
+      'inclut': {
+        'array': 'includes',
+        'string': 'includes',
+        'default': 'includes'
+      },
+      'trouver': {
+        'array': 'find',
+        'string': 'search',
+        'default': 'find'
+      },
+      'joindre': {
+        'array': 'join',
+        'string': 'concat',
+        'default': 'join'
+      },
+      'inverser': {
+        'array': 'reverse',
+        'string': 'split().reverse().join()',
+        'default': 'reverse'
+      },
+      'trier': {
+        'array': 'sort',
+        'default': 'sort'
+      },
+      'filtrer': {
+        'array': 'filter',
+        'default': 'filter'
+      },
+      'transformer': {
+        'array': 'map',
+        'default': 'map'
+      },
+      'réduire': {
+        'array': 'reduce',
+        'default': 'reduce'
+      }
+    }
   }
 
-  translateGeneric(word) {
-    const translations = {
+  buildDefaultMaps() {
+    this.keywordMap = {
       'variable': 'let',
       'constante': 'const',
+      'variable globale': 'var',
+      'utilisant': 'using',
+      'attendre utilisant': 'await using',
       'fonction': 'function',
+      'fonction fléchée': '=>',
+      'fonction asynchrone': 'async function',
+      'fonction génératrice': 'function*',
       'retourner': 'return',
       'si': 'if',
       'sinon': 'else',
       'sinon si': 'else if',
       'pour': 'for',
+      'pour de': 'for...of',
+      'pour dans': 'for...in',
+      'pour attendre de': 'for await...of',
       'tant que': 'while',
       'faire': 'do',
+      'faire tant que': 'do...while',
       'selon': 'switch',
       'cas': 'case',
-      'defaut': 'default',
+      'défaut': 'default',
       'sortir': 'break',
       'continuer': 'continue',
+      'étiquette': 'label',
+      'débogueur': 'debugger',
       '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',
+      'indéfini': 'undefined',
+      'infini': 'Infinity',
+      'infini négatif': '-Infinity',
+      'pas un nombre': 'NaN',
+      'cet objet global': 'globalThis',
       'ceci': 'this',
       'classe': 'class',
-      'etend': 'extends',
+      'étend': 'extends',
       'super': 'super',
       'constructeur': 'constructor',
       'statique': 'static',
+      'privé': '#',
+      'public': 'public',
+      'protégé': 'protected',
       'obtenir': 'get',
-      'definir': 'set',
+      'définir': 'set',
       'asynchrone': 'async',
       'attendre': 'await',
-      'produire': 'yield',
+      'céder': 'yield',
+      'céder tout': 'yield*',
+      'générateur': 'generator',
+      'itérateur': 'Iterator',
+      'itérable': 'iterable',
       'importer': 'import',
       'exporter': 'export',
+      'exporter par défaut': 'export default',
       'depuis': 'from',
       'comme': 'as',
-      'par defaut': 'default',
-      'et': '&&',
-      'ou': '||',
-      'non': '!',
-      'egal': '===',
-      'different': '!==',
-      'inferieur': '<',
-      'superieur': '>',
-      'inferieur ou egal': '<=',
-      'superieur ou egal': '>=',
+      'avec': 'with',
+      'promesse': 'Promise',
+      'résoudre': 'resolve',
+      'rejeter': 'reject',
+      'alors': 'then',
+      'tout': 'Promise.all',
+      'tout réglé': 'Promise.allSettled',
+      "n'importe": 'Promise.any',
+      'course': 'Promise.race',
+      'avec résolveurs': 'Promise.withResolvers',
+      'erreur': 'Error',
+      'erreur type': 'TypeError',
+      'erreur référence': 'ReferenceError',
+      'erreur syntaxe': 'SyntaxError',
+      'erreur plage': 'RangeError',
+      'erreur URI': 'URIError',
+      'erreur évaluation': 'EvalError',
+      'erreur agrégée': 'AggregateError',
+      'erreur supprimée': 'SuppressedError',
+      'nombre': 'number',
+      'chaîne': 'string',
+      'booléen': 'boolean',
+      'symbole': 'symbol',
+      'grand entier': 'bigint',
+      'objet': 'object',
+      'tableau': 'Array',
+      'date': 'Date',
+      'expression régulière': 'RegExp',
+      'regex': 'RegExp',
+      'ensemble': 'Set',
+      'carte': 'Map',
+      'carte faible': 'WeakMap',
+      'ensemble faible': 'WeakSet',
+      'buffer tableau': 'ArrayBuffer',
+      'vue données': 'DataView',
+      'proxy': 'Proxy',
+      'réfléchir': 'Reflect',
+      'intl': 'Intl',
+      'utiliser strict': 'use strict',
+      'gabarit': 'template literal',
+      'gabarit étiqueté': 'tagged template'
+    }
+
+    this.operatorMap = {
       'plus': '+',
       'moins': '-',
       'fois': '*',
-      'divise': '/',
+      'divisé': '/',
       'modulo': '%',
+      'reste': '%',
       'puissance': '**',
+      'incrément': '++',
+      'décrément': '--',
+      'égal': '==',
+      'différent': '!=',
+      'strictement égal': '===',
+      'strictement différent': '!==',
+      'supérieur': '>',
+      'inférieur': '<',
+      'supérieur ou égal': '>=',
+      'inférieur ou égal': '<=',
+      'et': '&&',
+      'ou': '||',
+      'non': '!',
+      'coalescence nulle': '??',
+      'chaînage optionnel': '?.',
+      'et binaire': '&',
+      'ou binaire': '|',
+      'ou exclusif': '^',
+      'non binaire': '~',
+      'décalage gauche': '<<',
+      'décalage droite': '>>',
+      'décalage droite non signé': '>>>',
+      'plus unaire': '+',
+      'moins unaire': '-',
+      'vide': 'void',
+      'virgule': ',',
+      'décomposition': '...'
+    }
+
+    this.methodMap = {
+      'afficher': 'console.log',
+      'journal': 'console.log',
+      'erreur': 'console.error',
+      'avertir': 'console.warn',
+      'info': 'console.info',
+      'déboguer': 'console.debug',
+      'table': 'console.table',
+      'groupe': 'console.group',
+      'fin groupe': 'console.groupEnd',
+      'temps': 'console.time',
+      'fin temps': 'console.timeEnd',
+      'trace': 'console.trace',
       'longueur': 'length',
       'ajouter': 'push',
       'retirer': 'pop',
-      'decaler': 'shift',
-      'inserer debut': 'unshift',
-      'trancher': 'slice',
-      'epiisser': 'splice',
-      'concatener': 'concat',
-      'joindre': 'join',
+      'décaler': 'shift',
+      'insérer début': 'unshift',
+      'épisser': 'splice',
+      'remplir': 'fill',
+      'copier dans': 'copyWithin',
       'inverser': 'reverse',
       'trier': 'sort',
+      'trancher': 'slice',
+      'concaténer': 'concat',
+      'joindre': 'join',
+      'à': 'at',
+      'index de': 'indexOf',
+      'dernier index de': 'lastIndexOf',
+      'inclut': 'includes',
+      'pour chaque': 'forEach',
+      'transformer': 'map',
       'filtrer': 'filter',
-      'mapper': 'map',
-      'reduire': 'reduce',
+      'réduire': 'reduce',
+      'réduire droite': 'reduceRight',
       'trouver': 'find',
       'trouver index': 'findIndex',
-      'chaque': 'forEach',
-      'certains': 'some',
+      'trouver dernier': 'findLast',
+      'trouver dernier index': 'findLastIndex',
+      'quelques': 'some',
       'tous': 'every',
-      'inclut': 'includes',
-      'index de': 'indexOf',
-      'majuscules': 'toUpperCase',
-      'minuscules': 'toLowerCase',
-      'diviser': 'split',
-      'remplacer': 'replace',
-      'supprimer espaces': 'trim',
+      'aplatir': 'flat',
+      'aplatir transformer': 'flatMap',
+      'vers inversé': 'toReversed',
+      'vers trié': 'toSorted',
+      'vers épissé': 'toSpliced',
+      'est tableau': 'Array.isArray',
+      'clés': 'keys',
+      'valeurs': 'values',
+      'entrées': 'entries',
+      'caractère à': 'charAt',
+      'code caractère à': 'charCodeAt',
+      'point de code à': 'codePointAt',
       'commence par': 'startsWith',
-      'finit par': 'endsWith',
-      'sous chaine': 'substring',
-      'afficher': 'console.log',
-      'alerte': 'alert',
-      'confirmer': 'confirm',
-      'demander': 'prompt',
+      'termine par': 'endsWith',
+      'rechercher': 'search',
+      'correspondance': 'match',
+      'toutes correspondances': 'matchAll',
+      'en majuscules': 'toUpperCase',
+      'en minuscules': 'toLowerCase',
+      'supprimer espaces': 'trim',
+      'supprimer début': 'trimStart',
+      'supprimer fin': 'trimEnd',
+      'compléter début': 'padStart',
+      'compléter fin': 'padEnd',
+      'répéter': 'repeat',
+      'remplacer': 'replace',
+      'remplacer tout': 'replaceAll',
+      'normaliser': 'normalize',
+      'diviser': 'split',
+      'sous-chaîne': 'substring',
+      'depuis code caractère': 'String.fromCharCode',
+      'depuis point de code': 'String.fromCodePoint',
+      'brut': 'String.raw',
+      'clés obj': 'Object.keys',
+      'valeurs obj': 'Object.values',
+      'entrées obj': 'Object.entries',
+      'depuis entrées': 'Object.fromEntries',
+      'assigner': 'Object.assign',
+      'geler': 'Object.freeze',
+      'est gelé': 'Object.isFrozen',
+      'sceller': 'Object.seal',
+      'est scellé': 'Object.isSealed',
+      'empêcher extensions': 'Object.preventExtensions',
+      'est extensible': 'Object.isExtensible',
+      'créer': 'Object.create',
+      'définir propriété': 'Object.defineProperty',
+      'définir propriétés': 'Object.defineProperties',
+      'obtenir descripteur': 'Object.getOwnPropertyDescriptor',
+      'obtenir descripteurs': 'Object.getOwnPropertyDescriptors',
+      'obtenir noms propriétés': 'Object.getOwnPropertyNames',
+      'obtenir symboles propriétés': 'Object.getOwnPropertySymbols',
+      'a propriété': 'Object.hasOwn',
+      'est': 'Object.is',
+      'obtenir prototype de': 'Object.getPrototypeOf',
+      'définir prototype de': 'Object.setPrototypeOf',
+      'grouper par': 'Object.groupBy',
+      'analyser': 'JSON.parse',
+      'convertir': 'JSON.stringify',
+      'sérialiser': 'JSON.stringify',
+      'pi': 'Math.PI',
+      'e': 'Math.E',
+      'arrondi': 'Math.round',
+      'plancher': 'Math.floor',
+      'plafond': 'Math.ceil',
+      'tronquer': 'Math.trunc',
+      'absolu': 'Math.abs',
+      'signe': 'Math.sign',
+      'minimum': 'Math.min',
+      'maximum': 'Math.max',
+      'puissance math': 'Math.pow',
+      'racine carrée': 'Math.sqrt',
+      'racine cubique': 'Math.cbrt',
+      'hypotènuse': 'Math.hypot',
+      'sinus': 'Math.sin',
+      'cosinus': 'Math.cos',
+      'tangente': 'Math.tan',
+      'arc sinus': 'Math.asin',
+      'arc cosinus': 'Math.acos',
+      'arc tangente': 'Math.atan',
+      'arc tangente 2': 'Math.atan2',
+      'sinus hyperbolique': 'Math.sinh',
+      'cosinus hyperbolique': 'Math.cosh',
+      'tangente hyperbolique': 'Math.tanh',
+      'logarithme': 'Math.log',
+      'logarithme 10': 'Math.log10',
+      'logarithme 2': 'Math.log2',
+      'exponentielle': 'Math.exp',
+      'aléatoire': 'Math.random',
+      'epsilon': 'Number.EPSILON',
+      'entier max sûr': 'Number.MAX_SAFE_INTEGER',
+      'entier min sûr': 'Number.MIN_SAFE_INTEGER',
+      'valeur max': 'Number.MAX_VALUE',
+      'valeur min': 'Number.MIN_VALUE',
+      'est fini': 'Number.isFinite',
+      'est entier': 'Number.isInteger',
+      'est NaN': 'Number.isNaN',
+      'est entier sûr': 'Number.isSafeInteger',
+      'analyser flottant': 'Number.parseFloat',
+      'analyser entier': 'Number.parseInt',
+      'vers fixe': 'toFixed',
+      'vers exponentiel': 'toExponential',
+      'vers précision': 'toPrecision',
+      'en tant que entier n': 'BigInt.asIntN',
+      'en tant que non signé n': 'BigInt.asUintN',
+      'symbole': 'Symbol',
+      'symbole pour': 'Symbol.for',
+      'clé pour': 'Symbol.keyFor',
+      'symbole itérateur': 'Symbol.iterator',
+      'symbole itérateur asynchrone': 'Symbol.asyncIterator',
+      'symbole correspondance': 'Symbol.match',
+      'symbole remplacer': 'Symbol.replace',
+      'symbole recherche': 'Symbol.search',
+      'symbole diviser': 'Symbol.split',
+      'symbole a instance': 'Symbol.hasInstance',
+      'symbole espèce': 'Symbol.species',
+      'symbole vers primitif': 'Symbol.toPrimitive',
+      'symbole vers tag chaîne': 'Symbol.toStringTag',
+      'symbole disposer': 'Symbol.dispose',
+      'symbole disposer asynchrone': 'Symbol.asyncDispose',
       'document': 'document',
-      'fenetre': 'window',
-      'element par id': 'getElementById',
-      'elements par classe': 'getElementsByClassName',
-      'elements par tag': 'getElementsByTagName',
-      'selecteur': 'querySelector',
-      'selecteurs': 'querySelectorAll',
-      'creer element': 'createElement',
+      'fenêtre': 'window',
+      'sélecteur': 'querySelector',
+      'sélecteurs': 'querySelectorAll',
+      'élément par id': 'getElementById',
+      'éléments par classe': 'getElementsByClassName',
+      'éléments par tag': 'getElementsByTagName',
+      'créer élément': 'createElement',
+      'créer fragment': 'createDocumentFragment',
+      'créer noeud texte': 'createTextNode',
       'ajouter enfant': 'appendChild',
       'supprimer enfant': 'removeChild',
-      'attribut': 'getAttribute',
-      'definir attribut': 'setAttribute',
-      'ecouter': 'addEventListener',
-      'stopper ecoute': 'removeEventListener',
-      'empecher defaut': 'preventDefault',
+      'remplacer enfant': 'replaceChild',
+      'insérer avant': 'insertBefore',
+      'cloner': 'cloneNode',
+      'supprimer élément': 'remove',
+      'ajouter dom': 'append',
+      'préfixer': 'prepend',
+      'après': 'after',
+      'avant': 'before',
+      'remplacer avec': 'replaceWith',
+      'contenu HTML': 'innerHTML',
+      'HTML externe': 'outerHTML',
+      'contenu texte': 'textContent',
+      'texte interne': 'innerText',
+      'obtenir attribut': 'getAttribute',
+      'définir attribut': 'setAttribute',
+      'supprimer attribut': 'removeAttribute',
+      'a attribut': 'hasAttribute',
+      'basculer attribut': 'toggleAttribute',
+      'liste classes': 'classList',
+      'ajouter classe': 'classList.add',
+      'supprimer classe': 'classList.remove',
+      'basculer classe': 'classList.toggle',
+      'contient classe': 'classList.contains',
+      'style': 'style',
+      'dataset': 'dataset',
+      'parent': 'parentNode',
+      'élément parent': 'parentElement',
+      'enfants': 'children',
+      'premier enfant': 'firstChild',
+      'dernier enfant': 'lastChild',
+      'premier élément enfant': 'firstElementChild',
+      'dernier élément enfant': 'lastElementChild',
+      'suivant dom': 'nextSibling',
+      'précédent': 'previousSibling',
+      'élément suivant': 'nextElementSibling',
+      'élément précédent': 'previousElementSibling',
+      'écouter': 'addEventListener',
+      'ajouter écouteur': 'addEventListener',
+      'supprimer écouteur': 'removeEventListener',
+      'émettre événement': 'dispatchEvent',
+      'empêcher défaut': 'preventDefault',
       'stopper propagation': 'stopPropagation',
+      'cible': 'target',
+      'cible courante': 'currentTarget',
+      'clic': 'click',
+      'double clic': 'dblclick',
+      'souris bas': 'mousedown',
+      'souris haut': 'mouseup',
+      'souris entre': 'mouseenter',
+      'souris quitte': 'mouseleave',
+      'souris bouge': 'mousemove',
+      'touche bas': 'keydown',
+      'touche haut': 'keyup',
+      'charger': 'load',
+      'redimensionner': 'resize',
+      'défiler': 'scroll',
+      'focus': 'focus',
+      'flou': 'blur',
+      'soumettre': 'submit',
+      'changer': 'change',
+      'entrée': 'input',
+      'récupérer': 'fetch',
+      'chercher': 'fetch',
+      'requête': 'Request',
+      'réponse': 'Response',
+      'en-têtes': 'Headers',
+      'méthode': 'method',
+      'corps': 'body',
+      'mode': 'mode',
+      'cache': 'cache',
+      'signal': 'signal',
+      'json': 'json',
+      'texte': 'text',
+      'blob': 'blob',
+      'tableau buffer': 'arrayBuffer',
+      'données formulaire': 'formData',
+      'ok': 'ok',
+      'statut': 'status',
+      'texte statut': 'statusText',
+      'url': 'url',
       'stockage local': 'localStorage',
       'stockage session': 'sessionStorage',
       'obtenir item': 'getItem',
-      'definir item': 'setItem',
+      'définir item': 'setItem',
       'supprimer item': 'removeItem',
       'vider': 'clear',
+      'clé': 'key',
       'temporisation': 'setTimeout',
-      'intervalle': 'setInterval',
+      'définir délai': 'setTimeout',
       'annuler temporisation': 'clearTimeout',
+      'annuler délai': 'clearTimeout',
+      'intervalle': 'setInterval',
+      'définir intervalle': 'setInterval',
       'annuler intervalle': 'clearInterval',
-      'promesse': 'Promise',
-      'resoudre': 'resolve',
-      'rejeter': 'reject',
-      'alors': 'then',
-      'capturer': 'catch',
-      'tout': 'all',
-      'course': 'race',
-      'recuperer': 'fetch',
-      'json': 'json',
-      'texte': 'text',
-      'reponse': 'response',
-      'requete': 'request',
-      'entetes': 'headers',
-      'corps': 'body',
-      'methode': 'method',
-      'analyser': 'JSON.parse',
-      'convertir': 'JSON.stringify',
-      'nombre': 'Number',
-      'chaine': 'String',
-      'booleen': 'Boolean',
-      'tableau': 'Array',
-      'objet': 'Object',
-      'date': 'Date',
-      'regex': 'RegExp',
-      'expression reguliere': 'RegExp',
-      'erreur': 'Error',
-      'erreur type': 'TypeError',
-      'erreur reference': 'ReferenceError',
-      'erreur syntaxe': 'SyntaxError',
-      'erreur plage': 'RangeError',
-      'math': 'Math',
-      'aleatoire': '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',
+      'demander animation frame': 'requestAnimationFrame',
+      'annuler animation frame': 'cancelAnimationFrame',
+      'gestionnaire': 'handler',
+      'cible proxy': 'target',
+      'révocable': 'Proxy.revocable',
+      'obtenir trap': 'get',
+      'définir trap': 'set',
+      'a trap': 'has',
+      'supprimer propriété': 'deleteProperty',
+      'appliquer trap': 'apply',
+      'construire trap': 'construct',
+      'propres clés': 'ownKeys',
+      'réfléchir.obtenir': 'Reflect.get',
+      'réfléchir.définir': 'Reflect.set',
+      'réfléchir.a': 'Reflect.has',
+      'réfléchir.supprimer propriété': 'Reflect.deleteProperty',
+      'réfléchir.appliquer': 'Reflect.apply',
+      'réfléchir.construire': 'Reflect.construct',
+      'ajouter coll': 'add',
+      'supprimer coll': 'delete',
+      'a coll': 'has',
+      'effacer': 'clear',
+      'taille': 'size',
+      'obtenir coll': 'get',
+      'définir coll': 'set',
+      'union': 'union',
+      'intersection': 'intersection',
+      'différence': 'difference',
+      'différence symétrique': 'symmetricDifference',
+      'est sous-ensemble de': 'isSubsetOf',
+      'est sur-ensemble de': 'isSupersetOf',
+      'grouper par carte': 'Map.groupBy',
       'maintenant': 'Date.now',
-      'heure actuelle': 'Date.now'
+      'obtenir temps': 'getTime',
+      'obtenir année': 'getFullYear',
+      'obtenir mois': 'getMonth',
+      'obtenir date': 'getDate',
+      'obtenir jour': 'getDay',
+      'obtenir heures': 'getHours',
+      'obtenir minutes': 'getMinutes',
+      'obtenir secondes': 'getSeconds',
+      'obtenir millisecondes': 'getMilliseconds',
+      'définir année': 'setFullYear',
+      'définir mois': 'setMonth',
+      'définir date jour': 'setDate',
+      'définir heures': 'setHours',
+      'définir minutes': 'setMinutes',
+      'définir secondes': 'setSeconds',
+      'vers chaîne ISO': 'toISOString',
+      'vers chaîne locale': 'toLocaleString',
+      'tester': 'test',
+      'exécuter': 'exec',
+      'source': 'source',
+      'drapeaux': 'flags',
+      'global': 'global',
+      'ignorer casse': 'ignoreCase',
+      'multiligne': 'multiline',
+      'unicode': 'unicode',
+      'collant': 'sticky',
+      'dot all': 'dotAll',
+      'dernier index': 'lastIndex',
+      'tableau typé': 'TypedArray',
+      'tableau int8': 'Int8Array',
+      'tableau uint8': 'Uint8Array',
+      'tableau int16': 'Int16Array',
+      'tableau uint16': 'Uint16Array',
+      'tableau int32': 'Int32Array',
+      'tableau uint32': 'Uint32Array',
+      'tableau float32': 'Float32Array',
+      'tableau float64': 'Float64Array',
+      'tableau bigint64': 'BigInt64Array',
+      'tableau biguint64': 'BigUint64Array',
+      'buffer tableau partagé': 'SharedArrayBuffer',
+      'longueur octets': 'byteLength',
+      'décalage octets': 'byteOffset',
+      'buffer': 'buffer',
+      'référence faible': 'WeakRef',
+      'déréférencer': 'deref',
+      'registre finalisation': 'FinalizationRegistry',
+      'enregistrer': 'register',
+      'désenregistrer': 'unregister',
+      'pile jetable': 'DisposableStack',
+      'pile jetable asynchrone': 'AsyncDisposableStack',
+      'collateur': 'Intl.Collator',
+      'format date temps': 'Intl.DateTimeFormat',
+      'format liste': 'Intl.ListFormat',
+      'locale': 'Intl.Locale',
+      'format nombre': 'Intl.NumberFormat',
+      'règles pluriel': 'Intl.PluralRules',
+      'format temps relatif': 'Intl.RelativeTimeFormat',
+      'segmenteur': 'Intl.Segmenter',
+      'formater': 'format',
+      'évaluer': 'eval',
+      'décoder URI': 'decodeURI',
+      'décoder composant URI': 'decodeURIComponent',
+      'encoder URI': 'encodeURI',
+      'encoder composant URI': 'encodeURIComponent'
     }
 
+    this.buildConflictResolution()
+  }
+
+  pushContext(ctx) {
+    this.context.push(ctx)
+  }
+
+  popContext() {
+    return this.context.pop()
+  }
+
+  getCurrentContext() {
+    return this.context.length > 0 ? this.context[this.context.length - 1] : null
+  }
+
+  translateWithContext(word, explicitContext = null) {
+    const lower = word.toLowerCase()
+    const ctx = explicitContext || this.getCurrentContext()
+    
+    if (this.conflicts[lower] && ctx) {
+      const resolved = this.conflicts[lower][ctx] || this.conflicts[lower]['default']
+      if (resolved) return resolved
+    }
+    
+    if (this.contextualMap[lower] && ctx) {
+      const resolved = this.contextualMap[lower][ctx]
+      if (resolved) return resolved
+    }
+    
+    return this.keywordMap[lower] || 
+           this.operatorMap[lower] || 
+           this.methodMap[lower] || 
+           word
+  }
+
+  translate(word) {
     const lower = word.toLowerCase()
-    return translations[lower] || word
+    
+    if (this.keywordMap[lower]) {
+      return this.keywordMap[lower]
+    }
+    if (this.operatorMap[lower]) {
+      return this.operatorMap[lower]
+    }
+    if (this.methodMap[lower]) {
+      return this.methodMap[lower]
+    }
+    
+    return word
+  }
+
+  translateOperator(op) {
+    const lower = op.toLowerCase()
+    return this.operatorMap[lower] || op
   }
 
   generate(ast) {
     this.output = ''
     this.indent = 0
+    this.context = []
 
     if (Array.isArray(ast)) {
       for (const node of ast) {
@@ -260,102 +856,137 @@ class JSGenerator {
   }
 
   generateNode(node) {
-    if (!node) return
+    if (!node) return ''
 
     switch (node.type) {
       case 'Program':
-        this.generateProgram(node)
-        break
+        return this.generateProgram(node)
       case 'VariableDeclaration':
-        this.generateVariableDeclaration(node)
-        break
+        return this.generateVariableDeclaration(node)
       case 'FunctionDeclaration':
-        this.generateFunctionDeclaration(node)
-        break
+        return this.generateFunctionDeclaration(node)
+      case 'FunctionExpression':
+        return this.generateFunctionExpression(node)
       case 'ClassDeclaration':
-        this.generateClassDeclaration(node)
-        break
+        return this.generateClassDeclaration(node)
+      case 'ClassExpression':
+        return this.generateClassExpression(node)
       case 'IfStatement':
-        this.generateIfStatement(node)
-        break
+        return this.generateIfStatement(node)
       case 'ForStatement':
-        this.generateForStatement(node)
-        break
+        return this.generateForStatement(node)
       case 'ForOfStatement':
+        return this.generateForOfStatement(node)
       case 'ForInStatement':
-        this.generateForOfStatement(node)
-        break
+        return this.generateForInStatement(node)
+      case 'ForAwaitStatement':
+        return this.generateForAwaitStatement(node)
       case 'WhileStatement':
-        this.generateWhileStatement(node)
-        break
+        return this.generateWhileStatement(node)
       case 'DoWhileStatement':
-        this.generateDoWhileStatement(node)
-        break
+        return this.generateDoWhileStatement(node)
       case 'SwitchStatement':
-        this.generateSwitchStatement(node)
-        break
+        return this.generateSwitchStatement(node)
       case 'TryStatement':
-        this.generateTryStatement(node)
-        break
+        return this.generateTryStatement(node)
       case 'ReturnStatement':
-        this.generateReturnStatement(node)
-        break
+        return this.generateReturnStatement(node)
       case 'ThrowStatement':
-        this.generateThrowStatement(node)
-        break
+        return this.generateThrowStatement(node)
       case 'BreakStatement':
-        this.writeLine('break;')
-        break
+        return this.generateBreakStatement(node)
       case 'ContinueStatement':
-        this.writeLine('continue;')
-        break
+        return this.generateContinueStatement(node)
+      case 'LabeledStatement':
+        return this.generateLabeledStatement(node)
+      case 'DebuggerStatement':
+        return this.generateDebuggerStatement(node)
       case 'ExpressionStatement':
-        this.generateExpressionStatement(node)
-        break
+        return this.generateExpressionStatement(node)
       case 'BlockStatement':
-        this.generateBlockStatement(node)
-        break
+        return this.generateBlockStatement(node)
+      case 'EmptyStatement':
+        return ''
       case 'ImportDeclaration':
-        this.generateImportDeclaration(node)
-        break
+        return this.generateImportDeclaration(node)
       case 'ExportDeclaration':
       case 'ExportNamedDeclaration':
+        return this.generateExportDeclaration(node)
       case 'ExportDefaultDeclaration':
-        this.generateExportDeclaration(node)
-        break
+        return this.generateExportDefaultDeclaration(node)
+      case 'ExportAllDeclaration':
+        return this.generateExportAllDeclaration(node)
       case 'ArrowFunctionExpression':
         return this.generateArrowFunction(node)
-      case 'FunctionExpression':
-        return this.generateFunctionExpression(node)
       case 'CallExpression':
         return this.generateCallExpression(node)
       case 'MemberExpression':
         return this.generateMemberExpression(node)
+      case 'OptionalMemberExpression':
+        return this.generateOptionalMemberExpression(node)
+      case 'OptionalCallExpression':
+        return this.generateOptionalCallExpression(node)
+      case 'ChainExpression':
+        return this.generateChainExpression(node)
       case 'BinaryExpression':
       case 'LogicalExpression':
         return this.generateBinaryExpression(node)
       case 'UnaryExpression':
         return this.generateUnaryExpression(node)
+      case 'UpdateExpression':
+        return this.generateUpdateExpression(node)
       case 'AssignmentExpression':
         return this.generateAssignmentExpression(node)
+      case 'AssignmentPattern':
+        return this.generateAssignmentPattern(node)
       case 'ConditionalExpression':
         return this.generateConditionalExpression(node)
       case 'ObjectExpression':
         return this.generateObjectExpression(node)
+      case 'ObjectPattern':
+        return this.generateObjectPattern(node)
       case 'ArrayExpression':
         return this.generateArrayExpression(node)
+      case 'ArrayPattern':
+        return this.generateArrayPattern(node)
+      case 'SpreadElement':
+        return this.generateSpreadElement(node)
+      case 'RestElement':
+        return this.generateRestElement(node)
       case 'Identifier':
         return this.translate(node.name)
-      case 'Parameter':
-        return this.generateParameter(node)
+      case 'PrivateIdentifier':
+        return this.generatePrivateIdentifier(node)
       case 'Literal':
         return this.generateLiteral(node)
       case 'TemplateLiteral':
         return this.generateTemplateLiteral(node)
+      case 'TaggedTemplateExpression':
+        return this.generateTaggedTemplateExpression(node)
       case 'NewExpression':
         return this.generateNewExpression(node)
+      case 'ThisExpression':
+        return 'this'
+      case 'Super':
+        return 'super'
       case 'AwaitExpression':
         return this.generateAwaitExpression(node)
+      case 'YieldExpression':
+        return this.generateYieldExpression(node)
+      case 'SequenceExpression':
+        return this.generateSequenceExpression(node)
+      case 'Property':
+        return this.generateProperty(node)
+      case 'MethodDefinition':
+        return this.generateMethodDefinition(node)
+      case 'PropertyDefinition':
+        return this.generatePropertyDefinition(node)
+      case 'StaticBlock':
+        return this.generateStaticBlock(node)
+      case 'MetaProperty':
+        return this.generateMetaProperty(node)
+      case 'ImportExpression':
+        return this.generateImportExpression(node)
       default:
         if (node.expression) {
           return this.generateNode(node.expression)
@@ -371,22 +1002,23 @@ class JSGenerator {
   }
 
   generateVariableDeclaration(node) {
-    const kind = this.translate(node.kind || 'let')
-    
-    if (node.declarations && Array.isArray(node.declarations)) {
-      for (const decl of node.declarations) {
-        const name = this.generateNode(decl.id || decl.name)
-        if (decl.init) {
-          const init = this.generateNode(decl.init)
-          this.writeLine(`${kind} ${name} = ${init};`)
-        } else {
-          this.writeLine(`${kind} ${name};`)
-        }
-      }
-    } else {
-      const name = typeof node.name === 'string' ? node.name : this.generateNode(node.name)
-      if (node.init) {
-        const init = this.generateNode(node.init)
+    let kind = node.kind || 'let'
+    
+    const kindTranslations = {
+      'variable': 'let',
+      'constante': 'const',
+      'variable globale': 'var',
+      'utilisant': 'using',
+      'attendre utilisant': 'await using'
+    }
+    kind = kindTranslations[kind.toLowerCase()] || this.translate(kind)
+    
+    const declarations = node.declarations || []
+
+    for (const decl of declarations) {
+      const name = this.generateNode(decl.id || decl.name)
+      if (decl.init) {
+        const init = this.generateNode(decl.init)
         this.writeLine(`${kind} ${name} = ${init};`)
       } else {
         this.writeLine(`${kind} ${name};`)
@@ -397,8 +1029,8 @@ class JSGenerator {
   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.generateParameter(p)).join(', ')
+    const name = node.id ? this.translate(node.id.name || node.id) : ''
+    const params = (node.params || []).map(p => this.generateNode(p)).join(', ')
 
     this.writeLine(`${async}function${generator} ${name}(${params}) {`)
     this.indent++
@@ -411,45 +1043,23 @@ class JSGenerator {
   generateFunctionExpression(node) {
     const async = node.async ? 'async ' : ''
     const generator = node.generator ? '*' : ''
-    const name = node.name ? this.translate(node.name) : ''
-    const params = (node.params || []).map(p => this.generateParameter(p)).join(', ')
-    
-    const bodyStatements = node.body?.body || []
-    const bodyCode = bodyStatements.map(stmt => {
-      const savedOutput = this.output
-      const savedIndent = this.indent
-      this.output = ''
-      this.indent = 1
-      this.generateNode(stmt)
-      const stmtCode = this.output.trim()
-      this.output = savedOutput
-      this.indent = savedIndent
-      return stmtCode
-    }).join('\n    ')
-    
-    return `${async}function${generator}${name ? ' ' + name : ''}(${params}) {\n    ${bodyCode}\n  }`
-  }
+    const name = node.id ? this.translate(node.id.name || node.id) : ''
+    const params = (node.params || []).map(p => this.generateNode(p)).join(', ')
 
-  generateParameter(node) {
-    if (!node) return ''
-    if (typeof node === 'string') return node
-    if (node.type === 'Identifier') return this.translate(node.name)
-    
-    let result = this.translate(node.name || '')
-    
-    if (node.typeAnnotation) {
-      result += `: ${this.generateNode(node.typeAnnotation)}`
-    }
-    
-    if (node.default) {
-      result += ` = ${this.generateNode(node.default)}`
-    }
-    
-    return result
+    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}function${generator} ${name}(${params}) {\n${body}\n${this.getIndent()}}`
   }
 
   generateClassDeclaration(node) {
-    const name = this.translate(node.id?.name || node.name || '')
+    const name = node.id ? (node.id.name || node.id) : ''
     const extend = node.superClass ? ` extends ${this.generateNode(node.superClass)}` : ''
 
     this.writeLine(`class ${name}${extend} {`)
@@ -465,21 +1075,58 @@ class JSGenerator {
     this.writeLine('')
   }
 
+  generateClassExpression(node) {
+    const name = node.id ? (node.id.name || node.id) : ''
+    const extend = node.superClass ? ` extends ${this.generateNode(node.superClass)}` : ''
+
+    let body = ''
+    const savedOutput = this.output
+    this.output = ''
+    this.indent++
+    const members = node.body?.body || node.body || []
+    for (const member of members) {
+      this.generateClassMember(member)
+    }
+    this.indent--
+    body = this.output.trim()
+    this.output = savedOutput
+
+    return `class ${name}${extend} {\n${body}\n${this.getIndent()}}`
+  }
+
   generateClassMember(node) {
     const isStatic = node.static ? 'static ' : ''
+    const isPrivate = node.key?.type === 'PrivateIdentifier'
     const kind = node.kind || 'method'
-    const name = this.translate(node.key?.name || node.name || '')
+    
+    let name
+    if (isPrivate) {
+      name = '#' + (node.key.name || '')
+    } else {
+      const rawName = node.key?.name || node.name || ''
+      if (rawName === 'constructeur') {
+        name = 'constructor'
+      } else if (rawName === 'obtenir') {
+        name = 'get'
+      } else if (rawName === 'définir') {
+        name = 'set'
+      } else {
+        name = rawName
+      }
+    }
+    
     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') {
+    } else if (kind === 'get' || kind === 'obtenir') {
       this.writeLine(`${isStatic}get ${name}() {`)
-    } else if (kind === 'set') {
+    } else if (kind === 'set' || kind === 'définir') {
       this.writeLine(`${isStatic}set ${name}(${params}) {`)
     } else {
       const async = node.value?.async || node.async ? 'async ' : ''
-      this.writeLine(`${isStatic}${async}${name}(${params}) {`)
+      const generator = node.value?.generator || node.generator ? '*' : ''
+      this.writeLine(`${isStatic}${async}${generator}${name}(${params}) {`)
     }
 
     this.indent++
@@ -489,22 +1136,52 @@ class JSGenerator {
     this.writeLine('')
   }
 
-  generateIfStatement(node, isElseIf = false) {
-    const test = this.generateNode(node.test || node.condition)
+  generateMethodDefinition(node) {
+    return this.generateClassMember(node)
+  }
+
+  generatePropertyDefinition(node) {
+    const isStatic = node.static ? 'static ' : ''
+    const isPrivate = node.key?.type === 'PrivateIdentifier'
     
-    if (isElseIf) {
-      this.writeLine(`} else if (${test}) {`)
+    let name
+    if (isPrivate) {
+      name = '#' + (node.key.name || '')
     } else {
-      this.writeLine(`if (${test}) {`)
+      name = node.computed ? `[${this.generateNode(node.key)}]` : this.generateNode(node.key)
     }
     
+    if (node.value) {
+      const value = this.generateNode(node.value)
+      this.writeLine(`${isStatic}${name} = ${value};`)
+    } else {
+      this.writeLine(`${isStatic}${name};`)
+    }
+  }
+
+  generateStaticBlock(node) {
+    this.writeLine('static {')
+    this.indent++
+    this.generateNode(node.body)
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generatePrivateIdentifier(node) {
+    return '#' + (node.name || '')
+  }
+
+  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.generateIfStatement(node.alternate, true)
+        this.output = this.output.trimEnd() + ' else '
+        this.generateIfStatement(node.alternate)
       } else {
         this.writeLine('} else {')
         this.indent++
@@ -518,7 +1195,19 @@ class JSGenerator {
   }
 
   generateForStatement(node) {
-    const init = node.init ? this.generateNode(node.init).replace(/;$/, '') : ''
+    let init = ''
+    if (node.init) {
+      if (node.init.type === 'VariableDeclaration') {
+        const kind = this.translate(node.init.kind || 'let')
+        const decls = node.init.declarations.map(d => {
+          const name = this.generateNode(d.id)
+          return d.init ? `${name} = ${this.generateNode(d.init)}` : name
+        }).join(', ')
+        init = `${kind} ${decls}`
+      } else {
+        init = this.generateNode(node.init)
+      }
+    }
     const test = node.test ? this.generateNode(node.test) : ''
     const update = node.update ? this.generateNode(node.update) : ''
 
@@ -530,15 +1219,63 @@ class JSGenerator {
   }
 
   generateForOfStatement(node) {
-    const left = this.generateNode(node.left)
+    this.pushContext('loop')
+    let left
+    if (node.left.type === 'VariableDeclaration') {
+      const kind = this.translate(node.left.kind || 'const')
+      const name = this.generateNode(node.left.declarations[0].id)
+      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.writeLine(`for (${left} of ${right}) {`)
     this.indent++
     this.generateNode(node.body)
     this.indent--
     this.writeLine('}')
+    this.popContext()
+  }
+
+  generateForInStatement(node) {
+    this.pushContext('loop')
+    let left
+    if (node.left.type === 'VariableDeclaration') {
+      const kind = this.translate(node.left.kind || 'const')
+      const name = this.generateNode(node.left.declarations[0].id)
+      left = `${kind} ${name}`
+    } else {
+      left = this.generateNode(node.left)
+    }
+    const right = this.generateNode(node.right)
+
+    this.writeLine(`for (${left} in ${right}) {`)
+    this.indent++
+    this.generateNode(node.body)
+    this.indent--
+    this.writeLine('}')
+    this.popContext()
+  }
+
+  generateForAwaitStatement(node) {
+    this.pushContext('loop')
+    let left
+    if (node.left.type === 'VariableDeclaration') {
+      const kind = this.translate(node.left.kind || 'const')
+      const name = this.generateNode(node.left.declarations[0].id)
+      left = `${kind} ${name}`
+    } else {
+      left = this.generateNode(node.left)
+    }
+    const right = this.generateNode(node.right)
+
+    this.writeLine(`for await (${left} of ${right}) {`)
+    this.indent++
+    this.generateNode(node.body)
+    this.indent--
+    this.writeLine('}')
+    this.popContext()
   }
 
   generateWhileStatement(node) {
@@ -589,8 +1326,12 @@ class JSGenerator {
     this.indent--
 
     if (node.handler) {
-      const param = node.handler.param ? this.generateNode(node.handler.param) : 'e'
-      this.writeLine(`} catch (${param}) {`)
+      const param = node.handler.param ? this.generateNode(node.handler.param) : ''
+      if (param) {
+        this.writeLine(`} catch (${param}) {`)
+      } else {
+        this.writeLine('} catch {')
+      }
       this.indent++
       this.generateNode(node.handler.body)
       this.indent--
@@ -607,9 +1348,8 @@ class JSGenerator {
   }
 
   generateReturnStatement(node) {
-    const value = node.argument || node.value
-    if (value) {
-      const arg = this.generateNode(value)
+    if (node.argument) {
+      const arg = this.generateNode(node.argument)
       this.writeLine(`return ${arg};`)
     } else {
       this.writeLine('return;')
@@ -621,9 +1361,37 @@ class JSGenerator {
     this.writeLine(`throw ${arg};`)
   }
 
+  generateBreakStatement(node) {
+    if (node.label) {
+      this.writeLine(`break ${this.generateNode(node.label)};`)
+    } else {
+      this.writeLine('break;')
+    }
+  }
+
+  generateContinueStatement(node) {
+    if (node.label) {
+      this.writeLine(`continue ${this.generateNode(node.label)};`)
+    } else {
+      this.writeLine('continue;')
+    }
+  }
+
+  generateLabeledStatement(node) {
+    const label = this.generateNode(node.label)
+    this.writeLine(`${label}:`)
+    this.generateNode(node.body)
+  }
+
+  generateDebuggerStatement(node) {
+    this.writeLine('debugger;')
+  }
+
   generateExpressionStatement(node) {
     const expr = this.generateNode(node.expression)
-    this.writeLine(`${expr};`)
+    if (expr) {
+      this.writeLine(`${expr};`)
+    }
   }
 
   generateBlockStatement(node) {
@@ -633,11 +1401,19 @@ class JSGenerator {
   }
 
   generateImportDeclaration(node) {
+    this.pushContext('module')
     const source = this.generateLiteral(node.source)
     const specifiers = node.specifiers || []
+    const attributes = node.attributes || node.assertions || []
 
     if (specifiers.length === 0) {
-      this.writeLine(`import ${source};`)
+      if (attributes.length > 0) {
+        const attrs = this.generateImportAttributes(attributes)
+        this.writeLine(`import ${source} with ${attrs};`)
+      } else {
+        this.writeLine(`import ${source};`)
+      }
+      this.popContext()
       return
     }
 
@@ -664,14 +1440,36 @@ class JSGenerator {
       importParts.push(`{ ${named} }`)
     }
 
-    this.writeLine(`import ${importParts.join(', ')} from ${source};`)
+    if (attributes.length > 0) {
+      const attrs = this.generateImportAttributes(attributes)
+      this.writeLine(`import ${importParts.join(', ')} from ${source} with ${attrs};`)
+    } else {
+      this.writeLine(`import ${importParts.join(', ')} from ${source};`)
+    }
+    this.popContext()
+  }
+
+  generateImportAttributes(attributes) {
+    const attrs = attributes.map(attr => {
+      const key = this.generateNode(attr.key)
+      const value = this.generateNode(attr.value)
+      return `${key}: ${value}`
+    }).join(', ')
+    return `{ ${attrs} }`
+  }
+
+  generateImportExpression(node) {
+    const source = this.generateNode(node.source)
+    if (node.options) {
+      const options = this.generateNode(node.options)
+      return `import(${source}, ${options})`
+    }
+    return `import(${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.pushContext('module')
+    if (node.declaration) {
       this.output += 'export '
       this.generateNode(node.declaration)
     } else if (node.specifiers) {
@@ -680,14 +1478,45 @@ class JSGenerator {
         const exported = this.generateNode(s.exported)
         return local === exported ? local : `${local} as ${exported}`
       }).join(', ')
-      this.writeLine(`export { ${specs} };`)
+      
+      if (node.source) {
+        const source = this.generateLiteral(node.source)
+        this.writeLine(`export { ${specs} } from ${source};`)
+      } else {
+        this.writeLine(`export { ${specs} };`)
+      }
+    }
+    this.popContext()
+  }
+
+  generateExportDefaultDeclaration(node) {
+    this.pushContext('module')
+    const decl = this.generateNode(node.declaration)
+    if (node.declaration.type === 'FunctionDeclaration' || 
+        node.declaration.type === 'ClassDeclaration') {
+      this.output = this.output.replace(/\n$/, '')
+    } else {
+      this.writeLine(`export default ${decl};`)
+    }
+    this.popContext()
+  }
+
+  generateExportAllDeclaration(node) {
+    const source = this.generateLiteral(node.source)
+    if (node.exported) {
+      const exported = this.generateNode(node.exported)
+      this.writeLine(`export * as ${exported} from ${source};`)
+    } else {
+      this.writeLine(`export * from ${source};`)
     }
   }
 
   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})`
+    const paramsStr = node.params?.length === 1 && node.params[0].type === 'Identifier' 
+      ? params 
+      : `(${params})`
 
     if (node.body?.type === 'BlockStatement') {
       let body = ''
@@ -713,19 +1542,56 @@ class JSGenerator {
 
   generateMemberExpression(node) {
     const object = this.generateNode(node.object)
-    const property = this.generateNode(node.property)
+    const property = node.computed 
+      ? this.generateNode(node.property)
+      : (node.property.name || this.generateNode(node.property))
     
     if (node.computed) {
       return `${object}[${property}]`
     }
-    return `${object}.${property}`
+    
+    const translatedProperty = this.translate(property)
+    
+    if (translatedProperty.includes('.')) {
+      const parts = translatedProperty.split('.')
+      if (parts[0].toLowerCase() === object.toLowerCase()) {
+        return translatedProperty
+      }
+      return `${object}.${parts.slice(-1)[0]}`
+    }
+    
+    return `${object}.${translatedProperty}`
+  }
+
+  generateOptionalMemberExpression(node) {
+    const object = this.generateNode(node.object)
+    const property = node.computed 
+      ? this.generateNode(node.property)
+      : (node.property.name || this.generateNode(node.property))
+    
+    if (node.computed) {
+      return `${object}?.[${property}]`
+    }
+    
+    const translatedProperty = this.translate(property)
+    return `${object}?.${translatedProperty}`
+  }
+
+  generateOptionalCallExpression(node) {
+    const callee = this.generateNode(node.callee)
+    const args = (node.arguments || []).map(a => this.generateNode(a)).join(', ')
+    return `${callee}?.(${args})`
+  }
+
+  generateChainExpression(node) {
+    return this.generateNode(node.expression)
   }
 
   generateBinaryExpression(node) {
     const left = this.generateNode(node.left)
     const right = this.generateNode(node.right)
     const op = this.translateOperator(node.operator)
-    return `${left} ${op} ${right}`
+    return `(${left} ${op} ${right})`
   }
 
   generateUnaryExpression(node) {
@@ -733,9 +1599,22 @@ class JSGenerator {
     const op = this.translateOperator(node.operator)
     
     if (node.prefix) {
-      return op === 'typeof' || op === 'delete' || op === 'void' 
-        ? `${op} ${arg}` 
-        : `${op}${arg}`
+      if (op === 'typeof' || op === 'delete' || op === 'void' || 
+          op === 'type de' || op === 'supprimer' || op === 'vide') {
+        const translatedOp = this.translateOperator(op)
+        return `${translatedOp} ${arg}`
+      }
+      return `${op}${arg}`
+    }
+    return `${arg}${op}`
+  }
+
+  generateUpdateExpression(node) {
+    const arg = this.generateNode(node.argument)
+    const op = node.operator
+    
+    if (node.prefix) {
+      return `${op}${arg}`
     }
     return `${arg}${op}`
   }
@@ -747,6 +1626,12 @@ class JSGenerator {
     return `${left} ${op} ${right}`
   }
 
+  generateAssignmentPattern(node) {
+    const left = this.generateNode(node.left)
+    const right = this.generateNode(node.right)
+    return `${left} = ${right}`
+  }
+
   generateConditionalExpression(node) {
     const test = this.generateNode(node.test)
     const consequent = this.generateNode(node.consequent)
@@ -756,17 +1641,10 @@ class JSGenerator {
 
   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}) { ... }`
+      if (p.type === 'SpreadElement') {
+        return this.generateSpreadElement(p)
       }
-      return `${key}: ${value}`
+      return this.generateProperty(p)
     })
     
     if (props.length === 0) return '{}'
@@ -776,8 +1654,87 @@ class JSGenerator {
     return `{\n${this.getIndent()}  ${props.join(',\n' + this.getIndent() + '  ')}\n${this.getIndent()}}`
   }
 
+  generateProperty(node) {
+    const key = node.computed 
+      ? `[${this.generateNode(node.key)}]` 
+      : this.generateNode(node.key)
+    
+    if (node.shorthand) {
+      return key
+    }
+    
+    if (node.method) {
+      const async = node.value?.async ? 'async ' : ''
+      const generator = node.value?.generator ? '*' : ''
+      const params = (node.value?.params || []).map(p => this.generateNode(p)).join(', ')
+      
+      let body = ''
+      const savedOutput = this.output
+      this.output = ''
+      this.indent++
+      this.generateNode(node.value?.body)
+      this.indent--
+      body = this.output.trim()
+      this.output = savedOutput
+      
+      return `${async}${generator}${key}(${params}) {\n${body}\n${this.getIndent()}}`
+    }
+    
+    if (node.kind === 'get') {
+      let body = ''
+      const savedOutput = this.output
+      this.output = ''
+      this.indent++
+      this.generateNode(node.value?.body)
+      this.indent--
+      body = this.output.trim()
+      this.output = savedOutput
+      
+      return `get ${key}() {\n${body}\n${this.getIndent()}}`
+    }
+    
+    if (node.kind === 'set') {
+      const params = (node.value?.params || []).map(p => this.generateNode(p)).join(', ')
+      let body = ''
+      const savedOutput = this.output
+      this.output = ''
+      this.indent++
+      this.generateNode(node.value?.body)
+      this.indent--
+      body = this.output.trim()
+      this.output = savedOutput
+      
+      return `set ${key}(${params}) {\n${body}\n${this.getIndent()}}`
+    }
+    
+    const value = this.generateNode(node.value)
+    return `${key}: ${value}`
+  }
+
+  generateObjectPattern(node) {
+    const props = (node.properties || []).map(p => {
+      if (p.type === 'RestElement') {
+        return this.generateRestElement(p)
+      }
+      
+      const key = this.generateNode(p.key)
+      const value = this.generateNode(p.value)
+      
+      if (p.shorthand || key === value) {
+        return key
+      }
+      return `${key}: ${value}`
+    }).join(', ')
+    
+    return `{ ${props} }`
+  }
+
   generateArrayExpression(node) {
-    const elements = (node.elements || []).map(e => e ? this.generateNode(e) : '')
+    const elements = (node.elements || []).map(e => {
+      if (!e) return ''
+      if (e.type === 'SpreadElement') return this.generateSpreadElement(e)
+      return this.generateNode(e)
+    })
     
     if (elements.length === 0) return '[]'
     if (elements.length <= 5 && !elements.some(e => e.includes('\n'))) {
@@ -786,16 +1743,39 @@ class JSGenerator {
     return `[\n${this.getIndent()}  ${elements.join(',\n' + this.getIndent() + '  ')}\n${this.getIndent()}]`
   }
 
+  generateArrayPattern(node) {
+    const elements = (node.elements || []).map(e => {
+      if (!e) return ''
+      if (e.type === 'RestElement') return this.generateRestElement(e)
+      return this.generateNode(e)
+    }).join(', ')
+    
+    return `[${elements}]`
+  }
+
+  generateSpreadElement(node) {
+    const arg = this.generateNode(node.argument)
+    return `...${arg}`
+  }
+
+  generateRestElement(node) {
+    const arg = this.generateNode(node.argument)
+    return `...${arg}`
+  }
+
   generateLiteral(node) {
     if (node.raw) return node.raw
     if (typeof node.value === 'string') {
-      return `"${node.value.replace(/"/g, '\\"')}"`
+      return `"${node.value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`
     }
     if (node.value === null) return 'null'
     if (node.value === undefined) return 'undefined'
     if (node.regex) {
       return `/${node.regex.pattern}/${node.regex.flags}`
     }
+    if (typeof node.value === 'bigint' || (typeof node.value === 'string' && node.bigint)) {
+      return `${node.value}n`
+    }
     return String(node.value)
   }
 
@@ -814,6 +1794,12 @@ class JSGenerator {
     return result + '`'
   }
 
+  generateTaggedTemplateExpression(node) {
+    const tag = this.generateNode(node.tag)
+    const quasi = this.generateTemplateLiteral(node.quasi)
+    return `${tag}${quasi}`
+  }
+
   generateNewExpression(node) {
     const callee = this.generateNode(node.callee)
     const args = (node.arguments || []).map(a => this.generateNode(a)).join(', ')
@@ -825,21 +1811,24 @@ class JSGenerator {
     return `await ${arg}`
   }
 
-  translateOperator(op) {
-    const operators = {
-      'et': '&&',
-      'ou': '||',
-      'non': '!',
-      'egal': '===',
-      'different': '!==',
-      'plus': '+',
-      'moins': '-',
-      'fois': '*',
-      'divise': '/',
-      'modulo': '%',
-      'puissance': '**'
+  generateYieldExpression(node) {
+    const delegate = node.delegate ? '*' : ''
+    if (node.argument) {
+      const arg = this.generateNode(node.argument)
+      return `yield${delegate} ${arg}`
     }
-    return operators[op] || op
+    return `yield${delegate}`
+  }
+
+  generateSequenceExpression(node) {
+    const expressions = (node.expressions || []).map(e => this.generateNode(e))
+    return `(${expressions.join(', ')})`
+  }
+
+  generateMetaProperty(node) {
+    const meta = node.meta?.name || node.meta
+    const property = node.property?.name || node.property
+    return `${meta}.${property}`
   }
 
   writeLine(text) {
@@ -853,4 +1842,4 @@ class JSGenerator {
 
 module.exports = {
   JSGenerator
-}
+}