ether-code 0.1.5 → 0.1.7

package/parsers/js-parser.js

@@ -1,2564 +0,0 @@
-const fs = require('fs')
-const AST = require('./ast-js')
-
-const KEYWORDS = new Set([
-    'if', 'else', 'for', 'while', 'do', 'switch', 'case', 'default', 'break',
-    'continue', 'return', 'throw', 'try', 'catch', 'finally', 'function',
-    'class', 'extends', 'new', 'this', 'super', 'import', 'export', 'from',
-    'as', 'const', 'let', 'var', 'async', 'await', 'yield', 'typeof',
-    'instanceof', 'in', 'of', 'delete', 'void', 'debugger', 'with', 'static',
-    'get', 'set', 'true', 'false', 'null', 'undefined', 'using'
-])
-
-const OPERATORS = {
-    '+': 'PLUS', '-': 'MINUS', '*': 'STAR', '/': 'SLASH', '%': 'PERCENT',
-    '**': 'POWER', '++': 'INCREMENT', '--': 'DECREMENT',
-    '=': 'ASSIGN', '+=': 'PLUS_ASSIGN', '-=': 'MINUS_ASSIGN',
-    '*=': 'STAR_ASSIGN', '/=': 'SLASH_ASSIGN', '%=': 'PERCENT_ASSIGN',
-    '**=': 'POWER_ASSIGN', '&&=': 'AND_ASSIGN', '||=': 'OR_ASSIGN',
-    '??=': 'NULLISH_ASSIGN', '&=': 'BIT_AND_ASSIGN', '|=': 'BIT_OR_ASSIGN',
-    '^=': 'BIT_XOR_ASSIGN', '<<=': 'LEFT_SHIFT_ASSIGN', '>>=': 'RIGHT_SHIFT_ASSIGN',
-    '>>>=': 'UNSIGNED_RIGHT_SHIFT_ASSIGN',
-    '==': 'EQUAL', '===': 'STRICT_EQUAL', '!=': 'NOT_EQUAL', '!==': 'STRICT_NOT_EQUAL',
-    '<': 'LT', '>': 'GT', '<=': 'LTE', '>=': 'GTE',
-    '&&': 'AND', '||': 'OR', '!': 'NOT', '??': 'NULLISH',
-    '&': 'BIT_AND', '|': 'BIT_OR', '^': 'BIT_XOR', '~': 'BIT_NOT',
-    '<<': 'LEFT_SHIFT', '>>': 'RIGHT_SHIFT', '>>>': 'UNSIGNED_RIGHT_SHIFT',
-    '?': 'QUESTION', ':': 'COLON', '.': 'DOT', '?.': 'OPTIONAL_CHAIN',
-    '...': 'SPREAD', '=>': 'ARROW', ',': 'COMMA', ';': 'SEMICOLON'
-}
-
-class JSLexer {
-    constructor(source, i18n) {
-        this.source = source
-        this.i18n = i18n
-        this.pos = 0
-        this.line = 1
-        this.column = 1
-        this.tokens = []
-    }
-
-    peek(offset = 0) {
-        return this.source[this.pos + offset] || ''
-    }
-
-    advance() {
-        const char = this.source[this.pos]
-        this.pos++
-        if (char === '\n') {
-            this.line++
-            this.column = 1
-        } else {
-            this.column++
-        }
-        return char
-    }
-
-    skipWhitespace() {
-        while (this.pos < this.source.length) {
-            const char = this.peek()
-            if (char === ' ' || char === '\t' || char === '\r') {
-                this.advance()
-            } else if (char === '\n') {
-                this.advance()
-            } else if (char === '/' && this.peek(1) === '/') {
-                this.skipLineComment()
-            } else if (char === '/' && this.peek(1) === '*') {
-                this.skipBlockComment()
-            } else if (char === '-' && this.peek(1) === '-' && this.peek(2) !== '-') {
-                this.skipLineComment()
-            } else if (char === '{' && this.peek(1) === '-') {
-                this.skipEtherBlockComment()
-            } else {
-                break
-            }
-        }
-    }
-
-    skipLineComment() {
-        while (this.pos < this.source.length && this.peek() !== '\n') {
-            this.advance()
-        }
-    }
-
-    skipBlockComment() {
-        this.advance()
-        this.advance()
-        while (this.pos < this.source.length) {
-            if (this.peek() === '*' && this.peek(1) === '/') {
-                this.advance()
-                this.advance()
-                break
-            }
-            this.advance()
-        }
-    }
-
-    skipEtherBlockComment() {
-        this.advance()
-        this.advance()
-        while (this.pos < this.source.length) {
-            if (this.peek() === '-' && this.peek(1) === '}') {
-                this.advance()
-                this.advance()
-                break
-            }
-            this.advance()
-        }
-    }
-
-    readString(quote) {
-        let value = ''
-        const loc = { line: this.line, column: this.column }
-        this.advance()
-        while (this.pos < this.source.length) {
-            const char = this.peek()
-            if (char === quote) {
-                this.advance()
-                break
-            }
-            if (char === '\\') {
-                this.advance()
-                const escaped = this.advance()
-                switch (escaped) {
-                    case 'n': value += '\n'; break
-                    case 't': value += '\t'; break
-                    case 'r': value += '\r'; break
-                    case '\\': value += '\\'; break
-                    case "'": value += "'"; break
-                    case '"': value += '"'; break
-                    case '`': value += '`'; break
-                    case '0': value += '\0'; break
-                    default: value += escaped
-                }
-            } else {
-                value += this.advance()
-            }
-        }
-        return { type: 'STRING', value, quote, loc }
-    }
-
-    readTemplateLiteral() {
-        const loc = { line: this.line, column: this.column }
-        this.advance()
-        let value = ''
-        const quasis = []
-        const expressions = []
-        
-        while (this.pos < this.source.length) {
-            const char = this.peek()
-            if (char === '`') {
-                this.advance()
-                quasis.push({ value, tail: true })
-                break
-            }
-            if (char === '$' && this.peek(1) === '{') {
-                quasis.push({ value, tail: false })
-                value = ''
-                this.advance()
-                this.advance()
-                let braceCount = 1
-                let expr = ''
-                while (this.pos < this.source.length && braceCount > 0) {
-                    const c = this.peek()
-                    if (c === '{') braceCount++
-                    if (c === '}') braceCount--
-                    if (braceCount > 0) expr += this.advance()
-                    else this.advance()
-                }
-                expressions.push(expr.trim())
-            } else if (char === '\\') {
-                this.advance()
-                const escaped = this.advance()
-                switch (escaped) {
-                    case 'n': value += '\n'; break
-                    case 't': value += '\t'; break
-                    default: value += escaped
-                }
-            } else {
-                value += this.advance()
-            }
-        }
-        
-        return { type: 'TEMPLATE', quasis, expressions, loc }
-    }
-
-    readNumber() {
-        const loc = { line: this.line, column: this.column }
-        let value = ''
-        let isFloat = false
-        let isBigInt = false
-        
-        if (this.peek() === '0' && (this.peek(1) === 'x' || this.peek(1) === 'X')) {
-            value += this.advance() + this.advance()
-            while (/[0-9a-fA-F_]/.test(this.peek())) {
-                if (this.peek() !== '_') value += this.advance()
-                else this.advance()
-            }
-        } else if (this.peek() === '0' && (this.peek(1) === 'b' || this.peek(1) === 'B')) {
-            value += this.advance() + this.advance()
-            while (/[01_]/.test(this.peek())) {
-                if (this.peek() !== '_') value += this.advance()
-                else this.advance()
-            }
-        } else if (this.peek() === '0' && (this.peek(1) === 'o' || this.peek(1) === 'O')) {
-            value += this.advance() + this.advance()
-            while (/[0-7_]/.test(this.peek())) {
-                if (this.peek() !== '_') value += this.advance()
-                else this.advance()
-            }
-        } else {
-            while (/[0-9_]/.test(this.peek())) {
-                if (this.peek() !== '_') value += this.advance()
-                else this.advance()
-            }
-            if (this.peek() === '.' && /[0-9]/.test(this.peek(1))) {
-                isFloat = true
-                value += this.advance()
-                while (/[0-9_]/.test(this.peek())) {
-                    if (this.peek() !== '_') value += this.advance()
-                    else this.advance()
-                }
-            }
-            if (this.peek() === 'e' || this.peek() === 'E') {
-                isFloat = true
-                value += this.advance()
-                if (this.peek() === '+' || this.peek() === '-') {
-                    value += this.advance()
-                }
-                while (/[0-9_]/.test(this.peek())) {
-                    if (this.peek() !== '_') value += this.advance()
-                    else this.advance()
-                }
-            }
-        }
-        
-        if (this.peek() === 'n') {
-            isBigInt = true
-            this.advance()
-        }
-        
-        return { type: isBigInt ? 'BIGINT' : 'NUMBER', value, loc }
-    }
-
-    readWord() {
-        const loc = { line: this.line, column: this.column }
-        let word = ''
-        
-        while (this.pos < this.source.length) {
-            const char = this.peek()
-            if (/[a-zA-ZÀ-ÿА-яぁ-ゟァ-ヿ一-龯0-9_$]/.test(char)) {
-                word += this.advance()
-            } else {
-                break
-            }
-        }
-        
-        const nextWords = this.peekMultiWord()
-        if (nextWords) {
-            const fullWord = word + ' ' + nextWords
-            if (this.isMultiWordKeyword(fullWord)) {
-                for (let i = 0; i < nextWords.length + 1; i++) {
-                    this.advance()
-                }
-                word = fullWord
-            }
-        }
-        
-        return { word, loc }
-    }
-
-    peekMultiWord() {
-        let tempPos = this.pos
-        while (tempPos < this.source.length && this.source[tempPos] === ' ') {
-            tempPos++
-        }
-        let nextWord = ''
-        while (tempPos < this.source.length && /[a-zA-ZÀ-ÿА-яぁ-ゟァ-ヿ一-龯0-9_$]/.test(this.source[tempPos])) {
-            nextWord += this.source[tempPos]
-            tempPos++
-        }
-        return nextWord || null
-    }
-
-    isMultiWordKeyword(text) {
-        const patterns = [
-            'sinon si', 'else if', 'sino si', 'иначе если', '否则如果', 'そうでなければもし',
-            'tant que', 'while', 'mientras', 'пока', '当', 'ながら',
-            'faire tant que', 'do while', 'hacer mientras', 'делать пока', '做当', 'する間',
-            'pour de', 'for of', 'para de', 'для из', '为的', 'のために',
-            'pour dans', 'for in', 'para en', 'для в', '为在', 'の中で',
-            'type de', 'typeof', 'tipo de', 'тип', '类型', 'タイプ',
-            'instance de', 'instanceof', 'instancia de', 'экземпляр', '实例', 'インスタンス',
-            'fonction asynchrone', 'async function', 'función asíncrona', 'асинхронная функция', '异步函数', '非同期関数',
-            'fonction génératrice', 'generator function', 'función generadora', 'функция генератор', '生成器函数', 'ジェネレータ関数',
-            'variable globale', 'global variable', 'variable global', 'глобальная переменная', '全局变量', 'グローバル変数',
-            'grand entier', 'big integer', 'entero grande', 'большое целое', '大整数', '大きな整数'
-        ]
-        return patterns.includes(text.toLowerCase())
-    }
-
-    readRegExp() {
-        const loc = { line: this.line, column: this.column }
-        this.advance()
-        let pattern = ''
-        let inClass = false
-        
-        while (this.pos < this.source.length) {
-            const char = this.peek()
-            if (char === '\\') {
-                pattern += this.advance() + this.advance()
-            } else if (char === '[') {
-                inClass = true
-                pattern += this.advance()
-            } else if (char === ']') {
-                inClass = false
-                pattern += this.advance()
-            } else if (char === '/' && !inClass) {
-                this.advance()
-                break
-            } else {
-                pattern += this.advance()
-            }
-        }
-        
-        let flags = ''
-        while (/[gimsuy]/.test(this.peek())) {
-            flags += this.advance()
-        }
-        
-        return { type: 'REGEXP', pattern, flags, loc }
-    }
-
-    tokenize() {
-        while (this.pos < this.source.length) {
-            this.skipWhitespace()
-            if (this.pos >= this.source.length) break
-            
-            const loc = { line: this.line, column: this.column }
-            const char = this.peek()
-            
-            if (char === '"' || char === "'") {
-                this.tokens.push(this.readString(char))
-                continue
-            }
-            
-            if (char === '`') {
-                this.tokens.push(this.readTemplateLiteral())
-                continue
-            }
-            
-            if (/[0-9]/.test(char) || (char === '.' && /[0-9]/.test(this.peek(1)))) {
-                this.tokens.push(this.readNumber())
-                continue
-            }
-            
-            if (/[a-zA-ZÀ-ÿА-яぁ-ゟァ-ヿ一-龯_$]/.test(char)) {
-                const { word, loc: wordLoc } = this.readWord()
-                const tokenType = this.classifyWord(word)
-                this.tokens.push({ type: tokenType, value: word, loc: wordLoc })
-                continue
-            }
-            
-            if (char === '#') {
-                this.advance()
-                const { word, loc: wordLoc } = this.readWord()
-                this.tokens.push({ type: 'PRIVATE_ID', value: word, loc })
-                continue
-            }
-            
-            const threeChar = this.source.slice(this.pos, this.pos + 3)
-            if (OPERATORS[threeChar]) {
-                this.tokens.push({ type: OPERATORS[threeChar], value: threeChar, loc })
-                this.advance(); this.advance(); this.advance()
-                continue
-            }
-            
-            const twoChar = this.source.slice(this.pos, this.pos + 2)
-            if (OPERATORS[twoChar]) {
-                this.tokens.push({ type: OPERATORS[twoChar], value: twoChar, loc })
-                this.advance(); this.advance()
-                continue
-            }
-            
-            if (OPERATORS[char]) {
-                this.tokens.push({ type: OPERATORS[char], value: char, loc })
-                this.advance()
-                continue
-            }
-            
-            if (char === '(') {
-                this.tokens.push({ type: 'LPAREN', loc })
-                this.advance()
-                continue
-            }
-            if (char === ')') {
-                this.tokens.push({ type: 'RPAREN', loc })
-                this.advance()
-                continue
-            }
-            if (char === '{') {
-                this.tokens.push({ type: 'LBRACE', loc })
-                this.advance()
-                continue
-            }
-            if (char === '}') {
-                this.tokens.push({ type: 'RBRACE', loc })
-                this.advance()
-                continue
-            }
-            if (char === '[') {
-                this.tokens.push({ type: 'LBRACKET', loc })
-                this.advance()
-                continue
-            }
-            if (char === ']') {
-                this.tokens.push({ type: 'RBRACKET', loc })
-                this.advance()
-                continue
-            }
-            
-            this.advance()
-        }
-        
-        this.tokens.push({ type: 'EOF', loc: { line: this.line, column: this.column } })
-        return this.tokens
-    }
-
-    classifyWord(word) {
-        const lowerWord = word.toLowerCase()
-        
-        if (KEYWORDS.has(lowerWord)) return 'KEYWORD'
-        if (this.isEtherKeyword(lowerWord)) return 'ETHER_KEYWORD'
-        
-        return 'IDENTIFIER'
-    }
-
-    isEtherKeyword(word) {
-        const etherKeywords = this.getEtherKeywords()
-        return etherKeywords.has(word.toLowerCase())
-    }
-
-    getEtherKeywords() {
-        const keywords = new Set()
-        
-        const categories = [
-            'variables', 'conditions', 'boucles', 'fonctions', 'classes',
-            'gestionErreurs', 'operateursLogiques', 'valeursSpeciales'
-        ]
-        
-        for (const cat of categories) {
-            const items = this.i18n[cat]
-            if (!items) continue
-            for (const item of Object.values(items)) {
-                if (typeof item === 'object') {
-                    for (const translation of Object.values(item)) {
-                        if (typeof translation === 'string') {
-                            keywords.add(translation.toLowerCase())
-                        }
-                    }
-                }
-            }
-        }
-        
-        return keywords
-    }
-}
-
-class JSParser {
-    constructor(i18nPath = null) {
-        this.i18n = {}
-        this.tokens = []
-        this.pos = 0
-        
-        if (i18nPath) {
-            this.loadI18n(i18nPath)
-        }
-    }
-
-    loadI18n(filePath) {
-        try {
-            const content = fs.readFileSync(filePath, 'utf-8')
-            this.i18n = JSON.parse(content)
-        } catch (e) {
-            console.error(`Erreur chargement i18n: ${e.message}`)
-            this.i18n = {}
-        }
-    }
-
-    setI18n(i18nData) {
-        this.i18n = i18nData
-    }
-
-    parse(source) {
-        const lexer = new JSLexer(source, this.i18n)
-        this.tokens = lexer.tokenize()
-        this.pos = 0
-        return this.parseProgram()
-    }
-
-    peek(offset = 0) {
-        const idx = this.pos + offset
-        return idx < this.tokens.length ? this.tokens[idx] : { type: 'EOF' }
-    }
-
-    advance() {
-        const token = this.tokens[this.pos]
-        this.pos++
-        return token
-    }
-
-    expect(type) {
-        const token = this.peek()
-        if (token.type !== type) {
-            throw new Error(`Attendu ${type}, reçu ${token.type} à ligne ${token.loc?.line}`)
-        }
-        return this.advance()
-    }
-
-    match(...types) {
-        return types.includes(this.peek().type)
-    }
-
-    matchValue(...values) {
-        const token = this.peek()
-        return values.includes(token.value?.toLowerCase())
-    }
-
-    parseProgram() {
-        const body = []
-        const loc = this.peek().loc
-        
-        while (!this.match('EOF')) {
-            const stmt = this.parseStatement()
-            if (stmt) body.push(stmt)
-        }
-        
-        return new AST.Program(body, 'module', loc)
-    }
-
-    parseStatement() {
-        const token = this.peek()
-        
-        if (token.type === 'KEYWORD' || token.type === 'ETHER_KEYWORD') {
-            const keyword = this.translateKeyword(token.value)
-            
-            switch (keyword) {
-                case 'let':
-                case 'const':
-                case 'var':
-                    return this.parseVariableDeclaration()
-                case 'function':
-                    return this.parseFunctionDeclaration()
-                case 'class':
-                    return this.parseClassDeclaration()
-                case 'if':
-                    return this.parseIfStatement()
-                case 'switch':
-                    return this.parseSwitchStatement()
-                case 'for':
-                    return this.parseForStatement()
-                case 'while':
-                    return this.parseWhileStatement()
-                case 'do':
-                    return this.parseDoWhileStatement()
-                case 'try':
-                    return this.parseTryStatement()
-                case 'throw':
-                    return this.parseThrowStatement()
-                case 'return':
-                    return this.parseReturnStatement()
-                case 'break':
-                    return this.parseBreakStatement()
-                case 'continue':
-                    return this.parseContinueStatement()
-                case 'import':
-                    return this.parseImportDeclaration()
-                case 'export':
-                    return this.parseExportDeclaration()
-                case 'debugger':
-                    this.advance()
-                    this.consumeSemicolon()
-                    return new AST.DebuggerStatement(token.loc)
-                case 'using':
-                    return this.parseUsingDeclaration()
-            }
-        }
-        
-        if (this.match('LBRACE')) {
-            return this.parseBlockStatement()
-        }
-        
-        if (this.match('SEMICOLON')) {
-            this.advance()
-            return new AST.EmptyStatement(token.loc)
-        }
-        
-        return this.parseExpressionStatement()
-    }
-
-    parseVariableDeclaration() {
-        const token = this.advance()
-        const kind = this.translateKeyword(token.value)
-        const declarations = []
-        
-        do {
-            const id = this.parseBindingPattern()
-            let init = null
-            
-            if (this.match('ASSIGN')) {
-                this.advance()
-                init = this.parseExpression()
-            }
-            
-            declarations.push(new AST.VariableDeclarator(id, init, id.loc))
-        } while (this.match('COMMA') && this.advance())
-        
-        this.consumeSemicolon()
-        
-        return new AST.VariableDeclaration(kind, declarations, token.loc)
-    }
-
-    parseFunctionDeclaration() {
-        const loc = this.peek().loc
-        let async = false
-        let generator = false
-        
-        if (this.matchValue('async', 'asynchrone', 'asíncrona', 'асинхронный')) {
-            async = true
-            this.advance()
-        }
-        
-        this.advance()
-        
-        if (this.match('STAR')) {
-            generator = true
-            this.advance()
-        }
-        
-        const id = this.parseIdentifier()
-        const params = this.parseParameters()
-        const body = this.parseBlockStatement()
-        
-        return new AST.FunctionDeclaration(id, params, body, async, generator, loc)
-    }
-
-    parseClassDeclaration() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const id = this.parseIdentifier()
-        let superClass = null
-        
-        if (this.matchValue('extends', 'étend', 'extiende', 'расширяет')) {
-            this.advance()
-            superClass = this.parseExpression()
-        }
-        
-        const body = this.parseClassBody()
-        
-        return new AST.ClassDeclaration(id, superClass, body, loc)
-    }
-
-    parseClassBody() {
-        const loc = this.peek().loc
-        this.expect('LBRACE')
-        const body = []
-        
-        while (!this.match('RBRACE', 'EOF')) {
-            const member = this.parseClassMember()
-            if (member) body.push(member)
-        }
-        
-        this.expect('RBRACE')
-        return new AST.ClassBody(body, loc)
-    }
-
-    parseClassMember() {
-        let isStatic = false
-        const loc = this.peek().loc
-        
-        if (this.matchValue('static', 'statique', 'estático', 'статический')) {
-            isStatic = true
-            this.advance()
-            
-            if (this.match('LBRACE')) {
-                return this.parseStaticBlock()
-            }
-        }
-        
-        let kind = 'method'
-        if (this.matchValue('get', 'obtenir', 'получить')) {
-            kind = 'get'
-            this.advance()
-        } else if (this.matchValue('set', 'définir', 'establecer', 'установить')) {
-            kind = 'set'
-            this.advance()
-        }
-        
-        let key
-        let computed = false
-        
-        if (this.match('PRIVATE_ID')) {
-            const token = this.advance()
-            key = new AST.PrivateIdentifier(token.value, token.loc)
-        } else if (this.match('LBRACKET')) {
-            computed = true
-            this.advance()
-            key = this.parseExpression()
-            this.expect('RBRACKET')
-        } else {
-            key = this.parseIdentifier()
-        }
-        
-        if (this.match('LPAREN')) {
-            const params = this.parseParameters()
-            const body = this.parseBlockStatement()
-            const value = new AST.FunctionExpression(null, params, body, false, false, loc)
-            return new AST.MethodDefinition(key, value, kind, computed, isStatic, loc)
-        } else {
-            let value = null
-            if (this.match('ASSIGN')) {
-                this.advance()
-                value = this.parseExpression()
-            }
-            this.consumeSemicolon()
-            return new AST.PropertyDefinition(key, value, computed, isStatic, loc)
-        }
-    }
-
-    parseStaticBlock() {
-        const loc = this.peek().loc
-        const block = this.parseBlockStatement()
-        return new AST.StaticBlock(block.body, loc)
-    }
-
-    parseIfStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        this.expect('LPAREN')
-        const test = this.parseExpression()
-        this.expect('RPAREN')
-        
-        const consequent = this.parseStatement()
-        let alternate = null
-        
-        if (this.matchValue('else', 'sinon', 'sino', 'иначе')) {
-            this.advance()
-            alternate = this.parseStatement()
-        }
-        
-        return new AST.IfStatement(test, consequent, alternate, loc)
-    }
-
-    parseSwitchStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        this.expect('LPAREN')
-        const discriminant = this.parseExpression()
-        this.expect('RPAREN')
-        
-        this.expect('LBRACE')
-        const cases = []
-        
-        while (!this.match('RBRACE', 'EOF')) {
-            cases.push(this.parseSwitchCase())
-        }
-        
-        this.expect('RBRACE')
-        
-        return new AST.SwitchStatement(discriminant, cases, loc)
-    }
-
-    parseSwitchCase() {
-        const loc = this.peek().loc
-        let test = null
-        
-        if (this.matchValue('case', 'cas', 'caso', 'случай')) {
-            this.advance()
-            test = this.parseExpression()
-        } else if (this.matchValue('default', 'défaut', 'predeterminado', 'по умолчанию')) {
-            this.advance()
-        }
-        
-        this.expect('COLON')
-        
-        const consequent = []
-        while (!this.matchValue('case', 'cas', 'caso', 'случай', 'default', 'défaut', 'predeterminado') && !this.match('RBRACE', 'EOF')) {
-            consequent.push(this.parseStatement())
-        }
-        
-        return new AST.SwitchCase(test, consequent, loc)
-    }
-
-    parseForStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        this.expect('LPAREN')
-        
-        let init = null
-        if (!this.match('SEMICOLON')) {
-            if (this.matchValue('let', 'const', 'var', 'variable', 'constante')) {
-                init = this.parseVariableDeclarationNoSemi()
-            } else {
-                init = this.parseExpression()
-            }
-        }
-        
-        if (this.matchValue('in', 'dans', 'en', 'в')) {
-            this.advance()
-            const right = this.parseExpression()
-            this.expect('RPAREN')
-            const body = this.parseStatement()
-            return new AST.ForInStatement(init, right, body, loc)
-        }
-        
-        if (this.matchValue('of', 'de')) {
-            this.advance()
-            const right = this.parseExpression()
-            this.expect('RPAREN')
-            const body = this.parseStatement()
-            return new AST.ForOfStatement(init, right, body, false, loc)
-        }
-        
-        this.expect('SEMICOLON')
-        
-        let test = null
-        if (!this.match('SEMICOLON')) {
-            test = this.parseExpression()
-        }
-        
-        this.expect('SEMICOLON')
-        
-        let update = null
-        if (!this.match('RPAREN')) {
-            update = this.parseExpression()
-        }
-        
-        this.expect('RPAREN')
-        const body = this.parseStatement()
-        
-        return new AST.ForStatement(init, test, update, body, loc)
-    }
-
-    parseVariableDeclarationNoSemi() {
-        const token = this.advance()
-        const kind = this.translateKeyword(token.value)
-        const declarations = []
-        
-        const id = this.parseBindingPattern()
-        let init = null
-        
-        if (this.match('ASSIGN')) {
-            this.advance()
-            init = this.parseExpression()
-        }
-        
-        declarations.push(new AST.VariableDeclarator(id, init, id.loc))
-        
-        return new AST.VariableDeclaration(kind, declarations, token.loc)
-    }
-
-    parseWhileStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        this.expect('LPAREN')
-        const test = this.parseExpression()
-        this.expect('RPAREN')
-        
-        const body = this.parseStatement()
-        
-        return new AST.WhileStatement(test, body, loc)
-    }
-
-    parseDoWhileStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const body = this.parseStatement()
-        
-        if (!this.matchValue('while', 'tant que', 'mientras', 'пока')) {
-            throw new Error('Attendu while après do')
-        }
-        this.advance()
-        
-        this.expect('LPAREN')
-        const test = this.parseExpression()
-        this.expect('RPAREN')
-        
-        this.consumeSemicolon()
-        
-        return new AST.DoWhileStatement(body, test, loc)
-    }
-
-    parseTryStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const block = this.parseBlockStatement()
-        let handler = null
-        let finalizer = null
-        
-        if (this.matchValue('catch', 'attraper', 'capturar', 'поймать')) {
-            const catchLoc = this.peek().loc
-            this.advance()
-            
-            let param = null
-            if (this.match('LPAREN')) {
-                this.advance()
-                param = this.parseBindingPattern()
-                this.expect('RPAREN')
-            }
-            
-            const catchBody = this.parseBlockStatement()
-            handler = new AST.CatchClause(param, catchBody, catchLoc)
-        }
-        
-        if (this.matchValue('finally', 'finalement', 'finalmente', 'наконец')) {
-            this.advance()
-            finalizer = this.parseBlockStatement()
-        }
-        
-        return new AST.TryStatement(block, handler, finalizer, loc)
-    }
-
-    parseThrowStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const argument = this.parseExpression()
-        this.consumeSemicolon()
-        
-        return new AST.ThrowStatement(argument, loc)
-    }
-
-    parseReturnStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let argument = null
-        if (!this.match('SEMICOLON', 'RBRACE', 'EOF')) {
-            argument = this.parseExpression()
-        }
-        
-        this.consumeSemicolon()
-        
-        return new AST.ReturnStatement(argument, loc)
-    }
-
-    parseBreakStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let label = null
-        if (this.match('IDENTIFIER')) {
-            label = this.parseIdentifier()
-        }
-        
-        this.consumeSemicolon()
-        
-        return new AST.BreakStatement(label, loc)
-    }
-
-    parseContinueStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let label = null
-        if (this.match('IDENTIFIER')) {
-            label = this.parseIdentifier()
-        }
-        
-        this.consumeSemicolon()
-        
-        return new AST.ContinueStatement(label, loc)
-    }
-
-    parseImportDeclaration() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const specifiers = []
-        
-        if (this.match('STRING')) {
-            const source = this.parseStringLiteral()
-            this.consumeSemicolon()
-            return new AST.ImportDeclaration(specifiers, source, loc)
-        }
-        
-        if (this.match('IDENTIFIER')) {
-            const local = this.parseIdentifier()
-            specifiers.push(new AST.ImportDefaultSpecifier(local, local.loc))
-            
-            if (this.match('COMMA')) {
-                this.advance()
-            }
-        }
-        
-        if (this.match('STAR')) {
-            this.advance()
-            this.expectValue('as', 'comme', 'como', 'как')
-            const local = this.parseIdentifier()
-            specifiers.push(new AST.ImportNamespaceSpecifier(local, local.loc))
-        } else if (this.match('LBRACE')) {
-            this.advance()
-            while (!this.match('RBRACE', 'EOF')) {
-                const imported = this.parseIdentifier()
-                let local = imported
-                
-                if (this.matchValue('as', 'comme', 'como', 'как')) {
-                    this.advance()
-                    local = this.parseIdentifier()
-                }
-                
-                specifiers.push(new AST.ImportSpecifier(imported, local, imported.loc))
-                
-                if (!this.match('RBRACE')) {
-                    this.expect('COMMA')
-                }
-            }
-            this.expect('RBRACE')
-        }
-        
-        this.expectValue('from', 'depuis', 'de', 'из')
-        const source = this.parseStringLiteral()
-        this.consumeSemicolon()
-        
-        return new AST.ImportDeclaration(specifiers, source, loc)
-    }
-
-    parseExportDeclaration() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        if (this.matchValue('default', 'défaut', 'predeterminado', 'по умолчанию')) {
-            this.advance()
-            let declaration
-            
-            if (this.matchValue('function', 'fonction', 'función', 'функция')) {
-                declaration = this.parseFunctionDeclaration()
-            } else if (this.matchValue('class', 'classe', 'clase', 'класс')) {
-                declaration = this.parseClassDeclaration()
-            } else {
-                declaration = this.parseExpression()
-                this.consumeSemicolon()
-            }
-            
-            return new AST.ExportDefaultDeclaration(declaration, loc)
-        }
-        
-        if (this.match('STAR')) {
-            this.advance()
-            let exported = null
-            
-            if (this.matchValue('as', 'comme', 'como', 'как')) {
-                this.advance()
-                exported = this.parseIdentifier()
-            }
-            
-            this.expectValue('from', 'depuis', 'de', 'из')
-            const source = this.parseStringLiteral()
-            this.consumeSemicolon()
-            
-            return new AST.ExportAllDeclaration(source, exported, loc)
-        }
-        
-        if (this.match('LBRACE')) {
-            this.advance()
-            const specifiers = []
-            
-            while (!this.match('RBRACE', 'EOF')) {
-                const local = this.parseIdentifier()
-                let exported = local
-                
-                if (this.matchValue('as', 'comme', 'como', 'как')) {
-                    this.advance()
-                    exported = this.parseIdentifier()
-                }
-                
-                specifiers.push(new AST.ExportSpecifier(local, exported, local.loc))
-                
-                if (!this.match('RBRACE')) {
-                    this.expect('COMMA')
-                }
-            }
-            this.expect('RBRACE')
-            
-            let source = null
-            if (this.matchValue('from', 'depuis', 'de', 'из')) {
-                this.advance()
-                source = this.parseStringLiteral()
-            }
-            
-            this.consumeSemicolon()
-            return new AST.ExportNamedDeclaration(null, specifiers, source, loc)
-        }
-        
-        const declaration = this.parseStatement()
-        return new AST.ExportNamedDeclaration(declaration, [], null, loc)
-    }
-
-    parseUsingDeclaration() {
-        const loc = this.peek().loc
-        let await_ = false
-        
-        if (this.matchValue('await', 'attendre', 'esperar', 'ждать')) {
-            await_ = true
-            this.advance()
-        }
-        
-        this.advance()
-        
-        const declarations = []
-        do {
-            const id = this.parseBindingPattern()
-            let init = null
-            
-            if (this.match('ASSIGN')) {
-                this.advance()
-                init = this.parseExpression()
-            }
-            
-            declarations.push(new AST.VariableDeclarator(id, init, id.loc))
-        } while (this.match('COMMA') && this.advance())
-        
-        this.consumeSemicolon()
-        
-        return new AST.UsingDeclaration(declarations, await_, loc)
-    }
-
-    parseBlockStatement() {
-        const loc = this.peek().loc
-        this.expect('LBRACE')
-        const body = []
-        
-        while (!this.match('RBRACE', 'EOF')) {
-            const stmt = this.parseStatement()
-            if (stmt) body.push(stmt)
-        }
-        
-        this.expect('RBRACE')
-        return new AST.BlockStatement(body, loc)
-    }
-
-    parseExpressionStatement() {
-        const loc = this.peek().loc
-        const expression = this.parseExpression()
-        this.consumeSemicolon()
-        return new AST.ExpressionStatement(expression, loc)
-    }
-
-    parseExpression() {
-        return this.parseAssignmentExpression()
-    }
-
-    parseAssignmentExpression() {
-        const left = this.parseConditionalExpression()
-        
-        if (this.match('ASSIGN', 'PLUS_ASSIGN', 'MINUS_ASSIGN', 'STAR_ASSIGN', 
-            'SLASH_ASSIGN', 'PERCENT_ASSIGN', 'POWER_ASSIGN', 'AND_ASSIGN',
-            'OR_ASSIGN', 'NULLISH_ASSIGN', 'BIT_AND_ASSIGN', 'BIT_OR_ASSIGN',
-            'BIT_XOR_ASSIGN', 'LEFT_SHIFT_ASSIGN', 'RIGHT_SHIFT_ASSIGN',
-            'UNSIGNED_RIGHT_SHIFT_ASSIGN')) {
-            const op = this.advance()
-            const right = this.parseAssignmentExpression()
-            return new AST.AssignmentExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseConditionalExpression() {
-        const test = this.parseLogicalOrExpression()
-        
-        if (this.match('QUESTION')) {
-            this.advance()
-            const consequent = this.parseAssignmentExpression()
-            this.expect('COLON')
-            const alternate = this.parseAssignmentExpression()
-            return new AST.ConditionalExpression(test, consequent, alternate, test.loc)
-        }
-        
-        return test
-    }
-
-    parseLogicalOrExpression() {
-        let left = this.parseLogicalAndExpression()
-        
-        while (this.match('OR', 'NULLISH')) {
-            const op = this.advance()
-            const right = this.parseLogicalAndExpression()
-            left = new AST.LogicalExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseLogicalAndExpression() {
-        let left = this.parseBitwiseOrExpression()
-        
-        while (this.match('AND')) {
-            const op = this.advance()
-            const right = this.parseBitwiseOrExpression()
-            left = new AST.LogicalExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseBitwiseOrExpression() {
-        let left = this.parseBitwiseXorExpression()
-        
-        while (this.match('BIT_OR')) {
-            const op = this.advance()
-            const right = this.parseBitwiseXorExpression()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseBitwiseXorExpression() {
-        let left = this.parseBitwiseAndExpression()
-        
-        while (this.match('BIT_XOR')) {
-            const op = this.advance()
-            const right = this.parseBitwiseAndExpression()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseBitwiseAndExpression() {
-        let left = this.parseEqualityExpression()
-        
-        while (this.match('BIT_AND')) {
-            const op = this.advance()
-            const right = this.parseEqualityExpression()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseEqualityExpression() {
-        let left = this.parseRelationalExpression()
-        
-        while (this.match('EQUAL', 'NOT_EQUAL', 'STRICT_EQUAL', 'STRICT_NOT_EQUAL')) {
-            const op = this.advance()
-            const right = this.parseRelationalExpression()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseRelationalExpression() {
-        let left = this.parseShiftExpression()
-        
-        while (this.match('LT', 'GT', 'LTE', 'GTE') || 
-               this.matchValue('instanceof', 'instance de', 'instancia de', 'экземпляр') ||
-               this.matchValue('in', 'dans', 'en', 'в')) {
-            const op = this.advance()
-            const right = this.parseShiftExpression()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseShiftExpression() {
-        let left = this.parseAdditiveExpression()
-        
-        while (this.match('LEFT_SHIFT', 'RIGHT_SHIFT', 'UNSIGNED_RIGHT_SHIFT')) {
-            const op = this.advance()
-            const right = this.parseAdditiveExpression()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseAdditiveExpression() {
-        let left = this.parseMultiplicativeExpression()
-        
-        while (this.match('PLUS', 'MINUS')) {
-            const op = this.advance()
-            const right = this.parseMultiplicativeExpression()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseMultiplicativeExpression() {
-        let left = this.parseExponentiationExpression()
-        
-        while (this.match('STAR', 'SLASH', 'PERCENT')) {
-            const op = this.advance()
-            const right = this.parseExponentiationExpression()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseExponentiationExpression() {
-        const left = this.parseUnaryExpression()
-        
-        if (this.match('POWER')) {
-            const op = this.advance()
-            const right = this.parseExponentiationExpression()
-            return new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseUnaryExpression() {
-        if (this.match('NOT', 'BIT_NOT', 'PLUS', 'MINUS') ||
-            this.matchValue('typeof', 'type de', 'tipo de', 'тип') ||
-            this.matchValue('void', 'vide', 'vacío', 'пустой') ||
-            this.matchValue('delete', 'supprimer', 'eliminar', 'удалить')) {
-            const op = this.advance()
-            const argument = this.parseUnaryExpression()
-            return new AST.UnaryExpression(op.value, argument, true, op.loc)
-        }
-        
-        if (this.match('INCREMENT', 'DECREMENT')) {
-            const op = this.advance()
-            const argument = this.parseUnaryExpression()
-            return new AST.UpdateExpression(op.value, argument, true, op.loc)
-        }
-        
-        if (this.matchValue('await', 'attendre', 'esperar', 'ждать')) {
-            const loc = this.peek().loc
-            this.advance()
-            const argument = this.parseUnaryExpression()
-            return new AST.AwaitExpression(argument, loc)
-        }
-        
-        return this.parseUpdateExpression()
-    }
-
-    parseUpdateExpression() {
-        const argument = this.parseLeftHandSideExpression()
-        
-        if (this.match('INCREMENT', 'DECREMENT')) {
-            const op = this.advance()
-            return new AST.UpdateExpression(op.value, argument, false, argument.loc)
-        }
-        
-        return argument
-    }
-
-    parseLeftHandSideExpression() {
-        let expr
-        
-        if (this.matchValue('new', 'nouveau', 'nuevo', 'новый')) {
-            expr = this.parseNewExpression()
-        } else {
-            expr = this.parsePrimaryExpression()
-        }
-        
-        while (true) {
-            if (this.match('DOT')) {
-                this.advance()
-                const property = this.parseIdentifier()
-                expr = new AST.MemberExpression(expr, property, false, false, expr.loc)
-            } else if (this.match('OPTIONAL_CHAIN')) {
-                this.advance()
-                if (this.match('LPAREN')) {
-                    const args = this.parseArguments()
-                    expr = new AST.CallExpression(expr, args, true, expr.loc)
-                } else if (this.match('LBRACKET')) {
-                    this.advance()
-                    const property = this.parseExpression()
-                    this.expect('RBRACKET')
-                    expr = new AST.MemberExpression(expr, property, true, true, expr.loc)
-                } else {
-                    const property = this.parseIdentifier()
-                    expr = new AST.MemberExpression(expr, property, false, true, expr.loc)
-                }
-            } else if (this.match('LBRACKET')) {
-                this.advance()
-                const property = this.parseExpression()
-                this.expect('RBRACKET')
-                expr = new AST.MemberExpression(expr, property, true, false, expr.loc)
-            } else if (this.match('LPAREN')) {
-                const args = this.parseArguments()
-                expr = new AST.CallExpression(expr, args, false, expr.loc)
-            } else if (this.match('TEMPLATE')) {
-                const quasi = this.parseTemplateLiteral()
-                expr = new AST.TaggedTemplateExpression(expr, quasi, expr.loc)
-            } else {
-                break
-            }
-        }
-        
-        return expr
-    }
-
-    parseNewExpression() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        if (this.match('DOT')) {
-            this.advance()
-            const property = this.parseIdentifier()
-            return new AST.MetaProperty(new AST.Identifier('new', loc), property, loc)
-        }
-        
-        const callee = this.parseLeftHandSideExpression()
-        let args = []
-        
-        if (this.match('LPAREN')) {
-            args = this.parseArguments()
-        }
-        
-        return new AST.NewExpression(callee, args, loc)
-    }
-
-    parsePrimaryExpression() {
-        const token = this.peek()
-        
-        if (this.matchValue('this', 'ceci', 'esto', 'это')) {
-            this.advance()
-            return new AST.ThisExpression(token.loc)
-        }
-        
-        if (this.matchValue('super')) {
-            this.advance()
-            return new AST.Super(token.loc)
-        }
-        
-        if (this.matchValue('true', 'vrai', 'verdadero', 'истина')) {
-            this.advance()
-            return new AST.BooleanLiteral(true, token.loc)
-        }
-        
-        if (this.matchValue('false', 'faux', 'falso', 'ложь')) {
-            this.advance()
-            return new AST.BooleanLiteral(false, token.loc)
-        }
-        
-        if (this.matchValue('null', 'nul', 'nulo', 'нуль')) {
-            this.advance()
-            return new AST.NullLiteral(token.loc)
-        }
-        
-        if (this.matchValue('undefined', 'indéfini', 'indefinido', 'неопределённый')) {
-            this.advance()
-            return new AST.Identifier('undefined', token.loc)
-        }
-        
-        if (this.match('NUMBER')) {
-            return this.parseNumericLiteral()
-        }
-        
-        if (this.match('BIGINT')) {
-            return this.parseBigIntLiteral()
-        }
-        
-        if (this.match('STRING')) {
-            return this.parseStringLiteral()
-        }
-        
-        if (this.match('TEMPLATE')) {
-            return this.parseTemplateLiteral()
-        }
-        
-        if (this.match('REGEXP')) {
-            return this.parseRegExpLiteral()
-        }
-        
-        if (this.match('LBRACKET')) {
-            return this.parseArrayExpression()
-        }
-        
-        if (this.match('LBRACE')) {
-            return this.parseObjectExpression()
-        }
-        
-        if (this.match('LPAREN')) {
-            return this.parseParenthesizedOrArrow()
-        }
-        
-        if (this.matchValue('function', 'fonction', 'función', 'функция')) {
-            return this.parseFunctionExpression()
-        }
-        
-        if (this.matchValue('class', 'classe', 'clase', 'класс')) {
-            return this.parseClassExpression()
-        }
-        
-        if (this.matchValue('async', 'asynchrone', 'asíncrona', 'асинхронный')) {
-            return this.parseAsyncFunctionOrArrow()
-        }
-        
-        if (this.match('IDENTIFIER', 'KEYWORD', 'ETHER_KEYWORD')) {
-            return this.parseIdentifier()
-        }
-        
-        throw new Error(`Token inattendu: ${token.type} à ligne ${token.loc?.line}`)
-    }
-
-    parseIdentifier() {
-        const token = this.advance()
-        return new AST.Identifier(token.value, token.loc)
-    }
-
-    parseNumericLiteral() {
-        const token = this.advance()
-        return new AST.NumericLiteral(parseFloat(token.value), token.value, token.loc)
-    }
-
-    parseBigIntLiteral() {
-        const token = this.advance()
-        return new AST.BigIntLiteral(BigInt(token.value), token.value + 'n', token.loc)
-    }
-
-    parseStringLiteral() {
-        const token = this.advance()
-        return new AST.StringLiteral(token.value, `${token.quote}${token.value}${token.quote}`, token.loc)
-    }
-
-    parseTemplateLiteral() {
-        const token = this.advance()
-        const quasis = token.quasis.map((q, i) => 
-            new AST.TemplateElement({ raw: q.value, cooked: q.value }, q.tail, token.loc)
-        )
-        const expressions = token.expressions.map(e => {
-            const parser = new JSParser()
-            parser.setI18n(this.i18n)
-            const ast = parser.parse(e)
-            return ast.body[0]?.expression || new AST.Identifier(e, token.loc)
-        })
-        return new AST.TemplateLiteral(quasis, expressions, token.loc)
-    }
-
-    parseRegExpLiteral() {
-        const token = this.advance()
-        return new AST.RegExpLiteral(token.pattern, token.flags, token.loc)
-    }
-
-    parseArrayExpression() {
-        const loc = this.peek().loc
-        this.expect('LBRACKET')
-        const elements = []
-        
-        while (!this.match('RBRACKET', 'EOF')) {
-            if (this.match('COMMA')) {
-                elements.push(null)
-                this.advance()
-                continue
-            }
-            
-            if (this.match('SPREAD')) {
-                this.advance()
-                const argument = this.parseAssignmentExpression()
-                elements.push(new AST.SpreadElement(argument, argument.loc))
-            } else {
-                elements.push(this.parseAssignmentExpression())
-            }
-            
-            if (!this.match('RBRACKET')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        this.expect('RBRACKET')
-        return new AST.ArrayExpression(elements, loc)
-    }
-
-    parseObjectExpression() {
-        const loc = this.peek().loc
-        this.expect('LBRACE')
-        const properties = []
-        
-        while (!this.match('RBRACE', 'EOF')) {
-            properties.push(this.parseProperty())
-            
-            if (!this.match('RBRACE')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        this.expect('RBRACE')
-        return new AST.ObjectExpression(properties, loc)
-    }
-
-    parseProperty() {
-        const loc = this.peek().loc
-        
-        if (this.match('SPREAD')) {
-            this.advance()
-            const argument = this.parseAssignmentExpression()
-            return new AST.SpreadElement(argument, loc)
-        }
-        
-        let kind = 'init'
-        let method = false
-        let shorthand = false
-        let computed = false
-        let key
-        let value
-        
-        if (this.matchValue('get', 'obtenir', 'получить')) {
-            const next = this.peek(1)
-            if (next.type !== 'COLON' && next.type !== 'COMMA' && next.type !== 'RBRACE') {
-                kind = 'get'
-                this.advance()
-            }
-        } else if (this.matchValue('set', 'définir', 'establecer', 'установить')) {
-            const next = this.peek(1)
-            if (next.type !== 'COLON' && next.type !== 'COMMA' && next.type !== 'RBRACE') {
-                kind = 'set'
-                this.advance()
-            }
-        }
-        
-        if (this.match('LBRACKET')) {
-            computed = true
-            this.advance()
-            key = this.parseAssignmentExpression()
-            this.expect('RBRACKET')
-        } else if (this.match('STRING')) {
-            key = this.parseStringLiteral()
-        } else if (this.match('NUMBER')) {
-            key = this.parseNumericLiteral()
-        } else {
-            key = this.parseIdentifier()
-        }
-        
-        if (this.match('LPAREN')) {
-            method = true
-            const params = this.parseParameters()
-            const body = this.parseBlockStatement()
-            value = new AST.FunctionExpression(null, params, body, false, false, loc)
-        } else if (this.match('COLON')) {
-            this.advance()
-            value = this.parseAssignmentExpression()
-        } else if (this.match('ASSIGN')) {
-            this.advance()
-            const defaultValue = this.parseAssignmentExpression()
-            value = new AST.AssignmentPattern(key, defaultValue, loc)
-            shorthand = true
-        } else {
-            value = key
-            shorthand = true
-        }
-        
-        return new AST.Property(key, value, kind, method, shorthand, computed, loc)
-    }
-
-    parseParenthesizedOrArrow() {
-        const loc = this.peek().loc
-        this.expect('LPAREN')
-        
-        if (this.match('RPAREN')) {
-            this.advance()
-            if (this.match('ARROW')) {
-                this.advance()
-                return this.parseArrowFunctionBody([], false, loc)
-            }
-            throw new Error('Attendu => après ()')
-        }
-        
-        const first = this.parseAssignmentExpression()
-        
-        if (this.match('COMMA')) {
-            const expressions = [first]
-            while (this.match('COMMA')) {
-                this.advance()
-                if (this.match('RPAREN')) break
-                expressions.push(this.parseAssignmentExpression())
-            }
-            this.expect('RPAREN')
-            
-            if (this.match('ARROW')) {
-                this.advance()
-                return this.parseArrowFunctionBody(expressions, false, loc)
-            }
-            
-            return new AST.SequenceExpression(expressions, loc)
-        }
-        
-        this.expect('RPAREN')
-        
-        if (this.match('ARROW')) {
-            this.advance()
-            return this.parseArrowFunctionBody([first], false, loc)
-        }
-        
-        return first
-    }
-
-    parseArrowFunctionBody(params, async, loc) {
-        let body
-        let expression = false
-        
-        if (this.match('LBRACE')) {
-            body = this.parseBlockStatement()
-        } else {
-            body = this.parseAssignmentExpression()
-            expression = true
-        }
-        
-        return new AST.ArrowFunctionExpression(params, body, async, expression, loc)
-    }
-
-    parseFunctionExpression() {
-        const loc = this.peek().loc
-        let async = false
-        let generator = false
-        
-        if (this.matchValue('async', 'asynchrone', 'asíncrona', 'асинхронный')) {
-            async = true
-            this.advance()
-        }
-        
-        this.advance()
-        
-        if (this.match('STAR')) {
-            generator = true
-            this.advance()
-        }
-        
-        let id = null
-        if (this.match('IDENTIFIER')) {
-            id = this.parseIdentifier()
-        }
-        
-        const params = this.parseParameters()
-        const body = this.parseBlockStatement()
-        
-        return new AST.FunctionExpression(id, params, body, async, generator, loc)
-    }
-
-    parseClassExpression() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let id = null
-        if (this.match('IDENTIFIER')) {
-            id = this.parseIdentifier()
-        }
-        
-        let superClass = null
-        if (this.matchValue('extends', 'étend', 'extiende', 'расширяет')) {
-            this.advance()
-            superClass = this.parseExpression()
-        }
-        
-        const body = this.parseClassBody()
-        
-        return new AST.ClassExpression(id, superClass, body, loc)
-    }
-
-    parseAsyncFunctionOrArrow() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        if (this.matchValue('function', 'fonction', 'función', 'функция')) {
-            this.advance()
-            let generator = false
-            if (this.match('STAR')) {
-                generator = true
-                this.advance()
-            }
-            
-            let id = null
-            if (this.match('IDENTIFIER')) {
-                id = this.parseIdentifier()
-            }
-            
-            const params = this.parseParameters()
-            const body = this.parseBlockStatement()
-            
-            return new AST.FunctionExpression(id, params, body, true, generator, loc)
-        }
-        
-        if (this.match('LPAREN')) {
-            const params = this.parseParameters()
-            this.expect('ARROW')
-            return this.parseArrowFunctionBody(params, true, loc)
-        }
-        
-        if (this.match('IDENTIFIER')) {
-            const param = this.parseIdentifier()
-            this.expect('ARROW')
-            return this.parseArrowFunctionBody([param], true, loc)
-        }
-        
-        throw new Error('Syntaxe async invalide')
-    }
-
-    parseParameters() {
-        this.expect('LPAREN')
-        const params = []
-        
-        while (!this.match('RPAREN', 'EOF')) {
-            if (this.match('SPREAD')) {
-                this.advance()
-                const argument = this.parseBindingPattern()
-                params.push(new AST.RestElement(argument, argument.loc))
-                break
-            }
-            
-            const param = this.parseBindingPattern()
-            
-            if (this.match('ASSIGN')) {
-                this.advance()
-                const defaultValue = this.parseAssignmentExpression()
-                params.push(new AST.AssignmentPattern(param, defaultValue, param.loc))
-            } else {
-                params.push(param)
-            }
-            
-            if (!this.match('RPAREN')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        this.expect('RPAREN')
-        return params
-    }
-
-    parseBindingPattern() {
-        if (this.match('LBRACKET')) {
-            return this.parseArrayPattern()
-        }
-        
-        if (this.match('LBRACE')) {
-            return this.parseObjectPattern()
-        }
-        
-        return this.parseIdentifier()
-    }
-
-    parseArrayPattern() {
-        const loc = this.peek().loc
-        this.expect('LBRACKET')
-        const elements = []
-        
-        while (!this.match('RBRACKET', 'EOF')) {
-            if (this.match('COMMA')) {
-                elements.push(null)
-                this.advance()
-                continue
-            }
-            
-            if (this.match('SPREAD')) {
-                this.advance()
-                const argument = this.parseBindingPattern()
-                elements.push(new AST.RestElement(argument, argument.loc))
-                break
-            }
-            
-            let element = this.parseBindingPattern()
-            
-            if (this.match('ASSIGN')) {
-                this.advance()
-                const defaultValue = this.parseAssignmentExpression()
-                element = new AST.AssignmentPattern(element, defaultValue, element.loc)
-            }
-            
-            elements.push(element)
-            
-            if (!this.match('RBRACKET')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        this.expect('RBRACKET')
-        return new AST.ArrayPattern(elements, loc)
-    }
-
-    parseObjectPattern() {
-        const loc = this.peek().loc
-        this.expect('LBRACE')
-        const properties = []
-        
-        while (!this.match('RBRACE', 'EOF')) {
-            if (this.match('SPREAD')) {
-                this.advance()
-                const argument = this.parseBindingPattern()
-                properties.push(new AST.RestElement(argument, argument.loc))
-                break
-            }
-            
-            let key
-            let value
-            let computed = false
-            let shorthand = false
-            
-            if (this.match('LBRACKET')) {
-                computed = true
-                this.advance()
-                key = this.parseAssignmentExpression()
-                this.expect('RBRACKET')
-            } else {
-                key = this.parseIdentifier()
-            }
-            
-            if (this.match('COLON')) {
-                this.advance()
-                value = this.parseBindingPattern()
-            } else {
-                value = key
-                shorthand = true
-            }
-            
-            if (this.match('ASSIGN')) {
-                this.advance()
-                const defaultValue = this.parseAssignmentExpression()
-                value = new AST.AssignmentPattern(value, defaultValue, value.loc)
-            }
-            
-            properties.push(new AST.Property(key, value, 'init', false, shorthand, computed, key.loc))
-            
-            if (!this.match('RBRACE')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        this.expect('RBRACE')
-        return new AST.ObjectPattern(properties, loc)
-    }
-
-    parseArguments() {
-        this.expect('LPAREN')
-        const args = []
-        
-        while (!this.match('RPAREN', 'EOF')) {
-            if (this.match('SPREAD')) {
-                this.advance()
-                const argument = this.parseAssignmentExpression()
-                args.push(new AST.SpreadElement(argument, argument.loc))
-            } else {
-                args.push(this.parseAssignmentExpression())
-            }
-            
-            if (!this.match('RPAREN')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        this.expect('RPAREN')
-        return args
-    }
-
-    consumeSemicolon() {
-        if (this.match('SEMICOLON')) {
-            this.advance()
-        }
-    }
-
-    expectValue(...values) {
-        const token = this.peek()
-        if (!values.includes(token.value?.toLowerCase())) {
-            throw new Error(`Attendu un de ${values.join(', ')}, reçu ${token.value} à ligne ${token.loc?.line}`)
-        }
-        return this.advance()
-    }
-
-    translateKeyword(word) {
-        const lowerWord = word.toLowerCase()
-        
-        const translations = {
-            'variable': 'let', 'let': 'let', 'переменная': 'let', '变量': 'let', '変数': 'let',
-            'constante': 'const', 'constant': 'const', 'const': 'const', 'константа': 'const', '常量': 'const', '定数': 'const',
-            'variable globale': 'var', 'global variable': 'var', 'var': 'var', 'variable global': 'var', 'глобальная переменная': 'var', '全局变量': 'var', 'グローバル変数': 'var',
-            'fonction': 'function', 'function': 'function', 'función': 'function', 'функция': 'function', '函数': 'function', '関数': 'function',
-            'classe': 'class', 'class': 'class', 'clase': 'class', 'класс': 'class', '类': 'class', 'クラス': 'class',
-            'si': 'if', 'if': 'if', 'если': 'if', '如果': 'if', 'もし': 'if',
-            'sinon': 'else', 'else': 'else', 'sino': 'else', 'иначе': 'else', '否则': 'else', 'そうでなければ': 'else',
-            'sinon si': 'else if', 'else if': 'else if', 'sino si': 'else if', 'иначе если': 'else if', '否则如果': 'else if', 'そうでなければもし': 'else if',
-            'pour': 'for', 'for': 'for', 'para': 'for', 'для': 'for', '为': 'for', 'ために': 'for',
-            'tant que': 'while', 'while': 'while', 'mientras': 'while', 'пока': 'while', '当': 'while', 'ながら': 'while',
-            'faire': 'do', 'do': 'do', 'hacer': 'do', 'делать': 'do', '做': 'do', 'する': 'do',
-            'selon': 'switch', 'switch': 'switch', 'según': 'switch', 'segun': 'switch', 'переключатель': 'switch', '开关': 'switch', 'スイッチ': 'switch',
-            'cas': 'case', 'case': 'case', 'caso': 'case', 'случай': 'case', '情况': 'case', 'ケース': 'case',
-            'defaut': 'default', 'défaut': 'default', 'default': 'default', 'predeterminado': 'default', 'по умолчанию': 'default', '默认': 'default', 'デフォルト': 'default',
-            'sortir': 'break', 'break': 'break', 'romper': 'break', 'прервать': 'break', '跳出': 'break', 'ブレーク': 'break',
-            'continuer': 'continue', 'continue': 'continue', 'continuar': 'continue', 'продолжить': 'continue', '继续': 'continue', 'コンティニュー': 'continue',
-            'retourner': 'return', 'return': 'return', 'retornar': 'return', 'вернуть': 'return', '返回': 'return', 'リターン': 'return',
-            'lancer': 'throw', 'throw': 'throw', 'lanzar': 'throw', 'бросить': 'throw', '抛出': 'throw', 'スロー': 'throw',
-            'essayer': 'try', 'try': 'try', 'intentar': 'try', 'попробовать': 'try', '尝试': 'try', 'トライ': 'try',
-            'attraper': 'catch', 'catch': 'catch', 'capturar': 'catch', 'поймать': 'catch', '捕获': 'catch', 'キャッチ': 'catch',
-            'finalement': 'finally', 'finally': 'finally', 'finalmente': 'finally', 'наконец': 'finally', '最终': 'finally', 'ファイナリー': 'finally',
-            'importer': 'import', 'import': 'import', 'importar': 'import', 'импортировать': 'import', '导入': 'import', 'インポート': 'import',
-            'exporter': 'export', 'export': 'export', 'exportar': 'export', 'экспортировать': 'export', '导出': 'export', 'エクスポート': 'export',
-            'depuis': 'from', 'from': 'from', 'de': 'from', 'desde': 'from', 'из': 'from', '从': 'from', 'から': 'from',
-            'comme': 'as', 'as': 'as', 'como': 'as', 'как': 'as', '作为': 'as', 'として': 'as',
-            'nouveau': 'new', 'new': 'new', 'nuevo': 'new', 'новый': 'new', '新建': 'new', '新規': 'new',
-            'ceci': 'this', 'this': 'this', 'esto': 'this', 'это': 'this', '这个': 'this', 'これ': 'this',
-            'parent': 'super', 'super': 'super', 'padre': 'super', 'родитель': 'super', '父类': 'super', 'スーパー': 'super',
-            'etend': 'extends', 'étend': 'extends', 'extends': 'extends', 'extiende': 'extends', 'расширяет': 'extends', '扩展': 'extends', '拡張': 'extends',
-            'statique': 'static', 'static': 'static', 'estático': 'static', 'estatico': 'static', 'статический': 'static', '静态': 'static', '静的': 'static',
-            'obtenir': 'get', 'get': 'get', 'получить': 'get', '获取': 'get', 'ゲット': 'get',
-            'definir': 'set', 'définir': 'set', 'set': 'set', 'establecer': 'set', 'установить': 'set', '设置': 'set', 'セット': 'set',
-            'asynchrone': 'async', 'async': 'async', 'asíncrona': 'async', 'asincrona': 'async', 'асинхронный': 'async', '异步': 'async', '非同期': 'async',
-            'attendre': 'await', 'await': 'await', 'esperar': 'await', 'ждать': 'await', '等待': 'await', 'アウェイト': 'await',
-            'ceder': 'yield', 'céder': 'yield', 'yield': 'yield', 'уступить': 'yield', '产出': 'yield', 'イールド': 'yield',
-            'utilisant': 'using', 'using': 'using', 'usando': 'using', 'используя': 'using', '使用': 'using', '使用中': 'using',
-            'vrai': 'true', 'true': 'true', 'verdadero': 'true', 'истина': 'true', '真': 'true', '真実': 'true',
-            'faux': 'false', 'false': 'false', 'falso': 'false', 'ложь': 'false', '假': 'false', '偽': 'false',
-            'nul': 'null', 'null': 'null', 'nulo': 'null', 'ноль': 'null', '空': 'null', 'ヌル': 'null',
-            'indefini': 'undefined', 'indéfini': 'undefined', 'undefined': 'undefined', 'indefinido': 'undefined', 'неопределено': 'undefined', '未定义': 'undefined', '未定義': 'undefined',
-            'type de': 'typeof', 'typeof': 'typeof', 'tipo de': 'typeof', 'тип': 'typeof', '类型': 'typeof', 'タイプ': 'typeof',
-            'instance de': 'instanceof', 'instanceof': 'instanceof', 'instancia de': 'instanceof', 'экземпляр': 'instanceof', '实例': 'instanceof', 'インスタンス': 'instanceof',
-            'dans': 'in', 'in': 'in', 'en': 'in', 'в': 'in', '在': 'in', '中': 'in',
-            'de': 'of', 'of': 'of', 'из': 'of', '的': 'of', 'の': 'of',
-            'supprimer': 'delete', 'delete': 'delete', 'eliminar': 'delete', 'удалить': 'delete', '删除': 'delete', '削除': 'delete',
-            'vide': 'void', 'void': 'void', 'vacío': 'void', 'vacio': 'void', 'пустой': 'void', '空值': 'void', 'ボイド': 'void',
-            'debogueur': 'debugger', 'débogueur': 'debugger', 'debugger': 'debugger', 'depurador': 'debugger', 'отладчик': 'debugger', '调试器': 'debugger', 'デバッガー': 'debugger',
-            'avec': 'with', 'with': 'with', 'con': 'with', 'с': 'with', '与': 'with', 'と': 'with'
-        }
-        
-        return translations[lowerWord] || word
-    }
-}
-
-class JSCodeGenerator {
-    constructor(options = {}) {
-        this.indent = 0
-        this.indentStr = options.indentStr || '  '
-    }
-
-    generate(ast) {
-        if (!ast) return ''
-        
-        const method = `generate${ast.type}`
-        if (this[method]) {
-            return this[method](ast)
-        }
-        
-        return ''
-    }
-
-    generateProgram(node) {
-        return node.body.map(stmt => this.generate(stmt)).join('\n')
-    }
-
-    generateIdentifier(node) {
-        return node.name
-    }
-
-    generateLiteral(node) {
-        return node.raw || String(node.value)
-    }
-
-    generateStringLiteral(node) {
-        return node.raw || `"${node.value}"`
-    }
-
-    generateNumericLiteral(node) {
-        return node.raw || String(node.value)
-    }
-
-    generateBooleanLiteral(node) {
-        return String(node.value)
-    }
-
-    generateNullLiteral() {
-        return 'null'
-    }
-
-    generateBigIntLiteral(node) {
-        return node.raw || `${node.value}n`
-    }
-
-    generateRegExpLiteral(node) {
-        return `/${node.pattern}/${node.flags}`
-    }
-
-    generateTemplateLiteral(node) {
-        let result = '`'
-        for (let i = 0; i < node.quasis.length; i++) {
-            result += node.quasis[i].value.raw || node.quasis[i].value
-            if (i < node.expressions.length) {
-                result += '${' + this.generate(node.expressions[i]) + '}'
-            }
-        }
-        result += '`'
-        return result
-    }
-
-    generateVariableDeclaration(node) {
-        const declarations = node.declarations.map(d => this.generate(d)).join(', ')
-        return `${node.kind} ${declarations};`
-    }
-
-    generateVariableDeclarator(node) {
-        let result = this.generate(node.id)
-        if (node.init) {
-            result += ' = ' + this.generate(node.init)
-        }
-        return result
-    }
-
-    generateFunctionDeclaration(node) {
-        let result = ''
-        if (node.async) result += 'async '
-        result += 'function'
-        if (node.generator) result += '*'
-        result += ' ' + this.generate(node.id)
-        result += '(' + node.params.map(p => this.generate(p)).join(', ') + ') '
-        result += this.generate(node.body)
-        return result
-    }
-
-    generateFunctionExpression(node) {
-        let result = ''
-        if (node.async) result += 'async '
-        result += 'function'
-        if (node.generator) result += '*'
-        if (node.id) result += ' ' + this.generate(node.id)
-        result += '(' + node.params.map(p => this.generate(p)).join(', ') + ') '
-        result += this.generate(node.body)
-        return result
-    }
-
-    generateArrowFunctionExpression(node) {
-        let result = ''
-        if (node.async) result += 'async '
-        
-        if (node.params.length === 1 && node.params[0].type === 'Identifier') {
-            result += this.generate(node.params[0])
-        } else {
-            result += '(' + node.params.map(p => this.generate(p)).join(', ') + ')'
-        }
-        
-        result += ' => '
-        
-        if (node.expression) {
-            result += this.generate(node.body)
-        } else {
-            result += this.generate(node.body)
-        }
-        
-        return result
-    }
-
-    generateClassDeclaration(node) {
-        let result = 'class ' + this.generate(node.id)
-        if (node.superClass) {
-            result += ' extends ' + this.generate(node.superClass)
-        }
-        result += ' ' + this.generate(node.body)
-        return result
-    }
-
-    generateClassBody(node) {
-        this.indent++
-        const body = node.body.map(m => this.getIndent() + this.generate(m)).join('\n')
-        this.indent--
-        return '{\n' + body + '\n' + this.getIndent() + '}'
-    }
-
-    generateMethodDefinition(node) {
-        let result = ''
-        if (node.static) result += 'static '
-        if (node.kind === 'get') result += 'get '
-        if (node.kind === 'set') result += 'set '
-        if (node.value.async) result += 'async '
-        if (node.value.generator) result += '*'
-        
-        if (node.computed) {
-            result += '[' + this.generate(node.key) + ']'
-        } else {
-            result += this.generate(node.key)
-        }
-        
-        result += '(' + node.value.params.map(p => this.generate(p)).join(', ') + ') '
-        result += this.generate(node.value.body)
-        
-        return result
-    }
-
-    generatePropertyDefinition(node) {
-        let result = ''
-        if (node.static) result += 'static '
-        
-        if (node.computed) {
-            result += '[' + this.generate(node.key) + ']'
-        } else {
-            result += this.generate(node.key)
-        }
-        
-        if (node.value) {
-            result += ' = ' + this.generate(node.value)
-        }
-        
-        return result + ';'
-    }
-
-    generatePrivateIdentifier(node) {
-        return '#' + node.name
-    }
-
-    generateBlockStatement(node) {
-        this.indent++
-        const body = node.body.map(s => this.getIndent() + this.generate(s)).join('\n')
-        this.indent--
-        return '{\n' + body + '\n' + this.getIndent() + '}'
-    }
-
-    generateExpressionStatement(node) {
-        return this.generate(node.expression) + ';'
-    }
-
-    generateEmptyStatement() {
-        return ';'
-    }
-
-    generateReturnStatement(node) {
-        if (node.argument) {
-            return 'return ' + this.generate(node.argument) + ';'
-        }
-        return 'return;'
-    }
-
-    generateBreakStatement(node) {
-        if (node.label) {
-            return 'break ' + this.generate(node.label) + ';'
-        }
-        return 'break;'
-    }
-
-    generateContinueStatement(node) {
-        if (node.label) {
-            return 'continue ' + this.generate(node.label) + ';'
-        }
-        return 'continue;'
-    }
-
-    generateIfStatement(node) {
-        let result = 'if (' + this.generate(node.test) + ') ' + this.generate(node.consequent)
-        if (node.alternate) {
-            result += ' else ' + this.generate(node.alternate)
-        }
-        return result
-    }
-
-    generateSwitchStatement(node) {
-        let result = 'switch (' + this.generate(node.discriminant) + ') {\n'
-        this.indent++
-        result += node.cases.map(c => this.getIndent() + this.generate(c)).join('\n')
-        this.indent--
-        result += '\n' + this.getIndent() + '}'
-        return result
-    }
-
-    generateSwitchCase(node) {
-        let result = node.test ? 'case ' + this.generate(node.test) + ':' : 'default:'
-        if (node.consequent.length > 0) {
-            this.indent++
-            result += '\n' + node.consequent.map(s => this.getIndent() + this.generate(s)).join('\n')
-            this.indent--
-        }
-        return result
-    }
-
-    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) + ');'
-    }
-
-    generateForStatement(node) {
-        let result = 'for ('
-        if (node.init) {
-            if (node.init.type === 'VariableDeclaration') {
-                result += node.init.kind + ' ' + node.init.declarations.map(d => this.generate(d)).join(', ')
-            } else {
-                result += this.generate(node.init)
-            }
-        }
-        result += '; '
-        if (node.test) result += this.generate(node.test)
-        result += '; '
-        if (node.update) result += this.generate(node.update)
-        result += ') ' + this.generate(node.body)
-        return result
-    }
-
-    generateForInStatement(node) {
-        let left
-        if (node.left.type === 'VariableDeclaration') {
-            left = node.left.kind + ' ' + this.generate(node.left.declarations[0].id)
-        } else {
-            left = this.generate(node.left)
-        }
-        return 'for (' + left + ' in ' + this.generate(node.right) + ') ' + this.generate(node.body)
-    }
-
-    generateForOfStatement(node) {
-        let left
-        if (node.left.type === 'VariableDeclaration') {
-            left = node.left.kind + ' ' + this.generate(node.left.declarations[0].id)
-        } else {
-            left = this.generate(node.left)
-        }
-        const await_ = node.await ? 'await ' : ''
-        return 'for ' + await_ + '(' + left + ' of ' + this.generate(node.right) + ') ' + this.generate(node.body)
-    }
-
-    generateTryStatement(node) {
-        let result = 'try ' + this.generate(node.block)
-        if (node.handler) {
-            result += ' ' + this.generate(node.handler)
-        }
-        if (node.finalizer) {
-            result += ' finally ' + this.generate(node.finalizer)
-        }
-        return result
-    }
-
-    generateCatchClause(node) {
-        let result = 'catch'
-        if (node.param) {
-            result += ' (' + this.generate(node.param) + ')'
-        }
-        result += ' ' + this.generate(node.body)
-        return result
-    }
-
-    generateThrowStatement(node) {
-        return 'throw ' + this.generate(node.argument) + ';'
-    }
-
-    generateDebuggerStatement() {
-        return 'debugger;'
-    }
-
-    generateBinaryExpression(node) {
-        return '(' + this.generate(node.left) + ' ' + node.operator + ' ' + this.generate(node.right) + ')'
-    }
-
-    generateLogicalExpression(node) {
-        return '(' + this.generate(node.left) + ' ' + node.operator + ' ' + this.generate(node.right) + ')'
-    }
-
-    generateUnaryExpression(node) {
-        if (node.prefix) {
-            const space = /[a-z]/i.test(node.operator) ? ' ' : ''
-            return node.operator + space + this.generate(node.argument)
-        }
-        return this.generate(node.argument) + node.operator
-    }
-
-    generateUpdateExpression(node) {
-        if (node.prefix) {
-            return node.operator + this.generate(node.argument)
-        }
-        return this.generate(node.argument) + node.operator
-    }
-
-    generateAssignmentExpression(node) {
-        return this.generate(node.left) + ' ' + node.operator + ' ' + this.generate(node.right)
-    }
-
-    generateConditionalExpression(node) {
-        return '(' + this.generate(node.test) + ' ? ' + this.generate(node.consequent) + ' : ' + this.generate(node.alternate) + ')'
-    }
-
-    generateCallExpression(node) {
-        const callee = this.generate(node.callee)
-        const args = node.arguments.map(a => this.generate(a)).join(', ')
-        const opt = node.optional ? '?.' : ''
-        return callee + opt + '(' + 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 obj = this.generate(node.object)
-        const prop = this.generate(node.property)
-        const opt = node.optional ? '?' : ''
-        
-        if (node.computed) {
-            return obj + opt + '[' + prop + ']'
-        }
-        return obj + opt + '.' + prop
-    }
-
-    generateThisExpression() {
-        return 'this'
-    }
-
-    generateSuper() {
-        return 'super'
-    }
-
-    generateSpreadElement(node) {
-        return '...' + this.generate(node.argument)
-    }
-
-    generateRestElement(node) {
-        return '...' + this.generate(node.argument)
-    }
-
-    generateYieldExpression(node) {
-        let result = 'yield'
-        if (node.delegate) result += '*'
-        if (node.argument) result += ' ' + this.generate(node.argument)
-        return result
-    }
-
-    generateAwaitExpression(node) {
-        return 'await ' + this.generate(node.argument)
-    }
-
-    generateArrayExpression(node) {
-        const elements = node.elements.map(e => e ? this.generate(e) : '').join(', ')
-        return '[' + elements + ']'
-    }
-
-    generateObjectExpression(node) {
-        if (node.properties.length === 0) return '{}'
-        
-        this.indent++
-        const props = node.properties.map(p => this.getIndent() + this.generate(p)).join(',\n')
-        this.indent--
-        return '{\n' + props + '\n' + this.getIndent() + '}'
-    }
-
-    generateProperty(node) {
-        if (node.type === 'SpreadElement') {
-            return this.generate(node)
-        }
-        
-        if (node.shorthand) {
-            return this.generate(node.key)
-        }
-        
-        let result = ''
-        if (node.kind === 'get') result += 'get '
-        if (node.kind === 'set') result += 'set '
-        
-        if (node.computed) {
-            result += '[' + this.generate(node.key) + ']'
-        } else {
-            result += this.generate(node.key)
-        }
-        
-        if (node.method) {
-            result += '(' + node.value.params.map(p => this.generate(p)).join(', ') + ') '
-            result += this.generate(node.value.body)
-        } else {
-            result += ': ' + this.generate(node.value)
-        }
-        
-        return result
-    }
-
-    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 + ' }'
-    }
-
-    generateAssignmentPattern(node) {
-        return this.generate(node.left) + ' = ' + this.generate(node.right)
-    }
-
-    generateImportDeclaration(node) {
-        if (node.specifiers.length === 0) {
-            return 'import ' + this.generate(node.source) + ';'
-        }
-        
-        const specifiers = []
-        let defaultSpec = null
-        let namespaceSpec = null
-        const namedSpecs = []
-        
-        for (const spec of node.specifiers) {
-            if (spec.type === 'ImportDefaultSpecifier') {
-                defaultSpec = this.generate(spec.local)
-            } else if (spec.type === 'ImportNamespaceSpecifier') {
-                namespaceSpec = '* as ' + this.generate(spec.local)
-            } else {
-                const imported = this.generate(spec.imported)
-                const local = this.generate(spec.local)
-                if (imported === local) {
-                    namedSpecs.push(imported)
-                } else {
-                    namedSpecs.push(imported + ' as ' + local)
-                }
-            }
-        }
-        
-        if (defaultSpec) specifiers.push(defaultSpec)
-        if (namespaceSpec) specifiers.push(namespaceSpec)
-        if (namedSpecs.length > 0) specifiers.push('{ ' + namedSpecs.join(', ') + ' }')
-        
-        return 'import ' + specifiers.join(', ') + ' from ' + this.generate(node.source) + ';'
-    }
-
-    generateExportNamedDeclaration(node) {
-        if (node.declaration) {
-            return 'export ' + this.generate(node.declaration)
-        }
-        
-        const specifiers = node.specifiers.map(s => {
-            const local = this.generate(s.local)
-            const exported = this.generate(s.exported)
-            return local === exported ? local : local + ' as ' + exported
-        }).join(', ')
-        
-        let result = 'export { ' + specifiers + ' }'
-        if (node.source) {
-            result += ' from ' + this.generate(node.source)
-        }
-        return result + ';'
-    }
-
-    generateExportDefaultDeclaration(node) {
-        return 'export default ' + this.generate(node.declaration) + (node.declaration.type?.includes('Declaration') ? '' : ';')
-    }
-
-    generateExportAllDeclaration(node) {
-        let result = 'export *'
-        if (node.exported) {
-            result += ' as ' + this.generate(node.exported)
-        }
-        result += ' from ' + this.generate(node.source) + ';'
-        return result
-    }
-
-    generateUsingDeclaration(node) {
-        let result = ''
-        if (node.await) result += 'await '
-        result += 'using '
-        result += node.declarations.map(d => this.generate(d)).join(', ')
-        return result + ';'
-    }
-
-    getIndent() {
-        return this.indentStr.repeat(this.indent)
-    }
-}
-
-module.exports = {
-    JSLexer,
-    JSParser,
-    JSCodeGenerator
-}