ether-code 0.1.6 → 0.1.7

package/parsers/node-parser.js

@@ -1,2644 +0,0 @@
-const AST = require('./ast-node')
-
-class NodeParser {
-    constructor(i18n = null) {
-        this.i18n = i18n || {}
-        this.pos = 0
-        this.input = ''
-        this.tokens = []
-        this.current = 0
-        this.lang = 'fr'
-    }
-
-    setLanguage(lang) {
-        this.lang = lang
-    }
-
-    buildKeywordMap() {
-        const map = {}
-        const addMapping = (category, key, nodeValue) => {
-            if (this.i18n[category] && this.i18n[category][key]) {
-                const translations = this.i18n[category][key]
-                Object.values(translations).forEach(term => {
-                    if (term) map[term.toLowerCase()] = nodeValue
-                })
-            }
-        }
-
-        addMapping('modulesCommonJS', 'charger', 'require')
-        addMapping('modulesCommonJS', 'moduleNode', 'module')
-        addMapping('modulesCommonJS', 'exporter', 'exports')
-        addMapping('modulesCommonJS', 'moduleExports', 'module.exports')
-
-        addMapping('modulesES', 'importer', 'import')
-        addMapping('modulesES', 'exporterES', 'export')
-        addMapping('modulesES', 'exporterDefaut', 'export default')
-        addMapping('modulesES', 'importerDynamique', 'import()')
-
-        addMapping('fsLecture', 'lireFichier', 'fs.readFile')
-        addMapping('fsLecture', 'lireFichierSync', 'fs.readFileSync')
-        addMapping('fsLecture', 'lireRepertoire', 'fs.readdir')
-        addMapping('fsLecture', 'lireRepertoireSync', 'fs.readdirSync')
-
-        addMapping('fsEcriture', 'ecrireFichier', 'fs.writeFile')
-        addMapping('fsEcriture', 'ecrireFichierSync', 'fs.writeFileSync')
-        addMapping('fsEcriture', 'ajouterFichier', 'fs.appendFile')
-        addMapping('fsEcriture', 'ajouterFichierSync', 'fs.appendFileSync')
-
-        addMapping('fsGestion', 'creerDossier', 'fs.mkdir')
-        addMapping('fsGestion', 'creerDossierSync', 'fs.mkdirSync')
-        addMapping('fsGestion', 'supprimerFichier', 'fs.unlink')
-        addMapping('fsGestion', 'supprimerFichierSync', 'fs.unlinkSync')
-        addMapping('fsGestion', 'supprimerDossier', 'fs.rmdir')
-        addMapping('fsGestion', 'supprimerDossierSync', 'fs.rmdirSync')
-        addMapping('fsGestion', 'supprimer', 'fs.rm')
-        addMapping('fsGestion', 'supprimerSync', 'fs.rmSync')
-        addMapping('fsGestion', 'renommerFichier', 'fs.rename')
-        addMapping('fsGestion', 'renommerSync', 'fs.renameSync')
-        addMapping('fsGestion', 'copierFichier', 'fs.copyFile')
-        addMapping('fsGestion', 'copierFichierSync', 'fs.copyFileSync')
-
-        addMapping('fsInfos', 'statsFichier', 'fs.stat')
-        addMapping('fsInfos', 'statsSync', 'fs.statSync')
-        addMapping('fsInfos', 'lienStats', 'fs.lstat')
-        addMapping('fsInfos', 'existeFichier', 'fs.existsSync')
-        addMapping('fsInfos', 'accesFichier', 'fs.access')
-        addMapping('fsInfos', 'accesSync', 'fs.accessSync')
-
-        addMapping('fsFlux', 'creerFluxLecture', 'fs.createReadStream')
-        addMapping('fsFlux', 'creerFluxEcriture', 'fs.createWriteStream')
-
-        addMapping('fsSurveillance', 'surveillerFichier', 'fs.watchFile')
-        addMapping('fsSurveillance', 'arreterSurveillance', 'fs.unwatchFile')
-        addMapping('fsSurveillance', 'surveiller', 'fs.watch')
-
-        addMapping('path', 'joindre', 'path.join')
-        addMapping('path', 'resoudre', 'path.resolve')
-        addMapping('path', 'normaliser', 'path.normalize')
-        addMapping('path', 'estAbsolu', 'path.isAbsolute')
-        addMapping('path', 'relatif', 'path.relative')
-        addMapping('path', 'repertoire', 'path.dirname')
-        addMapping('path', 'nomBase', 'path.basename')
-        addMapping('path', 'extension', 'path.extname')
-        addMapping('path', 'analyser', 'path.parse')
-        addMapping('path', 'formater', 'path.format')
-
-        addMapping('httpServeur', 'creerServeur', 'http.createServer')
-        addMapping('httpServeur', 'creerServeurSecurise', 'https.createServer')
-        addMapping('httpServeur', 'ecouter', 'server.listen')
-        addMapping('httpServeur', 'fermerServeur', 'server.close')
-
-        addMapping('httpRequete', 'requeteHttp', 'http.request')
-        addMapping('httpRequete', 'recuperer', 'http.get')
-        addMapping('httpRequete', 'requeteSecurisee', 'https.request')
-        addMapping('httpRequete', 'recupererSecurise', 'https.get')
-
-        addMapping('httpResponse', 'codeStatut', 'res.statusCode')
-        addMapping('httpResponse', 'messageStatut', 'res.statusMessage')
-        addMapping('httpResponse', 'definirEntete', 'res.setHeader')
-        addMapping('httpResponse', 'obtenirEntete', 'res.getHeader')
-        addMapping('httpResponse', 'supprimerEntete', 'res.removeHeader')
-        addMapping('httpResponse', 'ecrireEntete', 'res.writeHead')
-        addMapping('httpResponse', 'ecrireReponse', 'res.write')
-        addMapping('httpResponse', 'terminerReponse', 'res.end')
-
-        addMapping('process', 'arguments', 'process.argv')
-        addMapping('process', 'environnement', 'process.env')
-        addMapping('process', 'idProcessus', 'process.pid')
-        addMapping('process', 'plateforme', 'process.platform')
-        addMapping('process', 'architecture', 'process.arch')
-        addMapping('process', 'versionNode', 'process.version')
-
-        addMapping('processMethodes', 'repertoireCourant', 'process.cwd')
-        addMapping('processMethodes', 'changerRepertoire', 'process.chdir')
-        addMapping('processMethodes', 'quitter', 'process.exit')
-        addMapping('processMethodes', 'tuer', 'process.kill')
-        addMapping('processMethodes', 'prochainTick', 'process.nextTick')
-        addMapping('processMethodes', 'utilisationMemoire', 'process.memoryUsage')
-        addMapping('processMethodes', 'utilisationCpu', 'process.cpuUsage')
-        addMapping('processMethodes', 'tempsExecution', 'process.uptime')
-        addMapping('processMethodes', 'tempsHauteResolution', 'process.hrtime')
-
-        addMapping('processFlux', 'entreeStandard', 'process.stdin')
-        addMapping('processFlux', 'sortieStandard', 'process.stdout')
-        addMapping('processFlux', 'sortieErreur', 'process.stderr')
-
-        addMapping('events', 'EmetteurEvenements', 'EventEmitter')
-        addMapping('events', 'emettre', 'emit')
-        addMapping('events', 'surEvenement', 'on')
-        addMapping('events', 'uneFois', 'once')
-        addMapping('events', 'supprimerEcouteur', 'removeListener')
-        addMapping('events', 'supprimerTousEcouteurs', 'removeAllListeners')
-        addMapping('events', 'ecouteurs', 'listeners')
-        addMapping('events', 'nombreEcouteurs', 'listenerCount')
-        addMapping('events', 'definirMaxEcouteurs', 'setMaxListeners')
-
-        addMapping('streams', 'FluxLecture', 'stream.Readable')
-        addMapping('streams', 'FluxEcriture', 'stream.Writable')
-        addMapping('streams', 'FluxDuplex', 'stream.Duplex')
-        addMapping('streams', 'FluxTransformation', 'stream.Transform')
-        addMapping('streams', 'FluxPassage', 'stream.PassThrough')
-        addMapping('streams', 'tuyauter', 'pipe')
-        addMapping('streams', 'detuyauter', 'unpipe')
-        addMapping('streams', 'lireFlux', 'read')
-        addMapping('streams', 'ecrireFlux', 'write')
-        addMapping('streams', 'terminerFlux', 'end')
-        addMapping('streams', 'detruireFlux', 'destroy')
-        addMapping('streams', 'pauserFlux', 'pause')
-        addMapping('streams', 'reprendreFlux', 'resume')
-
-        addMapping('buffer', 'tamponAlloc', 'Buffer.alloc')
-        addMapping('buffer', 'tamponAllocNonSecurise', 'Buffer.allocUnsafe')
-        addMapping('buffer', 'tamponDepuis', 'Buffer.from')
-        addMapping('buffer', 'concatenerTampons', 'Buffer.concat')
-        addMapping('buffer', 'comparerTampons', 'Buffer.compare')
-        addMapping('buffer', 'estTampon', 'Buffer.isBuffer')
-        addMapping('buffer', 'tailleOctets', 'Buffer.byteLength')
-        addMapping('buffer', 'versChaine', 'toString')
-        addMapping('buffer', 'versJSON', 'toJSON')
-        addMapping('buffer', 'copier', 'copy')
-        addMapping('buffer', 'trancher', 'slice')
-        addMapping('buffer', 'sousTableau', 'subarray')
-        addMapping('buffer', 'remplir', 'fill')
-        addMapping('buffer', 'inclut', 'includes')
-
-        addMapping('os', 'typeOS', 'os.type')
-        addMapping('os', 'plateformeOS', 'os.platform')
-        addMapping('os', 'architectureOS', 'os.arch')
-        addMapping('os', 'versionOS', 'os.version')
-        addMapping('os', 'releaseOS', 'os.release')
-        addMapping('os', 'nomHote', 'os.hostname')
-        addMapping('os', 'memoireTotale', 'os.totalmem')
-        addMapping('os', 'memoireLibre', 'os.freemem')
-        addMapping('os', 'cpus', 'os.cpus')
-        addMapping('os', 'chargeSysteme', 'os.loadavg')
-        addMapping('os', 'infoUtilisateur', 'os.userInfo')
-        addMapping('os', 'repertoireHome', 'os.homedir')
-        addMapping('os', 'repertoireTemp', 'os.tmpdir')
-        addMapping('os', 'interfacesReseau', 'os.networkInterfaces')
-        addMapping('os', 'tempsActivite', 'os.uptime')
-
-        addMapping('crypto', 'creerHash', 'crypto.createHash')
-        addMapping('crypto', 'creerHmac', 'crypto.createHmac')
-        addMapping('crypto', 'mettreAJour', 'update')
-        addMapping('crypto', 'digest', 'digest')
-        addMapping('crypto', 'creerChiffreur', 'crypto.createCipheriv')
-        addMapping('crypto', 'creerDechiffreur', 'crypto.createDecipheriv')
-        addMapping('crypto', 'octetsAleatoires', 'crypto.randomBytes')
-        addMapping('crypto', 'remplirAleatoire', 'crypto.randomFill')
-        addMapping('crypto', 'uuidAleatoire', 'crypto.randomUUID')
-        addMapping('crypto', 'entierAleatoire', 'crypto.randomInt')
-        addMapping('crypto', 'pbkdf2', 'crypto.pbkdf2')
-        addMapping('crypto', 'pbkdf2Sync', 'crypto.pbkdf2Sync')
-        addMapping('crypto', 'scrypt', 'crypto.scrypt')
-        addMapping('crypto', 'scryptSync', 'crypto.scryptSync')
-        addMapping('crypto', 'creerSignature', 'crypto.createSign')
-        addMapping('crypto', 'creerVerificateur', 'crypto.createVerify')
-        addMapping('crypto', 'signer', 'sign')
-        addMapping('crypto', 'verifier', 'verify')
-
-        addMapping('url', 'URLNode', 'URL')
-        addMapping('url', 'analyserUrl', 'url.parse')
-        addMapping('url', 'formaterUrl', 'url.format')
-        addMapping('url', 'resoudreUrl', 'url.resolve')
-        addMapping('url', 'ParamsRecherche', 'URLSearchParams')
-        addMapping('url', 'obtenir', 'get')
-        addMapping('url', 'obtenirTous', 'getAll')
-        addMapping('url', 'ajouter', 'append')
-        addMapping('url', 'definir', 'set')
-        addMapping('url', 'possede', 'has')
-        addMapping('url', 'trier', 'sort')
-
-        addMapping('childProcess', 'spawn', 'child_process.spawn')
-        addMapping('childProcess', 'exec', 'child_process.exec')
-        addMapping('childProcess', 'execFile', 'child_process.execFile')
-        addMapping('childProcess', 'fork', 'child_process.fork')
-        addMapping('childProcess', 'spawnSync', 'child_process.spawnSync')
-        addMapping('childProcess', 'execSync', 'child_process.execSync')
-        addMapping('childProcess', 'execFileSync', 'child_process.execFileSync')
-        addMapping('childProcess', 'tuerEnfant', 'child.kill')
-        addMapping('childProcess', 'envoyerMessage', 'child.send')
-        addMapping('childProcess', 'deconnecterEnfant', 'child.disconnect')
-
-        addMapping('util', 'promisifier', 'util.promisify')
-        addMapping('util', 'callbackifier', 'util.callbackify')
-        addMapping('util', 'formaterUtil', 'util.format')
-        addMapping('util', 'inspecter', 'util.inspect')
-        addMapping('util', 'obsolete', 'util.deprecate')
-        addMapping('util', 'estTableau', 'util.types.isArray')
-        addMapping('util', 'estDate', 'util.types.isDate')
-        addMapping('util', 'estErreur', 'util.types.isNativeError')
-        addMapping('util', 'estPromesse', 'util.types.isPromise')
-        addMapping('util', 'estRegExp', 'util.types.isRegExp')
-
-        addMapping('dns', 'resoudreHote', 'dns.lookup')
-        addMapping('dns', 'resoudre', 'dns.resolve')
-        addMapping('dns', 'resoudre4', 'dns.resolve4')
-        addMapping('dns', 'resoudre6', 'dns.resolve6')
-        addMapping('dns', 'resoudreMx', 'dns.resolveMx')
-        addMapping('dns', 'resoudreTxt', 'dns.resolveTxt')
-        addMapping('dns', 'resoudreNs', 'dns.resolveNs')
-        addMapping('dns', 'resoudreCname', 'dns.resolveCname')
-        addMapping('dns', 'resoudreInverse', 'dns.reverse')
-
-        addMapping('timers', 'definirDelai', 'setTimeout')
-        addMapping('timers', 'annulerDelai', 'clearTimeout')
-        addMapping('timers', 'definirIntervalle', 'setInterval')
-        addMapping('timers', 'annulerIntervalle', 'clearInterval')
-        addMapping('timers', 'definirImmediat', 'setImmediate')
-        addMapping('timers', 'annulerImmediat', 'clearImmediate')
-
-        addMapping('console', 'afficher', 'console.log')
-        addMapping('console', 'erreur', 'console.error')
-        addMapping('console', 'avertir', 'console.warn')
-        addMapping('console', 'info', 'console.info')
-        addMapping('console', 'debug', 'console.debug')
-        addMapping('console', 'tableau', 'console.table')
-        addMapping('console', 'temps', 'console.time')
-        addMapping('console', 'finTemps', 'console.timeEnd')
-        addMapping('console', 'tempsLog', 'console.timeLog')
-        addMapping('console', 'trace', 'console.trace')
-        addMapping('console', 'vider', 'console.clear')
-        addMapping('console', 'compter', 'console.count')
-        addMapping('console', 'reinitialiserCompteur', 'console.countReset')
-        addMapping('console', 'groupe', 'console.group')
-        addMapping('console', 'finGroupe', 'console.groupEnd')
-        addMapping('console', 'groupeReduit', 'console.groupCollapsed')
-        addMapping('console', 'affirmer', 'console.assert')
-        addMapping('console', 'repertoireConsole', 'console.dir')
-
-        addMapping('globaux', 'global', 'global')
-        addMapping('globaux', 'globalThis', 'globalThis')
-        addMapping('globaux', 'nomFichier', '__filename')
-        addMapping('globaux', 'nomRepertoire', '__dirname')
-
-        addMapping('globauxModule', 'exportations', 'exports')
-        addMapping('globauxModule', 'cacheRequire', 'require.cache')
-        addMapping('globauxModule', 'resoudreRequire', 'require.resolve')
-
-        return map
-    }
-
-    tokenize(input) {
-        this.input = input
-        this.pos = 0
-        this.tokens = []
-
-        while (this.pos < input.length) {
-            this.skipWhitespace()
-            if (this.pos >= input.length) break
-
-            const char = input[this.pos]
-
-            if (char === '/' && input[this.pos + 1] === '/') {
-                this.skipLineComment()
-                continue
-            }
-
-            if (char === '/' && input[this.pos + 1] === '*') {
-                this.skipBlockComment()
-                continue
-            }
-
-            if (char === '"' || char === "'") {
-                this.tokens.push(this.readString())
-                continue
-            }
-
-            if (char === '`') {
-                this.tokens.push(this.readTemplateLiteral())
-                continue
-            }
-
-            if (/[0-9]/.test(char)) {
-                this.tokens.push(this.readNumber())
-                continue
-            }
-
-            if (/[a-zA-Z_$\u00C0-\u024F\u0400-\u04FF\u4E00-\u9FFF\u3040-\u309F\u30A0-\u30FF]/.test(char)) {
-                this.tokens.push(this.readIdentifier())
-                continue
-            }
-
-            if ('(){}[],.;:'.includes(char)) {
-                this.tokens.push({ type: 'punctuation', value: char })
-                this.pos++
-                continue
-            }
-
-            if ('+-*/%=<>!&|^~?@#'.includes(char)) {
-                this.tokens.push(this.readOperator())
-                continue
-            }
-
-            this.pos++
-        }
-
-        return this.tokens
-    }
-
-    skipWhitespace() {
-        while (this.pos < this.input.length && /\s/.test(this.input[this.pos])) {
-            this.pos++
-        }
-    }
-
-    skipLineComment() {
-        while (this.pos < this.input.length && this.input[this.pos] !== '\n') {
-            this.pos++
-        }
-    }
-
-    skipBlockComment() {
-        this.pos += 2
-        while (this.pos < this.input.length - 1) {
-            if (this.input[this.pos] === '*' && this.input[this.pos + 1] === '/') {
-                this.pos += 2
-                return
-            }
-            this.pos++
-        }
-    }
-
-    readString() {
-        const quote = this.input[this.pos]
-        let value = ''
-        this.pos++
-        while (this.pos < this.input.length && this.input[this.pos] !== quote) {
-            if (this.input[this.pos] === '\\') {
-                this.pos++
-                value += this.input[this.pos] || ''
-            } else {
-                value += this.input[this.pos]
-            }
-            this.pos++
-        }
-        this.pos++
-        return { type: 'string', value, raw: `${quote}${value}${quote}` }
-    }
-
-    readTemplateLiteral() {
-        this.pos++
-        let value = ''
-        const expressions = []
-        while (this.pos < this.input.length && this.input[this.pos] !== '`') {
-            if (this.input[this.pos] === '$' && this.input[this.pos + 1] === '{') {
-                expressions.push({ quasi: value, start: this.pos })
-                value = ''
-                this.pos += 2
-                let depth = 1
-                let expr = ''
-                while (depth > 0 && this.pos < this.input.length) {
-                    if (this.input[this.pos] === '{') depth++
-                    if (this.input[this.pos] === '}') depth--
-                    if (depth > 0) expr += this.input[this.pos]
-                    this.pos++
-                }
-                expressions[expressions.length - 1].expression = expr
-            } else {
-                value += this.input[this.pos]
-                this.pos++
-            }
-        }
-        this.pos++
-        return { type: 'template', value, expressions }
-    }
-
-    readNumber() {
-        let value = ''
-        let isFloat = false
-        let isHex = false
-        let isBinary = false
-        let isOctal = false
-
-        if (this.input[this.pos] === '0') {
-            if (this.input[this.pos + 1] === 'x' || this.input[this.pos + 1] === 'X') {
-                isHex = true
-                value = '0x'
-                this.pos += 2
-            } else if (this.input[this.pos + 1] === 'b' || this.input[this.pos + 1] === 'B') {
-                isBinary = true
-                value = '0b'
-                this.pos += 2
-            } else if (this.input[this.pos + 1] === 'o' || this.input[this.pos + 1] === 'O') {
-                isOctal = true
-                value = '0o'
-                this.pos += 2
-            }
-        }
-
-        while (this.pos < this.input.length) {
-            const char = this.input[this.pos]
-            if (isHex && /[0-9a-fA-F_]/.test(char)) {
-                if (char !== '_') value += char
-                this.pos++
-            } else if (isBinary && /[01_]/.test(char)) {
-                if (char !== '_') value += char
-                this.pos++
-            } else if (isOctal && /[0-7_]/.test(char)) {
-                if (char !== '_') value += char
-                this.pos++
-            } else if (!isHex && !isBinary && !isOctal && /[0-9_]/.test(char)) {
-                if (char !== '_') value += char
-                this.pos++
-            } else if (char === '.' && !isFloat && !isHex && !isBinary && !isOctal) {
-                isFloat = true
-                value += char
-                this.pos++
-            } else if ((char === 'e' || char === 'E') && !isHex && !isBinary && !isOctal) {
-                value += char
-                this.pos++
-                if (this.input[this.pos] === '+' || this.input[this.pos] === '-') {
-                    value += this.input[this.pos]
-                    this.pos++
-                }
-            } else if (char === 'n') {
-                this.pos++
-                return { type: 'bigint', value: BigInt(value), raw: value + 'n' }
-            } else {
-                break
-            }
-        }
-
-        return { type: 'number', value: isFloat ? parseFloat(value) : parseInt(value), raw: value }
-    }
-
-    readIdentifier() {
-        let value = ''
-        while (this.pos < this.input.length && /[a-zA-Z0-9_$\u00C0-\u024F\u0400-\u04FF\u4E00-\u9FFF\u3040-\u309F\u30A0-\u30FF]/.test(this.input[this.pos])) {
-            value += this.input[this.pos]
-            this.pos++
-        }
-        const keywords = ['si', 'sinon', 'sinonsi', 'pour', 'tantque', 'faire', 'retourner', 'essayer', 'saufsi', 'enfin', 'lancer', 'classe', 'herite', 'hérite', 'nouveau', 'soi', 'super', 'statique', 'asynchrone', 'attendre', 'generateur', 'générateur', 'produire', 'def', 'définir', 'fonction', 'const', 'soit', 'vrai', 'faux', 'nul', 'indefini', 'indéfini', 'de', 'dans', 'depuis', 'comme', 'cas', 'selon', 'defaut', 'défaut', 'continuer', 'sortir', 'debugger', 'debogueur', 'débogueur', 'avec', 'etiquette', 'étiquette']
-        const keywordsEN = ['if', 'else', 'elseif', 'for', 'while', 'do', 'return', 'try', 'catch', 'finally', 'throw', 'class', 'extends', 'new', 'this', 'super', 'static', 'async', 'await', 'generator', 'yield', 'function', 'const', 'let', 'true', 'false', 'null', 'undefined', 'of', 'in', 'from', 'as', 'case', 'switch', 'default', 'continue', 'break', 'debugger', 'with', 'label']
-        const keywordsES = ['si', 'sino', 'sinosi', 'para', 'mientras', 'hacer', 'retornar', 'intentar', 'capturar', 'finalmente', 'lanzar', 'clase', 'extiende', 'nuevo', 'esto', 'super', 'estatico', 'estático', 'asincrono', 'asíncrono', 'esperar', 'generador', 'producir', 'funcion', 'función', 'const', 'let', 'verdadero', 'falso', 'nulo', 'indefinido', 'de', 'en', 'desde', 'como', 'caso', 'segun', 'según', 'porDefecto', 'continuar', 'romper', 'depurador', 'con', 'etiqueta']
-        const keywordsRU = ['если', 'иначе', 'иначеесли', 'для', 'пока', 'делать', 'вернуть', 'попробовать', 'поймать', 'наконец', 'бросить', 'класс', 'расширяет', 'новый', 'это', 'супер', 'статический', 'асинхронный', 'ждать', 'генератор', 'выдать', 'функция', 'конст', 'пусть', 'истина', 'ложь', 'ноль', 'неопределено', 'из', 'в', 'от', 'как', 'случай', 'переключатель', 'поумолчанию', 'продолжить', 'прервать', 'отладчик', 'с', 'метка']
-        const keywordsZH = ['如果', '否则', '否则如果', '对于', '当', '做', '返回', '尝试', '捕获', '最终', '抛出', '类', '继承', '新建', '这', '超级', '静态', '异步', '等待', '生成器', '产出', '函数', '常量', '让', '真', '假', '空', '未定义', '的', '在', '从', '作为', '情况', '开关', '默认', '继续', '中断', '调试器', '与', '标签']
-        const keywordsJA = ['もし', 'そうでなければ', 'でなければもし', 'ため', 'の間', 'する', '戻る', 'トライ', 'キャッチ', 'ファイナリー', 'スロー', 'クラス', '継承', '新規', 'これ', 'スーパー', 'スタティック', '非同期', '待つ', 'ジェネレーター', '譲る', '関数', '定数', 'レット', '真実', '偽', 'ヌル', '未定義', 'の', 'の中', 'から', 'として', 'ケース', 'スイッチ', 'デフォルト', '続ける', 'ブレーク', 'デバッガー', 'と共に', 'ラベル']
-        if (keywords.includes(value) || keywordsEN.includes(value) || keywordsES.includes(value) || keywordsRU.includes(value) || keywordsZH.includes(value) || keywordsJA.includes(value)) {
-            return { type: 'keyword', value }
-        }
-        return { type: 'identifier', value }
-    }
-
-    readOperator() {
-        const ops3 = ['===', '!==', '>>>', '**=', '&&=', '||=', '??=', '...']
-        const ops2 = ['==', '!=', '<=', '>=', '&&', '||', '??', '++', '--', '+=', '-=', '*=', '/=', '%=', '**', '=>', '->', '<<', '>>', '&=', '|=', '^=', '?.', '::']
-        
-        const three = this.input.substr(this.pos, 3)
-        if (ops3.includes(three)) {
-            this.pos += 3
-            return { type: 'operator', value: three }
-        }
-
-        const two = this.input.substr(this.pos, 2)
-        if (ops2.includes(two)) {
-            this.pos += 2
-            return { type: 'operator', value: two }
-        }
-
-        const char = this.input[this.pos]
-        this.pos++
-        return { type: 'operator', value: char }
-    }
-
-    parse(input) {
-        this.tokenize(input)
-        this.current = 0
-        this.keywordMap = this.buildKeywordMap()
-        const body = []
-
-        while (this.current < this.tokens.length) {
-            const stmt = this.parseStatement()
-            if (stmt) body.push(stmt)
-        }
-
-        return new AST.Program(body)
-    }
-
-    peek(offset = 0) {
-        return this.tokens[this.current + offset]
-    }
-
-    consume() {
-        return this.tokens[this.current++]
-    }
-
-    expect(type, value = null) {
-        const token = this.consume()
-        if (!token || token.type !== type || (value !== null && token.value !== value)) {
-            throw new Error(`Expected ${type}${value ? ` '${value}'` : ''}, got ${token ? `${token.type} '${token.value}'` : 'EOF'}`)
-        }
-        return token
-    }
-
-    match(type, value = null) {
-        const token = this.peek()
-        if (!token) return false
-        if (token.type !== type) return false
-        if (value !== null && token.value !== value) return false
-        return true
-    }
-
-    parseStatement() {
-        const token = this.peek()
-        if (!token) return null
-
-        if (token.type === 'keyword') {
-            switch (token.value) {
-                case 'charger':
-                case 'require':
-                    return this.parseRequire()
-                case 'importer':
-                case 'import':
-                    return this.parseImport()
-                case 'exporter':
-                case 'exporterES':
-                case 'export':
-                    return this.parseExport()
-                case 'si':
-                case 'if':
-                    return this.parseIfStatement()
-                case 'pour':
-                case 'for':
-                    return this.parseForStatement()
-                case 'tantque':
-                case 'while':
-                    return this.parseWhileStatement()
-                case 'faire':
-                case 'do':
-                    return this.parseDoWhileStatement()
-                case 'selon':
-                case 'switch':
-                    return this.parseSwitchStatement()
-                case 'essayer':
-                case 'try':
-                    return this.parseTryStatement()
-                case 'lancer':
-                case 'throw':
-                    return this.parseThrowStatement()
-                case 'retourner':
-                case 'return':
-                    return this.parseReturnStatement()
-                case 'sortir':
-                case 'break':
-                    this.consume()
-                    return new AST.BreakStatement()
-                case 'continuer':
-                case 'continue':
-                    this.consume()
-                    return new AST.ContinueStatement()
-                case 'debugger':
-                    this.consume()
-                    return new AST.DebuggerStatement()
-                case 'classe':
-                case 'class':
-                    return this.parseClassDeclaration()
-                case 'def':
-                case 'fonction':
-                case 'function':
-                    return this.parseFunctionDeclaration()
-                case 'asynchrone':
-                case 'async':
-                    return this.parseAsyncFunction()
-                case 'generateur':
-                case 'generator':
-                    return this.parseGeneratorFunction()
-                case 'const':
-                case 'soit':
-                case 'let':
-                    return this.parseVariableDeclaration()
-            }
-        }
-
-        if (token.type === 'identifier') {
-            const nodeValue = this.keywordMap[token.value.toLowerCase()]
-            if (nodeValue) {
-                return this.parseNodeAPICall(nodeValue)
-            }
-            
-            if (token.value === 'moduleExports' || token.value === 'exportarModulo') {
-                return this.parseModuleExports()
-            }
-        }
-
-        return this.parseExpressionStatement()
-    }
-
-    parseRequire() {
-        this.consume()
-        let variable = null
-        let destructuring = null
-
-        if (this.match('punctuation', '{')) {
-            destructuring = this.parseObjectPattern()
-        } else if (this.match('identifier')) {
-            variable = this.consume().value
-        }
-
-        if (this.match('keyword', 'depuis') || this.match('keyword', 'from')) {
-            this.consume()
-        }
-
-        const moduleToken = this.expect('string')
-        const module = moduleToken.value
-
-        if (destructuring) {
-            return new AST.RequireDestructuring(module, destructuring.properties)
-        }
-
-        return new AST.RequireStatement(module, variable)
-    }
-
-    parseImport() {
-        this.consume()
-        const specifiers = []
-        let source = null
-
-        if (this.match('punctuation', '*')) {
-            this.consume()
-            this.expect('keyword', 'comme') || this.expect('keyword', 'as')
-            const local = new AST.Identifier(this.expect('identifier').value)
-            specifiers.push(new AST.ImportNamespaceSpecifier(local))
-        } else if (this.match('punctuation', '{')) {
-            this.consume()
-            while (!this.match('punctuation', '}')) {
-                const imported = new AST.Identifier(this.expect('identifier').value)
-                let local = imported
-                if (this.match('keyword', 'comme') || this.match('keyword', 'as')) {
-                    this.consume()
-                    local = new AST.Identifier(this.expect('identifier').value)
-                }
-                specifiers.push(new AST.ImportSpecifier(imported, local))
-                if (this.match('punctuation', ',')) this.consume()
-            }
-            this.expect('punctuation', '}')
-        } else if (this.match('identifier')) {
-            const local = new AST.Identifier(this.consume().value)
-            specifiers.push(new AST.ImportDefaultSpecifier(local))
-            
-            if (this.match('punctuation', ',')) {
-                this.consume()
-                if (this.match('punctuation', '{')) {
-                    this.consume()
-                    while (!this.match('punctuation', '}')) {
-                        const imported = new AST.Identifier(this.expect('identifier').value)
-                        let localNamed = imported
-                        if (this.match('keyword', 'comme') || this.match('keyword', 'as')) {
-                            this.consume()
-                            localNamed = new AST.Identifier(this.expect('identifier').value)
-                        }
-                        specifiers.push(new AST.ImportSpecifier(imported, localNamed))
-                        if (this.match('punctuation', ',')) this.consume()
-                    }
-                    this.expect('punctuation', '}')
-                }
-            }
-        }
-
-        if (this.match('keyword', 'depuis') || this.match('keyword', 'from')) {
-            this.consume()
-        }
-
-        source = new AST.StringLiteral(this.expect('string').value)
-
-        return new AST.ImportDeclaration(specifiers, source)
-    }
-
-    parseExport() {
-        this.consume()
-
-        if (this.match('keyword', 'defaut') || this.match('keyword', 'default') ||
-            this.peek()?.value === 'exporterDefaut' || this.peek()?.value === 'exportDefault') {
-            if (this.match('keyword')) this.consume()
-            const declaration = this.parseExpression()
-            return new AST.ExportDefaultDeclaration(declaration)
-        }
-
-        if (this.match('punctuation', '{')) {
-            this.consume()
-            const specifiers = []
-            while (!this.match('punctuation', '}')) {
-                const local = new AST.Identifier(this.expect('identifier').value)
-                let exported = local
-                if (this.match('keyword', 'comme') || this.match('keyword', 'as')) {
-                    this.consume()
-                    exported = new AST.Identifier(this.expect('identifier').value)
-                }
-                specifiers.push(new AST.ExportSpecifier(local, exported))
-                if (this.match('punctuation', ',')) this.consume()
-            }
-            this.expect('punctuation', '}')
-            
-            let source = null
-            if (this.match('keyword', 'depuis') || this.match('keyword', 'from')) {
-                this.consume()
-                source = new AST.StringLiteral(this.expect('string').value)
-            }
-            return new AST.ExportNamedDeclaration(null, specifiers, source)
-        }
-
-        if (this.match('keyword', 'classe') || this.match('keyword', 'class')) {
-            const declaration = this.parseClassDeclaration()
-            return new AST.ExportNamedDeclaration(declaration)
-        }
-
-        if (this.match('keyword', 'def') || this.match('keyword', 'fonction') || this.match('keyword', 'function')) {
-            const declaration = this.parseFunctionDeclaration()
-            return new AST.ExportNamedDeclaration(declaration)
-        }
-
-        if (this.match('keyword', 'const') || this.match('keyword', 'soit') || this.match('keyword', 'let')) {
-            const declaration = this.parseVariableDeclaration()
-            return new AST.ExportNamedDeclaration(declaration)
-        }
-
-        return new AST.ExportNamedDeclaration(this.parseExpression())
-    }
-
-    parseModuleExports() {
-        this.consume()
-        this.expect('operator', '=')
-        const value = this.parseExpression()
-        return new AST.ModuleExports(value)
-    }
-
-    parseNodeAPICall(nodeValue) {
-        this.consume()
-
-        if (this.match('punctuation', ':')) {
-            this.consume()
-        }
-
-        const args = this.parseArguments()
-
-        switch (nodeValue) {
-            case 'fs.readFile':
-                return new AST.FSReadFile(args[0], args[1], args[2])
-            case 'fs.readFileSync':
-                return new AST.FSReadFileSync(args[0], args[1])
-            case 'fs.writeFile':
-                return new AST.FSWriteFile(args[0], args[1], args[2], args[3])
-            case 'fs.writeFileSync':
-                return new AST.FSWriteFileSync(args[0], args[1], args[2])
-            case 'fs.readdir':
-                return new AST.FSReadDir(args[0], args[1], args[2])
-            case 'fs.mkdir':
-                return new AST.FSMkdir(args[0], args[1], args[2])
-            case 'fs.unlink':
-                return new AST.FSUnlink(args[0], args[1])
-            case 'fs.rmdir':
-                return new AST.FSRmdir(args[0], args[1], args[2])
-            case 'fs.rm':
-                return new AST.FSRm(args[0], args[1], args[2])
-            case 'fs.rename':
-                return new AST.FSRename(args[0], args[1], args[2])
-            case 'fs.copyFile':
-                return new AST.FSCopyFile(args[0], args[1], args[2], args[3])
-            case 'fs.stat':
-                return new AST.FSStat(args[0], args[1], args[2])
-            case 'fs.existsSync':
-                return new AST.FSExists(args[0])
-            case 'fs.access':
-                return new AST.FSAccess(args[0], args[1], args[2])
-            case 'fs.appendFile':
-                return new AST.FSAppendFile(args[0], args[1], args[2], args[3])
-            case 'fs.createReadStream':
-                return new AST.FSCreateReadStream(args[0], args[1])
-            case 'fs.createWriteStream':
-                return new AST.FSCreateWriteStream(args[0], args[1])
-            case 'fs.watch':
-                return new AST.FSWatch(args[0], args[1], args[2])
-            case 'fs.watchFile':
-                return new AST.FSWatchFile(args[0], args[1], args[2])
-            case 'path.join':
-                return new AST.PathJoin(args)
-            case 'path.resolve':
-                return new AST.PathResolve(args)
-            case 'path.normalize':
-                return new AST.PathNormalize(args[0])
-            case 'path.dirname':
-                return new AST.PathDirname(args[0])
-            case 'path.basename':
-                return new AST.PathBasename(args[0], args[1])
-            case 'path.extname':
-                return new AST.PathExtname(args[0])
-            case 'path.parse':
-                return new AST.PathParse(args[0])
-            case 'path.format':
-                return new AST.PathFormat(args[0])
-            case 'path.isAbsolute':
-                return new AST.PathIsAbsolute(args[0])
-            case 'path.relative':
-                return new AST.PathRelative(args[0], args[1])
-            case 'http.createServer':
-                return new AST.HttpCreateServer(args[0])
-            case 'https.createServer':
-                return new AST.HttpsCreateServer(args[0], args[1])
-            case 'server.listen':
-                return new AST.ServerListen(args[0], args[1], args[2], args[3])
-            case 'server.close':
-                return new AST.ServerClose(args[0])
-            case 'http.request':
-                return new AST.HttpRequest(args[0], args[1])
-            case 'http.get':
-                return new AST.HttpGet(args[0], args[1], args[2])
-            case 'process.cwd':
-                return new AST.ProcessCwd()
-            case 'process.chdir':
-                return new AST.ProcessChdir(args[0])
-            case 'process.exit':
-                return new AST.ProcessExit(args[0])
-            case 'process.kill':
-                return new AST.ProcessKill(args[0], args[1])
-            case 'process.nextTick':
-                return new AST.ProcessNextTick(args[0], args.slice(1))
-            case 'process.memoryUsage':
-                return new AST.ProcessMemoryUsage()
-            case 'process.cpuUsage':
-                return new AST.ProcessCpuUsage(args[0])
-            case 'process.uptime':
-                return new AST.ProcessUptime()
-            case 'process.hrtime':
-                return new AST.ProcessHrtime(args[0])
-            case 'crypto.createHash':
-                return new AST.CryptoCreateHash(args[0], args[1])
-            case 'crypto.createHmac':
-                return new AST.CryptoCreateHmac(args[0], args[1], args[2])
-            case 'crypto.randomBytes':
-                return new AST.CryptoRandomBytes(args[0], args[1])
-            case 'crypto.randomUUID':
-                return new AST.CryptoRandomUUID(args[0])
-            case 'crypto.randomInt':
-                return new AST.CryptoRandomInt(args[0], args[1], args[2])
-            case 'crypto.pbkdf2':
-                return new AST.CryptoPbkdf2(args[0], args[1], args[2], args[3], args[4], args[5])
-            case 'crypto.pbkdf2Sync':
-                return new AST.CryptoPbkdf2Sync(args[0], args[1], args[2], args[3], args[4])
-            case 'crypto.scrypt':
-                return new AST.CryptoScrypt(args[0], args[1], args[2], args[3], args[4])
-            case 'crypto.scryptSync':
-                return new AST.CryptoScryptSync(args[0], args[1], args[2], args[3])
-            case 'Buffer.alloc':
-                return new AST.BufferAlloc(args[0], args[1], args[2])
-            case 'Buffer.allocUnsafe':
-                return new AST.BufferAllocUnsafe(args[0])
-            case 'Buffer.from':
-                return new AST.BufferFrom(args[0], args[1], args[2])
-            case 'Buffer.concat':
-                return new AST.BufferConcat(args[0], args[1])
-            case 'Buffer.compare':
-                return new AST.BufferCompare(args[0], args[1])
-            case 'Buffer.isBuffer':
-                return new AST.BufferIsBuffer(args[0])
-            case 'Buffer.byteLength':
-                return new AST.BufferByteLength(args[0], args[1])
-            case 'os.type':
-                return new AST.OsType()
-            case 'os.platform':
-                return new AST.OsPlatform()
-            case 'os.arch':
-                return new AST.OsArch()
-            case 'os.version':
-                return new AST.OsVersion()
-            case 'os.release':
-                return new AST.OsRelease()
-            case 'os.hostname':
-                return new AST.OsHostname()
-            case 'os.totalmem':
-                return new AST.OsTotalmem()
-            case 'os.freemem':
-                return new AST.OsFreemem()
-            case 'os.cpus':
-                return new AST.OsCpus()
-            case 'os.loadavg':
-                return new AST.OsLoadavg()
-            case 'os.userInfo':
-                return new AST.OsUserInfo(args[0])
-            case 'os.homedir':
-                return new AST.OsHomedir()
-            case 'os.tmpdir':
-                return new AST.OsTmpdir()
-            case 'os.networkInterfaces':
-                return new AST.OsNetworkInterfaces()
-            case 'os.uptime':
-                return new AST.OsUptime()
-            case 'child_process.spawn':
-                return new AST.ChildProcessSpawn(args[0], args[1], args[2])
-            case 'child_process.exec':
-                return new AST.ChildProcessExec(args[0], args[1], args[2])
-            case 'child_process.execFile':
-                return new AST.ChildProcessExecFile(args[0], args[1], args[2], args[3])
-            case 'child_process.fork':
-                return new AST.ChildProcessFork(args[0], args[1], args[2])
-            case 'child_process.spawnSync':
-                return new AST.ChildProcessSpawnSync(args[0], args[1], args[2])
-            case 'child_process.execSync':
-                return new AST.ChildProcessExecSync(args[0], args[1])
-            case 'child_process.execFileSync':
-                return new AST.ChildProcessExecFileSync(args[0], args[1], args[2])
-            case 'util.promisify':
-                return new AST.UtilPromisify(args[0])
-            case 'util.callbackify':
-                return new AST.UtilCallbackify(args[0])
-            case 'util.format':
-                return new AST.UtilFormat(args[0], args.slice(1))
-            case 'util.inspect':
-                return new AST.UtilInspect(args[0], args[1])
-            case 'util.deprecate':
-                return new AST.UtilDeprecate(args[0], args[1], args[2])
-            case 'dns.lookup':
-                return new AST.DnsLookup(args[0], args[1], args[2])
-            case 'dns.resolve':
-                return new AST.DnsResolve(args[0], args[1], args[2])
-            case 'dns.resolve4':
-                return new AST.DnsResolve4(args[0], args[1], args[2])
-            case 'dns.resolve6':
-                return new AST.DnsResolve6(args[0], args[1], args[2])
-            case 'dns.resolveMx':
-                return new AST.DnsResolveMx(args[0], args[1])
-            case 'dns.resolveTxt':
-                return new AST.DnsResolveTxt(args[0], args[1])
-            case 'dns.resolveNs':
-                return new AST.DnsResolveNs(args[0], args[1])
-            case 'dns.resolveCname':
-                return new AST.DnsResolveCname(args[0], args[1])
-            case 'dns.reverse':
-                return new AST.DnsReverse(args[0], args[1])
-            case 'setTimeout':
-                return new AST.SetTimeout(args[0], args[1], args.slice(2))
-            case 'clearTimeout':
-                return new AST.ClearTimeout(args[0])
-            case 'setInterval':
-                return new AST.SetInterval(args[0], args[1], args.slice(2))
-            case 'clearInterval':
-                return new AST.ClearInterval(args[0])
-            case 'setImmediate':
-                return new AST.SetImmediate(args[0], args.slice(1))
-            case 'clearImmediate':
-                return new AST.ClearImmediate(args[0])
-            case 'console.log':
-                return new AST.ConsoleLog(args)
-            case 'console.error':
-                return new AST.ConsoleError(args)
-            case 'console.warn':
-                return new AST.ConsoleWarn(args)
-            case 'console.info':
-                return new AST.ConsoleInfo(args)
-            case 'console.debug':
-                return new AST.ConsoleDebug(args)
-            case 'console.table':
-                return new AST.ConsoleTable(args[0], args[1])
-            case 'console.time':
-                return new AST.ConsoleTime(args[0])
-            case 'console.timeEnd':
-                return new AST.ConsoleTimeEnd(args[0])
-            case 'console.timeLog':
-                return new AST.ConsoleTimeLog(args[0], args.slice(1))
-            case 'console.trace':
-                return new AST.ConsoleTrace(args)
-            case 'console.clear':
-                return new AST.ConsoleClear()
-            case 'console.count':
-                return new AST.ConsoleCount(args[0])
-            case 'console.countReset':
-                return new AST.ConsoleCountReset(args[0])
-            case 'console.group':
-                return new AST.ConsoleGroup(args)
-            case 'console.groupEnd':
-                return new AST.ConsoleGroupEnd()
-            case 'console.groupCollapsed':
-                return new AST.ConsoleGroupCollapsed(args)
-            case 'console.assert':
-                return new AST.ConsoleAssert(args[0], args.slice(1))
-            case 'console.dir':
-                return new AST.ConsoleDir(args[0], args[1])
-            case '__dirname':
-                return new AST.Dirname()
-            case '__filename':
-                return new AST.Filename()
-            default:
-                return new AST.CallExpression(
-                    new AST.Identifier(nodeValue),
-                    args
-                )
-        }
-    }
-
-    parseArguments() {
-        const args = []
-        
-        if (this.match('punctuation', '(')) {
-            this.consume()
-            while (!this.match('punctuation', ')')) {
-                args.push(this.parseExpression())
-                if (this.match('punctuation', ',')) this.consume()
-            }
-            this.expect('punctuation', ')')
-        } else {
-            while (this.peek() && !this.isStatementEnd()) {
-                args.push(this.parseExpression())
-                if (this.match('punctuation', ',')) {
-                    this.consume()
-                } else {
-                    break
-                }
-            }
-        }
-
-        return args
-    }
-
-    isStatementEnd() {
-        const token = this.peek()
-        if (!token) return true
-        if (token.type === 'punctuation' && [';', '}', ')'].includes(token.value)) return true
-        if (token.type === 'keyword') return true
-        return false
-    }
-
-    parseIfStatement() {
-        this.consume()
-
-        if (this.match('punctuation', ':')) this.consume()
-
-        const test = this.parseExpression()
-        const consequent = this.parseBlock()
-        let alternate = null
-
-        if (this.match('keyword', 'sinonsi') || this.match('keyword', 'elseif')) {
-            alternate = this.parseIfStatement()
-        } else if (this.match('keyword', 'sinon') || this.match('keyword', 'else')) {
-            this.consume()
-            alternate = this.parseBlock()
-        }
-
-        return new AST.IfStatement(test, consequent, alternate)
-    }
-
-    parseForStatement() {
-        this.consume()
-
-        if (this.match('punctuation', ':')) this.consume()
-
-        const id = this.expect('identifier')
-        const left = new AST.Identifier(id.value)
-
-        if (this.match('keyword', 'dans') || this.match('keyword', 'in')) {
-            this.consume()
-            const right = this.parseExpression()
-            const body = this.parseBlock()
-            return new AST.ForInStatement(left, right, body)
-        }
-
-        if (this.match('keyword', 'de') || this.match('keyword', 'of')) {
-            this.consume()
-            const right = this.parseExpression()
-            const body = this.parseBlock()
-            return new AST.ForOfStatement(left, right, body)
-        }
-
-        this.expect('operator', '=')
-        const initValue = this.parseExpression()
-        const init = new AST.VariableDeclaration('let', [
-            new AST.VariableDeclarator(left, initValue)
-        ])
-
-        this.expect('punctuation', ';')
-        const test = this.parseExpression()
-        this.expect('punctuation', ';')
-        const update = this.parseExpression()
-        const body = this.parseBlock()
-
-        return new AST.ForStatement(init, test, update, body)
-    }
-
-    parseWhileStatement() {
-        this.consume()
-        if (this.match('punctuation', ':')) this.consume()
-        const test = this.parseExpression()
-        const body = this.parseBlock()
-        return new AST.WhileStatement(test, body)
-    }
-
-    parseDoWhileStatement() {
-        this.consume()
-        const body = this.parseBlock()
-        this.expect('keyword', 'tantque') || this.expect('keyword', 'while')
-        if (this.match('punctuation', ':')) this.consume()
-        const test = this.parseExpression()
-        return new AST.DoWhileStatement(body, test)
-    }
-
-    parseSwitchStatement() {
-        this.consume()
-        if (this.match('punctuation', ':')) this.consume()
-        const discriminant = this.parseExpression()
-        const cases = []
-
-        while (this.match('keyword', 'cas') || this.match('keyword', 'case') ||
-               this.match('keyword', 'defaut') || this.match('keyword', 'default')) {
-            const isDefault = this.peek().value === 'defaut' || this.peek().value === 'default'
-            this.consume()
-            
-            let test = null
-            if (!isDefault) {
-                if (this.match('punctuation', ':')) this.consume()
-                test = this.parseExpression()
-            }
-            
-            if (this.match('punctuation', ':')) this.consume()
-            
-            const consequent = []
-            while (this.peek() && 
-                   !this.match('keyword', 'cas') && !this.match('keyword', 'case') &&
-                   !this.match('keyword', 'defaut') && !this.match('keyword', 'default') &&
-                   !this.match('punctuation', '}')) {
-                const stmt = this.parseStatement()
-                if (stmt) consequent.push(stmt)
-            }
-
-            cases.push(new AST.SwitchCase(test, consequent))
-        }
-
-        return new AST.SwitchStatement(discriminant, cases)
-    }
-
-    parseTryStatement() {
-        this.consume()
-        const block = this.parseBlock()
-        let handler = null
-        let finalizer = null
-
-        if (this.match('keyword', 'saufsi') || this.match('keyword', 'catch')) {
-            this.consume()
-            let param = null
-            if (this.match('identifier')) {
-                param = new AST.Identifier(this.consume().value)
-            }
-            const handlerBody = this.parseBlock()
-            handler = new AST.CatchClause(param, handlerBody)
-        }
-
-        if (this.match('keyword', 'enfin') || this.match('keyword', 'finally')) {
-            this.consume()
-            finalizer = this.parseBlock()
-        }
-
-        return new AST.TryStatement(block, handler, finalizer)
-    }
-
-    parseThrowStatement() {
-        this.consume()
-        if (this.match('punctuation', ':')) this.consume()
-        const argument = this.parseExpression()
-        return new AST.ThrowStatement(argument)
-    }
-
-    parseReturnStatement() {
-        this.consume()
-        if (this.match('punctuation', ':')) this.consume()
-        
-        if (this.isStatementEnd()) {
-            return new AST.ReturnStatement(null)
-        }
-        
-        const argument = this.parseExpression()
-        return new AST.ReturnStatement(argument)
-    }
-
-    parseClassDeclaration() {
-        this.consume()
-        const id = new AST.Identifier(this.expect('identifier').value)
-        let superClass = null
-
-        if (this.match('keyword', 'herite') || this.match('keyword', 'extends')) {
-            this.consume()
-            superClass = new AST.Identifier(this.expect('identifier').value)
-        }
-
-        const body = this.parseClassBody()
-        return new AST.ClassDeclaration(id, superClass, body)
-    }
-
-    parseClassBody() {
-        const body = []
-        
-        while (this.peek() && !this.match('keyword') && !this.isStatementEnd()) {
-            const isStatic = this.match('keyword', 'statique') || this.match('keyword', 'static')
-            if (isStatic) this.consume()
-
-            if (this.match('keyword', 'def') || this.match('keyword', 'fonction') || this.match('keyword', 'function')) {
-                this.consume()
-                const key = new AST.Identifier(this.expect('identifier').value)
-                const params = this.parseParams()
-                const methodBody = this.parseBlock()
-                const value = new AST.FunctionExpression(null, params, methodBody)
-                
-                let kind = 'method'
-                if (key.name === 'initialiser' || key.name === 'constructor') {
-                    kind = 'constructor'
-                } else if (key.name.startsWith('obtenir') || key.name.startsWith('get')) {
-                    kind = 'get'
-                } else if (key.name.startsWith('definir') || key.name.startsWith('set')) {
-                    kind = 'set'
-                }
-
-                body.push(new AST.MethodDefinition(key, value, kind, false, isStatic))
-            } else if (this.match('identifier')) {
-                const key = new AST.Identifier(this.consume().value)
-                let value = null
-                if (this.match('operator', '=')) {
-                    this.consume()
-                    value = this.parseExpression()
-                }
-                body.push(new AST.PropertyDefinition(key, value, false, isStatic))
-            } else {
-                break
-            }
-        }
-
-        return new AST.ClassBody(body)
-    }
-
-    parseFunctionDeclaration() {
-        this.consume()
-        const id = new AST.Identifier(this.expect('identifier').value)
-        const params = this.parseParams()
-        const body = this.parseBlock()
-        return new AST.FunctionDeclaration(id, params, body)
-    }
-
-    parseAsyncFunction() {
-        this.consume()
-        
-        if (this.match('keyword', 'def') || this.match('keyword', 'fonction') || this.match('keyword', 'function')) {
-            this.consume()
-        }
-        
-        const id = new AST.Identifier(this.expect('identifier').value)
-        const params = this.parseParams()
-        const body = this.parseBlock()
-        return new AST.FunctionDeclaration(id, params, body, true)
-    }
-
-    parseGeneratorFunction() {
-        this.consume()
-        
-        if (this.match('keyword', 'def') || this.match('keyword', 'fonction') || this.match('keyword', 'function')) {
-            this.consume()
-        }
-        
-        const id = new AST.Identifier(this.expect('identifier').value)
-        const params = this.parseParams()
-        const body = this.parseBlock()
-        return new AST.FunctionDeclaration(id, params, body, false, true)
-    }
-
-    parseParams() {
-        const params = []
-        
-        if (this.match('punctuation', '(')) {
-            this.consume()
-            while (!this.match('punctuation', ')')) {
-                if (this.match('operator', '...')) {
-                    this.consume()
-                    const arg = new AST.Identifier(this.expect('identifier').value)
-                    params.push(new AST.RestElement(arg))
-                } else {
-                    const param = new AST.Identifier(this.expect('identifier').value)
-                    if (this.match('operator', '=')) {
-                        this.consume()
-                        const defaultValue = this.parseExpression()
-                        params.push(new AST.AssignmentPattern(param, defaultValue))
-                    } else {
-                        params.push(param)
-                    }
-                }
-                if (this.match('punctuation', ',')) this.consume()
-            }
-            this.expect('punctuation', ')')
-        } else if (this.match('punctuation', ':')) {
-            this.consume()
-            while (this.match('identifier')) {
-                const param = new AST.Identifier(this.consume().value)
-                if (this.match('operator', '=')) {
-                    this.consume()
-                    const defaultValue = this.parseExpression()
-                    params.push(new AST.AssignmentPattern(param, defaultValue))
-                } else {
-                    params.push(param)
-                }
-                if (this.match('punctuation', ',')) this.consume()
-            }
-        }
-
-        return params
-    }
-
-    parseBlock() {
-        const body = []
-        const startIndent = this.getIndentLevel()
-
-        while (this.peek()) {
-            const currentIndent = this.getIndentLevel()
-            if (currentIndent <= startIndent && body.length > 0) break
-            
-            const stmt = this.parseStatement()
-            if (stmt) body.push(stmt)
-            else break
-        }
-
-        return new AST.BlockStatement(body)
-    }
-
-    getIndentLevel() {
-        return 0
-    }
-
-    parseVariableDeclaration() {
-        const kindToken = this.consume()
-        const kind = kindToken.value === 'const' ? 'const' : 'let'
-        const declarations = []
-
-        do {
-            let id
-            if (this.match('punctuation', '{')) {
-                id = this.parseObjectPattern()
-            } else if (this.match('punctuation', '[')) {
-                id = this.parseArrayPattern()
-            } else {
-                id = new AST.Identifier(this.expect('identifier').value)
-            }
-
-            let init = null
-            if (this.match('operator', '=')) {
-                this.consume()
-                init = this.parseExpression()
-            }
-
-            declarations.push(new AST.VariableDeclarator(id, init))
-        } while (this.match('punctuation', ',') && this.consume())
-
-        return new AST.VariableDeclaration(kind, declarations)
-    }
-
-    parseObjectPattern() {
-        this.expect('punctuation', '{')
-        const properties = []
-
-        while (!this.match('punctuation', '}')) {
-            const key = new AST.Identifier(this.expect('identifier').value)
-            let value = key
-            
-            if (this.match('punctuation', ':')) {
-                this.consume()
-                value = new AST.Identifier(this.expect('identifier').value)
-            }
-
-            let defaultValue = null
-            if (this.match('operator', '=')) {
-                this.consume()
-                defaultValue = this.parseExpression()
-                value = new AST.AssignmentPattern(value, defaultValue)
-            }
-
-            properties.push(new AST.Property(key, value, key === value))
-            if (this.match('punctuation', ',')) this.consume()
-        }
-
-        this.expect('punctuation', '}')
-        return new AST.ObjectPattern(properties)
-    }
-
-    parseArrayPattern() {
-        this.expect('punctuation', '[')
-        const elements = []
-
-        while (!this.match('punctuation', ']')) {
-            if (this.match('punctuation', ',')) {
-                elements.push(null)
-                this.consume()
-                continue
-            }
-
-            if (this.match('operator', '...')) {
-                this.consume()
-                const arg = new AST.Identifier(this.expect('identifier').value)
-                elements.push(new AST.RestElement(arg))
-            } else {
-                let element = new AST.Identifier(this.expect('identifier').value)
-                if (this.match('operator', '=')) {
-                    this.consume()
-                    const defaultValue = this.parseExpression()
-                    element = new AST.AssignmentPattern(element, defaultValue)
-                }
-                elements.push(element)
-            }
-
-            if (this.match('punctuation', ',')) this.consume()
-        }
-
-        this.expect('punctuation', ']')
-        return new AST.ArrayPattern(elements)
-    }
-
-    parseExpressionStatement() {
-        const expr = this.parseExpression()
-        return new AST.ExpressionStatement(expr)
-    }
-
-    parseExpression() {
-        return this.parseAssignment()
-    }
-
-    parseAssignment() {
-        const left = this.parseTernary()
-
-        if (this.match('operator', '=') || this.match('operator', '+=') || 
-            this.match('operator', '-=') || this.match('operator', '*=') ||
-            this.match('operator', '/=') || this.match('operator', '%=') ||
-            this.match('operator', '**=') || this.match('operator', '&&=') ||
-            this.match('operator', '||=') || this.match('operator', '??=')) {
-            const op = this.consume().value
-            const right = this.parseAssignment()
-            return new AST.AssignmentExpression(op, left, right)
-        }
-
-        return left
-    }
-
-    parseTernary() {
-        const test = this.parseLogicalOr()
-
-        if (this.match('operator', '?')) {
-            this.consume()
-            const consequent = this.parseExpression()
-            this.expect('punctuation', ':')
-            const alternate = this.parseExpression()
-            return new AST.ConditionalExpression(test, consequent, alternate)
-        }
-
-        return test
-    }
-
-    parseLogicalOr() {
-        let left = this.parseLogicalAnd()
-
-        while (this.match('operator', '||') || this.match('operator', '??')) {
-            const op = this.consume().value
-            const right = this.parseLogicalAnd()
-            left = new AST.LogicalExpression(op, left, right)
-        }
-
-        return left
-    }
-
-    parseLogicalAnd() {
-        let left = this.parseBitwiseOr()
-
-        while (this.match('operator', '&&')) {
-            this.consume()
-            const right = this.parseBitwiseOr()
-            left = new AST.LogicalExpression('&&', left, right)
-        }
-
-        return left
-    }
-
-    parseBitwiseOr() {
-        let left = this.parseBitwiseXor()
-
-        while (this.match('operator', '|') && !this.match('operator', '||')) {
-            this.consume()
-            const right = this.parseBitwiseXor()
-            left = new AST.BinaryExpression('|', left, right)
-        }
-
-        return left
-    }
-
-    parseBitwiseXor() {
-        let left = this.parseBitwiseAnd()
-
-        while (this.match('operator', '^')) {
-            this.consume()
-            const right = this.parseBitwiseAnd()
-            left = new AST.BinaryExpression('^', left, right)
-        }
-
-        return left
-    }
-
-    parseBitwiseAnd() {
-        let left = this.parseEquality()
-
-        while (this.match('operator', '&') && !this.match('operator', '&&')) {
-            this.consume()
-            const right = this.parseEquality()
-            left = new AST.BinaryExpression('&', left, right)
-        }
-
-        return left
-    }
-
-    parseEquality() {
-        let left = this.parseComparison()
-
-        while (this.match('operator', '==') || this.match('operator', '!=') ||
-               this.match('operator', '===') || this.match('operator', '!==')) {
-            const op = this.consume().value
-            const right = this.parseComparison()
-            left = new AST.BinaryExpression(op, left, right)
-        }
-
-        return left
-    }
-
-    parseComparison() {
-        let left = this.parseShift()
-
-        while (this.match('operator', '<') || this.match('operator', '>') ||
-               this.match('operator', '<=') || this.match('operator', '>=')) {
-            const op = this.consume().value
-            const right = this.parseShift()
-            left = new AST.BinaryExpression(op, left, right)
-        }
-
-        return left
-    }
-
-    parseShift() {
-        let left = this.parseAdditive()
-
-        while (this.match('operator', '<<') || this.match('operator', '>>') ||
-               this.match('operator', '>>>')) {
-            const op = this.consume().value
-            const right = this.parseAdditive()
-            left = new AST.BinaryExpression(op, left, right)
-        }
-
-        return left
-    }
-
-    parseAdditive() {
-        let left = this.parseMultiplicative()
-
-        while (this.match('operator', '+') || this.match('operator', '-')) {
-            const op = this.consume().value
-            const right = this.parseMultiplicative()
-            left = new AST.BinaryExpression(op, left, right)
-        }
-
-        return left
-    }
-
-    parseMultiplicative() {
-        let left = this.parseExponentiation()
-
-        while (this.match('operator', '*') || this.match('operator', '/') ||
-               this.match('operator', '%')) {
-            const op = this.consume().value
-            const right = this.parseExponentiation()
-            left = new AST.BinaryExpression(op, left, right)
-        }
-
-        return left
-    }
-
-    parseExponentiation() {
-        let left = this.parseUnary()
-
-        if (this.match('operator', '**')) {
-            this.consume()
-            const right = this.parseExponentiation()
-            left = new AST.BinaryExpression('**', left, right)
-        }
-
-        return left
-    }
-
-    parseUnary() {
-        if (this.match('operator', '!') || this.match('operator', '-') ||
-            this.match('operator', '+') || this.match('operator', '~') ||
-            this.match('operator', '...')) {
-            const op = this.consume().value
-            if (op === '...') {
-                const argument = this.parseUnary()
-                return new AST.SpreadElement(argument)
-            }
-            const argument = this.parseUnary()
-            return new AST.UnaryExpression(op, argument)
-        }
-
-        if (this.match('keyword', 'attendre') || this.match('keyword', 'await')) {
-            this.consume()
-            const argument = this.parseUnary()
-            return new AST.AwaitExpression(argument)
-        }
-
-        if (this.match('keyword', 'produire') || this.match('keyword', 'yield')) {
-            this.consume()
-            let delegate = false
-            if (this.match('operator', '*')) {
-                this.consume()
-                delegate = true
-            }
-            const argument = this.parseUnary()
-            return new AST.YieldExpression(argument, delegate)
-        }
-
-        if (this.match('operator', '++') || this.match('operator', '--')) {
-            const op = this.consume().value
-            const argument = this.parseUnary()
-            return new AST.UpdateExpression(op, argument, true)
-        }
-
-        return this.parseUpdate()
-    }
-
-    parseUpdate() {
-        const argument = this.parseCall()
-
-        if (this.match('operator', '++') || this.match('operator', '--')) {
-            const op = this.consume().value
-            return new AST.UpdateExpression(op, argument, false)
-        }
-
-        return argument
-    }
-
-    parseCall() {
-        let callee = this.parseMember()
-
-        while (true) {
-            if (this.match('punctuation', '(')) {
-                this.consume()
-                const args = []
-                while (!this.match('punctuation', ')')) {
-                    args.push(this.parseExpression())
-                    if (this.match('punctuation', ',')) this.consume()
-                }
-                this.expect('punctuation', ')')
-                callee = new AST.CallExpression(callee, args)
-            } else if (this.match('punctuation', ':') && 
-                       this.peek(1) && 
-                       (this.peek(1).type === 'string' || this.peek(1).type === 'number' || this.peek(1).type === 'identifier')) {
-                this.consume()
-                const args = this.parseArguments()
-                callee = new AST.CallExpression(callee, args)
-            } else if (this.match('operator', '?.')) {
-                this.consume()
-                if (this.match('punctuation', '(')) {
-                    this.consume()
-                    const args = []
-                    while (!this.match('punctuation', ')')) {
-                        args.push(this.parseExpression())
-                        if (this.match('punctuation', ',')) this.consume()
-                    }
-                    this.expect('punctuation', ')')
-                    callee = new AST.CallExpression(callee, args, true)
-                } else {
-                    const property = new AST.Identifier(this.expect('identifier').value)
-                    callee = new AST.MemberExpression(callee, property, false, true)
-                }
-            } else {
-                break
-            }
-        }
-
-        return callee
-    }
-
-    parseMember() {
-        let object = this.parsePrimary()
-
-        while (true) {
-            if (this.match('punctuation', '.')) {
-                this.consume()
-                const property = new AST.Identifier(this.expect('identifier').value)
-                object = new AST.MemberExpression(object, property)
-            } else if (this.match('punctuation', '[')) {
-                this.consume()
-                const property = this.parseExpression()
-                this.expect('punctuation', ']')
-                object = new AST.MemberExpression(object, property, true)
-            } else {
-                break
-            }
-        }
-
-        return object
-    }
-
-    parsePrimary() {
-        const token = this.peek()
-        if (!token) return null
-
-        if (token.type === 'number') {
-            this.consume()
-            return new AST.NumericLiteral(token.value, token.raw)
-        }
-
-        if (token.type === 'bigint') {
-            this.consume()
-            return new AST.BigIntLiteral(token.value, token.raw)
-        }
-
-        if (token.type === 'string') {
-            this.consume()
-            return new AST.StringLiteral(token.value, token.raw)
-        }
-
-        if (token.type === 'template') {
-            return this.parseTemplateLiteral()
-        }
-
-        if (token.type === 'keyword') {
-            if (token.value === 'vrai' || token.value === 'true') {
-                this.consume()
-                return new AST.BooleanLiteral(true)
-            }
-            if (token.value === 'faux' || token.value === 'false') {
-                this.consume()
-                return new AST.BooleanLiteral(false)
-            }
-            if (token.value === 'nul' || token.value === 'null') {
-                this.consume()
-                return new AST.NullLiteral()
-            }
-            if (token.value === 'indefini' || token.value === 'undefined') {
-                this.consume()
-                return new AST.UndefinedLiteral()
-            }
-            if (token.value === 'soi' || token.value === 'this') {
-                this.consume()
-                return new AST.ThisExpression()
-            }
-            if (token.value === 'super') {
-                this.consume()
-                return new AST.Super()
-            }
-            if (token.value === 'nouveau' || token.value === 'new') {
-                return this.parseNewExpression()
-            }
-        }
-
-        if (token.type === 'identifier') {
-            const nodeValue = this.keywordMap[token.value.toLowerCase()]
-            if (nodeValue) {
-                return this.parseNodeAPICall(nodeValue)
-            }
-            this.consume()
-            return new AST.Identifier(token.value)
-        }
-
-        if (this.match('punctuation', '(')) {
-            this.consume()
-            
-            if (this.match('punctuation', ')') || this.isArrowParams()) {
-                return this.parseArrowFunction()
-            }
-            
-            const expr = this.parseExpression()
-            this.expect('punctuation', ')')
-            return expr
-        }
-
-        if (this.match('punctuation', '[')) {
-            return this.parseArrayExpression()
-        }
-
-        if (this.match('punctuation', '{')) {
-            return this.parseObjectExpression()
-        }
-
-        if (this.match('operator', '->') || this.match('operator', '=>')) {
-            return this.parseArrowFunction()
-        }
-
-        this.consume()
-        return new AST.Identifier(token.value || '')
-    }
-
-    isArrowParams() {
-        let depth = 1
-        let pos = this.current
-        while (depth > 0 && pos < this.tokens.length) {
-            const t = this.tokens[pos]
-            if (t.value === '(') depth++
-            if (t.value === ')') depth--
-            pos++
-        }
-        const next = this.tokens[pos]
-        return next && (next.value === '->' || next.value === '=>')
-    }
-
-    parseArrowFunction() {
-        const params = []
-        
-        if (this.match('punctuation', '(')) {
-            while (!this.match('punctuation', ')')) {
-                if (this.match('operator', '...')) {
-                    this.consume()
-                    const arg = new AST.Identifier(this.expect('identifier').value)
-                    params.push(new AST.RestElement(arg))
-                } else if (this.match('identifier')) {
-                    const param = new AST.Identifier(this.consume().value)
-                    if (this.match('operator', '=')) {
-                        this.consume()
-                        const defaultValue = this.parseExpression()
-                        params.push(new AST.AssignmentPattern(param, defaultValue))
-                    } else {
-                        params.push(param)
-                    }
-                }
-                if (this.match('punctuation', ',')) this.consume()
-            }
-            if (this.match('punctuation', ')')) this.consume()
-        }
-
-        if (this.match('operator', '->') || this.match('operator', '=>')) {
-            this.consume()
-        }
-
-        let body
-        let expression = false
-        
-        if (this.match('punctuation', '{')) {
-            body = this.parseBlock()
-        } else {
-            body = this.parseExpression()
-            expression = true
-        }
-
-        return new AST.ArrowFunctionExpression(params, body, false, expression)
-    }
-
-    parseNewExpression() {
-        this.consume()
-        const callee = this.parseMember()
-        let args = []
-        
-        if (this.match('punctuation', '(')) {
-            this.consume()
-            while (!this.match('punctuation', ')')) {
-                args.push(this.parseExpression())
-                if (this.match('punctuation', ',')) this.consume()
-            }
-            this.expect('punctuation', ')')
-        } else if (this.match('punctuation', ':')) {
-            this.consume()
-            args = this.parseArguments()
-        }
-
-        return new AST.NewExpression(callee, args)
-    }
-
-    parseArrayExpression() {
-        this.expect('punctuation', '[')
-        const elements = []
-
-        while (!this.match('punctuation', ']')) {
-            if (this.match('punctuation', ',')) {
-                elements.push(null)
-                this.consume()
-                continue
-            }
-            elements.push(this.parseExpression())
-            if (this.match('punctuation', ',')) this.consume()
-        }
-
-        this.expect('punctuation', ']')
-        return new AST.ArrayExpression(elements)
-    }
-
-    parseObjectExpression() {
-        this.expect('punctuation', '{')
-        const properties = []
-
-        while (!this.match('punctuation', '}')) {
-            if (this.match('operator', '...')) {
-                this.consume()
-                const arg = this.parseExpression()
-                properties.push(new AST.SpreadElement(arg))
-            } else {
-                let computed = false
-                let key
-                
-                if (this.match('punctuation', '[')) {
-                    computed = true
-                    this.consume()
-                    key = this.parseExpression()
-                    this.expect('punctuation', ']')
-                } else if (this.match('string')) {
-                    key = new AST.StringLiteral(this.consume().value)
-                } else if (this.match('number')) {
-                    key = new AST.NumericLiteral(this.consume().value)
-                } else {
-                    key = new AST.Identifier(this.expect('identifier').value)
-                }
-
-                let value = key
-                let shorthand = true
-
-                if (this.match('punctuation', ':')) {
-                    this.consume()
-                    value = this.parseExpression()
-                    shorthand = false
-                } else if (this.match('punctuation', '(') || this.match('operator', '->') || this.match('operator', '=>')) {
-                    const params = this.parseParams()
-                    if (this.match('operator', '->') || this.match('operator', '=>')) this.consume()
-                    const body = this.parseBlock()
-                    value = new AST.FunctionExpression(null, params, body)
-                    shorthand = false
-                }
-
-                properties.push(new AST.Property(key, value, shorthand, computed))
-            }
-
-            if (this.match('punctuation', ',')) this.consume()
-        }
-
-        this.expect('punctuation', '}')
-        return new AST.ObjectExpression(properties)
-    }
-
-    parseTemplateLiteral() {
-        const token = this.consume()
-        const quasis = []
-        const expressions = []
-
-        if (token.expressions && token.expressions.length > 0) {
-            let lastEnd = 0
-            token.expressions.forEach((expr, i) => {
-                quasis.push(new AST.TemplateElement({ raw: expr.quasi, cooked: expr.quasi }, false))
-                const exprParser = new NodeParser(this.i18n)
-                const parsed = exprParser.parse(expr.expression)
-                if (parsed.body.length > 0 && parsed.body[0].expression) {
-                    expressions.push(parsed.body[0].expression)
-                }
-            })
-            quasis.push(new AST.TemplateElement({ raw: token.value, cooked: token.value }, true))
-        } else {
-            quasis.push(new AST.TemplateElement({ raw: token.value, cooked: token.value }, true))
-        }
-
-        return new AST.TemplateLiteral(quasis, expressions)
-    }
-}
-
-class NodeCodeGenerator {
-    constructor() {
-        this.indent = 0
-        this.indentStr = '    '
-    }
-
-    generate(node) {
-        if (!node) return ''
-        const method = `generate${node.type}`
-        if (this[method]) {
-            return this[method](node)
-        }
-        return ''
-    }
-
-    getIndent() {
-        return this.indentStr.repeat(this.indent)
-    }
-
-    generateProgram(node) {
-        return node.body.map(stmt => this.generate(stmt)).join('\n')
-    }
-
-    generateRequireStatement(node) {
-        if (node.variable) {
-            return `const ${node.variable} = require("${node.module}");`
-        }
-        return `require("${node.module}");`
-    }
-
-    generateRequireDestructuring(node) {
-        const props = node.properties.map(p => {
-            if (p.shorthand) return p.key.name
-            return `${p.key.name}: ${this.generate(p.value)}`
-        }).join(', ')
-        return `const { ${props} } = require("${node.module}");`
-    }
-
-    generateImportDeclaration(node) {
-        const specifiers = node.specifiers.map(s => this.generate(s)).join(', ')
-        return `import ${specifiers} from ${this.generate(node.source)};`
-    }
-
-    generateImportDefaultSpecifier(node) {
-        return this.generate(node.local)
-    }
-
-    generateImportSpecifier(node) {
-        if (node.imported.name === node.local.name) {
-            return node.imported.name
-        }
-        return `${node.imported.name} as ${node.local.name}`
-    }
-
-    generateImportNamespaceSpecifier(node) {
-        return `* as ${this.generate(node.local)}`
-    }
-
-    generateExportNamedDeclaration(node) {
-        if (node.declaration) {
-            return `export ${this.generate(node.declaration)}`
-        }
-        const specifiers = node.specifiers.map(s => this.generate(s)).join(', ')
-        let code = `export { ${specifiers} }`
-        if (node.source) {
-            code += ` from ${this.generate(node.source)}`
-        }
-        return code + ';'
-    }
-
-    generateExportDefaultDeclaration(node) {
-        return `export default ${this.generate(node.declaration)};`
-    }
-
-    generateExportSpecifier(node) {
-        if (node.local.name === node.exported.name) {
-            return node.local.name
-        }
-        return `${node.local.name} as ${node.exported.name}`
-    }
-
-    generateModuleExports(node) {
-        return `module.exports = ${this.generate(node.value)};`
-    }
-
-    generateVariableDeclaration(node) {
-        const declarations = node.declarations.map(d => this.generate(d)).join(', ')
-        return `${node.kind} ${declarations};`
-    }
-
-    generateVariableDeclarator(node) {
-        if (node.init) {
-            return `${this.generate(node.id)} = ${this.generate(node.init)}`
-        }
-        return this.generate(node.id)
-    }
-
-    generateFunctionDeclaration(node) {
-        const async = node.async ? 'async ' : ''
-        const generator = node.generator ? '*' : ''
-        const params = node.params.map(p => this.generate(p)).join(', ')
-        const body = this.generate(node.body)
-        return `${async}function${generator} ${this.generate(node.id)}(${params}) ${body}`
-    }
-
-    generateFunctionExpression(node) {
-        const async = node.async ? 'async ' : ''
-        const generator = node.generator ? '*' : ''
-        const id = node.id ? ` ${this.generate(node.id)}` : ''
-        const params = node.params.map(p => this.generate(p)).join(', ')
-        const body = this.generate(node.body)
-        return `${async}function${generator}${id}(${params}) ${body}`
-    }
-
-    generateArrowFunctionExpression(node) {
-        const async = node.async ? 'async ' : ''
-        const params = node.params.length === 1 && node.params[0].type === 'Identifier'
-            ? this.generate(node.params[0])
-            : `(${node.params.map(p => this.generate(p)).join(', ')})`
-        const body = node.expression ? this.generate(node.body) : this.generate(node.body)
-        return `${async}${params} => ${body}`
-    }
-
-    generateBlockStatement(node) {
-        this.indent++
-        const body = node.body.map(stmt => this.getIndent() + this.generate(stmt)).join('\n')
-        this.indent--
-        return `{\n${body}\n${this.getIndent()}}`
-    }
-
-    generateReturnStatement(node) {
-        if (node.argument) {
-            return `return ${this.generate(node.argument)};`
-        }
-        return 'return;'
-    }
-
-    generateIfStatement(node) {
-        let code = `if (${this.generate(node.test)}) ${this.generate(node.consequent)}`
-        if (node.alternate) {
-            if (node.alternate.type === 'IfStatement') {
-                code += ` else ${this.generate(node.alternate)}`
-            } else {
-                code += ` else ${this.generate(node.alternate)}`
-            }
-        }
-        return code
-    }
-
-    generateForStatement(node) {
-        const init = node.init ? this.generate(node.init).replace(/;$/, '') : ''
-        const test = node.test ? this.generate(node.test) : ''
-        const update = node.update ? this.generate(node.update) : ''
-        return `for (${init}; ${test}; ${update}) ${this.generate(node.body)}`
-    }
-
-    generateForInStatement(node) {
-        return `for (${this.generate(node.left)} in ${this.generate(node.right)}) ${this.generate(node.body)}`
-    }
-
-    generateForOfStatement(node) {
-        const await_ = node.await ? 'await ' : ''
-        return `for ${await_}(${this.generate(node.left)} of ${this.generate(node.right)}) ${this.generate(node.body)}`
-    }
-
-    generateWhileStatement(node) {
-        return `while (${this.generate(node.test)}) ${this.generate(node.body)}`
-    }
-
-    generateDoWhileStatement(node) {
-        return `do ${this.generate(node.body)} while (${this.generate(node.test)});`
-    }
-
-    generateSwitchStatement(node) {
-        this.indent++
-        const cases = node.cases.map(c => this.getIndent() + this.generate(c)).join('\n')
-        this.indent--
-        return `switch (${this.generate(node.discriminant)}) {\n${cases}\n${this.getIndent()}}`
-    }
-
-    generateSwitchCase(node) {
-        const test = node.test ? `case ${this.generate(node.test)}:` : 'default:'
-        this.indent++
-        const consequent = node.consequent.map(s => this.getIndent() + this.generate(s)).join('\n')
-        this.indent--
-        return `${test}\n${consequent}`
-    }
-
-    generateTryStatement(node) {
-        let code = `try ${this.generate(node.block)}`
-        if (node.handler) {
-            code += ` ${this.generate(node.handler)}`
-        }
-        if (node.finalizer) {
-            code += ` finally ${this.generate(node.finalizer)}`
-        }
-        return code
-    }
-
-    generateCatchClause(node) {
-        const param = node.param ? `(${this.generate(node.param)})` : ''
-        return `catch ${param} ${this.generate(node.body)}`
-    }
-
-    generateThrowStatement(node) {
-        return `throw ${this.generate(node.argument)};`
-    }
-
-    generateBreakStatement(node) {
-        return node.label ? `break ${this.generate(node.label)};` : 'break;'
-    }
-
-    generateContinueStatement(node) {
-        return node.label ? `continue ${this.generate(node.label)};` : 'continue;'
-    }
-
-    generateDebuggerStatement() {
-        return 'debugger;'
-    }
-
-    generateClassDeclaration(node) {
-        const extend = node.superClass ? ` extends ${this.generate(node.superClass)}` : ''
-        return `class ${this.generate(node.id)}${extend} ${this.generate(node.body)}`
-    }
-
-    generateClassBody(node) {
-        this.indent++
-        const body = node.body.map(m => this.getIndent() + this.generate(m)).join('\n\n')
-        this.indent--
-        return `{\n${body}\n${this.getIndent()}}`
-    }
-
-    generateMethodDefinition(node) {
-        const static_ = node.static ? 'static ' : ''
-        const kind = node.kind === 'get' ? 'get ' : node.kind === 'set' ? 'set ' : ''
-        const key = this.generate(node.key)
-        const value = this.generate(node.value)
-        const params = node.value.params.map(p => this.generate(p)).join(', ')
-        const body = this.generate(node.value.body)
-        
-        if (node.kind === 'constructor') {
-            return `constructor(${params}) ${body}`
-        }
-        
-        return `${static_}${kind}${key}(${params}) ${body}`
-    }
-
-    generatePropertyDefinition(node) {
-        const static_ = node.static ? 'static ' : ''
-        const key = this.generate(node.key)
-        if (node.value) {
-            return `${static_}${key} = ${this.generate(node.value)};`
-        }
-        return `${static_}${key};`
-    }
-
-    generateExpressionStatement(node) {
-        return this.generate(node.expression) + ';'
-    }
-
-    generateCallExpression(node) {
-        const callee = this.generate(node.callee)
-        const args = node.arguments.map(a => this.generate(a)).join(', ')
-        const optional = node.optional ? '?.' : ''
-        return `${callee}${optional}(${args})`
-    }
-
-    generateNewExpression(node) {
-        const callee = this.generate(node.callee)
-        const args = node.arguments.map(a => this.generate(a)).join(', ')
-        return `new ${callee}(${args})`
-    }
-
-    generateMemberExpression(node) {
-        const object = this.generate(node.object)
-        const property = this.generate(node.property)
-        const optional = node.optional ? '?.' : ''
-        if (node.computed) {
-            return `${object}${optional}[${property}]`
-        }
-        return `${object}${optional}.${property}`
-    }
-
-    generateBinaryExpression(node) {
-        return `${this.generate(node.left)} ${node.operator} ${this.generate(node.right)}`
-    }
-
-    generateUnaryExpression(node) {
-        if (node.prefix) {
-            return `${node.operator}${this.generate(node.argument)}`
-        }
-        return `${this.generate(node.argument)}${node.operator}`
-    }
-
-    generateUpdateExpression(node) {
-        if (node.prefix) {
-            return `${node.operator}${this.generate(node.argument)}`
-        }
-        return `${this.generate(node.argument)}${node.operator}`
-    }
-
-    generateLogicalExpression(node) {
-        return `${this.generate(node.left)} ${node.operator} ${this.generate(node.right)}`
-    }
-
-    generateConditionalExpression(node) {
-        return `${this.generate(node.test)} ? ${this.generate(node.consequent)} : ${this.generate(node.alternate)}`
-    }
-
-    generateAssignmentExpression(node) {
-        return `${this.generate(node.left)} ${node.operator} ${this.generate(node.right)}`
-    }
-
-    generateSequenceExpression(node) {
-        return node.expressions.map(e => this.generate(e)).join(', ')
-    }
-
-    generateAwaitExpression(node) {
-        return `await ${this.generate(node.argument)}`
-    }
-
-    generateYieldExpression(node) {
-        const delegate = node.delegate ? '*' : ''
-        if (node.argument) {
-            return `yield${delegate} ${this.generate(node.argument)}`
-        }
-        return `yield${delegate}`
-    }
-
-    generateThisExpression() {
-        return 'this'
-    }
-
-    generateSuper() {
-        return 'super'
-    }
-
-    generateIdentifier(node) {
-        return node.name
-    }
-
-    generateStringLiteral(node) {
-        return `"${node.value}"`
-    }
-
-    generateNumericLiteral(node) {
-        return String(node.value)
-    }
-
-    generateBooleanLiteral(node) {
-        return String(node.value)
-    }
-
-    generateNullLiteral() {
-        return 'null'
-    }
-
-    generateUndefinedLiteral() {
-        return 'undefined'
-    }
-
-    generateArrayExpression(node) {
-        const elements = node.elements.map(e => e ? this.generate(e) : '').join(', ')
-        return `[${elements}]`
-    }
-
-    generateObjectExpression(node) {
-        if (node.properties.length === 0) return '{}'
-        const props = node.properties.map(p => this.generate(p)).join(', ')
-        return `{ ${props} }`
-    }
-
-    generateProperty(node) {
-        if (node.shorthand) {
-            return this.generate(node.key)
-        }
-        const key = node.computed ? `[${this.generate(node.key)}]` : this.generate(node.key)
-        return `${key}: ${this.generate(node.value)}`
-    }
-
-    generateSpreadElement(node) {
-        return `...${this.generate(node.argument)}`
-    }
-
-    generateRestElement(node) {
-        return `...${this.generate(node.argument)}`
-    }
-
-    generateAssignmentPattern(node) {
-        return `${this.generate(node.left)} = ${this.generate(node.right)}`
-    }
-
-    generateArrayPattern(node) {
-        const elements = node.elements.map(e => e ? this.generate(e) : '').join(', ')
-        return `[${elements}]`
-    }
-
-    generateObjectPattern(node) {
-        const props = node.properties.map(p => this.generate(p)).join(', ')
-        return `{ ${props} }`
-    }
-
-    generateTemplateLiteral(node) {
-        let code = '`'
-        for (let i = 0; i < node.quasis.length; i++) {
-            code += node.quasis[i].value.raw
-            if (i < node.expressions.length) {
-                code += '${' + this.generate(node.expressions[i]) + '}'
-            }
-        }
-        return code + '`'
-    }
-
-    generateTemplateElement(node) {
-        return node.value.raw
-    }
-
-    generateFSReadFile(node) {
-        const args = [this.generate(node.path)]
-        if (node.options) args.push(this.generate(node.options))
-        if (node.callback) args.push(this.generate(node.callback))
-        return `fs.readFile(${args.join(', ')})`
-    }
-
-    generateFSReadFileSync(node) {
-        const args = [this.generate(node.path)]
-        if (node.options) args.push(this.generate(node.options))
-        return `fs.readFileSync(${args.join(', ')})`
-    }
-
-    generateFSWriteFile(node) {
-        const args = [this.generate(node.path), this.generate(node.data)]
-        if (node.options) args.push(this.generate(node.options))
-        if (node.callback) args.push(this.generate(node.callback))
-        return `fs.writeFile(${args.join(', ')})`
-    }
-
-    generateFSWriteFileSync(node) {
-        const args = [this.generate(node.path), this.generate(node.data)]
-        if (node.options) args.push(this.generate(node.options))
-        return `fs.writeFileSync(${args.join(', ')})`
-    }
-
-    generatePathJoin(node) {
-        return `path.join(${node.paths.map(p => this.generate(p)).join(', ')})`
-    }
-
-    generatePathResolve(node) {
-        return `path.resolve(${node.paths.map(p => this.generate(p)).join(', ')})`
-    }
-
-    generatePathDirname(node) {
-        return `path.dirname(${this.generate(node.path)})`
-    }
-
-    generatePathBasename(node) {
-        const args = [this.generate(node.path)]
-        if (node.ext) args.push(this.generate(node.ext))
-        return `path.basename(${args.join(', ')})`
-    }
-
-    generatePathExtname(node) {
-        return `path.extname(${this.generate(node.path)})`
-    }
-
-    generateHttpCreateServer(node) {
-        if (node.requestListener) {
-            return `http.createServer(${this.generate(node.requestListener)})`
-        }
-        return 'http.createServer()'
-    }
-
-    generateServerListen(node) {
-        const args = [this.generate(node.port)]
-        if (node.hostname) args.push(this.generate(node.hostname))
-        if (node.callback) args.push(this.generate(node.callback))
-        return `server.listen(${args.join(', ')})`
-    }
-
-    generateProcessCwd() {
-        return 'process.cwd()'
-    }
-
-    generateProcessExit(node) {
-        if (node.code !== null && node.code !== undefined) {
-            return `process.exit(${this.generate(node.code)})`
-        }
-        return 'process.exit()'
-    }
-
-    generateProcessEnv(node) {
-        if (node.variable) {
-            return `process.env.${node.variable}`
-        }
-        return 'process.env'
-    }
-
-    generateConsoleLog(node) {
-        return `console.log(${node.args.map(a => this.generate(a)).join(', ')})`
-    }
-
-    generateConsoleError(node) {
-        return `console.error(${node.args.map(a => this.generate(a)).join(', ')})`
-    }
-
-    generateConsoleWarn(node) {
-        return `console.warn(${node.args.map(a => this.generate(a)).join(', ')})`
-    }
-
-    generateSetTimeout(node) {
-        const args = [this.generate(node.callback), this.generate(node.delay)]
-        args.push(...node.args.map(a => this.generate(a)))
-        return `setTimeout(${args.join(', ')})`
-    }
-
-    generateClearTimeout(node) {
-        return `clearTimeout(${this.generate(node.timeoutId)})`
-    }
-
-    generateSetInterval(node) {
-        const args = [this.generate(node.callback), this.generate(node.delay)]
-        args.push(...node.args.map(a => this.generate(a)))
-        return `setInterval(${args.join(', ')})`
-    }
-
-    generateClearInterval(node) {
-        return `clearInterval(${this.generate(node.intervalId)})`
-    }
-
-    generateDirname() {
-        return '__dirname'
-    }
-
-    generateFilename() {
-        return '__filename'
-    }
-
-    generateCryptoRandomBytes(node) {
-        const args = [this.generate(node.size)]
-        if (node.callback) args.push(this.generate(node.callback))
-        return `crypto.randomBytes(${args.join(', ')})`
-    }
-
-    generateCryptoRandomUUID() {
-        return 'crypto.randomUUID()'
-    }
-
-    generateCryptoPbkdf2Sync(node) {
-        return `crypto.pbkdf2Sync(${this.generate(node.password)}, ${this.generate(node.salt)}, ${this.generate(node.iterations)}, ${this.generate(node.keylen)}, ${this.generate(node.digest)})`
-    }
-
-    generateBufferFrom(node) {
-        const args = [this.generate(node.data)]
-        if (node.encodingOrOffset) args.push(this.generate(node.encodingOrOffset))
-        if (node.length) args.push(this.generate(node.length))
-        return `Buffer.from(${args.join(', ')})`
-    }
-
-    generateBufferAlloc(node) {
-        const args = [this.generate(node.size)]
-        if (node.fill) args.push(this.generate(node.fill))
-        if (node.encoding) args.push(this.generate(node.encoding))
-        return `Buffer.alloc(${args.join(', ')})`
-    }
-
-    generateOsType() {
-        return 'os.type()'
-    }
-
-    generateOsPlatform() {
-        return 'os.platform()'
-    }
-
-    generateOsArch() {
-        return 'os.arch()'
-    }
-
-    generateOsHomedir() {
-        return 'os.homedir()'
-    }
-
-    generateOsTmpdir() {
-        return 'os.tmpdir()'
-    }
-
-    generateOsTotalmem() {
-        return 'os.totalmem()'
-    }
-
-    generateOsFreemem() {
-        return 'os.freemem()'
-    }
-
-    generateOsCpus() {
-        return 'os.cpus()'
-    }
-
-    generateChildProcessExec(node) {
-        const args = [this.generate(node.command)]
-        if (node.options) args.push(this.generate(node.options))
-        if (node.callback) args.push(this.generate(node.callback))
-        return `child_process.exec(${args.join(', ')})`
-    }
-
-    generateChildProcessSpawn(node) {
-        const args = [this.generate(node.command)]
-        if (node.args && node.args.length) args.push(this.generate(node.args))
-        if (node.options) args.push(this.generate(node.options))
-        return `child_process.spawn(${args.join(', ')})`
-    }
-
-    generateUtilPromisify(node) {
-        return `util.promisify(${this.generate(node.original)})`
-    }
-
-    generateDnsLookup(node) {
-        const args = [this.generate(node.hostname)]
-        if (node.options) args.push(this.generate(node.options))
-        if (node.callback) args.push(this.generate(node.callback))
-        return `dns.lookup(${args.join(', ')})`
-    }
-
-    generatePromiseExpression(node) {
-        return `new Promise(${this.generate(node.executor)})`
-    }
-
-    generatePromiseResolve(node) {
-        if (node.value) {
-            return `Promise.resolve(${this.generate(node.value)})`
-        }
-        return 'Promise.resolve()'
-    }
-
-    generatePromiseReject(node) {
-        if (node.reason) {
-            return `Promise.reject(${this.generate(node.reason)})`
-        }
-        return 'Promise.reject()'
-    }
-
-    generatePromiseAll(node) {
-        return `Promise.all(${this.generate(node.iterable)})`
-    }
-
-    generatePromiseRace(node) {
-        return `Promise.race(${this.generate(node.iterable)})`
-    }
-
-    generateEmptyStatement() {
-        return ';'
-    }
-}
-
-module.exports = { NodeParser, NodeCodeGenerator }