ether-code 0.1.6 → 0.1.8

package/parsers/ts-parser.js

@@ -1,3881 +0,0 @@
-const fs = require('fs')
-const AST = require('./ast-ts')
-
-
-const TS_KEYWORDS = {
-    'interface': 'interface', 'interfaz': 'interface', 'интерфейс': 'interface', '接口': 'interface', 'インターフェース': 'interface',
-    'type': 'type', 'tipo': 'type', 'тип': 'type', '类型': 'type', 'タイプ': 'type',
-    'enumeration': 'enum', 'énumération': 'enum', 'enum': 'enum', 'enumeracion': 'enum', 'enumeración': 'enum', 'перечисление': 'enum', '枚举': 'enum', '列挙': 'enum',
-    'espaceNom': 'namespace', 'namespace': 'namespace', 'espacioNombre': 'namespace', 'пространствоИмен': 'namespace', '命名空间': 'namespace', '名前空間': 'namespace',
-    'declarer': 'declare', 'déclarer': 'declare', 'declare': 'declare', 'declarar': 'declare', 'объявить': 'declare', '声明': 'declare', '宣言': 'declare',
-    'module': 'module', 'modulo': 'module', 'módulo': 'module', 'модуль': 'module', '模块': 'module', 'モジュール': 'module',
-    
-    'public': 'public', 'publico': 'public', 'público': 'public', 'публичный': 'public', '公开': 'public', 'パブリック': 'public',
-    'prive': 'private', 'privé': 'private', 'private': 'private', 'privado': 'private', 'приватный': 'private', '私有': 'private', 'プライベート': 'private',
-    'protege': 'protected', 'protégé': 'protected', 'protected': 'protected', 'protegido': 'protected', 'защищенный': 'protected', '受保护': 'protected', 'プロテクト': 'protected',
-    'lectureSeule': 'readonly', 'readonly': 'readonly', 'soloLectura': 'readonly', 'толькоЧтение': 'readonly', '只读': 'readonly', '読み取り専用': 'readonly',
-    'statique': 'static', 'static': 'static', 'estatico': 'static', 'estático': 'static', 'статический': 'static', '静态': 'static', 'スタティック': 'static',
-    'abstrait': 'abstract', 'abstract': 'abstract', 'abstracto': 'abstract', 'абстрактный': 'abstract', '抽象': 'abstract', 'アブストラクト': 'abstract',
-    
-    'etend': 'extends', 'étend': 'extends', 'extends': 'extends', 'extiende': 'extends', 'расширяет': 'extends', '扩展': 'extends', '拡張': 'extends',
-    'implemente': 'implements', 'implémente': 'implements', 'implements': 'implements', 'implementa': 'implements', 'реализует': 'implements', '实现': 'implements', '実装': 'implements',
-    'redefinir': 'override', 'redéfinir': 'override', 'override': 'override', 'anular': 'override', 'переопределить': 'override', '覆盖': 'override', 'オーバーライド': 'override',
-    
-    'comme': 'as', 'as': 'as', 'como': 'as', 'как': 'as', '作为': 'as', 'として': 'as',
-    'est': 'is', 'is': 'is', 'es': 'is', 'является': 'is', '是': 'is', 'である': 'is',
-    'affirme': 'asserts', 'asserts': 'asserts', 'afirma': 'asserts', 'утверждает': 'asserts', '断言': 'asserts', 'アサート': 'asserts',
-    'satisfait': 'satisfies', 'satisfies': 'satisfies', 'satisface': 'satisfies', 'удовлетворяет': 'satisfies', '满足': 'satisfies', '満たす': 'satisfies',
-    
-    'cleDe': 'keyof', 'cléDe': 'keyof', 'keyof': 'keyof', 'claveDe': 'keyof', 'ключ': 'keyof', '键类型': 'keyof', 'キー型': 'keyof',
-    'typeDe': 'typeof', 'typeof': 'typeof', 'tipoDe': 'typeof', 'типОт': 'typeof', '类型': 'typeof', 'タイプオブ': 'typeof',
-    'inferer': 'infer', 'inférer': 'infer', 'infer': 'infer', 'inferir': 'infer', 'выводить': 'infer', '推断': 'infer', '推論': 'infer',
-    
-    'constructeur': 'constructor', 'constructor': 'constructor', 'конструктор': 'constructor', '构造函数': 'constructor', 'コンストラクタ': 'constructor',
-    'obtenir': 'get', 'get': 'get', 'obtener': 'get', 'получить': 'get', '获取': 'get', 'ゲット': 'get',
-    'definir': 'set', 'définir': 'set', 'set': 'set', 'establecer': 'set', 'установить': 'set', '设置': 'set', 'セット': 'set',
-    
-    'si': 'if', 'if': 'if', 'если': 'if', '如果': 'if', 'もし': 'if',
-    'sinon': 'else', 'else': 'else', 'sino': 'else', 'иначе': 'else', '否则': 'else', 'そうでなければ': 'else',
-    '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', 'segun': 'switch', 'según': 'switch', 'переключатель': 'switch', '开关': 'switch', 'スイッチ': 'switch',
-    'cas': 'case', 'case': 'case', 'caso': 'case', 'случай': 'case', '情况': 'case', 'ケース': 'case',
-    'defaut': 'default', 'défaut': 'default', 'default': 'default', 'porDefecto': 'default', 'поумолчанию': 'default', '默认': 'default', 'デフォルト': 'default',
-    'continuer': 'continue', 'continue': 'continue', 'continuar': 'continue', 'продолжить': 'continue', '继续': 'continue', '続ける': 'continue',
-    'sortir': 'break', 'break': 'break', 'romper': 'break', 'прервать': 'break', '中断': 'break', 'ブレーク': 'break',
-    'retourner': 'return', 'return': 'return', 'retornar': 'return', 'возвращать': 'return', '返回': 'return', '戻る': 'return',
-    
-    'fonction': 'function', 'function': 'function', 'funcion': 'function', 'función': 'function', 'функция': 'function', '函数': 'function', '関数': 'function',
-    'classe': 'class', 'class': 'class', 'clase': 'class', 'класс': 'class', '类': 'class', 'クラス': 'class',
-    'nouveau': 'new', 'new': 'new', 'nuevo': 'new', 'новый': 'new', '新建': 'new', '新規': 'new',
-    
-    'constante': 'const', 'const': 'const', 'константа': 'const', '常量': 'const', '定数': 'const',
-    'variable': 'let', 'let': 'let', 'переменная': 'let', '变量': 'let', '変数': 'let',
-    'var': 'var',
-    
-    'essayer': 'try', 'try': 'try', 'intentar': 'try', 'попробовать': 'try', '尝试': 'try', 'トライ': 'try',
-    'attraper': 'catch', 'catch': 'catch', 'capturar': 'catch', 'поймать': 'catch', '捕获': 'catch', 'キャッチ': 'catch',
-    'enfin': 'finally', 'finally': 'finally', 'finalmente': 'finally', 'наконец': 'finally', '最终': 'finally', 'ファイナリー': 'finally',
-    'lancer': 'throw', 'throw': 'throw', 'lanzar': 'throw', 'бросить': 'throw', '抛出': 'throw', 'スロー': 'throw',
-    
-    'importer': 'import', 'import': 'import', 'importar': 'import', 'импортировать': 'import', '导入': 'import', 'インポート': 'import',
-    'exporter': 'export', 'export': 'export', 'exportar': 'export', 'экспортировать': 'export', '导出': 'export', 'エクスポート': 'export',
-    'depuis': 'from', 'from': 'from', 'desde': 'from', 'из': 'from', '从': 'from', 'から': 'from',
-    
-    'asynchrone': 'async', 'async': 'async', 'asincrono': 'async', 'asíncrono': 'async', 'асинхронный': 'async', '异步': 'async', '非同期': 'async',
-    'attendre': 'await', 'await': 'await', 'esperar': 'await', 'ожидать': 'await', '等待': 'await', '待つ': 'await',
-    
-    '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',
-    
-    'dans': 'in', 'in': 'in', 'en': 'in', 'в': 'in', '在': 'in', 'の中': 'in',
-    'de': 'of', 'of': 'of', 'от': 'of', '的': 'of', 'の': 'of',
-    'instanceDe': 'instanceof', 'instanceof': 'instanceof', 'instanciaDe': 'instanceof', 'экземпляр': 'instanceof', '实例': 'instanceof', 'インスタンス': 'instanceof',
-    'supprimer': 'delete', 'delete': 'delete', 'eliminar': 'delete', 'удалить': 'delete', '删除': 'delete', '削除': 'delete',
-    
-    'soi': 'this', 'this': 'this', 'esto': 'this', 'это': 'this', '这': 'this', 'これ': 'this',
-    'super': 'super', 'супер': 'super', '超级': 'super', 'スーパー': 'super',
-    
-    'ou': 'or', 'or': 'or', 'o': 'or', 'или': 'or', '或': 'or', 'または': 'or',
-    'et': 'and', 'and': 'and', 'y': 'and', 'и': 'and', '且': 'and', 'かつ': 'and'
-}
-
-const TS_TYPES = {
-    'chaine': 'string', 'chaîne': 'string', 'string': 'string', 'cadena': 'string', 'строка': 'string', '字符串': 'string', '文字列': 'string',
-    'nombre': 'number', 'number': 'number', 'numero': 'number', 'número': 'number', 'число': 'number', '数字': 'number', '数値': 'number',
-    'booleen': 'boolean', 'booléen': 'boolean', 'boolean': 'boolean', 'booleano': 'boolean', 'логический': 'boolean', '布尔': 'boolean', 'ブール': 'boolean',
-    'objet': 'object', 'object': 'object', 'objeto': 'object', 'объект': 'object', '对象': 'object', 'オブジェクト': 'object',
-    'symbole': 'symbol', 'symbol': 'symbol', 'simbolo': 'symbol', 'símbolo': 'symbol', 'символ': 'symbol', '符号': 'symbol', 'シンボル': 'symbol',
-    'grandEntier': 'bigint', 'bigint': 'bigint', 'enteroGrande': 'bigint', 'большоеЦелое': 'bigint', '大整数': 'bigint', 'ビッグイント': 'bigint',
-    
-    'quelconque': 'any', 'any': 'any', 'cualquier': 'any', 'любой': 'any', '任意': 'any', '任意型': 'any',
-    'inconnu': 'unknown', 'unknown': 'unknown', 'desconocido': 'unknown', 'неизвестный': 'unknown', '未知': 'unknown', '不明': 'unknown',
-    'jamais': 'never', 'never': 'never', 'nunca': 'never', 'никогда': 'never', '永不': 'never', '決して': 'never',
-    'vide': 'void', 'void': 'void', 'vacio': 'void', 'vacío': 'void', 'пустой': 'void', '空': 'void', 'ボイド': 'void',
-    
-    'Tableau': 'Array', 'Array': 'Array', 'Arreglo': 'Array', 'Массив': 'Array', '数组': 'Array', '配列': 'Array',
-    'Promesse': 'Promise', 'Promise': 'Promise', 'Promesa': 'Promise', 'Промис': 'Promise', '承诺': 'Promise', 'プロミス': 'Promise',
-    'Ensemble': 'Set', 'Set': 'Set', 'Conjunto': 'Set', 'Набор': 'Set', '集合': 'Set', 'セット': 'Set',
-    'Map': 'Map', 'Carte': 'Map', 'Mapa': 'Map', 'Карта': 'Map', '映射': 'Map', 'マップ': 'Map',
-    
-    'Partiel': 'Partial', 'Partial': 'Partial', 'Parcial': 'Partial', 'Частичный': 'Partial', '部分': 'Partial', '部分的': 'Partial',
-    'Requis': 'Required', 'Required': 'Required', 'Requerido': 'Required', 'Обязательный': 'Required', '必需': 'Required', '必須': 'Required',
-    'LectureSeule': 'Readonly', 'Readonly': 'Readonly', 'SoloLectura': 'Readonly', 'ТолькоЧтение': 'Readonly', '只读类型': 'Readonly', '読み取り専用型': 'Readonly',
-    'Choisir': 'Pick', 'Pick': 'Pick', 'Elegir': 'Pick', 'Выбрать': 'Pick', '选取': 'Pick', 'ピック': 'Pick',
-    'Omettre': 'Omit', 'Omit': 'Omit', 'Omitir': 'Omit', 'Опустить': 'Omit', '省略': 'Omit', 'オミット': 'Omit',
-    'Exclure': 'Exclude', 'Exclude': 'Exclude', 'Excluir': 'Exclude', 'Исключить': 'Exclude', '排除': 'Exclude', '除外': 'Exclude',
-    'Extraire': 'Extract', 'Extract': 'Extract', 'Extraer': 'Extract', 'Извлечь': 'Extract', '提取': 'Extract', '抽出': 'Extract',
-    'NonNul': 'NonNullable', 'NonNullable': 'NonNullable', 'NoNulo': 'NonNullable', 'НеНулевой': 'NonNullable', '非空': 'NonNullable', '非ヌル': 'NonNullable',
-    'TypeRetour': 'ReturnType', 'ReturnType': 'ReturnType', 'TipoRetorno': 'ReturnType', 'ТипВозврата': 'ReturnType', '返回类型': 'ReturnType', '戻り型': 'ReturnType',
-    'Parametres': 'Parameters', 'Paramètres': 'Parameters', 'Parameters': 'Parameters', 'Parametros': 'Parameters', 'Parámetros': 'Parameters', 'Параметры': 'Parameters', '参数': 'Parameters', 'パラメータ': 'Parameters',
-    'TypeInstance': 'InstanceType', 'InstanceType': 'InstanceType', 'TipoInstancia': 'InstanceType', 'ТипЭкземпляра': 'InstanceType', '实例类型': 'InstanceType', 'インスタンス型': 'InstanceType',
-    'Enregistrement': 'Record', 'Record': 'Record', 'Registro': 'Record', 'Запись': 'Record', '记录': 'Record', 'レコード': 'Record',
-    'Attendu': 'Awaited', 'Awaited': 'Awaited', 'Esperado': 'Awaited', 'Ожидаемый': 'Awaited', '等待': 'Awaited', '待機': 'Awaited',
-    'Majuscule': 'Uppercase', 'Uppercase': 'Uppercase', 'Mayuscula': 'Uppercase', 'Mayúscula': 'Uppercase', 'Верхний': 'Uppercase', '大写': 'Uppercase', '大文字': 'Uppercase',
-    'Minuscule': 'Lowercase', 'Lowercase': 'Lowercase', 'Minuscula': 'Lowercase', 'Minúscula': 'Lowercase', 'Нижний': 'Lowercase', '小写': 'Lowercase', '小文字': 'Lowercase',
-    'Capitaliser': 'Capitalize', 'Capitalize': 'Capitalize', 'Capitalizar': 'Capitalize', 'Капитализировать': 'Capitalize', '首字母大写': 'Capitalize', '先頭大文字': 'Capitalize',
-    'Decapitaliser': 'Uncapitalize', 'Décapitaliser': 'Uncapitalize', 'Uncapitalize': 'Uncapitalize', 'Descapitalizar': 'Uncapitalize', 'Декапитализировать': 'Uncapitalize', '首字母小写': 'Uncapitalize', '先頭小文字': 'Uncapitalize'
-}
-
-class TSLexer {
-    constructor(source, i18n = {}) {
-        this.source = source
-        this.pos = 0
-        this.line = 1
-        this.column = 1
-        this.tokens = []
-        this.i18n = i18n
-    }
-
-    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 && /\s/.test(this.peek())) {
-            this.advance()
-        }
-    }
-
-    skipComment() {
-        if (this.peek() === '/' && this.peek(1) === '/') {
-            while (this.pos < this.source.length && this.peek() !== '\n') {
-                this.advance()
-            }
-            return true
-        }
-        if (this.peek() === '/' && this.peek(1) === '*') {
-            this.advance()
-            this.advance()
-            while (this.pos < this.source.length) {
-                if (this.peek() === '*' && this.peek(1) === '/') {
-                    this.advance()
-                    this.advance()
-                    break
-                }
-                this.advance()
-            }
-            return true
-        }
-        return false
-    }
-
-    tokenize() {
-        while (this.pos < this.source.length) {
-            this.skipWhitespace()
-            while (this.skipComment()) {
-                this.skipWhitespace()
-            }
-            if (this.pos >= this.source.length) break
-
-            const loc = { line: this.line, column: this.column }
-            const char = this.peek()
-
-            if (char === '"' || char === "'" || char === '`') {
-                this.tokens.push(this.readString(char))
-                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)) {
-                this.tokens.push(this.readWord())
-                continue
-            }
-
-            if (char === '@') {
-                this.advance()
-                this.tokens.push({ type: 'AT', value: '@', loc })
-                continue
-            }
-
-            if (char === '#') {
-                this.advance()
-                const name = this.readIdentifier()
-                this.tokens.push({ type: 'PRIVATE_IDENTIFIER', value: name, loc })
-                continue
-            }
-
-            const token = this.readOperator()
-            if (token) {
-                this.tokens.push(token)
-                continue
-            }
-
-            this.advance()
-        }
-
-        this.tokens.push({ type: 'EOF', loc: { line: this.line, column: this.column } })
-        return this.tokens
-    }
-
-    readIdentifier() {
-        let name = ''
-        while (this.pos < this.source.length && /[a-zA-Z0-9À-ÿА-яぁ-ゟァ-ヿ一-龯_$]/.test(this.peek())) {
-            name += this.advance()
-        }
-        return name
-    }
-
-    readWord() {
-        const loc = { line: this.line, column: this.column }
-        let word = this.readIdentifier()
-        
-        const lowerWord = word.toLowerCase()
-        
-        if (TS_KEYWORDS[word] || TS_KEYWORDS[lowerWord]) {
-            return { type: 'KEYWORD', value: word, loc }
-        }
-        
-        if (TS_TYPES[word] || TS_TYPES[lowerWord]) {
-            return { type: 'TYPE', value: word, loc }
-        }
-        
-        return { type: 'IDENTIFIER', value: word, loc }
-    }
-
-    readString(quote) {
-        const loc = { line: this.line, column: this.column }
-        this.advance()
-        
-        if (quote === '`') {
-            return this.readTemplateLiteral(loc)
-        }
-        
-        let value = ''
-        let raw = quote
-        
-        while (this.pos < this.source.length && this.peek() !== quote) {
-            if (this.peek() === '\\') {
-                raw += this.advance()
-                if (this.pos < this.source.length) {
-                    const escaped = this.advance()
-                    raw += escaped
-                    switch (escaped) {
-                        case 'n': value += '\n'; break
-                        case 'r': value += '\r'; break
-                        case 't': value += '\t'; break
-                        case '\\': value += '\\'; break
-                        case quote: value += quote; break
-                        default: value += '\\' + escaped
-                    }
-                }
-            } else {
-                const c = this.advance()
-                value += c
-                raw += c
-            }
-        }
-        
-        if (this.peek() === quote) {
-            raw += this.advance()
-        }
-        
-        return { type: 'STRING', value, raw, loc }
-    }
-
-    readTemplateLiteral(loc) {
-        const quasis = []
-        const expressions = []
-        let current = ''
-        let raw = '`'
-        
-        while (this.pos < this.source.length) {
-            if (this.peek() === '`') {
-                raw += this.advance()
-                quasis.push({ value: current, tail: true })
-                break
-            }
-            
-            if (this.peek() === '$' && this.peek(1) === '{') {
-                quasis.push({ value: current, tail: false })
-                current = ''
-                raw += this.advance() + this.advance()
-                
-                let braceCount = 1
-                let expr = ''
-                while (braceCount > 0 && this.pos < this.source.length) {
-                    const c = this.peek()
-                    if (c === '{') braceCount++
-                    if (c === '}') braceCount--
-                    if (braceCount > 0) {
-                        expr += this.advance()
-                    } else {
-                        raw += this.advance()
-                    }
-                }
-                expressions.push(expr)
-            } else if (this.peek() === '\\') {
-                raw += this.advance()
-                if (this.pos < this.source.length) {
-                    const escaped = this.advance()
-                    raw += escaped
-                    switch (escaped) {
-                        case 'n': current += '\n'; break
-                        case 'r': current += '\r'; break
-                        case 't': current += '\t'; break
-                        default: current += escaped
-                    }
-                }
-            } else {
-                const c = this.advance()
-                current += c
-                raw += c
-            }
-        }
-        
-        return { type: 'TEMPLATE', quasis, expressions, raw, loc }
-    }
-
-    readNumber() {
-        const loc = { line: this.line, column: this.column }
-        let value = ''
-        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())) {
-                value += 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())) {
-                value += 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())) {
-                value += this.advance()
-            }
-        } else {
-            while (/[0-9_]/.test(this.peek())) {
-                value += this.advance()
-            }
-            
-            if (this.peek() === '.' && /[0-9]/.test(this.peek(1))) {
-                value += this.advance()
-                while (/[0-9_]/.test(this.peek())) {
-                    value += this.advance()
-                }
-            }
-            
-            if (this.peek() === 'e' || this.peek() === 'E') {
-                value += this.advance()
-                if (this.peek() === '+' || this.peek() === '-') {
-                    value += this.advance()
-                }
-                while (/[0-9_]/.test(this.peek())) {
-                    value += this.advance()
-                }
-            }
-        }
-        
-        if (this.peek() === 'n') {
-            isBigInt = true
-            this.advance()
-        }
-        
-        const cleanValue = value.replace(/_/g, '')
-        
-        if (isBigInt) {
-            return { type: 'BIGINT', value: cleanValue, raw: value + 'n', loc }
-        }
-        
-        return { 
-            type: 'NUMBER', 
-            value: cleanValue.includes('.') || cleanValue.includes('e') || cleanValue.includes('E') 
-                ? parseFloat(cleanValue) 
-                : parseInt(cleanValue, value.startsWith('0x') ? 16 : value.startsWith('0b') ? 2 : value.startsWith('0o') ? 8 : 10), 
-            raw: value, 
-            loc 
-        }
-    }
-
-    readOperator() {
-        const loc = { line: this.line, column: this.column }
-        
-        const fourChar = this.source.slice(this.pos, this.pos + 4)
-        const threeChar = this.source.slice(this.pos, this.pos + 3)
-        const twoChar = this.source.slice(this.pos, this.pos + 2)
-        const oneChar = this.peek()
-        
-        const fourCharOps = { '>>>=': 'UNSIGNED_RIGHT_SHIFT_ASSIGN' }
-        
-        const threeCharOps = {
-            '===': 'STRICT_EQUAL', '!==': 'STRICT_NOT_EQUAL',
-            '...': 'SPREAD', '>>>': 'UNSIGNED_RIGHT_SHIFT',
-            '**=': 'POW_ASSIGN', '&&=': 'AND_ASSIGN', '||=': 'OR_ASSIGN', '??=': 'NULLISH_ASSIGN',
-            '<<=': 'LEFT_SHIFT_ASSIGN', '>>=': 'RIGHT_SHIFT_ASSIGN'
-        }
-        
-        const twoCharOps = {
-            '==': 'EQUAL', '!=': 'NOT_EQUAL',
-            '<=': 'LTE', '>=': 'GTE',
-            '&&': 'AND', '||': 'OR', '??': 'NULLISH',
-            '++': 'INCREMENT', '--': 'DECREMENT',
-            '**': 'POW', '<<': 'LEFT_SHIFT', '>>': 'RIGHT_SHIFT',
-            '+=': 'PLUS_ASSIGN', '-=': 'MINUS_ASSIGN', '*=': 'TIMES_ASSIGN', '/=': 'DIV_ASSIGN', '%=': 'MOD_ASSIGN',
-            '&=': 'BIT_AND_ASSIGN', '|=': 'BIT_OR_ASSIGN', '^=': 'BIT_XOR_ASSIGN',
-            '=>': 'ARROW', '?.': 'OPTIONAL_CHAIN',
-            '?.': 'OPTIONAL_CHAIN'
-        }
-        
-        const oneCharOps = {
-            '+': 'PLUS', '-': 'MINUS', '*': 'TIMES', '/': 'DIV', '%': 'MOD',
-            '=': 'ASSIGN', '<': 'LT', '>': 'GT', '!': 'NOT', '~': 'TILDE',
-            '&': 'BIT_AND', '|': 'BIT_OR', '^': 'BIT_XOR',
-            '(': 'LPAREN', ')': 'RPAREN', '[': 'LBRACKET', ']': 'RBRACKET',
-            '{': 'LBRACE', '}': 'RBRACE', ';': 'SEMICOLON', ':': 'COLON',
-            ',': 'COMMA', '.': 'DOT', '?': 'QUESTION'
-        }
-        
-        if (fourCharOps[fourChar]) {
-            this.pos += 4
-            return { type: fourCharOps[fourChar], value: fourChar, loc }
-        }
-        
-        if (threeCharOps[threeChar]) {
-            this.pos += 3
-            return { type: threeCharOps[threeChar], value: threeChar, loc }
-        }
-        
-        if (twoCharOps[twoChar]) {
-            this.pos += 2
-            return { type: twoCharOps[twoChar], value: twoChar, loc }
-        }
-        
-        if (oneCharOps[oneChar]) {
-            this.advance()
-            return { type: oneCharOps[oneChar], value: oneChar, loc }
-        }
-        
-        return null
-    }
-}
-
-class TSParser {
-    constructor(i18nPath = null) {
-        this.tokens = []
-        this.pos = 0
-        this.i18n = {}
-        
-        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 = {}
-        }
-    }
-
-    parse(source) {
-        const lexer = new TSLexer(source, this.i18n)
-        this.tokens = lexer.tokenize()
-        this.pos = 0
-        return this.parseProgram()
-    }
-
-    peek(offset = 0) {
-        return this.tokens[this.pos + offset] || { type: 'EOF' }
-    }
-
-    advance() {
-        return this.tokens[this.pos++]
-    }
-
-    match(...types) {
-        return types.includes(this.peek().type)
-    }
-
-    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()
-    }
-
-    translateKeyword(word) {
-        return TS_KEYWORDS[word] || TS_KEYWORDS[word.toLowerCase()] || word
-    }
-
-    translateType(word) {
-        return TS_TYPES[word] || TS_TYPES[word.toLowerCase()] || word
-    }
-
-    parseProgram() {
-        const body = []
-        
-        while (!this.match('EOF')) {
-            const stmt = this.parseStatement()
-            if (stmt) body.push(stmt)
-        }
-        
-        return new AST.Program(body)
-    }
-
-    parseStatement() {
-        const token = this.peek()
-        
-        if (token.type === 'AT') {
-            return this.parseDecoratedDeclaration()
-        }
-        
-        if (token.type === 'KEYWORD') {
-            const kw = this.translateKeyword(token.value)
-            
-            switch (kw) {
-                case 'interface': return this.parseInterfaceDeclaration()
-                case 'type': return this.parseTypeAliasDeclaration()
-                case 'enum': return this.parseEnumDeclaration()
-                case 'namespace': return this.parseNamespaceDeclaration()
-                case 'module': return this.parseModuleDeclaration()
-                case 'declare': return this.parseDeclareStatement()
-                case 'class': return this.parseClassDeclaration()
-                case 'abstract': return this.parseAbstractClass()
-                case 'function': return this.parseFunctionDeclaration()
-                case 'const':
-                case 'let':
-                case 'var': return this.parseVariableDeclaration()
-                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 'async': return this.parseAsyncFunction()
-            }
-        }
-        
-        if (this.match('LBRACE')) {
-            return this.parseBlockStatement()
-        }
-        
-        if (this.match('SEMICOLON')) {
-            this.advance()
-            return new AST.EmptyStatement(token.loc)
-        }
-        
-        const expr = this.parseExpression()
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.ExpressionStatement(expr, token.loc)
-    }
-
-    parseInterfaceDeclaration() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const id = new AST.Identifier(this.expect('IDENTIFIER').value)
-        
-        let typeParameters = null
-        if (this.match('LT')) {
-            typeParameters = this.parseTypeParameters()
-        }
-        
-        const extends_ = []
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'extends') {
-            this.advance()
-            extends_.push(this.parseInterfaceHeritage())
-            while (this.match('COMMA')) {
-                this.advance()
-                extends_.push(this.parseInterfaceHeritage())
-            }
-        }
-        
-        const body = this.parseInterfaceBody()
-        
-        return new AST.TSInterfaceDeclaration(id, body, extends_, typeParameters, false, loc)
-    }
-
-    parseInterfaceHeritage() {
-        const expression = this.parseIdentifierOrQualifiedName()
-        let typeParameters = null
-        
-        if (this.match('LT')) {
-            typeParameters = this.parseTypeArguments()
-        }
-        
-        return new AST.TSInterfaceHeritage(expression, typeParameters)
-    }
-
-    parseInterfaceBody() {
-        this.expect('LBRACE')
-        const body = []
-        
-        while (!this.match('RBRACE', 'EOF')) {
-            const member = this.parseTypeMember()
-            if (member) body.push(member)
-            if (this.match('SEMICOLON', 'COMMA')) this.advance()
-        }
-        
-        this.expect('RBRACE')
-        return new AST.TSInterfaceBody(body)
-    }
-
-    parseTypeMember() {
-        const loc = this.peek().loc
-        let readonly = false
-        let optional = false
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'readonly') {
-            readonly = true
-            this.advance()
-        }
-        
-        if (this.match('LBRACKET')) {
-            return this.parseIndexSignature(readonly, loc)
-        }
-        
-        if (this.match('LPAREN') || this.match('LT')) {
-            return this.parseCallSignature()
-        }
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'new') {
-            return this.parseConstructSignature()
-        }
-        
-        const key = this.parsePropertyName()
-        
-        if (this.match('QUESTION')) {
-            this.advance()
-            optional = true
-        }
-        
-        if (this.match('LPAREN') || this.match('LT')) {
-            return this.parseMethodSignature(key, optional, loc)
-        }
-        
-        let typeAnnotation = null
-        if (this.match('COLON')) {
-            this.advance()
-            typeAnnotation = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        return new AST.TSPropertySignature(key, typeAnnotation, false, optional, readonly, loc)
-    }
-
-    parseIndexSignature(readonly, loc) {
-        this.expect('LBRACKET')
-        
-        const parameters = []
-        const paramName = this.expect('IDENTIFIER').value
-        this.expect('COLON')
-        const paramType = this.parseType()
-        parameters.push({ name: paramName, type: paramType })
-        
-        this.expect('RBRACKET')
-        
-        let typeAnnotation = null
-        if (this.match('COLON')) {
-            this.advance()
-            typeAnnotation = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        return new AST.TSIndexSignature(parameters, typeAnnotation, readonly, false, loc)
-    }
-
-    parseCallSignature() {
-        let typeParameters = null
-        if (this.match('LT')) {
-            typeParameters = this.parseTypeParameters()
-        }
-        
-        this.expect('LPAREN')
-        const params = this.parseParameterList()
-        this.expect('RPAREN')
-        
-        let returnType = null
-        if (this.match('COLON')) {
-            this.advance()
-            returnType = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        return new AST.TSCallSignatureDeclaration(params, returnType, typeParameters)
-    }
-
-    parseConstructSignature() {
-        this.advance()
-        
-        let typeParameters = null
-        if (this.match('LT')) {
-            typeParameters = this.parseTypeParameters()
-        }
-        
-        this.expect('LPAREN')
-        const params = this.parseParameterList()
-        this.expect('RPAREN')
-        
-        let returnType = null
-        if (this.match('COLON')) {
-            this.advance()
-            returnType = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        return new AST.TSConstructSignatureDeclaration(params, returnType, typeParameters)
-    }
-
-    parseMethodSignature(key, optional, loc) {
-        let typeParameters = null
-        if (this.match('LT')) {
-            typeParameters = this.parseTypeParameters()
-        }
-        
-        this.expect('LPAREN')
-        const params = this.parseParameterList()
-        this.expect('RPAREN')
-        
-        let returnType = null
-        if (this.match('COLON')) {
-            this.advance()
-            returnType = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        return new AST.TSMethodSignature(key, params, returnType, false, optional, typeParameters, loc)
-    }
-
-    parseTypeAliasDeclaration() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const id = new AST.Identifier(this.expect('IDENTIFIER').value)
-        
-        let typeParameters = null
-        if (this.match('LT')) {
-            typeParameters = this.parseTypeParameters()
-        }
-        
-        this.expect('ASSIGN')
-        const typeAnnotation = this.parseType()
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.TSTypeAliasDeclaration(id, typeAnnotation, typeParameters, false, loc)
-    }
-
-    parseEnumDeclaration() {
-        const loc = this.peek().loc
-        let const_ = false
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'const') {
-            const_ = true
-            this.advance()
-        }
-        
-        this.advance()
-        
-        const id = new AST.Identifier(this.expect('IDENTIFIER').value)
-        
-        this.expect('LBRACE')
-        const members = []
-        
-        while (!this.match('RBRACE', 'EOF')) {
-            const memberName = this.expect('IDENTIFIER').value
-            let initializer = null
-            
-            if (this.match('ASSIGN')) {
-                this.advance()
-                initializer = this.parseExpression()
-            }
-            
-            members.push(new AST.TSEnumMember(new AST.Identifier(memberName), initializer))
-            
-            if (this.match('COMMA')) this.advance()
-        }
-        
-        this.expect('RBRACE')
-        
-        return new AST.TSEnumDeclaration(id, members, const_, false, loc)
-    }
-
-    parseNamespaceDeclaration() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const id = new AST.Identifier(this.expect('IDENTIFIER').value)
-        
-        this.expect('LBRACE')
-        const body = []
-        
-        while (!this.match('RBRACE', 'EOF')) {
-            body.push(this.parseStatement())
-        }
-        
-        this.expect('RBRACE')
-        
-        return new AST.TSModuleDeclaration(id, new AST.TSModuleBlock(body), false, false, loc)
-    }
-
-    parseModuleDeclaration() {
-        return this.parseNamespaceDeclaration()
-    }
-
-    parseDeclareStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const next = this.peek()
-        if (next.type === 'KEYWORD') {
-            const kw = this.translateKeyword(next.value)
-            
-            if (kw === 'function') {
-                this.advance()
-                return this.parseDeclareFunction(loc)
-            }
-            if (kw === 'class') {
-                const classDecl = this.parseClassDeclaration()
-                classDecl.declare = true
-                return classDecl
-            }
-            if (kw === 'const' || kw === 'let' || kw === 'var') {
-                const varDecl = this.parseVariableDeclaration()
-                varDecl.declare = true
-                return varDecl
-            }
-            if (kw === 'interface') {
-                const ifaceDecl = this.parseInterfaceDeclaration()
-                ifaceDecl.declare = true
-                return ifaceDecl
-            }
-            if (kw === 'type') {
-                const typeDecl = this.parseTypeAliasDeclaration()
-                typeDecl.declare = true
-                return typeDecl
-            }
-            if (kw === 'enum') {
-                const enumDecl = this.parseEnumDeclaration()
-                enumDecl.declare = true
-                return enumDecl
-            }
-            if (kw === 'namespace' || kw === 'module') {
-                const nsDecl = this.parseNamespaceDeclaration()
-                nsDecl.declare = true
-                return nsDecl
-            }
-            if (kw === 'global') {
-                this.advance()
-                this.expect('LBRACE')
-                const body = []
-                while (!this.match('RBRACE', 'EOF')) {
-                    body.push(this.parseStatement())
-                }
-                this.expect('RBRACE')
-                return new AST.TSModuleDeclaration(null, new AST.TSModuleBlock(body), true, true, loc)
-            }
-        }
-        
-        throw new Error(`Déclaration inattendue après declare à ligne ${loc.line}`)
-    }
-
-    parseDeclareFunction(loc) {
-        const id = new AST.Identifier(this.expect('IDENTIFIER').value)
-        
-        let typeParameters = null
-        if (this.match('LT')) {
-            typeParameters = this.parseTypeParameters()
-        }
-        
-        this.expect('LPAREN')
-        const params = this.parseParameterList()
-        this.expect('RPAREN')
-        
-        let returnType = null
-        if (this.match('COLON')) {
-            this.advance()
-            returnType = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.TSDeclareFunction(id, params, returnType, typeParameters, false, false, loc)
-    }
-
-    parseClassDeclaration() {
-        const loc = this.peek().loc
-        const decorators = []
-        let abstract = false
-        
-        while (this.match('AT')) {
-            decorators.push(this.parseDecorator())
-        }
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'abstract') {
-            abstract = true
-            this.advance()
-        }
-        
-        this.expect('KEYWORD')
-        
-        const id = new AST.Identifier(this.expect('IDENTIFIER').value)
-        
-        let typeParameters = null
-        if (this.match('LT')) {
-            typeParameters = this.parseTypeParameters()
-        }
-        
-        let superClass = null
-        let superTypeParameters = null
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'extends') {
-            this.advance()
-            superClass = this.parseIdentifierOrQualifiedName()
-            if (this.match('LT')) {
-                superTypeParameters = this.parseTypeArguments()
-            }
-        }
-        
-        const implements_ = []
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'implements') {
-            this.advance()
-            implements_.push(this.parseInterfaceHeritage())
-            while (this.match('COMMA')) {
-                this.advance()
-                implements_.push(this.parseInterfaceHeritage())
-            }
-        }
-        
-        const body = this.parseClassBody()
-        
-        return new AST.ClassDeclaration(id, body, superClass, implements_, decorators, abstract, typeParameters, superTypeParameters, loc)
-    }
-
-    parseAbstractClass() {
-        this.advance()
-        return this.parseClassDeclaration()
-    }
-
-    parseClassBody() {
-        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)
-    }
-
-    parseClassMember() {
-        const loc = this.peek().loc
-        const decorators = []
-        
-        while (this.match('AT')) {
-            decorators.push(this.parseDecorator())
-        }
-        
-        let accessibility = null
-        let isStatic = false
-        let readonly = false
-        let abstract = false
-        let override = false
-        
-        while (this.match('KEYWORD')) {
-            const kw = this.translateKeyword(this.peek().value)
-            if (kw === 'public' || kw === 'private' || kw === 'protected') {
-                accessibility = kw
-                this.advance()
-            } else if (kw === 'static') {
-                isStatic = true
-                this.advance()
-            } else if (kw === 'readonly') {
-                readonly = true
-                this.advance()
-            } else if (kw === 'abstract') {
-                abstract = true
-                this.advance()
-            } else if (kw === 'override') {
-                override = true
-                this.advance()
-            } else {
-                break
-            }
-        }
-        
-        if (isStatic && this.match('LBRACE')) {
-            return this.parseStaticBlock()
-        }
-        
-        if (this.match('KEYWORD')) {
-            const kw = this.translateKeyword(this.peek().value)
-            
-            if (kw === 'constructor') {
-                this.advance()
-                return this.parseConstructor(accessibility, loc)
-            }
-            
-            if (kw === 'get' || kw === 'set') {
-                const kind = kw
-                this.advance()
-                return this.parseAccessor(kind, accessibility, isStatic, decorators, loc)
-            }
-        }
-        
-        const key = this.parsePropertyName()
-        
-        let optional = false
-        let definite = false
-        
-        if (this.match('QUESTION')) {
-            optional = true
-            this.advance()
-        } else if (this.match('NOT')) {
-            definite = true
-            this.advance()
-        }
-        
-        if (this.match('LPAREN') || this.match('LT')) {
-            return this.parseMethod(key, accessibility, isStatic, abstract, override, decorators, loc)
-        }
-        
-        return this.parseProperty(key, accessibility, isStatic, readonly, abstract, override, optional, definite, decorators, loc)
-    }
-
-    parseConstructor(accessibility, loc) {
-        this.expect('LPAREN')
-        const params = this.parseConstructorParameters()
-        this.expect('RPAREN')
-        
-        let body = null
-        if (this.match('LBRACE')) {
-            body = this.parseBlockStatement()
-        }
-        
-        return new AST.MethodDefinition(
-            new AST.Identifier('constructor'),
-            new AST.FunctionExpression(null, params, body),
-            'constructor',
-            false,
-            false,
-            accessibility,
-            false,
-            false,
-            [],
-            loc
-        )
-    }
-
-    parseConstructorParameters() {
-        const params = []
-        
-        while (!this.match('RPAREN', 'EOF')) {
-            let accessibility = null
-            let readonly = false
-            let override = false
-            
-            while (this.match('KEYWORD')) {
-                const kw = this.translateKeyword(this.peek().value)
-                if (kw === 'public' || kw === 'private' || kw === 'protected') {
-                    accessibility = kw
-                    this.advance()
-                } else if (kw === 'readonly') {
-                    readonly = true
-                    this.advance()
-                } else if (kw === 'override') {
-                    override = true
-                    this.advance()
-                } else {
-                    break
-                }
-            }
-            
-            const param = this.parseParameter()
-            
-            if (accessibility || readonly || override) {
-                params.push(new AST.TSParameterProperty(param, accessibility, readonly, override))
-            } else {
-                params.push(param)
-            }
-            
-            if (!this.match('RPAREN')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        return params
-    }
-
-    parseMethod(key, accessibility, isStatic, abstract, override, decorators, loc) {
-        let typeParameters = null
-        if (this.match('LT')) {
-            typeParameters = this.parseTypeParameters()
-        }
-        
-        this.expect('LPAREN')
-        const params = this.parseParameterList()
-        this.expect('RPAREN')
-        
-        let returnType = null
-        if (this.match('COLON')) {
-            this.advance()
-            returnType = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        let body = null
-        if (this.match('LBRACE')) {
-            body = this.parseBlockStatement()
-        } else if (this.match('SEMICOLON')) {
-            this.advance()
-        }
-        
-        return new AST.MethodDefinition(
-            key,
-            new AST.FunctionExpression(null, params, body, false, false, returnType, typeParameters),
-            'method',
-            key.type === 'Identifier' ? false : true,
-            isStatic,
-            accessibility,
-            abstract,
-            override,
-            decorators,
-            loc
-        )
-    }
-
-    parseAccessor(kind, accessibility, isStatic, decorators, loc) {
-        const key = this.parsePropertyName()
-        
-        this.expect('LPAREN')
-        const params = this.parseParameterList()
-        this.expect('RPAREN')
-        
-        let returnType = null
-        if (this.match('COLON')) {
-            this.advance()
-            returnType = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        let body = null
-        if (this.match('LBRACE')) {
-            body = this.parseBlockStatement()
-        }
-        
-        return new AST.MethodDefinition(
-            key,
-            new AST.FunctionExpression(null, params, body, false, false, returnType),
-            kind,
-            false,
-            isStatic,
-            accessibility,
-            false,
-            false,
-            decorators,
-            loc
-        )
-    }
-
-    parseProperty(key, accessibility, isStatic, readonly, abstract, override, optional, definite, decorators, loc) {
-        let typeAnnotation = null
-        if (this.match('COLON')) {
-            this.advance()
-            typeAnnotation = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        let value = null
-        if (this.match('ASSIGN')) {
-            this.advance()
-            value = this.parseExpression()
-        }
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.PropertyDefinition(
-            key, value, false, isStatic, accessibility, readonly, abstract, override, optional, definite, typeAnnotation, decorators, loc
-        )
-    }
-
-    parseStaticBlock() {
-        this.expect('LBRACE')
-        const body = []
-        
-        while (!this.match('RBRACE', 'EOF')) {
-            body.push(this.parseStatement())
-        }
-        
-        this.expect('RBRACE')
-        return new AST.StaticBlock(body)
-    }
-
-    parseDecorator() {
-        const loc = this.peek().loc
-        this.expect('AT')
-        
-        let expression = this.parseIdentifierOrQualifiedName()
-        
-        if (this.match('LPAREN')) {
-            this.advance()
-            const args = []
-            while (!this.match('RPAREN', 'EOF')) {
-                args.push(this.parseExpression())
-                if (!this.match('RPAREN')) {
-                    this.expect('COMMA')
-                }
-            }
-            this.expect('RPAREN')
-            expression = new AST.CallExpression(expression, args, false, loc)
-        }
-        
-        return new AST.Decorator(expression, loc)
-    }
-
-    parseDecoratedDeclaration() {
-        const decorators = []
-        while (this.match('AT')) {
-            decorators.push(this.parseDecorator())
-        }
-        
-        const declaration = this.parseStatement()
-        if (declaration.decorators !== undefined) {
-            declaration.decorators = decorators.concat(declaration.decorators)
-        }
-        return declaration
-    }
-
-    parseFunctionDeclaration() {
-        const loc = this.peek().loc
-        let async = false
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'async') {
-            async = true
-            this.advance()
-        }
-        
-        this.advance()
-        
-        let generator = false
-        if (this.match('TIMES')) {
-            generator = true
-            this.advance()
-        }
-        
-        const id = new AST.Identifier(this.expect('IDENTIFIER').value)
-        
-        let typeParameters = null
-        if (this.match('LT')) {
-            typeParameters = this.parseTypeParameters()
-        }
-        
-        this.expect('LPAREN')
-        const params = this.parseParameterList()
-        this.expect('RPAREN')
-        
-        let returnType = null
-        if (this.match('COLON')) {
-            this.advance()
-            returnType = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        const body = this.parseBlockStatement()
-        
-        return new AST.FunctionDeclaration(id, params, body, async, generator, returnType, typeParameters, loc)
-    }
-
-    parseAsyncFunction() {
-        this.advance()
-        return this.parseFunctionDeclaration()
-    }
-
-    parseVariableDeclaration() {
-        const loc = this.peek().loc
-        const kind = this.translateKeyword(this.advance().value)
-        const declarations = []
-        
-        do {
-            if (this.match('COMMA')) this.advance()
-            declarations.push(this.parseVariableDeclarator())
-        } while (this.match('COMMA'))
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.VariableDeclaration(kind, declarations, loc)
-    }
-
-    parseVariableDeclarator() {
-        const loc = this.peek().loc
-        const id = this.parseBindingPattern()
-        
-        let init = null
-        if (this.match('ASSIGN')) {
-            this.advance()
-            init = this.parseExpression()
-        }
-        
-        return new AST.VariableDeclarator(id, init, loc)
-    }
-
-    parseBindingPattern() {
-        if (this.match('LBRACKET')) {
-            return this.parseArrayPattern()
-        }
-        if (this.match('LBRACE')) {
-            return this.parseObjectPattern()
-        }
-        
-        const id = new AST.Identifier(this.expect('IDENTIFIER').value)
-        
-        if (this.match('COLON')) {
-            this.advance()
-            id.typeAnnotation = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        return id
-    }
-
-    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))
-                break
-            }
-            
-            elements.push(this.parseBindingPattern())
-            
-            if (!this.match('RBRACKET')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        this.expect('RBRACKET')
-        
-        let typeAnnotation = null
-        if (this.match('COLON')) {
-            this.advance()
-            typeAnnotation = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        return new AST.ArrayPattern(elements, typeAnnotation, 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))
-                break
-            }
-            
-            const key = this.parsePropertyName()
-            let value = key
-            let shorthand = true
-            
-            if (this.match('COLON')) {
-                this.advance()
-                value = this.parseBindingPattern()
-                shorthand = false
-            }
-            
-            if (this.match('ASSIGN')) {
-                this.advance()
-                const defaultValue = this.parseExpression()
-                value = new AST.AssignmentPattern(value, defaultValue)
-            }
-            
-            properties.push(new AST.Property(key, value, 'init', false, shorthand, false))
-            
-            if (!this.match('RBRACE')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        this.expect('RBRACE')
-        
-        let typeAnnotation = null
-        if (this.match('COLON')) {
-            this.advance()
-            typeAnnotation = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        return new AST.ObjectPattern(properties, typeAnnotation, loc)
-    }
-
-    parseParameterList() {
-        const params = []
-        
-        while (!this.match('RPAREN', 'EOF')) {
-            params.push(this.parseParameter())
-            if (!this.match('RPAREN')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        return params
-    }
-
-    parseParameter() {
-        const loc = this.peek().loc
-        let rest = false
-        
-        if (this.match('SPREAD')) {
-            this.advance()
-            rest = true
-        }
-        
-        const pattern = this.parseBindingPattern()
-        
-        let optional = false
-        if (this.match('QUESTION')) {
-            optional = true
-            this.advance()
-        }
-        
-        if (this.match('COLON') && !pattern.typeAnnotation) {
-            this.advance()
-            pattern.typeAnnotation = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        if (optional) {
-            pattern.optional = true
-        }
-        
-        let defaultValue = null
-        if (this.match('ASSIGN')) {
-            this.advance()
-            defaultValue = this.parseExpression()
-        }
-        
-        if (rest) {
-            return new AST.RestElement(pattern, pattern.typeAnnotation, loc)
-        }
-        
-        if (defaultValue) {
-            return new AST.AssignmentPattern(pattern, defaultValue, loc)
-        }
-        
-        return pattern
-    }
-
-    parseTypeParameters() {
-        this.expect('LT')
-        const params = []
-        
-        while (!this.match('GT', 'EOF')) {
-            params.push(this.parseTypeParameter())
-            if (!this.match('GT')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        this.expect('GT')
-        return new AST.TSTypeParameterDeclaration(params)
-    }
-
-    parseTypeParameter() {
-        const loc = this.peek().loc
-        let in_ = false
-        let out = false
-        let const_ = false
-        
-        while (this.match('KEYWORD')) {
-            const kw = this.translateKeyword(this.peek().value)
-            if (kw === 'in') { in_ = true; this.advance() }
-            else if (kw === 'out') { out = true; this.advance() }
-            else if (kw === 'const') { const_ = true; this.advance() }
-            else break
-        }
-        
-        const name = new AST.Identifier(this.expect('IDENTIFIER').value)
-        
-        let constraint = null
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'extends') {
-            this.advance()
-            constraint = this.parseType()
-        }
-        
-        let default_ = null
-        if (this.match('ASSIGN')) {
-            this.advance()
-            default_ = this.parseType()
-        }
-        
-        return new AST.TSTypeParameter(name, constraint, default_, in_, out, const_, loc)
-    }
-
-    parseTypeArguments() {
-        this.expect('LT')
-        const params = []
-        
-        while (!this.match('GT', 'EOF')) {
-            params.push(this.parseType())
-            if (!this.match('GT')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        this.expect('GT')
-        return new AST.TSTypeParameterInstantiation(params)
-    }
-
-    parseType() {
-        return this.parseUnionType()
-    }
-
-    parseUnionType() {
-        if (this.match('BIT_OR')) this.advance()
-        
-        let type = this.parseIntersectionType()
-        
-        if (this.match('BIT_OR')) {
-            const types = [type]
-            while (this.match('BIT_OR')) {
-                this.advance()
-                types.push(this.parseIntersectionType())
-            }
-            return new AST.TSUnionType(types)
-        }
-        
-        return type
-    }
-
-    parseIntersectionType() {
-        if (this.match('BIT_AND')) this.advance()
-        
-        let type = this.parseTypeOperator()
-        
-        if (this.match('BIT_AND')) {
-            const types = [type]
-            while (this.match('BIT_AND')) {
-                this.advance()
-                types.push(this.parseTypeOperator())
-            }
-            return new AST.TSIntersectionType(types)
-        }
-        
-        return type
-    }
-
-    parseTypeOperator() {
-        if (this.match('KEYWORD')) {
-            const kw = this.translateKeyword(this.peek().value)
-            
-            if (kw === 'keyof') {
-                this.advance()
-                return new AST.TSTypeOperator('keyof', this.parseTypeOperator())
-            }
-            if (kw === 'typeof') {
-                this.advance()
-                const exprName = this.parseIdentifierOrQualifiedName()
-                let typeParameters = null
-                if (this.match('LT')) {
-                    typeParameters = this.parseTypeArguments()
-                }
-                return new AST.TSTypeQuery(exprName, typeParameters)
-            }
-            if (kw === 'readonly') {
-                this.advance()
-                return new AST.TSTypeOperator('readonly', this.parseTypeOperator())
-            }
-            if (kw === 'infer') {
-                this.advance()
-                const param = this.parseTypeParameter()
-                return new AST.TSInferType(param)
-            }
-        }
-        
-        return this.parseArrayPostfix()
-    }
-
-    parseArrayPostfix() {
-        let type = this.parsePrimaryType()
-        
-        while (true) {
-            if (this.match('LBRACKET')) {
-                this.advance()
-                if (this.match('RBRACKET')) {
-                    this.advance()
-                    type = new AST.TSArrayType(type)
-                } else {
-                    const indexType = this.parseType()
-                    this.expect('RBRACKET')
-                    type = new AST.TSIndexedAccessType(type, indexType)
-                }
-            } else {
-                break
-            }
-        }
-        
-        return type
-    }
-
-    parsePrimaryType() {
-        const loc = this.peek().loc
-        
-        if (this.match('TYPE')) {
-            const typeName = this.translateType(this.advance().value)
-            
-            switch (typeName) {
-                case 'string': return new AST.TSStringKeyword(loc)
-                case 'number': return new AST.TSNumberKeyword(loc)
-                case 'boolean': return new AST.TSBooleanKeyword(loc)
-                case 'bigint': return new AST.TSBigIntKeyword(loc)
-                case 'symbol': return new AST.TSSymbolKeyword(loc)
-                case 'object': return new AST.TSObjectKeyword(loc)
-                case 'any': return new AST.TSAnyKeyword(loc)
-                case 'unknown': return new AST.TSUnknownKeyword(loc)
-                case 'never': return new AST.TSNeverKeyword(loc)
-                case 'void': return new AST.TSVoidKeyword(loc)
-            }
-            
-            let typeParameters = null
-            if (this.match('LT')) {
-                typeParameters = this.parseTypeArguments()
-            }
-            return new AST.TSTypeReference(new AST.Identifier(typeName), typeParameters, loc)
-        }
-        
-        if (this.match('KEYWORD')) {
-            const kw = this.translateKeyword(this.peek().value)
-            
-            if (kw === 'undefined') {
-                this.advance()
-                return new AST.TSUndefinedKeyword(loc)
-            }
-            if (kw === 'null') {
-                this.advance()
-                return new AST.TSNullKeyword(loc)
-            }
-            if (kw === 'this') {
-                this.advance()
-                return new AST.TSThisType(loc)
-            }
-            if (kw === 'true' || kw === 'false') {
-                this.advance()
-                return new AST.TSLiteralType(new AST.BooleanLiteral(kw === 'true'))
-            }
-            if (kw === 'new') {
-                return this.parseConstructorType()
-            }
-        }
-        
-        if (this.match('IDENTIFIER')) {
-            const name = this.parseIdentifierOrQualifiedName()
-            let typeParameters = null
-            if (this.match('LT')) {
-                typeParameters = this.parseTypeArguments()
-            }
-            return new AST.TSTypeReference(name, typeParameters, loc)
-        }
-        
-        if (this.match('STRING')) {
-            const token = this.advance()
-            return new AST.TSLiteralType(new AST.StringLiteral(token.value, token.raw))
-        }
-        
-        if (this.match('NUMBER')) {
-            const token = this.advance()
-            return new AST.TSLiteralType(new AST.NumericLiteral(token.value, token.raw))
-        }
-        
-        if (this.match('MINUS') && this.peek(1).type === 'NUMBER') {
-            this.advance()
-            const token = this.advance()
-            return new AST.TSLiteralType(new AST.NumericLiteral(-token.value, '-' + token.raw))
-        }
-        
-        if (this.match('LBRACE')) {
-            return this.parseTypeLiteral()
-        }
-        
-        if (this.match('LBRACKET')) {
-            return this.parseTupleType()
-        }
-        
-        if (this.match('LPAREN')) {
-            this.advance()
-            const type = this.parseType()
-            this.expect('RPAREN')
-            
-            if (this.match('ARROW')) {
-                this.advance()
-                const returnType = this.parseType()
-                return new AST.TSFunctionType([type], new AST.TSTypeAnnotation(returnType))
-            }
-            
-            return new AST.TSParenthesizedType(type)
-        }
-        
-        throw new Error(`Type inattendu à ligne ${loc.line}`)
-    }
-
-    parseTypeLiteral() {
-        this.expect('LBRACE')
-        const members = []
-        
-        while (!this.match('RBRACE', 'EOF')) {
-            const member = this.parseTypeMember()
-            if (member) members.push(member)
-            if (this.match('SEMICOLON', 'COMMA')) this.advance()
-        }
-        
-        this.expect('RBRACE')
-        return new AST.TSTypeLiteral(members)
-    }
-
-    parseTupleType() {
-        this.expect('LBRACKET')
-        const elementTypes = []
-        
-        while (!this.match('RBRACKET', 'EOF')) {
-            if (this.match('SPREAD')) {
-                this.advance()
-                elementTypes.push(new AST.TSRestType(this.parseType()))
-            } else {
-                let label = null
-                let optional = false
-                
-                if (this.match('IDENTIFIER') && this.peek(1).type === 'COLON') {
-                    label = new AST.Identifier(this.advance().value)
-                    this.advance()
-                }
-                
-                const type = this.parseType()
-                
-                if (this.match('QUESTION')) {
-                    optional = true
-                    this.advance()
-                }
-                
-                if (label) {
-                    elementTypes.push(new AST.TSNamedTupleMember(label, type, optional))
-                } else if (optional) {
-                    elementTypes.push(new AST.TSOptionalType(type))
-                } else {
-                    elementTypes.push(type)
-                }
-            }
-            
-            if (!this.match('RBRACKET')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        this.expect('RBRACKET')
-        return new AST.TSTupleType(elementTypes)
-    }
-
-    parseConstructorType() {
-        const loc = this.peek().loc
-        let abstract = false
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'abstract') {
-            abstract = true
-            this.advance()
-        }
-        
-        this.advance()
-        
-        let typeParameters = null
-        if (this.match('LT')) {
-            typeParameters = this.parseTypeParameters()
-        }
-        
-        this.expect('LPAREN')
-        const params = this.parseParameterList()
-        this.expect('RPAREN')
-        
-        this.expect('ARROW')
-        const returnType = this.parseType()
-        
-        return new AST.TSConstructorType(params, new AST.TSTypeAnnotation(returnType), typeParameters, abstract, loc)
-    }
-
-    parseIdentifierOrQualifiedName() {
-        let left = new AST.Identifier(this.expect('IDENTIFIER').value)
-        
-        while (this.match('DOT')) {
-            this.advance()
-            const right = new AST.Identifier(this.expect('IDENTIFIER').value)
-            left = new AST.TSQualifiedName(left, right)
-        }
-        
-        return left
-    }
-
-    parsePropertyName() {
-        if (this.match('STRING')) {
-            const token = this.advance()
-            return new AST.StringLiteral(token.value, token.raw)
-        }
-        if (this.match('NUMBER')) {
-            const token = this.advance()
-            return new AST.NumericLiteral(token.value, token.raw)
-        }
-        if (this.match('LBRACKET')) {
-            this.advance()
-            const expr = this.parseExpression()
-            this.expect('RBRACKET')
-            return expr
-        }
-        if (this.match('PRIVATE_IDENTIFIER')) {
-            return new AST.PrivateIdentifier(this.advance().value)
-        }
-        
-        return new AST.Identifier(this.expect('IDENTIFIER').value)
-    }
-
-    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.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'else') {
-            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.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'case') {
-            this.advance()
-            test = this.parseExpression()
-        } else {
-            this.advance()
-        }
-        
-        this.expect('COLON')
-        
-        const consequent = []
-        while (!this.match('RBRACE', 'EOF')) {
-            const next = this.peek()
-            if (next.type === 'KEYWORD') {
-                const kw = this.translateKeyword(next.value)
-                if (kw === 'case' || kw === 'default') break
-            }
-            consequent.push(this.parseStatement())
-        }
-        
-        return new AST.SwitchCase(test, consequent, loc)
-    }
-
-    parseForStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'await') {
-            this.advance()
-            return this.parseForAwaitOf(loc)
-        }
-        
-        this.expect('LPAREN')
-        
-        let init = null
-        if (!this.match('SEMICOLON')) {
-            if (this.match('KEYWORD')) {
-                const kw = this.translateKeyword(this.peek().value)
-                if (kw === 'const' || kw === 'let' || kw === 'var') {
-                    init = this.parseVariableDeclaration()
-                    
-                    if (this.peek(-1).type !== 'SEMICOLON') {
-                        if (this.match('KEYWORD')) {
-                            const nextKw = this.translateKeyword(this.peek().value)
-                            if (nextKw === 'in') {
-                                return this.parseForIn(init, loc)
-                            }
-                            if (nextKw === 'of') {
-                                return this.parseForOf(init, loc, false)
-                            }
-                        }
-                    }
-                } else {
-                    init = this.parseExpression()
-                }
-            } else {
-                init = this.parseExpression()
-            }
-        }
-        
-        if (!this.match('SEMICOLON')) {
-            if (this.match('KEYWORD')) {
-                const kw = this.translateKeyword(this.peek().value)
-                if (kw === 'in') return this.parseForIn(init, loc)
-                if (kw === 'of') return this.parseForOf(init, loc, false)
-            }
-        }
-        
-        this.expect('SEMICOLON')
-        
-        const test = this.match('SEMICOLON') ? null : this.parseExpression()
-        this.expect('SEMICOLON')
-        
-        const update = this.match('RPAREN') ? null : this.parseExpression()
-        this.expect('RPAREN')
-        
-        const body = this.parseStatement()
-        
-        return new AST.ForStatement(init, test, update, body, loc)
-    }
-
-    parseForIn(left, loc) {
-        this.advance()
-        const right = this.parseExpression()
-        this.expect('RPAREN')
-        const body = this.parseStatement()
-        return new AST.ForInStatement(left, right, body, loc)
-    }
-
-    parseForOf(left, loc, await_) {
-        this.advance()
-        const right = this.parseExpression()
-        this.expect('RPAREN')
-        const body = this.parseStatement()
-        return new AST.ForOfStatement(left, right, body, await_, loc)
-    }
-
-    parseForAwaitOf(loc) {
-        this.expect('LPAREN')
-        
-        let left
-        if (this.match('KEYWORD')) {
-            const kw = this.translateKeyword(this.peek().value)
-            if (kw === 'const' || kw === 'let' || kw === 'var') {
-                left = this.parseVariableDeclaration()
-            }
-        }
-        if (!left) {
-            left = this.parseExpression()
-        }
-        
-        this.expect('KEYWORD')
-        return this.parseForOf(left, loc, true)
-    }
-
-    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()
-        
-        this.expect('KEYWORD')
-        this.expect('LPAREN')
-        const test = this.parseExpression()
-        this.expect('RPAREN')
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.DoWhileStatement(body, test, loc)
-    }
-
-    parseTryStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const block = this.parseBlockStatement()
-        
-        let handler = null
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'catch') {
-            handler = this.parseCatchClause()
-        }
-        
-        let finalizer = null
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'finally') {
-            this.advance()
-            finalizer = this.parseBlockStatement()
-        }
-        
-        return new AST.TryStatement(block, handler, finalizer, loc)
-    }
-
-    parseCatchClause() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let param = null
-        if (this.match('LPAREN')) {
-            this.advance()
-            param = this.parseBindingPattern()
-            this.expect('RPAREN')
-        }
-        
-        const body = this.parseBlockStatement()
-        
-        return new AST.CatchClause(param, body, loc)
-    }
-
-    parseThrowStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const argument = this.parseExpression()
-        if (this.match('SEMICOLON')) this.advance()
-        
-        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()
-        }
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.ReturnStatement(argument, loc)
-    }
-
-    parseBreakStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let label = null
-        if (this.match('IDENTIFIER')) {
-            label = new AST.Identifier(this.advance().value)
-        }
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.BreakStatement(label, loc)
-    }
-
-    parseContinueStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let label = null
-        if (this.match('IDENTIFIER')) {
-            label = new AST.Identifier(this.advance().value)
-        }
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.ContinueStatement(label, loc)
-    }
-
-    parseBlockStatement() {
-        const loc = this.peek().loc
-        this.expect('LBRACE')
-        const body = []
-        
-        while (!this.match('RBRACE', 'EOF')) {
-            body.push(this.parseStatement())
-        }
-        
-        this.expect('RBRACE')
-        return new AST.BlockStatement(body, loc)
-    }
-
-    parseImportDeclaration() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let importKind = 'value'
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'type') {
-            importKind = 'type'
-            this.advance()
-        }
-        
-        const specifiers = []
-        
-        if (this.match('STRING')) {
-            const source = this.advance()
-            if (this.match('SEMICOLON')) this.advance()
-            return new AST.ImportDeclaration([], new AST.StringLiteral(source.value, source.raw), importKind, loc)
-        }
-        
-        if (this.match('IDENTIFIER')) {
-            specifiers.push(new AST.ImportDefaultSpecifier(new AST.Identifier(this.advance().value)))
-            
-            if (this.match('COMMA')) {
-                this.advance()
-            }
-        }
-        
-        if (this.match('TIMES')) {
-            this.advance()
-            this.expect('KEYWORD')
-            specifiers.push(new AST.ImportNamespaceSpecifier(new AST.Identifier(this.expect('IDENTIFIER').value)))
-        } else if (this.match('LBRACE')) {
-            this.advance()
-            while (!this.match('RBRACE', 'EOF')) {
-                let specKind = 'value'
-                if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'type') {
-                    specKind = 'type'
-                    this.advance()
-                }
-                
-                const imported = new AST.Identifier(this.expect('IDENTIFIER').value)
-                let local = imported
-                
-                if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'as') {
-                    this.advance()
-                    local = new AST.Identifier(this.expect('IDENTIFIER').value)
-                }
-                
-                specifiers.push(new AST.ImportSpecifier(imported, local, specKind))
-                
-                if (!this.match('RBRACE')) {
-                    this.expect('COMMA')
-                }
-            }
-            this.expect('RBRACE')
-        }
-        
-        this.expect('KEYWORD')
-        const source = this.expect('STRING')
-        
-        if (this.match('SEMICOLON')) this.advance()
-        
-        return new AST.ImportDeclaration(specifiers, new AST.StringLiteral(source.value, source.raw), importKind, loc)
-    }
-
-    parseExportDeclaration() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'default') {
-            this.advance()
-            const declaration = this.parseExpression()
-            if (this.match('SEMICOLON')) this.advance()
-            return new AST.ExportDefaultDeclaration(declaration, loc)
-        }
-        
-        if (this.match('TIMES')) {
-            this.advance()
-            let exported = null
-            if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'as') {
-                this.advance()
-                exported = new AST.Identifier(this.expect('IDENTIFIER').value)
-            }
-            this.expect('KEYWORD')
-            const source = this.expect('STRING')
-            if (this.match('SEMICOLON')) this.advance()
-            return new AST.ExportAllDeclaration(new AST.StringLiteral(source.value, source.raw), exported, 'value', loc)
-        }
-        
-        let exportKind = 'value'
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'type') {
-            exportKind = 'type'
-            this.advance()
-        }
-        
-        if (this.match('LBRACE')) {
-            this.advance()
-            const specifiers = []
-            
-            while (!this.match('RBRACE', 'EOF')) {
-                const local = new AST.Identifier(this.expect('IDENTIFIER').value)
-                let exported = local
-                
-                if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'as') {
-                    this.advance()
-                    exported = new AST.Identifier(this.expect('IDENTIFIER').value)
-                }
-                
-                specifiers.push(new AST.ExportSpecifier(local, exported, exportKind))
-                
-                if (!this.match('RBRACE')) {
-                    this.expect('COMMA')
-                }
-            }
-            this.expect('RBRACE')
-            
-            let source = null
-            if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'from') {
-                this.advance()
-                const sourceToken = this.expect('STRING')
-                source = new AST.StringLiteral(sourceToken.value, sourceToken.raw)
-            }
-            
-            if (this.match('SEMICOLON')) this.advance()
-            
-            return new AST.ExportNamedDeclaration(null, specifiers, source, exportKind, loc)
-        }
-        
-        const declaration = this.parseStatement()
-        return new AST.ExportNamedDeclaration(declaration, [], null, exportKind, loc)
-    }
-
-    parseExpression() {
-        return this.parseAssignment()
-    }
-
-    parseAssignment() {
-        const left = this.parseConditional()
-        
-        if (this.match('ASSIGN', 'PLUS_ASSIGN', 'MINUS_ASSIGN', 'TIMES_ASSIGN', 'DIV_ASSIGN', 'MOD_ASSIGN',
-            'POW_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.parseAssignment()
-            return new AST.AssignmentExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseConditional() {
-        const test = this.parseNullish()
-        
-        if (this.match('QUESTION')) {
-            this.advance()
-            const consequent = this.parseAssignment()
-            this.expect('COLON')
-            const alternate = this.parseAssignment()
-            return new AST.ConditionalExpression(test, consequent, alternate, test.loc)
-        }
-        
-        return test
-    }
-
-    parseNullish() {
-        let left = this.parseLogicalOr()
-        
-        while (this.match('NULLISH')) {
-            this.advance()
-            const right = this.parseLogicalOr()
-            left = new AST.LogicalExpression('??', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseLogicalOr() {
-        let left = this.parseLogicalAnd()
-        
-        while (this.match('OR')) {
-            this.advance()
-            const right = this.parseLogicalAnd()
-            left = new AST.LogicalExpression('||', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseLogicalAnd() {
-        let left = this.parseBitwiseOr()
-        
-        while (this.match('AND')) {
-            this.advance()
-            const right = this.parseBitwiseOr()
-            left = new AST.LogicalExpression('&&', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseBitwiseOr() {
-        let left = this.parseBitwiseXor()
-        
-        while (this.match('BIT_OR')) {
-            this.advance()
-            const right = this.parseBitwiseXor()
-            left = new AST.BinaryExpression('|', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseBitwiseXor() {
-        let left = this.parseBitwiseAnd()
-        
-        while (this.match('BIT_XOR')) {
-            this.advance()
-            const right = this.parseBitwiseAnd()
-            left = new AST.BinaryExpression('^', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseBitwiseAnd() {
-        let left = this.parseEquality()
-        
-        while (this.match('BIT_AND')) {
-            this.advance()
-            const right = this.parseEquality()
-            left = new AST.BinaryExpression('&', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseEquality() {
-        let left = this.parseRelational()
-        
-        while (this.match('EQUAL', 'NOT_EQUAL', 'STRICT_EQUAL', 'STRICT_NOT_EQUAL')) {
-            const op = this.advance()
-            const right = this.parseRelational()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseRelational() {
-        let left = this.parseShift()
-        
-        while (this.match('LT', 'GT', 'LTE', 'GTE') || 
-               (this.match('KEYWORD') && (this.translateKeyword(this.peek().value) === 'in' || this.translateKeyword(this.peek().value) === 'instanceof'))) {
-            if (this.match('KEYWORD')) {
-                const kw = this.translateKeyword(this.advance().value)
-                const right = this.parseShift()
-                left = new AST.BinaryExpression(kw, left, right, left.loc)
-            } else {
-                const op = this.advance()
-                const right = this.parseShift()
-                left = new AST.BinaryExpression(op.value, left, right, left.loc)
-            }
-        }
-        
-        return left
-    }
-
-    parseShift() {
-        let left = this.parseAdditive()
-        
-        while (this.match('LEFT_SHIFT', 'RIGHT_SHIFT', 'UNSIGNED_RIGHT_SHIFT')) {
-            const op = this.advance()
-            const right = this.parseAdditive()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseAdditive() {
-        let left = this.parseMultiplicative()
-        
-        while (this.match('PLUS', 'MINUS')) {
-            const op = this.advance()
-            const right = this.parseMultiplicative()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseMultiplicative() {
-        let left = this.parseExponential()
-        
-        while (this.match('TIMES', 'DIV', 'MOD')) {
-            const op = this.advance()
-            const right = this.parseExponential()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseExponential() {
-        const left = this.parseUnary()
-        
-        if (this.match('POW')) {
-            this.advance()
-            const right = this.parseExponential()
-            return new AST.BinaryExpression('**', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseUnary() {
-        const loc = this.peek().loc
-        
-        if (this.match('NOT', 'TILDE', 'PLUS', 'MINUS')) {
-            const op = this.advance()
-            return new AST.UnaryExpression(op.value, this.parseUnary(), true, loc)
-        }
-        
-        if (this.match('INCREMENT', 'DECREMENT')) {
-            const op = this.advance()
-            return new AST.UpdateExpression(op.value, this.parseUnary(), true, loc)
-        }
-        
-        if (this.match('KEYWORD')) {
-            const kw = this.translateKeyword(this.peek().value)
-            if (kw === 'typeof' || kw === 'void' || kw === 'delete') {
-                this.advance()
-                return new AST.UnaryExpression(kw, this.parseUnary(), true, loc)
-            }
-            if (kw === 'await') {
-                this.advance()
-                return new AST.AwaitExpression(this.parseUnary(), loc)
-            }
-        }
-        
-        return this.parsePostfix()
-    }
-
-    parsePostfix() {
-        let expr = this.parseCall()
-        
-        if (this.match('INCREMENT', 'DECREMENT')) {
-            const op = this.advance()
-            return new AST.UpdateExpression(op.value, expr, false, expr.loc)
-        }
-        
-        if (this.match('NOT')) {
-            this.advance()
-            return new AST.TSNonNullExpression(expr, expr.loc)
-        }
-        
-        if (this.match('KEYWORD')) {
-            const kw = this.translateKeyword(this.peek().value)
-            if (kw === 'as') {
-                this.advance()
-                if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'const') {
-                    this.advance()
-                    return new AST.TSAsExpression(expr, new AST.TSTypeReference(new AST.Identifier('const')))
-                }
-                const type = this.parseType()
-                return new AST.TSAsExpression(expr, type, expr.loc)
-            }
-            if (kw === 'satisfies') {
-                this.advance()
-                const type = this.parseType()
-                return new AST.TSSatisfiesExpression(expr, type, expr.loc)
-            }
-        }
-        
-        return expr
-    }
-
-    parseCall() {
-        let expr = this.parseMember()
-        
-        while (true) {
-            if (this.match('LPAREN')) {
-                this.advance()
-                const args = []
-                while (!this.match('RPAREN', 'EOF')) {
-                    if (this.match('SPREAD')) {
-                        this.advance()
-                        args.push(new AST.SpreadElement(this.parseAssignment()))
-                    } else {
-                        args.push(this.parseAssignment())
-                    }
-                    if (!this.match('RPAREN')) {
-                        this.expect('COMMA')
-                    }
-                }
-                this.expect('RPAREN')
-                expr = new AST.CallExpression(expr, args, false, expr.loc)
-            } else if (this.match('OPTIONAL_CHAIN')) {
-                this.advance()
-                if (this.match('LPAREN')) {
-                    this.advance()
-                    const args = []
-                    while (!this.match('RPAREN', 'EOF')) {
-                        args.push(this.parseAssignment())
-                        if (!this.match('RPAREN')) {
-                            this.expect('COMMA')
-                        }
-                    }
-                    this.expect('RPAREN')
-                    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 = new AST.Identifier(this.expect('IDENTIFIER').value)
-                    expr = new AST.MemberExpression(expr, property, false, true, expr.loc)
-                }
-            } else if (this.match('LT') && this.looksLikeTypeArguments()) {
-                const typeArgs = this.parseTypeArguments()
-                expr = new AST.TSInstantiationExpression(expr, typeArgs, expr.loc)
-            } else {
-                break
-            }
-        }
-        
-        return expr
-    }
-
-    looksLikeTypeArguments() {
-        let pos = this.pos
-        let depth = 1
-        pos++
-        
-        while (pos < this.tokens.length && depth > 0) {
-            const t = this.tokens[pos]
-            if (t.type === 'LT') depth++
-            else if (t.type === 'GT') depth--
-            pos++
-        }
-        
-        if (depth !== 0) return false
-        
-        const next = this.tokens[pos]
-        return next && (next.type === 'LPAREN' || next.type === 'DOT' || next.type === 'SEMICOLON' || next.type === 'COMMA' || next.type === 'RPAREN')
-    }
-
-    parseMember() {
-        let expr = this.parsePrimary()
-        
-        while (true) {
-            if (this.match('DOT')) {
-                this.advance()
-                const property = this.parsePropertyName()
-                expr = new AST.MemberExpression(expr, property, false, false, 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 {
-                break
-            }
-        }
-        
-        return expr
-    }
-
-    parsePrimary() {
-        const token = this.peek()
-        const loc = token.loc
-        
-        if (token.type === 'IDENTIFIER') {
-            this.advance()
-            return new AST.Identifier(token.value, loc)
-        }
-        
-        if (token.type === 'NUMBER') {
-            this.advance()
-            return new AST.NumericLiteral(token.value, token.raw, loc)
-        }
-        
-        if (token.type === 'BIGINT') {
-            this.advance()
-            return new AST.BigIntLiteral(token.value, token.raw, loc)
-        }
-        
-        if (token.type === 'STRING') {
-            this.advance()
-            return new AST.StringLiteral(token.value, token.raw, loc)
-        }
-        
-        if (token.type === 'TEMPLATE') {
-            this.advance()
-            const quasis = token.quasis.map((q, i) => new AST.TemplateElement(q.value, i === token.quasis.length - 1))
-            const expressions = token.expressions.map(e => {
-                const subParser = new TSParser()
-                subParser.tokens = new TSLexer(e).tokenize()
-                subParser.pos = 0
-                return subParser.parseExpression()
-            })
-            return new AST.TemplateLiteral(quasis, expressions, loc)
-        }
-        
-        if (token.type === 'PRIVATE_IDENTIFIER') {
-            this.advance()
-            return new AST.PrivateIdentifier(token.value, loc)
-        }
-        
-        if (token.type === 'KEYWORD') {
-            const kw = this.translateKeyword(token.value)
-            
-            if (kw === 'true') {
-                this.advance()
-                return new AST.BooleanLiteral(true, loc)
-            }
-            if (kw === 'false') {
-                this.advance()
-                return new AST.BooleanLiteral(false, loc)
-            }
-            if (kw === 'null') {
-                this.advance()
-                return new AST.NullLiteral(loc)
-            }
-            if (kw === 'undefined') {
-                this.advance()
-                return new AST.UndefinedLiteral(loc)
-            }
-            if (kw === 'this') {
-                this.advance()
-                return new AST.ThisExpression(loc)
-            }
-            if (kw === 'super') {
-                this.advance()
-                return new AST.Super(loc)
-            }
-            if (kw === 'new') {
-                return this.parseNewExpression()
-            }
-            if (kw === 'function') {
-                return this.parseFunctionExpression()
-            }
-            if (kw === 'class') {
-                return this.parseClassExpression()
-            }
-            if (kw === 'async') {
-                if (this.peek(1).type === 'KEYWORD' && this.translateKeyword(this.peek(1).value) === 'function') {
-                    this.advance()
-                    return this.parseFunctionExpression(true)
-                }
-                if (this.peek(1).type === 'LPAREN' || this.peek(1).type === 'IDENTIFIER') {
-                    return this.parseArrowFunction(true)
-                }
-            }
-            if (kw === 'yield') {
-                return this.parseYieldExpression()
-            }
-            if (kw === 'import') {
-                this.advance()
-                if (this.match('DOT')) {
-                    this.advance()
-                    const property = new AST.Identifier(this.expect('IDENTIFIER').value)
-                    return new AST.MetaProperty(new AST.Identifier('import'), property, loc)
-                }
-                this.expect('LPAREN')
-                const source = this.parseAssignment()
-                this.expect('RPAREN')
-                return new AST.ImportExpression(source, loc)
-            }
-        }
-        
-        if (this.match('LBRACKET')) {
-            return this.parseArrayExpression()
-        }
-        
-        if (this.match('LBRACE')) {
-            return this.parseObjectExpression()
-        }
-        
-        if (this.match('LPAREN')) {
-            return this.parseParenthesizedOrArrow()
-        }
-        
-        if (this.match('LT')) {
-            return this.parseTypeAssertion()
-        }
-        
-        throw new Error(`Token inattendu ${token.type} à ligne ${loc.line}`)
-    }
-
-    parseNewExpression() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        if (this.match('DOT')) {
-            this.advance()
-            const property = new AST.Identifier(this.expect('IDENTIFIER').value)
-            return new AST.MetaProperty(new AST.Identifier('new'), property, loc)
-        }
-        
-        let callee = this.parseMember()
-        
-        if (this.match('LT')) {
-            const typeArgs = this.parseTypeArguments()
-            callee = new AST.TSInstantiationExpression(callee, typeArgs)
-        }
-        
-        let args = []
-        if (this.match('LPAREN')) {
-            this.advance()
-            while (!this.match('RPAREN', 'EOF')) {
-                if (this.match('SPREAD')) {
-                    this.advance()
-                    args.push(new AST.SpreadElement(this.parseAssignment()))
-                } else {
-                    args.push(this.parseAssignment())
-                }
-                if (!this.match('RPAREN')) {
-                    this.expect('COMMA')
-                }
-            }
-            this.expect('RPAREN')
-        }
-        
-        return new AST.NewExpression(callee, args, loc)
-    }
-
-    parseFunctionExpression(async = false) {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let generator = false
-        if (this.match('TIMES')) {
-            generator = true
-            this.advance()
-        }
-        
-        let id = null
-        if (this.match('IDENTIFIER')) {
-            id = new AST.Identifier(this.advance().value)
-        }
-        
-        let typeParameters = null
-        if (this.match('LT')) {
-            typeParameters = this.parseTypeParameters()
-        }
-        
-        this.expect('LPAREN')
-        const params = this.parseParameterList()
-        this.expect('RPAREN')
-        
-        let returnType = null
-        if (this.match('COLON')) {
-            this.advance()
-            returnType = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        const body = this.parseBlockStatement()
-        
-        return new AST.FunctionExpression(id, params, body, async, generator, returnType, typeParameters, loc)
-    }
-
-    parseClassExpression() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let id = null
-        if (this.match('IDENTIFIER')) {
-            id = new AST.Identifier(this.advance().value)
-        }
-        
-        let typeParameters = null
-        if (this.match('LT')) {
-            typeParameters = this.parseTypeParameters()
-        }
-        
-        let superClass = null
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'extends') {
-            this.advance()
-            superClass = this.parseIdentifierOrQualifiedName()
-        }
-        
-        const implements_ = []
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'implements') {
-            this.advance()
-            implements_.push(this.parseInterfaceHeritage())
-            while (this.match('COMMA')) {
-                this.advance()
-                implements_.push(this.parseInterfaceHeritage())
-            }
-        }
-        
-        const body = this.parseClassBody()
-        
-        return new AST.ClassExpression(id, body, superClass, implements_, [], false, typeParameters, loc)
-    }
-
-    parseYieldExpression() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let delegate = false
-        if (this.match('TIMES')) {
-            delegate = true
-            this.advance()
-        }
-        
-        let argument = null
-        if (!this.match('SEMICOLON', 'RPAREN', 'RBRACKET', 'COMMA', 'RBRACE', 'COLON')) {
-            argument = this.parseAssignment()
-        }
-        
-        return new AST.YieldExpression(argument, delegate, 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()
-                elements.push(new AST.SpreadElement(this.parseAssignment()))
-            } else {
-                elements.push(this.parseAssignment())
-            }
-            
-            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')) {
-            if (this.match('SPREAD')) {
-                this.advance()
-                properties.push(new AST.SpreadElement(this.parseAssignment()))
-            } else {
-                properties.push(this.parsePropertyDefinition())
-            }
-            
-            if (!this.match('RBRACE')) {
-                this.expect('COMMA')
-            }
-        }
-        
-        this.expect('RBRACE')
-        return new AST.ObjectExpression(properties, loc)
-    }
-
-    parsePropertyDefinition() {
-        const loc = this.peek().loc
-        let computed = false
-        let method = false
-        let shorthand = false
-        let kind = 'init'
-        
-        if (this.match('KEYWORD')) {
-            const kw = this.translateKeyword(this.peek().value)
-            if (kw === 'get' || kw === 'set') {
-                kind = kw
-                this.advance()
-            } else if (kw === 'async') {
-                this.advance()
-                const key = this.parsePropertyName()
-                return this.parseMethodProperty(key, true, false, loc)
-            }
-        }
-        
-        if (this.match('TIMES')) {
-            this.advance()
-            const key = this.parsePropertyName()
-            return this.parseMethodProperty(key, false, true, loc)
-        }
-        
-        const key = this.parsePropertyName()
-        
-        if (kind !== 'init') {
-            return this.parseAccessorProperty(kind, key, loc)
-        }
-        
-        if (this.match('LPAREN') || this.match('LT')) {
-            return this.parseMethodProperty(key, false, false, loc)
-        }
-        
-        if (this.match('COLON')) {
-            this.advance()
-            const value = this.parseAssignment()
-            return new AST.Property(key, value, 'init', key.type !== 'Identifier', false, false, loc)
-        }
-        
-        if (this.match('ASSIGN')) {
-            this.advance()
-            const value = this.parseAssignment()
-            return new AST.Property(key, new AST.AssignmentPattern(key, value), 'init', false, true, false, loc)
-        }
-        
-        return new AST.Property(key, key, 'init', false, true, false, loc)
-    }
-
-    parseMethodProperty(key, async, generator, loc) {
-        let typeParameters = null
-        if (this.match('LT')) {
-            typeParameters = this.parseTypeParameters()
-        }
-        
-        this.expect('LPAREN')
-        const params = this.parseParameterList()
-        this.expect('RPAREN')
-        
-        let returnType = null
-        if (this.match('COLON')) {
-            this.advance()
-            returnType = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        const body = this.parseBlockStatement()
-        
-        const value = new AST.FunctionExpression(null, params, body, async, generator, returnType, typeParameters)
-        return new AST.Property(key, value, 'init', key.type !== 'Identifier', false, true, loc)
-    }
-
-    parseAccessorProperty(kind, key, loc) {
-        this.expect('LPAREN')
-        const params = kind === 'set' ? [this.parseParameter()] : []
-        this.expect('RPAREN')
-        
-        let returnType = null
-        if (this.match('COLON')) {
-            this.advance()
-            returnType = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        const body = this.parseBlockStatement()
-        
-        const value = new AST.FunctionExpression(null, params, body, false, false, returnType)
-        return new AST.Property(key, value, kind, key.type !== 'Identifier', false, false, loc)
-    }
-
-    parseParenthesizedOrArrow() {
-        const loc = this.peek().loc
-        const startPos = this.pos
-        
-        this.expect('LPAREN')
-        
-        if (this.match('RPAREN')) {
-            this.advance()
-            if (this.match('ARROW') || this.match('COLON')) {
-                return this.parseArrowFunctionRest([], false, loc)
-            }
-            this.pos = startPos
-        } else {
-            const items = []
-            let mightBeArrow = true
-            
-            while (!this.match('RPAREN', 'EOF') && mightBeArrow) {
-                if (this.match('SPREAD')) {
-                    this.advance()
-                    items.push({ type: 'rest', value: this.parseBindingPattern() })
-                    break
-                }
-                
-                const expr = this.parseAssignment()
-                items.push({ type: 'expr', value: expr })
-                
-                if (!this.match('RPAREN')) {
-                    if (this.match('COMMA')) {
-                        this.advance()
-                    } else {
-                        mightBeArrow = false
-                    }
-                }
-            }
-            
-            if (this.match('RPAREN')) {
-                this.advance()
-                
-                if (this.match('ARROW') || this.match('COLON')) {
-                    const params = items.map(item => {
-                        if (item.type === 'rest') {
-                            return new AST.RestElement(item.value)
-                        }
-                        return this.expressionToPattern(item.value)
-                    })
-                    return this.parseArrowFunctionRest(params, false, loc)
-                }
-            }
-            
-            this.pos = startPos
-        }
-        
-        this.expect('LPAREN')
-        const expr = this.parseExpression()
-        this.expect('RPAREN')
-        return expr
-    }
-
-    expressionToPattern(expr) {
-        if (expr.type === 'Identifier') return expr
-        if (expr.type === 'AssignmentExpression' && expr.operator === '=') {
-            return new AST.AssignmentPattern(this.expressionToPattern(expr.left), expr.right)
-        }
-        if (expr.type === 'ArrayExpression') {
-            return new AST.ArrayPattern(expr.elements.map(e => e ? this.expressionToPattern(e) : null))
-        }
-        if (expr.type === 'ObjectExpression') {
-            return new AST.ObjectPattern(expr.properties.map(p => {
-                if (p.type === 'SpreadElement') {
-                    return new AST.RestElement(this.expressionToPattern(p.argument))
-                }
-                return new AST.Property(p.key, this.expressionToPattern(p.value), p.kind, p.computed, p.shorthand, p.method)
-            }))
-        }
-        return expr
-    }
-
-    parseArrowFunction(async = false) {
-        const loc = this.peek().loc
-        
-        if (async) this.advance()
-        
-        if (this.match('IDENTIFIER')) {
-            const param = new AST.Identifier(this.advance().value)
-            this.expect('ARROW')
-            const body = this.match('LBRACE') ? this.parseBlockStatement() : this.parseAssignment()
-            return new AST.ArrowFunctionExpression([param], body, async, body.type !== 'BlockStatement', null, null, loc)
-        }
-        
-        this.expect('LPAREN')
-        const params = this.parseParameterList()
-        this.expect('RPAREN')
-        
-        return this.parseArrowFunctionRest(params, async, loc)
-    }
-
-    parseArrowFunctionRest(params, async, loc) {
-        let returnType = null
-        if (this.match('COLON')) {
-            this.advance()
-            returnType = new AST.TSTypeAnnotation(this.parseType())
-        }
-        
-        this.expect('ARROW')
-        
-        const body = this.match('LBRACE') ? this.parseBlockStatement() : this.parseAssignment()
-        
-        return new AST.ArrowFunctionExpression(params, body, async, body.type !== 'BlockStatement', returnType, null, loc)
-    }
-
-    parseTypeAssertion() {
-        const loc = this.peek().loc
-        this.expect('LT')
-        const type = this.parseType()
-        this.expect('GT')
-        const expression = this.parseUnary()
-        return new AST.TSTypeAssertion(type, expression, loc)
-    }
-}
-
-class TSCodeGenerator {
-    constructor(options = {}) {
-        this.indentStr = options.indentStr || '    '
-        this.indentLevel = 0
-    }
-
-    indent() {
-        return this.indentStr.repeat(this.indentLevel)
-    }
-
-    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')
-    }
-
-    generateTSInterfaceDeclaration(node) {
-        let result = `${this.indent()}${node.declare ? 'declare ' : ''}interface ${this.generate(node.id)}`
-        if (node.typeParameters) result += this.generate(node.typeParameters)
-        if (node.extends.length) result += ` extends ${node.extends.map(e => this.generate(e)).join(', ')}`
-        result += ' ' + this.generate(node.body)
-        return result
-    }
-
-    generateTSInterfaceBody(node) {
-        this.indentLevel++
-        const members = node.body.map(m => this.generate(m)).join('\n')
-        this.indentLevel--
-        return `{\n${members}\n${this.indent()}}`
-    }
-
-    generateTSInterfaceHeritage(node) {
-        let result = this.generate(node.expression)
-        if (node.typeParameters) result += this.generate(node.typeParameters)
-        return result
-    }
-
-    generateTSPropertySignature(node) {
-        let result = this.indent()
-        if (node.readonly) result += 'readonly '
-        result += this.generate(node.key)
-        if (node.optional) result += '?'
-        if (node.typeAnnotation) result += ': ' + this.generate(node.typeAnnotation.typeAnnotation)
-        result += ';'
-        return result
-    }
-
-    generateTSMethodSignature(node) {
-        let result = this.indent() + this.generate(node.key)
-        if (node.optional) result += '?'
-        if (node.typeParameters) result += this.generate(node.typeParameters)
-        result += '(' + node.params.map(p => this.generate(p)).join(', ') + ')'
-        if (node.returnType) result += ': ' + this.generate(node.returnType.typeAnnotation)
-        result += ';'
-        return result
-    }
-
-    generateTSIndexSignature(node) {
-        let result = this.indent()
-        if (node.readonly) result += 'readonly '
-        result += '['
-        result += node.parameters.map(p => `${p.name}: ${this.generate(p.type)}`).join(', ')
-        result += ']'
-        if (node.typeAnnotation) result += ': ' + this.generate(node.typeAnnotation.typeAnnotation)
-        result += ';'
-        return result
-    }
-
-    generateTSTypeAliasDeclaration(node) {
-        let result = `${this.indent()}${node.declare ? 'declare ' : ''}type ${this.generate(node.id)}`
-        if (node.typeParameters) result += this.generate(node.typeParameters)
-        result += ' = ' + this.generate(node.typeAnnotation) + ';'
-        return result
-    }
-
-    generateTSEnumDeclaration(node) {
-        let result = `${this.indent()}${node.declare ? 'declare ' : ''}${node.const ? 'const ' : ''}enum ${this.generate(node.id)} {\n`
-        this.indentLevel++
-        result += node.members.map(m => this.generate(m)).join(',\n')
-        this.indentLevel--
-        result += `\n${this.indent()}}`
-        return result
-    }
-
-    generateTSEnumMember(node) {
-        let result = this.indent() + this.generate(node.id)
-        if (node.initializer) result += ' = ' + this.generate(node.initializer)
-        return result
-    }
-
-    generateTSModuleDeclaration(node) {
-        let result = `${this.indent()}${node.declare ? 'declare ' : ''}${node.global ? 'global' : 'namespace ' + this.generate(node.id)}`
-        if (node.body) result += ' ' + this.generate(node.body)
-        return result
-    }
-
-    generateTSModuleBlock(node) {
-        this.indentLevel++
-        const body = node.body.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        return `{\n${body}\n${this.indent()}}`
-    }
-
-    generateTSTypeParameterDeclaration(node) {
-        return '<' + node.params.map(p => this.generate(p)).join(', ') + '>'
-    }
-
-    generateTSTypeParameter(node) {
-        let result = ''
-        if (node.in) result += 'in '
-        if (node.out) result += 'out '
-        if (node.const) result += 'const '
-        result += this.generate(node.name)
-        if (node.constraint) result += ' extends ' + this.generate(node.constraint)
-        if (node.default) result += ' = ' + this.generate(node.default)
-        return result
-    }
-
-    generateTSTypeParameterInstantiation(node) {
-        return '<' + node.params.map(p => this.generate(p)).join(', ') + '>'
-    }
-
-    generateTSTypeReference(node) {
-        let result = this.generate(node.typeName)
-        if (node.typeParameters) result += this.generate(node.typeParameters)
-        return result
-    }
-
-    generateTSQualifiedName(node) {
-        return this.generate(node.left) + '.' + this.generate(node.right)
-    }
-
-    generateTSStringKeyword() { return 'string' }
-    generateTSNumberKeyword() { return 'number' }
-    generateTSBooleanKeyword() { return 'boolean' }
-    generateTSBigIntKeyword() { return 'bigint' }
-    generateTSSymbolKeyword() { return 'symbol' }
-    generateTSObjectKeyword() { return 'object' }
-    generateTSAnyKeyword() { return 'any' }
-    generateTSUnknownKeyword() { return 'unknown' }
-    generateTSNeverKeyword() { return 'never' }
-    generateTSVoidKeyword() { return 'void' }
-    generateTSUndefinedKeyword() { return 'undefined' }
-    generateTSNullKeyword() { return 'null' }
-    generateTSThisType() { return 'this' }
-
-    generateTSArrayType(node) {
-        const elem = this.generate(node.elementType)
-        if (node.elementType.type === 'TSUnionType' || node.elementType.type === 'TSIntersectionType') {
-            return `(${elem})[]`
-        }
-        return `${elem}[]`
-    }
-
-    generateTSTupleType(node) {
-        return '[' + node.elementTypes.map(e => this.generate(e)).join(', ') + ']'
-    }
-
-    generateTSNamedTupleMember(node) {
-        return `${this.generate(node.label)}${node.optional ? '?' : ''}: ${this.generate(node.elementType)}`
-    }
-
-    generateTSOptionalType(node) {
-        return this.generate(node.typeAnnotation) + '?'
-    }
-
-    generateTSRestType(node) {
-        return '...' + this.generate(node.typeAnnotation)
-    }
-
-    generateTSUnionType(node) {
-        return node.types.map(t => this.generate(t)).join(' | ')
-    }
-
-    generateTSIntersectionType(node) {
-        return node.types.map(t => this.generate(t)).join(' & ')
-    }
-
-    generateTSParenthesizedType(node) {
-        return '(' + this.generate(node.typeAnnotation) + ')'
-    }
-
-    generateTSTypeLiteral(node) {
-        if (node.members.length === 0) return '{}'
-        this.indentLevel++
-        const members = node.members.map(m => this.generate(m)).join('\n')
-        this.indentLevel--
-        return `{\n${members}\n${this.indent()}}`
-    }
-
-    generateTSFunctionType(node) {
-        let result = '('
-        result += node.params.map(p => this.generate(p)).join(', ')
-        result += ') => '
-        result += this.generate(node.returnType?.typeAnnotation || { type: 'TSVoidKeyword' })
-        return result
-    }
-
-    generateTSConstructorType(node) {
-        let result = node.abstract ? 'abstract ' : ''
-        result += 'new ('
-        result += node.params.map(p => this.generate(p)).join(', ')
-        result += ') => '
-        result += this.generate(node.returnType?.typeAnnotation || { type: 'TSVoidKeyword' })
-        return result
-    }
-
-    generateTSConditionalType(node) {
-        return `${this.generate(node.checkType)} extends ${this.generate(node.extendsType)} ? ${this.generate(node.trueType)} : ${this.generate(node.falseType)}`
-    }
-
-    generateTSInferType(node) {
-        return 'infer ' + this.generate(node.typeParameter)
-    }
-
-    generateTSMappedType(node) {
-        let result = '{ '
-        if (node.readonly === '+') result += '+readonly '
-        else if (node.readonly === '-') result += '-readonly '
-        else if (node.readonly) result += 'readonly '
-        result += '[' + this.generate(node.typeParameter)
-        if (node.nameType) result += ' as ' + this.generate(node.nameType)
-        result += ']'
-        if (node.optional === '+') result += '+?'
-        else if (node.optional === '-') result += '-?'
-        else if (node.optional) result += '?'
-        result += ': ' + this.generate(node.typeAnnotation)
-        result += ' }'
-        return result
-    }
-
-    generateTSIndexedAccessType(node) {
-        return `${this.generate(node.objectType)}[${this.generate(node.indexType)}]`
-    }
-
-    generateTSTypeOperator(node) {
-        return `${node.operator} ${this.generate(node.typeAnnotation)}`
-    }
-
-    generateTSTypePredicate(node) {
-        let result = ''
-        if (node.asserts) result += 'asserts '
-        result += this.generate(node.parameterName)
-        if (node.typeAnnotation) result += ' is ' + this.generate(node.typeAnnotation.typeAnnotation)
-        return result
-    }
-
-    generateTSTypeQuery(node) {
-        let result = 'typeof ' + this.generate(node.exprName)
-        if (node.typeParameters) result += this.generate(node.typeParameters)
-        return result
-    }
-
-    generateTSLiteralType(node) {
-        return this.generate(node.literal)
-    }
-
-    generateTSAsExpression(node) {
-        return `${this.generate(node.expression)} as ${this.generate(node.typeAnnotation)}`
-    }
-
-    generateTSSatisfiesExpression(node) {
-        return `${this.generate(node.expression)} satisfies ${this.generate(node.typeAnnotation)}`
-    }
-
-    generateTSTypeAssertion(node) {
-        return `<${this.generate(node.typeAnnotation)}>${this.generate(node.expression)}`
-    }
-
-    generateTSNonNullExpression(node) {
-        return this.generate(node.expression) + '!'
-    }
-
-    generateTSInstantiationExpression(node) {
-        return this.generate(node.expression) + this.generate(node.typeParameters)
-    }
-
-    generateTSDeclareFunction(node) {
-        let result = `${this.indent()}declare function ${this.generate(node.id)}`
-        if (node.typeParameters) result += this.generate(node.typeParameters)
-        result += '(' + node.params.map(p => this.generate(p)).join(', ') + ')'
-        if (node.returnType) result += ': ' + this.generate(node.returnType.typeAnnotation)
-        result += ';'
-        return result
-    }
-
-    generateTSParameterProperty(node) {
-        let result = ''
-        if (node.accessibility) result += node.accessibility + ' '
-        if (node.readonly) result += 'readonly '
-        if (node.override) result += 'override '
-        result += this.generate(node.parameter)
-        return result
-    }
-
-    generateClassDeclaration(node) {
-        let result = this.indent()
-        for (const dec of (node.decorators || [])) {
-            result += this.generate(dec) + '\n' + this.indent()
-        }
-        if (node.abstract) result += 'abstract '
-        result += 'class ' + this.generate(node.id)
-        if (node.typeParameters) result += this.generate(node.typeParameters)
-        if (node.superClass) {
-            result += ' extends ' + this.generate(node.superClass)
-            if (node.superTypeParameters) result += this.generate(node.superTypeParameters)
-        }
-        if (node.implements?.length) result += ' implements ' + node.implements.map(i => this.generate(i)).join(', ')
-        result += ' ' + this.generate(node.body)
-        return result
-    }
-
-    generateClassBody(node) {
-        this.indentLevel++
-        const members = node.body.map(m => this.generate(m)).filter(m => m).join('\n\n')
-        this.indentLevel--
-        return `{\n${members}\n${this.indent()}}`
-    }
-
-    generateMethodDefinition(node) {
-        let result = this.indent()
-        for (const dec of (node.decorators || [])) {
-            result += this.generate(dec) + '\n' + this.indent()
-        }
-        if (node.accessibility) result += node.accessibility + ' '
-        if (node.static) result += 'static '
-        if (node.abstract) result += 'abstract '
-        if (node.override) result += 'override '
-        if (node.kind === 'get') result += 'get '
-        if (node.kind === 'set') result += 'set '
-        result += this.generate(node.key)
-        if (node.value) {
-            if (node.value.typeParameters) result += this.generate(node.value.typeParameters)
-            result += '(' + node.value.params.map(p => this.generate(p)).join(', ') + ')'
-            if (node.value.returnType) result += ': ' + this.generate(node.value.returnType.typeAnnotation)
-            if (node.value.body) result += ' ' + this.generate(node.value.body)
-            else result += ';'
-        }
-        return result
-    }
-
-    generatePropertyDefinition(node) {
-        let result = this.indent()
-        for (const dec of (node.decorators || [])) {
-            result += this.generate(dec) + '\n' + this.indent()
-        }
-        if (node.accessibility) result += node.accessibility + ' '
-        if (node.static) result += 'static '
-        if (node.abstract) result += 'abstract '
-        if (node.override) result += 'override '
-        if (node.readonly) result += 'readonly '
-        result += this.generate(node.key)
-        if (node.optional) result += '?'
-        if (node.definite) result += '!'
-        if (node.typeAnnotation) result += ': ' + this.generate(node.typeAnnotation.typeAnnotation)
-        if (node.value) result += ' = ' + this.generate(node.value)
-        result += ';'
-        return result
-    }
-
-    generateStaticBlock(node) {
-        return `${this.indent()}static ${this.generate(new AST.BlockStatement(node.body))}`
-    }
-
-    generateDecorator(node) {
-        return '@' + this.generate(node.expression)
-    }
-
-    generateFunctionDeclaration(node) {
-        let result = this.indent()
-        if (node.async) result += 'async '
-        result += 'function '
-        if (node.generator) result += '* '
-        result += this.generate(node.id)
-        if (node.typeParameters) result += this.generate(node.typeParameters)
-        result += '(' + node.params.map(p => this.generate(p)).join(', ') + ')'
-        if (node.returnType) result += ': ' + this.generate(node.returnType.typeAnnotation)
-        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)
-        if (node.typeParameters) result += this.generate(node.typeParameters)
-        result += '(' + node.params.map(p => this.generate(p)).join(', ') + ')'
-        if (node.returnType) result += ': ' + this.generate(node.returnType.typeAnnotation)
-        result += ' ' + this.generate(node.body)
-        return result
-    }
-
-    generateArrowFunctionExpression(node) {
-        let result = ''
-        if (node.async) result += 'async '
-        if (node.typeParameters) result += this.generate(node.typeParameters)
-        if (node.params.length === 1 && node.params[0].type === 'Identifier' && !node.params[0].typeAnnotation && !node.returnType) {
-            result += this.generate(node.params[0])
-        } else {
-            result += '(' + node.params.map(p => this.generate(p)).join(', ') + ')'
-        }
-        if (node.returnType) result += ': ' + this.generate(node.returnType.typeAnnotation)
-        result += ' => '
-        if (node.expression) {
-            result += this.generate(node.body)
-        } else {
-            result += this.generate(node.body)
-        }
-        return result
-    }
-
-    generateVariableDeclaration(node) {
-        return `${this.indent()}${node.kind} ${node.declarations.map(d => this.generate(d)).join(', ')};`
-    }
-
-    generateVariableDeclarator(node) {
-        let result = this.generate(node.id)
-        if (node.init) result += ' = ' + this.generate(node.init)
-        return result
-    }
-
-    generateIdentifier(node) {
-        let result = node.name
-        if (node.optional) result += '?'
-        if (node.typeAnnotation) result += ': ' + this.generate(node.typeAnnotation.typeAnnotation)
-        return result
-    }
-
-    generatePrivateIdentifier(node) {
-        return '#' + node.name
-    }
-
-    generateRestElement(node) {
-        let result = '...' + this.generate(node.argument)
-        if (node.typeAnnotation) result += ': ' + this.generate(node.typeAnnotation.typeAnnotation)
-        return result
-    }
-
-    generateAssignmentPattern(node) {
-        return this.generate(node.left) + ' = ' + this.generate(node.right)
-    }
-
-    generateArrayPattern(node) {
-        let result = '[' + node.elements.map(e => e ? this.generate(e) : '').join(', ') + ']'
-        if (node.typeAnnotation) result += ': ' + this.generate(node.typeAnnotation.typeAnnotation)
-        return result
-    }
-
-    generateObjectPattern(node) {
-        let result = '{ ' + node.properties.map(p => this.generate(p)).join(', ') + ' }'
-        if (node.typeAnnotation) result += ': ' + this.generate(node.typeAnnotation.typeAnnotation)
-        return result
-    }
-
-    generateBlockStatement(node) {
-        this.indentLevel++
-        const body = node.body.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        return `{\n${body}\n${this.indent()}}`
-    }
-
-    generateExpressionStatement(node) {
-        return this.indent() + this.generate(node.expression) + ';'
-    }
-
-    generateEmptyStatement() {
-        return this.indent() + ';'
-    }
-
-    generateIfStatement(node) {
-        let result = `${this.indent()}if (${this.generate(node.test)}) ${this.generate(node.consequent)}`
-        if (node.alternate) {
-            result += ` else ${this.generate(node.alternate)}`
-        }
-        return result
-    }
-
-    generateSwitchStatement(node) {
-        let result = `${this.indent()}switch (${this.generate(node.discriminant)}) {\n`
-        this.indentLevel++
-        result += node.cases.map(c => this.generate(c)).join('\n')
-        this.indentLevel--
-        result += `\n${this.indent()}}`
-        return result
-    }
-
-    generateSwitchCase(node) {
-        let result = node.test ? `${this.indent()}case ${this.generate(node.test)}:\n` : `${this.indent()}default:\n`
-        this.indentLevel++
-        result += node.consequent.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        return result
-    }
-
-    generateForStatement(node) {
-        let result = `${this.indent()}for (`
-        if (node.init) result += this.generate(node.init).replace(/;$/, '').trim()
-        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) {
-        const left = this.generate(node.left).replace(/;$/, '').trim()
-        return `${this.indent()}for (${left} in ${this.generate(node.right)}) ${this.generate(node.body)}`
-    }
-
-    generateForOfStatement(node) {
-        const left = this.generate(node.left).replace(/;$/, '').trim()
-        const await_ = node.await ? 'await ' : ''
-        return `${this.indent()}for ${await_}(${left} of ${this.generate(node.right)}) ${this.generate(node.body)}`
-    }
-
-    generateWhileStatement(node) {
-        return `${this.indent()}while (${this.generate(node.test)}) ${this.generate(node.body)}`
-    }
-
-    generateDoWhileStatement(node) {
-        return `${this.indent()}do ${this.generate(node.body)} while (${this.generate(node.test)});`
-    }
-
-    generateTryStatement(node) {
-        let result = `${this.indent()}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 `${this.indent()}throw ${this.generate(node.argument)};`
-    }
-
-    generateReturnStatement(node) {
-        return `${this.indent()}return${node.argument ? ' ' + this.generate(node.argument) : ''};`
-    }
-
-    generateBreakStatement(node) {
-        return `${this.indent()}break${node.label ? ' ' + this.generate(node.label) : ''};`
-    }
-
-    generateContinueStatement(node) {
-        return `${this.indent()}continue${node.label ? ' ' + this.generate(node.label) : ''};`
-    }
-
-    generateImportDeclaration(node) {
-        let result = this.indent() + 'import '
-        if (node.importKind === 'type') result += 'type '
-        
-        if (node.specifiers.length === 0) {
-            result += this.generate(node.source)
-        } else {
-            const defaultSpec = node.specifiers.find(s => s.type === 'ImportDefaultSpecifier')
-            const nsSpec = node.specifiers.find(s => s.type === 'ImportNamespaceSpecifier')
-            const namedSpecs = node.specifiers.filter(s => s.type === 'ImportSpecifier')
-            
-            if (defaultSpec) result += this.generate(defaultSpec.local)
-            if (defaultSpec && (nsSpec || namedSpecs.length)) result += ', '
-            if (nsSpec) result += '* as ' + this.generate(nsSpec.local)
-            if (namedSpecs.length) {
-                result += '{ ' + namedSpecs.map(s => {
-                    let spec = ''
-                    if (s.importKind === 'type') spec += 'type '
-                    spec += this.generate(s.imported)
-                    if (s.imported.name !== s.local.name) spec += ' as ' + this.generate(s.local)
-                    return spec
-                }).join(', ') + ' }'
-            }
-            result += ' from ' + this.generate(node.source)
-        }
-        result += ';'
-        return result
-    }
-
-    generateExportNamedDeclaration(node) {
-        let result = this.indent() + 'export '
-        if (node.exportKind === 'type') result += 'type '
-        
-        if (node.declaration) {
-            result += this.generate(node.declaration).trim()
-        } else {
-            result += '{ ' + node.specifiers.map(s => {
-                let spec = this.generate(s.local)
-                if (s.local.name !== s.exported.name) spec += ' as ' + this.generate(s.exported)
-                return spec
-            }).join(', ') + ' }'
-            if (node.source) result += ' from ' + this.generate(node.source)
-            result += ';'
-        }
-        return result
-    }
-
-    generateExportDefaultDeclaration(node) {
-        return `${this.indent()}export default ${this.generate(node.declaration)};`
-    }
-
-    generateExportAllDeclaration(node) {
-        let result = `${this.indent()}export *`
-        if (node.exported) result += ' as ' + this.generate(node.exported)
-        result += ' from ' + this.generate(node.source) + ';'
-        return result
-    }
-
-    generateBinaryExpression(node) {
-        return `${this.generate(node.left)} ${node.operator} ${this.generate(node.right)}`
-    }
-
-    generateUnaryExpression(node) {
-        if (node.prefix) {
-            const space = /[a-z]/.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)}`
-    }
-
-    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)}`
-    }
-
-    generateCallExpression(node) {
-        const callee = this.generate(node.callee)
-        const args = node.arguments.map(a => this.generate(a)).join(', ')
-        return `${callee}${node.optional ? '?.' : ''}(${args})`
-    }
-
-    generateNewExpression(node) {
-        const args = node.arguments.length ? '(' + node.arguments.map(a => this.generate(a)).join(', ') + ')' : ''
-        return `new ${this.generate(node.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}`
-    }
-
-    generateArrayExpression(node) {
-        return '[' + node.elements.map(e => e ? this.generate(e) : '').join(', ') + ']'
-    }
-
-    generateObjectExpression(node) {
-        if (node.properties.length === 0) return '{}'
-        return '{ ' + node.properties.map(p => this.generate(p)).join(', ') + ' }'
-    }
-
-    generateProperty(node) {
-        if (node.kind === 'get' || node.kind === 'set') {
-            return `${node.kind} ${this.generate(node.key)}() ${this.generate(node.value.body)}`
-        }
-        if (node.method) {
-            return `${this.generate(node.key)}(${node.value.params.map(p => this.generate(p)).join(', ')}) ${this.generate(node.value.body)}`
-        }
-        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)
-    }
-
-    generateTemplateLiteral(node) {
-        let result = '`'
-        for (let i = 0; i < node.quasis.length; i++) {
-            result += node.quasis[i].value
-            if (i < node.expressions.length) {
-                result += '${' + this.generate(node.expressions[i]) + '}'
-            }
-        }
-        result += '`'
-        return result
-    }
-
-    generateAwaitExpression(node) {
-        return 'await ' + this.generate(node.argument)
-    }
-
-    generateYieldExpression(node) {
-        let result = 'yield'
-        if (node.delegate) result += '*'
-        if (node.argument) result += ' ' + this.generate(node.argument)
-        return result
-    }
-
-    generateThisExpression() { return 'this' }
-    generateSuper() { return 'super' }
-
-    generateMetaProperty(node) {
-        return `${this.generate(node.meta)}.${this.generate(node.property)}`
-    }
-
-    generateImportExpression(node) {
-        return `import(${this.generate(node.source)})`
-    }
-
-    generateStringLiteral(node) {
-        return node.raw || `"${node.value}"`
-    }
-
-    generateNumericLiteral(node) {
-        return node.raw || String(node.value)
-    }
-
-    generateBigIntLiteral(node) {
-        return node.raw || node.value + 'n'
-    }
-
-    generateBooleanLiteral(node) {
-        return node.value ? 'true' : 'false'
-    }
-
-    generateNullLiteral() { return 'null' }
-    generateUndefinedLiteral() { return 'undefined' }
-}
-
-module.exports = {
-    TSLexer,
-    TSParser,
-    TSCodeGenerator,
-    TS_KEYWORDS,
-    TS_TYPES
-}