ether-code 0.1.6 → 0.1.7

package/parsers/ruby-parser.js

@@ -1,2680 +0,0 @@
-const fs = require('fs')
-const AST = require('./ast-ruby')
-
-const RUBY_KEYWORDS = {
-    'def': 'def', 'définir': 'def', 'опр': 'def', '定义': 'def', '定義': 'def',
-    'fin': 'end', 'end': 'end', 'конец': 'end', '结束': 'end', '終了': 'end',
-    'classe': 'class', 'class': 'class', 'clase': 'class', 'класс': 'class', '类': 'class', 'クラス': 'class',
-    'moduleRuby': 'module', 'module': 'module', 'modulo': 'module', 'módulo': 'module', 'модуль': 'module', '模块': 'module', 'モジュール': 'module',
-    
-    'vrai': 'true', 'true': 'true', 'verdadero': 'true', 'истина': 'true', '真': 'true', '真実': 'true',
-    'faux': 'false', 'false': 'false', 'falso': 'false', 'ложь': 'false', '假': 'false', '偽': 'false',
-    'nul': 'nil', 'nil': 'nil', 'nulo': 'nil', 'ноль': 'nil', '空': 'nil', 'ヌル': 'nil',
-    
-    'si': 'if', 'if': 'if', 'если': 'if', '如果': 'if', 'もし': 'if',
-    'sinon': 'else', 'else': 'else', 'sino': 'else', 'иначе': 'else', '否则': 'else', 'そうでなければ': 'else',
-    'sinonsi': 'elsif', 'elsif': 'elsif', 'sinosi': 'elsif', 'иначеесли': 'elsif', '否则如果': 'elsif', 'でなければもし': 'elsif',
-    'saufsi': 'unless', 'unless': 'unless', 'amenos': 'unless', 'еслине': 'unless', '除非': 'unless', 'でなければ': 'unless',
-    'cas': 'case', 'case': 'case', 'caso': 'case', 'случай': 'case', '情况': 'case', 'ケース': 'case',
-    'quand': 'when', 'when': 'when', 'cuando': 'when', 'когда': 'when', '当': 'when', '時': 'when',
-    'alors': 'then', 'then': 'then', 'entonces': 'then', 'тогда': 'then', '那么': 'then', 'それなら': 'then',
-    
-    'tantque': 'while', 'while': 'while', 'mientras': 'while', 'пока': 'while', 'の間': 'while', '循环': 'while',
-    'jusqua': 'until', "jusqu'à": 'until', 'until': 'until', 'hasta': 'until', 'допока': 'until', '直到': 'until', 'まで': 'until',
-    'pour': 'for', 'for': 'for', 'para': 'for', 'для': 'for', '对于': 'for', 'ため': 'for',
-    'dans': 'in', 'in': 'in', 'en': 'in', 'в': 'in', '在': 'in', 'の中': 'in',
-    'faire': 'do', 'do': 'do', 'hacer': 'do', 'делать': 'do', '做': 'do', 'する': 'do',
-    'boucle': 'loop', 'loop': 'loop', 'bucle': 'loop', 'цикл': 'loop', '循环': 'loop', 'ループ': 'loop',
-    
-    'arreter': 'break', 'arrêter': 'break', 'break': 'break', 'romper': 'break', 'прервать': 'break', '中断': 'break', 'ブレーク': 'break',
-    'suivant': 'next', 'next': 'next', 'siguiente': 'next', 'следующий': 'next', '下一个': 'next', '次': 'next',
-    'refaire': 'redo', 'redo': 'redo', 'rehacer': 'redo', 'повторить': 'redo', '重做': 'redo', 'やり直し': 'redo',
-    'reessayer': 'retry', 'réessayer': 'retry', 'retry': 'retry', 'reintentar': 'retry', '重试': 'retry', '再試行': 'retry',
-    
-    'retourner': 'return', 'return': 'return', 'retornar': 'return', 'вернуть': 'return', '返回': 'return', '戻る': 'return',
-    'ceder': 'yield', 'céder': 'yield', 'yield': 'yield', 'уступить': 'yield', '产出': 'yield', '譲る': 'yield',
-    'alias': 'alias', 'псевдоним': 'alias', '别名': 'alias', 'エイリアス': 'alias',
-    'indefinir': 'undef', 'indéfinir': 'undef', 'undef': 'undef', 'отменить': 'undef', '取消定义': 'undef', '未定義': 'undef',
-    
-    'soi': 'self', 'self': 'self', 'yo': 'self', 'себя': 'self', '自己': 'self', '自分': 'self',
-    'super': 'super', 'супер': 'super', '超级': 'super', 'スーパー': 'super',
-    'inclure': 'include', 'include': 'include', 'incluir': 'include', 'включить': 'include', '包含': 'include', 'インクルード': 'include',
-    'etendre': 'extend', 'étendre': 'extend', 'extend': 'extend', 'extender': 'extend', 'расширить': 'extend', '扩展': 'extend', 'エクステンド': 'extend',
-    'prependre': 'prepend', 'prépendre': 'prepend', 'prepend': 'prepend', 'anteponer': 'prepend', 'предшествовать': 'prepend', '前置': 'prepend', 'プリペンド': 'prepend',
-    
-    'debut': 'begin', 'début': 'begin', 'begin': 'begin', 'inicio': 'begin', 'начало': 'begin', '开始': 'begin', '開始': 'begin',
-    'secourir': 'rescue', 'rescue': 'rescue', 'rescatar': 'rescue', 'спасти': 'rescue', '救援': 'rescue', 'レスキュー': 'rescue',
-    'assurer': 'ensure', 'ensure': 'ensure', 'asegurar': 'ensure', 'обеспечить': 'ensure', '确保': 'ensure', '確保': 'ensure',
-    'lever': 'raise', 'raise': 'raise', 'lanzar': 'raise', 'вызвать': 'raise', '抛出': 'raise', '発生': 'raise',
-    
-    'et': 'and', 'and': 'and', 'y': 'and', 'и': 'and', '且': 'and', 'かつ': 'and',
-    'ou': 'or', 'or': 'or', 'o': 'or', 'или': 'or', '或': 'or', 'または': 'or',
-    'non': 'not', 'not': 'not', 'no': 'not', 'не': 'not', '非': 'not', 'ではない': 'not',
-    'defini': 'defined?', 'défini': 'defined?', 'defined?': 'defined?', 'definido': 'defined?', 'определен': 'defined?', '已定义': 'defined?', '定義済み': 'defined?',
-    
-    'exiger': 'require', 'require': 'require', 'requerir': 'require', 'требовать': 'require', '需要': 'require', '要求': 'require',
-    'exigerRelatif': 'require_relative', 'require_relative': 'require_relative', 'requerirRelativo': 'require_relative', 'требоватьОтносительно': 'require_relative', '相对需要': 'require_relative', '相対要求': 'require_relative',
-    'charger': 'load', 'load': 'load', 'cargar': 'load', 'загрузить': 'load', '加载': 'load', 'ロード': 'load',
-    
-    'lambda': 'lambda', 'лямбда': 'lambda', 'ラムダ': 'lambda',
-    'proc': 'proc', 'процедура': 'proc', 'プロシージャ': 'proc',
-    
-    'nouveau': 'new', 'new': 'new', 'nuevo': 'new', 'новый': 'new', '新': 'new', '新規': 'new',
-    
-    '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',
-    
-    'attr_reader': 'attr_reader', 'attr_writer': 'attr_writer', 'attr_accessor': 'attr_accessor',
-    'afficher': 'puts', 'puts': 'puts', 'mostrar': 'puts', 'показать': 'puts', '打印': 'puts', '表示': 'puts',
-    'imprimer': 'print', 'print': 'print', 'imprimir': 'print', 'печать': 'print', '印刷': 'print',
-    'p': 'p'
-}
-
-const RUBY_METHODS = {
-    'majuscule': 'upcase', 'upcase': 'upcase', 'mayuscula': 'upcase', 'mayúscula': 'upcase', 'верхний': 'upcase', '大写': 'upcase', '大文字': 'upcase',
-    'minuscule': 'downcase', 'downcase': 'downcase', 'minuscula': 'downcase', 'minúscula': 'downcase', 'нижний': 'downcase', '小写': 'downcase', '小文字': 'downcase',
-    'capitaliser': 'capitalize', 'capitalize': 'capitalize', 'capitalizar': 'capitalize', 'капитализировать': 'capitalize', '首字母大写': 'capitalize', '大文字化': 'capitalize',
-    'inverserCasse': 'swapcase', 'swapcase': 'swapcase', 'intercambiarCaso': 'swapcase', 'сменитьРегистр': 'swapcase', '交换大小写': 'swapcase', '大小文字変換': 'swapcase',
-    'remplacerTout': 'gsub', 'gsub': 'gsub', 'reemplazarTodo': 'gsub', 'заменитьВсе': 'gsub', '全部替换': 'gsub', '全置換': 'gsub',
-    'remplacer': 'sub', 'sub': 'sub', 'reemplazar': 'sub', 'заменить': 'sub', '替换': 'sub', '置換': 'sub',
-    'decouper': 'split', 'découper': 'split', 'split': 'split', 'dividir': 'split', 'разделить': 'split', '分割': 'split',
-    'joindre': 'join', 'join': 'join', 'unir': 'join', 'соединить': 'join', '连接': 'join', '結合': 'join',
-    'nettoyer': 'strip', 'strip': 'strip', 'limpiar': 'strip', 'очистить': 'strip', '清除空白': 'strip', '空白除去': 'strip',
-    'nettoyerGauche': 'lstrip', 'lstrip': 'lstrip', 'limpiarIzquierda': 'lstrip', 'очиститьСлева': 'lstrip', '清除左空白': 'lstrip', '左空白除去': 'lstrip',
-    'nettoyerDroite': 'rstrip', 'rstrip': 'rstrip', 'limpiarDerecha': 'rstrip', 'очиститьСправа': 'rstrip', '清除右空白': 'rstrip', '右空白除去': 'rstrip',
-    'vide?': 'empty?', 'empty?': 'empty?', 'vacio?': 'empty?', 'vacío?': 'empty?', 'пусто?': 'empty?', '空?': 'empty?', '空か?': 'empty?',
-    'inclut?': 'include?', 'include?': 'include?', 'incluye?': 'include?', 'включает?': 'include?', '包含?': 'include?', '含む?': 'include?',
-    'commencePar?': 'start_with?', 'start_with?': 'start_with?', 'comienzaCon?': 'start_with?', 'начинаетсяС?': 'start_with?', '以开头?': 'start_with?', '始まる?': 'start_with?',
-    'terminePar?': 'end_with?', 'end_with?': 'end_with?', 'terminaCon?': 'end_with?', 'заканчиваетсяНа?': 'end_with?', '以结尾?': 'end_with?', '終わる?': 'end_with?',
-    'longueur': 'length', 'length': 'length', 'longitud': 'length', 'длина': 'length', '长度': 'length', '長さ': 'length',
-    'taille': 'size', 'size': 'size', 'tamano': 'size', 'tamaño': 'size', 'размер': 'size', '大小': 'size', 'サイズ': 'size',
-    'inverser': 'reverse', 'reverse': 'reverse', 'invertir': 'reverse', 'обратить': 'reverse', '反转': 'reverse', '逆順': 'reverse',
-    
-    'ajouter': 'push', 'push': 'push', 'agregar': 'push', 'добавить': 'push', '添加': 'push', '追加': 'push',
-    'ajouterDebut': 'unshift', 'ajouterDébut': 'unshift', 'unshift': 'unshift', 'agregarInicio': 'unshift', 'добавитьВНачало': 'unshift', '添加到开头': 'unshift', '先頭追加': 'unshift',
-    'retirer': 'pop', 'pop': 'pop', 'quitar': 'pop', 'удалить': 'pop', '弹出': 'pop', '末尾削除': 'pop',
-    'retirerDebut': 'shift', 'retirerDébut': 'shift', 'shift': 'shift', 'quitarInicio': 'shift', 'удалитьИзНачала': 'shift', '弹出开头': 'shift', '先頭削除': 'shift',
-    'premier': 'first', 'first': 'first', 'primero': 'first', 'первый': 'first', '第一个': 'first', '最初': 'first',
-    'dernier': 'last', 'last': 'last', 'ultimo': 'last', 'último': 'last', 'последний': 'last', '最后一个': 'last', '最後': 'last',
-    'prendre': 'take', 'take': 'take', 'tomar': 'take', 'взять': 'take', '取': 'take', '取得': 'take',
-    'laisser': 'drop', 'drop': 'drop', 'dejar': 'drop', 'отбросить': 'drop', '丢弃': 'drop', '破棄': 'drop',
-    'unique': 'uniq', 'uniq': 'uniq', 'unico': 'uniq', 'único': 'uniq', 'уникальный': 'uniq', '唯一': 'uniq', '一意': 'uniq',
-    'compacter': 'compact', 'compact': 'compact', 'compactar': 'compact', 'уплотнить': 'compact', '压缩': 'compact', 'コンパクト': 'compact',
-    'aplatir': 'flatten', 'flatten': 'flatten', 'aplanar': 'flatten', 'сплющить': 'flatten', '扁平化': 'flatten', 'フラット化': 'flatten',
-    'trier': 'sort', 'sort': 'sort', 'ordenar': 'sort', 'сортировать': 'sort', '排序': 'sort', 'ソート': 'sort',
-    'trierPar': 'sort_by', 'sort_by': 'sort_by', 'ordenarPor': 'sort_by', 'сортироватьПо': 'sort_by', '按排序': 'sort_by', 'ソートバイ': 'sort_by',
-    'melanger': 'shuffle', 'mélanger': 'shuffle', 'shuffle': 'shuffle', 'mezclar': 'shuffle', 'перемешать': 'shuffle', '洗牌': 'shuffle', 'シャッフル': 'shuffle',
-    'echantillon': 'sample', 'échantillon': 'sample', 'sample': 'sample', 'muestra': 'sample', 'образец': 'sample', '样本': 'sample', 'サンプル': 'sample',
-    
-    'transformer': 'map', 'map': 'map', 'transformar': 'map', 'преобразовать': 'map', '映射': 'map', 'マップ': 'map',
-    'selectionner': 'select', 'sélectionner': 'select', 'select': 'select', 'seleccionar': 'select', 'выбрать': 'select', '选择': 'select', '選択': 'select',
-    'rejeter': 'reject', 'reject': 'reject', 'rechazar': 'reject', 'отклонить': 'reject', '拒绝': 'reject', '却下': 'reject',
-    'trouver': 'find', 'find': 'find', 'encontrar': 'find', 'найти': 'find', '查找': 'find', '見つける': 'find',
-    'chaque': 'each', 'each': 'each', 'cada': 'each', 'каждый': 'each', '每个': 'each', '各': 'each',
-    'chacunAvecIndex': 'each_with_index', 'each_with_index': 'each_with_index', 'cadaConIndice': 'each_with_index', 'каждыйСИндексом': 'each_with_index', '每个带索引': 'each_with_index', '各インデックス付き': 'each_with_index',
-    'reduire': 'reduce', 'réduire': 'reduce', 'reduce': 'reduce', 'reducir': 'reduce', 'уменьшить': 'reduce', '减少': 'reduce', '畳み込み': 'reduce',
-    'injecter': 'inject', 'inject': 'inject', 'inyectar': 'inject', 'инъекция': 'inject', '注入': 'inject', 'インジェクト': 'inject',
-    'tout?': 'all?', 'all?': 'all?', 'todo?': 'all?', 'все?': 'all?', '全部?': 'all?', '全て?': 'all?',
-    'quelconque?': 'any?', 'any?': 'any?', 'alguno?': 'any?', 'любой?': 'any?', '任意?': 'any?', '任意か?': 'any?',
-    'aucun?': 'none?', 'none?': 'none?', 'ninguno?': 'none?', 'никакой?': 'none?', '无?': 'none?', 'なし?': 'none?',
-    'compter': 'count', 'count': 'count', 'contar': 'count', 'считать': 'count', '计数': 'count', 'カウント': 'count',
-    'groupePar': 'group_by', 'group_by': 'group_by', 'agruparPor': 'group_by', 'группироватьПо': 'group_by', '分组按': 'group_by', 'グループ化': 'group_by',
-    'partition': 'partition', 'particion': 'partition', 'partición': 'partition', 'раздел': 'partition', '分区': 'partition', 'パーティション': 'partition',
-    'min': 'min', 'mínimo': 'min', 'минимум': 'min', '最小': 'min',
-    'max': 'max', 'máximo': 'max', 'максимум': 'max', '最大': 'max',
-    'somme': 'sum', 'sum': 'sum', 'suma': 'sum', 'сумма': 'sum', '总和': 'sum', '合計': 'sum',
-    
-    'cles': 'keys', 'clés': 'keys', 'keys': 'keys', 'llaves': 'keys', 'ключи': 'keys', '键': 'keys', 'キー': 'keys',
-    'valeurs': 'values', 'values': 'values', 'valores': 'values', 'значения': 'values', '值': 'values', '値': 'values',
-    'fusionner': 'merge', 'merge': 'merge', 'fusionar': 'merge', 'слить': 'merge', '合并': 'merge', 'マージ': 'merge',
-    'recuperer': 'fetch', 'récupérer': 'fetch', 'fetch': 'fetch', 'recuperar': 'fetch', 'получить': 'fetch', '获取': 'fetch', 'フェッチ': 'fetch',
-    'supprimer': 'delete', 'delete': 'delete', 'eliminar': 'delete', 'удалить': 'delete', '删除': 'delete', '削除': 'delete',
-    'aCle?': 'has_key?', 'aClé?': 'has_key?', 'has_key?': 'has_key?', 'key?': 'key?', 'tieneLlave?': 'has_key?', 'имеетКлюч?': 'has_key?', '有键?': 'has_key?', 'キーあり?': 'has_key?',
-    'aValeur?': 'has_value?', 'has_value?': 'has_value?', 'value?': 'value?', 'tieneValor?': 'has_value?', 'имеетЗначение?': 'has_value?', '有值?': 'has_value?', '値あり?': 'has_value?',
-    
-    'versEntier': 'to_i', 'to_i': 'to_i', 'aEntero': 'to_i', 'вЦелое': 'to_i', '转整数': 'to_i', '整数へ': 'to_i',
-    'versFlottant': 'to_f', 'to_f': 'to_f', 'aFlotante': 'to_f', 'вДробное': 'to_f', '转浮点数': 'to_f', '浮動小数点へ': 'to_f',
-    'versChaine': 'to_s', 'to_s': 'to_s', 'aCadena': 'to_s', 'вСтроку': 'to_s', '转字符串': 'to_s', '文字列へ': 'to_s',
-    'versSymbole': 'to_sym', 'to_sym': 'to_sym', 'aSimbolo': 'to_sym', 'aСímbolo': 'to_sym', 'вСимвол': 'to_sym', '转符号': 'to_sym', 'シンボルへ': 'to_sym',
-    'versTableau': 'to_a', 'to_a': 'to_a', 'aArreglo': 'to_a', 'вМассив': 'to_a', '转数组': 'to_a', '配列へ': 'to_a',
-    'versHash': 'to_h', 'to_h': 'to_h', 'aHash': 'to_h', 'вХеш': 'to_h', '转哈希': 'to_h', 'ハッシュへ': 'to_h',
-    
-    'appeler': 'call', 'call': 'call', 'llamar': 'call', 'вызвать': 'call', '调用': 'call', '呼び出し': 'call',
-    'ouvrir': 'open', 'open': 'open', 'abrir': 'open', 'открыть': 'open', '打开': 'open', '開く': 'open',
-    'lire': 'read', 'read': 'read', 'leer': 'read', 'читать': 'read', '读取': 'read', '読む': 'read',
-    'ecrire': 'write', 'écrire': 'write', 'write': 'write', 'escribir': 'write', 'писать': 'write', '写入': 'write', '書く': 'write',
-    'fermer': 'close', 'close': 'close', 'cerrar': 'close', 'закрыть': 'close', '关闭': 'close', '閉じる': 'close',
-    'chaqueLigne': 'each_line', 'each_line': 'each_line', 'cadaLinea': 'each_line', 'cadaLínea': 'each_line', 'каждаяСтрока': 'each_line', '每行': 'each_line', '各行': 'each_line',
-    'lireFichier': 'read', 'ecrireFichier': 'write', 'écrireFichier': 'write',
-    
-    'fois': 'times', 'times': 'times', 'veces': 'times', 'раз': 'times', '次': 'times', '回': 'times',
-    'jusqua': 'upto', "jusqu'à": 'upto', 'upto': 'upto', 'hasta': 'upto', 'до': 'upto', '到': 'upto', 'まで': 'upto',
-    'depuis': 'downto', 'downto': 'downto', 'desde': 'downto', 'от': 'downto', '从': 'downto', 'から': 'downto',
-    'pas': 'step', 'step': 'step', 'paso': 'step', 'шаг': 'step', '步': 'step', 'ステップ': 'step',
-    
-    'pair?': 'even?', 'even?': 'even?', 'par?': 'even?', 'четный?': 'even?', '偶数?': 'even?',
-    'impair?': 'odd?', 'odd?': 'odd?', 'impar?': 'odd?', 'нечетный?': 'odd?', '奇数?': 'odd?',
-    'zero?': 'zero?', 'zéro?': 'zero?', 'cero?': 'zero?', 'ноль?': 'zero?', '零?': 'zero?', 'ゼロ?': 'zero?',
-    'positif?': 'positive?', 'positive?': 'positive?', 'positivo?': 'positive?', 'положительный?': 'positive?', '正数?': 'positive?', '正?': 'positive?',
-    'negatif?': 'negative?', 'négatif?': 'negative?', 'negative?': 'negative?', 'negativo?': 'negative?', 'отрицательный?': 'negative?', '负数?': 'negative?', '負?': 'negative?',
-    'abs': 'abs', 'absolu': 'abs', 'absoluto': 'abs', 'абсолютный': 'abs', '绝对值': 'abs', '絶対値': 'abs',
-    'arrondi': 'round', 'round': 'round', 'redondear': 'round', 'округлить': 'round', '四舍五入': 'round', '丸め': 'round',
-    'plancher': 'floor', 'floor': 'floor', 'piso': 'floor', 'пол': 'floor', '向下取整': 'floor', '切り捨て': 'floor',
-    'plafond': 'ceil', 'ceil': 'ceil', 'techo': 'ceil', 'потолок': 'ceil', '向上取整': 'ceil', '切り上げ': 'ceil',
-    
-    'initialiser': 'initialize', 'initialize': 'initialize', 'inicializar': 'initialize', 'инициализировать': 'initialize', '初始化': 'initialize', '初期化': 'initialize',
-    
-    'repondA?': 'respond_to?', 'répondÀ?': 'respond_to?', 'respond_to?': 'respond_to?', 'respondeA?': 'respond_to?', 'отвечаетНа?': 'respond_to?', '响应?': 'respond_to?', '応答する?': 'respond_to?',
-    'estUn?': 'is_a?', 'is_a?': 'is_a?', 'kind_of?': 'kind_of?', 'esUn?': 'is_a?', 'являетсяЛи?': 'is_a?', '是?': 'is_a?', 'である?': 'is_a?',
-    'instanceDe?': 'instance_of?', 'instance_of?': 'instance_of?', 'instanciaDe?': 'instance_of?', 'экземплярЛи?': 'instance_of?', '实例?': 'instance_of?', 'インスタンス?': 'instance_of?',
-    'methodes': 'methods', 'méthodes': 'methods', 'methods': 'methods', 'metodos': 'methods', 'métodos': 'methods', 'методы': 'methods', '方法列表': 'methods', 'メソッド一覧': 'methods',
-    'envoyer': 'send', 'send': 'send', 'enviar': 'send', 'отправить': 'send', '发送': 'send', '送る': 'send',
-    'methode': 'method', 'méthode': 'method', 'method': 'method', 'metodo': 'method', 'método': 'method', 'метод': 'method', '方法': 'method', 'メソッド': 'method',
-    'tap': 'tap', 'then': 'then', 'yield_self': 'yield_self'
-}
-
-class RubyLexer {
-    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 && /[ \t]/.test(this.peek())) {
-            this.advance()
-        }
-    }
-
-    skipComment() {
-        if (this.peek() === '#') {
-            while (this.pos < this.source.length && this.peek() !== '\n') {
-                this.advance()
-            }
-            return true
-        }
-        if (this.peek() === '=' && this.peek(1) === 'b' && this.peek(2) === 'e' && this.peek(3) === 'g' && this.peek(4) === 'i' && this.peek(5) === 'n') {
-            while (this.pos < this.source.length) {
-                if (this.peek() === '=' && this.source.slice(this.pos, this.pos + 4) === '=end') {
-                    this.pos += 4
-                    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 === '\n' || char === ';') {
-                this.advance()
-                this.tokens.push({ type: 'NEWLINE', loc })
-                continue
-            }
-
-            if (char === '"' || char === "'") {
-                this.tokens.push(this.readString(char))
-                continue
-            }
-
-            if (char === '`') {
-                this.tokens.push(this.readBacktick())
-                continue
-            }
-
-            if (char === ':' && /[a-zA-Z_]/.test(this.peek(1))) {
-                this.tokens.push(this.readSymbol())
-                continue
-            }
-
-            if (char === '%') {
-                const next = this.peek(1)
-                if ('wWiIqQrxs'.includes(next)) {
-                    this.tokens.push(this.readPercentLiteral())
-                    continue
-                }
-            }
-
-            if (char === '/' && this.shouldBeRegex()) {
-                this.tokens.push(this.readRegexp())
-                continue
-            }
-
-            if (/[0-9]/.test(char) || (char === '.' && /[0-9]/.test(this.peek(1)))) {
-                this.tokens.push(this.readNumber())
-                continue
-            }
-
-            if (char === '@') {
-                this.tokens.push(this.readInstanceOrClassVar())
-                continue
-            }
-
-            if (char === '$') {
-                this.tokens.push(this.readGlobalVar())
-                continue
-            }
-
-            if (/[a-zA-ZÀ-ÿА-яぁ-ゟァ-ヿ一-龯_]/.test(char)) {
-                this.tokens.push(this.readWord())
-                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
-    }
-
-    shouldBeRegex() {
-        if (this.tokens.length === 0) return true
-        const last = this.tokens[this.tokens.length - 1]
-        const noRegexAfter = ['IDENTIFIER', 'CONSTANT', 'NUMBER', 'STRING', 'SYMBOL', 'RPAREN', 'RBRACKET', 'RBRACE', 'INSTANCE_VAR', 'CLASS_VAR', 'GLOBAL_VAR']
-        return !noRegexAfter.includes(last.type)
-    }
-
-    readWord() {
-        const loc = { line: this.line, column: this.column }
-        let word = ''
-        
-        while (this.pos < this.source.length && /[a-zA-Z0-9À-ÿА-яぁ-ゟァ-ヿ一-龯_?!]/.test(this.peek())) {
-            word += this.advance()
-        }
-        
-        if (/^[A-Z]/.test(word)) {
-            return { type: 'CONSTANT', value: word, loc }
-        }
-        
-        if (RUBY_KEYWORDS[word]) {
-            return { type: 'KEYWORD', value: word, loc }
-        }
-        
-        if (RUBY_METHODS[word]) {
-            return { type: 'METHOD', value: word, loc }
-        }
-        
-        return { type: 'IDENTIFIER', value: word, loc }
-    }
-
-    readInstanceOrClassVar() {
-        const loc = { line: this.line, column: this.column }
-        this.advance()
-        
-        if (this.peek() === '@') {
-            this.advance()
-            let name = ''
-            while (this.pos < this.source.length && /[a-zA-Z0-9_]/.test(this.peek())) {
-                name += this.advance()
-            }
-            return { type: 'CLASS_VAR', value: name, loc }
-        }
-        
-        let name = ''
-        while (this.pos < this.source.length && /[a-zA-Z0-9_]/.test(this.peek())) {
-            name += this.advance()
-        }
-        return { type: 'INSTANCE_VAR', value: name, loc }
-    }
-
-    readGlobalVar() {
-        const loc = { line: this.line, column: this.column }
-        this.advance()
-        
-        let name = ''
-        if (/[0-9~!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?`]/.test(this.peek())) {
-            name = this.advance()
-        } else {
-            while (this.pos < this.source.length && /[a-zA-Z0-9_]/.test(this.peek())) {
-                name += this.advance()
-            }
-        }
-        return { type: 'GLOBAL_VAR', value: name, loc }
-    }
-
-    readSymbol() {
-        const loc = { line: this.line, column: this.column }
-        this.advance()
-        
-        if (this.peek() === '"') {
-            this.advance()
-            let value = ''
-            while (this.pos < this.source.length && this.peek() !== '"') {
-                if (this.peek() === '\\') {
-                    this.advance()
-                    value += this.advance()
-                } else {
-                    value += this.advance()
-                }
-            }
-            this.advance()
-            return { type: 'SYMBOL', value, loc }
-        }
-        
-        let value = ''
-        while (this.pos < this.source.length && /[a-zA-Z0-9_?!=]/.test(this.peek())) {
-            value += this.advance()
-        }
-        return { type: 'SYMBOL', value, loc }
-    }
-
-    readString(quote) {
-        const loc = { line: this.line, column: this.column }
-        this.advance()
-        
-        let value = ''
-        let raw = quote
-        const parts = []
-        let currentPart = ''
-        let interpolated = false
-        
-        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': currentPart += '\n'; break
-                        case 'r': currentPart += '\r'; break
-                        case 't': currentPart += '\t'; break
-                        case '\\': currentPart += '\\'; break
-                        case quote: currentPart += quote; break
-                        default: currentPart += '\\' + escaped
-                    }
-                }
-            } else if (quote === '"' && this.peek() === '#' && this.peek(1) === '{') {
-                interpolated = true
-                if (currentPart) {
-                    parts.push({ type: 'string', value: currentPart })
-                    currentPart = ''
-                }
-                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()
-                        raw += expr[expr.length - 1]
-                    } else {
-                        raw += this.advance()
-                    }
-                }
-                parts.push({ type: 'interpolation', value: expr })
-            } else {
-                const c = this.advance()
-                currentPart += c
-                raw += c
-            }
-        }
-        
-        if (currentPart) {
-            parts.push({ type: 'string', value: currentPart })
-        }
-        
-        if (this.peek() === quote) {
-            raw += this.advance()
-        }
-        
-        if (interpolated) {
-            return { type: 'INTERPOLATED_STRING', parts, raw, loc }
-        }
-        
-        return { type: 'STRING', value: parts.map(p => p.value).join(''), raw, loc }
-    }
-
-    readBacktick() {
-        const loc = { line: this.line, column: this.column }
-        this.advance()
-        
-        let command = ''
-        while (this.pos < this.source.length && this.peek() !== '`') {
-            if (this.peek() === '\\') {
-                this.advance()
-                command += this.advance()
-            } else {
-                command += this.advance()
-            }
-        }
-        this.advance()
-        return { type: 'BACKTICK', value: command, loc }
-    }
-
-    readRegexp() {
-        const loc = { line: this.line, column: this.column }
-        this.advance()
-        
-        let pattern = ''
-        while (this.pos < this.source.length && this.peek() !== '/') {
-            if (this.peek() === '\\') {
-                pattern += this.advance()
-                pattern += this.advance()
-            } else {
-                pattern += this.advance()
-            }
-        }
-        this.advance()
-        
-        let flags = ''
-        while (/[imxo]/.test(this.peek())) {
-            flags += this.advance()
-        }
-        
-        return { type: 'REGEXP', pattern, flags, loc }
-    }
-
-    readPercentLiteral() {
-        const loc = { line: this.line, column: this.column }
-        this.advance()
-        const type = this.advance()
-        const delimiter = this.advance()
-        const closeDelimiter = { '(': ')', '[': ']', '{': '}', '<': '>' }[delimiter] || delimiter
-        
-        const elements = []
-        let current = ''
-        let depth = 1
-        
-        while (this.pos < this.source.length && depth > 0) {
-            const c = this.peek()
-            if (c === delimiter && delimiter !== closeDelimiter) {
-                depth++
-                current += this.advance()
-            } else if (c === closeDelimiter) {
-                depth--
-                if (depth > 0) current += this.advance()
-                else this.advance()
-            } else if (/\s/.test(c) && depth === 1 && 'wWiI'.includes(type)) {
-                if (current) elements.push(current)
-                current = ''
-                this.advance()
-            } else {
-                current += this.advance()
-            }
-        }
-        if (current) elements.push(current)
-        
-        return { type: 'PERCENT_LITERAL', literalType: type, elements, loc }
-    }
-
-    readNumber() {
-        const loc = { line: this.line, column: this.column }
-        let value = ''
-        let isFloat = false
-        let isRational = false
-        let isComplex = 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))) {
-                isFloat = true
-                value += this.advance()
-                while (/[0-9_]/.test(this.peek())) {
-                    value += this.advance()
-                }
-            }
-            
-            if (this.peek() === 'e' || this.peek() === 'E') {
-                isFloat = true
-                value += this.advance()
-                if (this.peek() === '+' || this.peek() === '-') {
-                    value += this.advance()
-                }
-                while (/[0-9_]/.test(this.peek())) {
-                    value += this.advance()
-                }
-            }
-        }
-        
-        if (this.peek() === 'r') {
-            isRational = true
-            this.advance()
-        } else if (this.peek() === 'i') {
-            isComplex = true
-            this.advance()
-        }
-        
-        const cleanValue = value.replace(/_/g, '')
-        
-        if (isRational) {
-            return { type: 'RATIONAL', value: cleanValue, raw: value + 'r', loc }
-        }
-        if (isComplex) {
-            return { type: 'COMPLEX', value: cleanValue, raw: value + 'i', loc }
-        }
-        if (isFloat) {
-            return { type: 'FLOAT', value: parseFloat(cleanValue), raw: value, loc }
-        }
-        
-        let numValue
-        if (value.startsWith('0x') || value.startsWith('0X')) {
-            numValue = parseInt(cleanValue.slice(2), 16)
-        } else if (value.startsWith('0b') || value.startsWith('0B')) {
-            numValue = parseInt(cleanValue.slice(2), 2)
-        } else if (value.startsWith('0o') || value.startsWith('0O')) {
-            numValue = parseInt(cleanValue.slice(2), 8)
-        } else {
-            numValue = parseInt(cleanValue, 10)
-        }
-        
-        return { type: 'NUMBER', value: numValue, raw: value, loc }
-    }
-
-    readOperator() {
-        const loc = { line: this.line, column: this.column }
-        
-        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 threeCharOps = {
-            '...': 'EXCLUSIVE_RANGE', '<=>': 'SPACESHIP', '===': 'CASE_EQUAL',
-            '&&=': 'AND_ASSIGN', '||=': 'OR_ASSIGN', '**=': 'POW_ASSIGN',
-            '<<=': 'LSHIFT_ASSIGN', '>>=': 'RSHIFT_ASSIGN', '&.': 'SAFE_NAV'
-        }
-        
-        const twoCharOps = {
-            '==': 'EQUAL', '!=': 'NOT_EQUAL', '<=': 'LTE', '>=': 'GTE',
-            '&&': 'AND', '||': 'OR', '..': 'INCLUSIVE_RANGE',
-            '<<': 'LSHIFT', '>>': 'RSHIFT', '**': 'POW',
-            '+=': 'PLUS_ASSIGN', '-=': 'MINUS_ASSIGN', '*=': 'TIMES_ASSIGN',
-            '/=': 'DIV_ASSIGN', '%=': 'MOD_ASSIGN', '&=': 'BIT_AND_ASSIGN',
-            '|=': 'BIT_OR_ASSIGN', '^=': 'BIT_XOR_ASSIGN',
-            '=~': 'MATCH', '!~': 'NOT_MATCH', '=>': 'HASH_ROCKET',
-            '::': 'SCOPE', '->': 'LAMBDA_ARROW', '&.': 'SAFE_NAV'
-        }
-        
-        const oneCharOps = {
-            '+': 'PLUS', '-': 'MINUS', '*': 'TIMES', '/': 'DIV', '%': 'MOD',
-            '=': 'ASSIGN', '<': 'LT', '>': 'GT', '!': 'NOT', '~': 'TILDE',
-            '&': 'AMPERSAND', '|': 'PIPE', '^': 'CARET',
-            '(': 'LPAREN', ')': 'RPAREN', '[': 'LBRACKET', ']': 'RBRACKET',
-            '{': 'LBRACE', '}': 'RBRACE', ',': 'COMMA', '.': 'DOT',
-            ':': 'COLON', '?': 'QUESTION', '\\': 'BACKSLASH'
-        }
-        
-        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 RubyParser {
-    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) {
-            this.i18n = {}
-        }
-    }
-
-    parse(source) {
-        const lexer = new RubyLexer(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()
-    }
-
-    skipNewlines() {
-        while (this.match('NEWLINE')) {
-            this.advance()
-        }
-    }
-
-    translateKeyword(word) {
-        return RUBY_KEYWORDS[word] || word
-    }
-
-    translateMethod(word) {
-        return RUBY_METHODS[word] || word
-    }
-
-    parseProgram() {
-        const body = []
-        this.skipNewlines()
-        
-        while (!this.match('EOF')) {
-            const stmt = this.parseStatement()
-            if (stmt) body.push(stmt)
-            this.skipNewlines()
-        }
-        
-        return new AST.Program(body)
-    }
-
-    parseStatement() {
-        this.skipNewlines()
-        const token = this.peek()
-        
-        if (token.type === 'KEYWORD') {
-            const kw = this.translateKeyword(token.value)
-            
-            switch (kw) {
-                case 'def': return this.parseMethodDefinition()
-                case 'class': return this.parseClassDefinition()
-                case 'module': return this.parseModuleDefinition()
-                case 'if': return this.parseIfStatement()
-                case 'unless': return this.parseUnlessStatement()
-                case 'case': return this.parseCaseStatement()
-                case 'while': return this.parseWhileStatement()
-                case 'until': return this.parseUntilStatement()
-                case 'for': return this.parseForStatement()
-                case 'loop': return this.parseLoopStatement()
-                case 'begin': return this.parseBeginBlock()
-                case 'return': return this.parseReturnStatement()
-                case 'break': return this.parseBreakStatement()
-                case 'next': return this.parseNextStatement()
-                case 'redo': return this.parseRedoStatement()
-                case 'retry': return this.parseRetryStatement()
-                case 'raise': return this.parseRaiseStatement()
-                case 'require': return this.parseRequireStatement()
-                case 'require_relative': return this.parseRequireRelativeStatement()
-                case 'load': return this.parseLoadStatement()
-                case 'include': return this.parseIncludeStatement()
-                case 'extend': return this.parseExtendStatement()
-                case 'prepend': return this.parsePrependStatement()
-                case 'alias': return this.parseAliasStatement()
-                case 'undef': return this.parseUndefStatement()
-                case 'public':
-                case 'private':
-                case 'protected': return this.parseVisibilityStatement()
-                case 'attr_reader':
-                case 'attr_writer':
-                case 'attr_accessor': return this.parseAttrAccessor()
-                case 'puts':
-                case 'print':
-                case 'p': return this.parsePrintStatement()
-                case 'end': return null
-            }
-        }
-        
-        const expr = this.parseExpression()
-        return new AST.ExpressionStatement(expr, token.loc)
-    }
-
-    parseMethodDefinition() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let singleton = null
-        let name = ''
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'self') {
-            singleton = new AST.SelfExpression()
-            this.advance()
-            this.expect('DOT')
-        }
-        
-        if (this.match('IDENTIFIER', 'METHOD', 'KEYWORD')) {
-            name = this.advance().value
-        } else if (this.match('CONSTANT')) {
-            name = this.advance().value
-        }
-        
-        if (this.peek().value === '=' || this.peek().value === '?' || this.peek().value === '!') {
-            name += this.advance().value
-        }
-        
-        const parameters = []
-        if (this.match('LPAREN')) {
-            this.advance()
-            while (!this.match('RPAREN', 'EOF')) {
-                parameters.push(this.parseMethodParameter())
-                if (this.match('COMMA')) this.advance()
-            }
-            this.expect('RPAREN')
-        } else if (this.match('IDENTIFIER', 'TIMES', 'POW', 'AMPERSAND')) {
-            while (!this.match('NEWLINE', 'EOF')) {
-                parameters.push(this.parseMethodParameter())
-                if (this.match('COMMA')) this.advance()
-                else break
-            }
-        }
-        
-        this.skipNewlines()
-        const body = this.parseBody('end')
-        
-        return new AST.MethodDefinition(name, parameters, body, singleton, loc)
-    }
-
-    parseMethodParameter() {
-        const loc = this.peek().loc
-        let splat = false
-        let doubleSplat = false
-        let blockArg = false
-        let keyword = false
-        
-        if (this.match('TIMES')) {
-            splat = true
-            this.advance()
-        } else if (this.match('POW')) {
-            doubleSplat = true
-            this.advance()
-        } else if (this.match('AMPERSAND')) {
-            blockArg = true
-            this.advance()
-        }
-        
-        const name = this.expect('IDENTIFIER').value
-        
-        if (this.match('COLON')) {
-            keyword = true
-            this.advance()
-        }
-        
-        let defaultValue = null
-        if (this.match('ASSIGN')) {
-            this.advance()
-            defaultValue = this.parseExpression()
-        }
-        
-        return new AST.MethodParameter(name, defaultValue, splat, doubleSplat, blockArg, keyword, loc)
-    }
-
-    parseClassDefinition() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        if (this.match('LSHIFT')) {
-            this.advance()
-            const object = this.parseExpression()
-            this.skipNewlines()
-            const body = this.parseBody('end')
-            return new AST.SingletonClass(object, body, loc)
-        }
-        
-        const name = this.parseConstantPath()
-        
-        let superclass = null
-        if (this.match('LT')) {
-            this.advance()
-            superclass = this.parseConstantPath()
-        }
-        
-        this.skipNewlines()
-        const body = this.parseBody('end')
-        
-        return new AST.ClassDefinition(name, superclass, body, loc)
-    }
-
-    parseModuleDefinition() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const name = this.parseConstantPath()
-        this.skipNewlines()
-        const body = this.parseBody('end')
-        
-        return new AST.ModuleDefinition(name, body, loc)
-    }
-
-    parseConstantPath() {
-        let path = null
-        
-        if (this.match('SCOPE')) {
-            this.advance()
-            path = new AST.ScopedConstant(null, this.expect('CONSTANT').value)
-        } else {
-            path = new AST.Constant(this.expect('CONSTANT').value)
-        }
-        
-        while (this.match('SCOPE')) {
-            this.advance()
-            path = new AST.ScopedConstant(path, this.expect('CONSTANT').value)
-        }
-        
-        return path
-    }
-
-    parseIfStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const test = this.parseExpression()
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'then') {
-            this.advance()
-        }
-        this.skipNewlines()
-        
-        const consequent = []
-        while (!this.match('EOF')) {
-            const token = this.peek()
-            if (token.type === 'KEYWORD') {
-                const kw = this.translateKeyword(token.value)
-                if (kw === 'end' || kw === 'else' || kw === 'elsif') break
-            }
-            consequent.push(this.parseStatement())
-            this.skipNewlines()
-        }
-        
-        let alternate = null
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'elsif') {
-            alternate = this.parseElsifClause()
-        } else if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'else') {
-            this.advance()
-            this.skipNewlines()
-            alternate = this.parseBody('end')
-        }
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'end') {
-            this.advance()
-        }
-        
-        return new AST.IfStatement(test, consequent, alternate, false, loc)
-    }
-
-    parseElsifClause() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const test = this.parseExpression()
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'then') {
-            this.advance()
-        }
-        this.skipNewlines()
-        
-        const consequent = []
-        while (!this.match('EOF')) {
-            const token = this.peek()
-            if (token.type === 'KEYWORD') {
-                const kw = this.translateKeyword(token.value)
-                if (kw === 'end' || kw === 'else' || kw === 'elsif') break
-            }
-            consequent.push(this.parseStatement())
-            this.skipNewlines()
-        }
-        
-        let nextClause = null
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'elsif') {
-            nextClause = this.parseElsifClause()
-        } else if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'else') {
-            this.advance()
-            this.skipNewlines()
-            nextClause = this.parseBody('end')
-        }
-        
-        return new AST.IfStatement(test, consequent, nextClause, false, loc)
-    }
-
-    parseUnlessStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const test = this.parseExpression()
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'then') {
-            this.advance()
-        }
-        this.skipNewlines()
-        
-        const consequent = []
-        while (!this.match('EOF')) {
-            const token = this.peek()
-            if (token.type === 'KEYWORD') {
-                const kw = this.translateKeyword(token.value)
-                if (kw === 'end' || kw === 'else') break
-            }
-            consequent.push(this.parseStatement())
-            this.skipNewlines()
-        }
-        
-        let alternate = null
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'else') {
-            this.advance()
-            this.skipNewlines()
-            alternate = this.parseBody('end')
-        }
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'end') {
-            this.advance()
-        }
-        
-        return new AST.UnlessStatement(test, consequent, alternate, false, loc)
-    }
-
-    parseCaseStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let expression = null
-        if (!this.match('NEWLINE', 'KEYWORD')) {
-            expression = this.parseExpression()
-        }
-        this.skipNewlines()
-        
-        const whens = []
-        while (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'when') {
-            whens.push(this.parseWhenClause())
-        }
-        
-        let elseBody = null
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'else') {
-            this.advance()
-            this.skipNewlines()
-            elseBody = this.parseBody('end')
-        }
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'end') {
-            this.advance()
-        }
-        
-        return new AST.CaseStatement(expression, whens, elseBody, loc)
-    }
-
-    parseWhenClause() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const conditions = [this.parseExpression()]
-        while (this.match('COMMA')) {
-            this.advance()
-            conditions.push(this.parseExpression())
-        }
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'then') {
-            this.advance()
-        }
-        this.skipNewlines()
-        
-        const body = []
-        while (!this.match('EOF')) {
-            const token = this.peek()
-            if (token.type === 'KEYWORD') {
-                const kw = this.translateKeyword(token.value)
-                if (kw === 'end' || kw === 'else' || kw === 'when') break
-            }
-            body.push(this.parseStatement())
-            this.skipNewlines()
-        }
-        
-        return new AST.WhenClause(conditions, body, loc)
-    }
-
-    parseWhileStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const test = this.parseExpression()
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'do') {
-            this.advance()
-        }
-        this.skipNewlines()
-        
-        const body = this.parseBody('end')
-        
-        return new AST.WhileStatement(test, body, false, loc)
-    }
-
-    parseUntilStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const test = this.parseExpression()
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'do') {
-            this.advance()
-        }
-        this.skipNewlines()
-        
-        const body = this.parseBody('end')
-        
-        return new AST.UntilStatement(test, body, false, loc)
-    }
-
-    parseForStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const variable = this.parseAssignmentTarget()
-        this.expect('KEYWORD')
-        const iterable = this.parseExpression()
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'do') {
-            this.advance()
-        }
-        this.skipNewlines()
-        
-        const body = this.parseBody('end')
-        
-        return new AST.ForStatement(variable, iterable, body, loc)
-    }
-
-    parseLoopStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'do') {
-            this.advance()
-        }
-        this.skipNewlines()
-        
-        const body = this.parseBody('end')
-        
-        return new AST.LoopStatement(body, loc)
-    }
-
-    parseBeginBlock() {
-        const loc = this.peek().loc
-        this.advance()
-        this.skipNewlines()
-        
-        const body = []
-        while (!this.match('EOF')) {
-            const token = this.peek()
-            if (token.type === 'KEYWORD') {
-                const kw = this.translateKeyword(token.value)
-                if (kw === 'end' || kw === 'rescue' || kw === 'else' || kw === 'ensure') break
-            }
-            body.push(this.parseStatement())
-            this.skipNewlines()
-        }
-        
-        const rescues = []
-        while (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'rescue') {
-            rescues.push(this.parseRescueClause())
-        }
-        
-        let elseBody = null
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'else') {
-            this.advance()
-            this.skipNewlines()
-            elseBody = []
-            while (!this.match('EOF')) {
-                const token = this.peek()
-                if (token.type === 'KEYWORD') {
-                    const kw = this.translateKeyword(token.value)
-                    if (kw === 'end' || kw === 'ensure') break
-                }
-                elseBody.push(this.parseStatement())
-                this.skipNewlines()
-            }
-        }
-        
-        let ensure = null
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'ensure') {
-            ensure = this.parseEnsureClause()
-        }
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'end') {
-            this.advance()
-        }
-        
-        return new AST.BeginBlock(body, rescues, elseBody, ensure, loc)
-    }
-
-    parseRescueClause() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const exceptionTypes = []
-        let variable = null
-        
-        if (!this.match('NEWLINE', 'HASH_ROCKET')) {
-            exceptionTypes.push(this.parseConstantPath())
-            while (this.match('COMMA')) {
-                this.advance()
-                exceptionTypes.push(this.parseConstantPath())
-            }
-        }
-        
-        if (this.match('HASH_ROCKET')) {
-            this.advance()
-            variable = new AST.Identifier(this.expect('IDENTIFIER').value)
-        }
-        
-        this.skipNewlines()
-        
-        const body = []
-        while (!this.match('EOF')) {
-            const token = this.peek()
-            if (token.type === 'KEYWORD') {
-                const kw = this.translateKeyword(token.value)
-                if (kw === 'end' || kw === 'rescue' || kw === 'else' || kw === 'ensure') break
-            }
-            body.push(this.parseStatement())
-            this.skipNewlines()
-        }
-        
-        return new AST.RescueClause(exceptionTypes, variable, body, loc)
-    }
-
-    parseEnsureClause() {
-        const loc = this.peek().loc
-        this.advance()
-        this.skipNewlines()
-        
-        const body = []
-        while (!this.match('EOF')) {
-            const token = this.peek()
-            if (token.type === 'KEYWORD' && this.translateKeyword(token.value) === 'end') break
-            body.push(this.parseStatement())
-            this.skipNewlines()
-        }
-        
-        return new AST.EnsureClause(body, loc)
-    }
-
-    parseReturnStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let value = null
-        if (!this.match('NEWLINE', 'EOF', 'KEYWORD')) {
-            value = this.parseExpression()
-        }
-        
-        return new AST.ReturnStatement(value, loc)
-    }
-
-    parseBreakStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let value = null
-        if (!this.match('NEWLINE', 'EOF', 'KEYWORD')) {
-            value = this.parseExpression()
-        }
-        
-        return new AST.BreakStatement(value, loc)
-    }
-
-    parseNextStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let value = null
-        if (!this.match('NEWLINE', 'EOF', 'KEYWORD')) {
-            value = this.parseExpression()
-        }
-        
-        return new AST.NextStatement(value, loc)
-    }
-
-    parseRedoStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        return new AST.RedoStatement(loc)
-    }
-
-    parseRetryStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        return new AST.RetryStatement(loc)
-    }
-
-    parseRaiseStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        let exception = null
-        let message = null
-        
-        if (!this.match('NEWLINE', 'EOF')) {
-            exception = this.parseExpression()
-            if (this.match('COMMA')) {
-                this.advance()
-                message = this.parseExpression()
-            }
-        }
-        
-        return new AST.RaiseStatement(exception, message, null, loc)
-    }
-
-    parseRequireStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        const path = this.parseExpression()
-        return new AST.RequireStatement(path, false, loc)
-    }
-
-    parseRequireRelativeStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        const path = this.parseExpression()
-        return new AST.RequireStatement(path, true, loc)
-    }
-
-    parseLoadStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        const path = this.parseExpression()
-        
-        let wrap = false
-        if (this.match('COMMA')) {
-            this.advance()
-            wrap = this.parseExpression()
-        }
-        
-        return new AST.LoadStatement(path, wrap, loc)
-    }
-
-    parseIncludeStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const modules = [this.parseConstantPath()]
-        while (this.match('COMMA')) {
-            this.advance()
-            modules.push(this.parseConstantPath())
-        }
-        
-        return new AST.IncludeStatement(modules, loc)
-    }
-
-    parseExtendStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const modules = [this.parseConstantPath()]
-        while (this.match('COMMA')) {
-            this.advance()
-            modules.push(this.parseConstantPath())
-        }
-        
-        return new AST.ExtendStatement(modules, loc)
-    }
-
-    parsePrependStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const modules = [this.parseConstantPath()]
-        while (this.match('COMMA')) {
-            this.advance()
-            modules.push(this.parseConstantPath())
-        }
-        
-        return new AST.PrependStatement(modules, loc)
-    }
-
-    parseAliasStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const newName = this.parseSymbolOrMethod()
-        const oldName = this.parseSymbolOrMethod()
-        
-        return new AST.AliasStatement(newName, oldName, loc)
-    }
-
-    parseSymbolOrMethod() {
-        if (this.match('SYMBOL')) {
-            return new AST.Symbol(this.advance().value)
-        }
-        return new AST.Identifier(this.advance().value)
-    }
-
-    parseUndefStatement() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const methods = [this.parseSymbolOrMethod()]
-        while (this.match('COMMA')) {
-            this.advance()
-            methods.push(this.parseSymbolOrMethod())
-        }
-        
-        return new AST.UndefStatement(methods, loc)
-    }
-
-    parseVisibilityStatement() {
-        const loc = this.peek().loc
-        const visibility = this.translateKeyword(this.advance().value)
-        
-        if (this.match('NEWLINE', 'EOF')) {
-            return new AST.MethodCall(null, visibility, [], null, false, loc)
-        }
-        
-        const methods = [this.parseSymbolOrMethod()]
-        while (this.match('COMMA')) {
-            this.advance()
-            methods.push(this.parseSymbolOrMethod())
-        }
-        
-        return new AST.MethodCall(null, visibility, methods, null, false, loc)
-    }
-
-    parseAttrAccessor() {
-        const loc = this.peek().loc
-        const type = this.translateKeyword(this.advance().value)
-        
-        const attributes = []
-        attributes.push(this.parseSymbolOrMethod())
-        while (this.match('COMMA')) {
-            this.advance()
-            attributes.push(this.parseSymbolOrMethod())
-        }
-        
-        return new AST.AttrAccessor(type, attributes, loc)
-    }
-
-    parsePrintStatement() {
-        const loc = this.peek().loc
-        const method = this.translateKeyword(this.advance().value)
-        
-        const args = []
-        if (!this.match('NEWLINE', 'EOF')) {
-            args.push(this.parseExpression())
-            while (this.match('COMMA')) {
-                this.advance()
-                args.push(this.parseExpression())
-            }
-        }
-        
-        return new AST.MethodCall(null, method, args, null, false, loc)
-    }
-
-    parseBody(endKeyword) {
-        const body = []
-        
-        while (!this.match('EOF')) {
-            const token = this.peek()
-            if (token.type === 'KEYWORD' && this.translateKeyword(token.value) === endKeyword) {
-                this.advance()
-                break
-            }
-            body.push(this.parseStatement())
-            this.skipNewlines()
-        }
-        
-        return body
-    }
-
-    parseExpression() {
-        return this.parseAssignment()
-    }
-
-    parseAssignment() {
-        const left = this.parseTernary()
-        
-        if (this.match('ASSIGN', 'PLUS_ASSIGN', 'MINUS_ASSIGN', 'TIMES_ASSIGN', 'DIV_ASSIGN', 'MOD_ASSIGN',
-            'POW_ASSIGN', 'AND_ASSIGN', 'OR_ASSIGN', 'BIT_AND_ASSIGN', 'BIT_OR_ASSIGN', 'BIT_XOR_ASSIGN',
-            'LSHIFT_ASSIGN', 'RSHIFT_ASSIGN')) {
-            const op = this.advance()
-            const right = this.parseAssignment()
-            return new AST.AssignmentExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseTernary() {
-        const test = this.parseOr()
-        
-        if (this.match('QUESTION')) {
-            this.advance()
-            const consequent = this.parseExpression()
-            this.expect('COLON')
-            const alternate = this.parseExpression()
-            return new AST.ConditionalExpression(test, consequent, alternate, test.loc)
-        }
-        
-        return test
-    }
-
-    parseOr() {
-        let left = this.parseAnd()
-        
-        while (this.match('OR') || (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'or')) {
-            this.advance()
-            const right = this.parseAnd()
-            left = new AST.LogicalExpression('||', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseAnd() {
-        let left = this.parseNot()
-        
-        while (this.match('AND') || (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'and')) {
-            this.advance()
-            const right = this.parseNot()
-            left = new AST.LogicalExpression('&&', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseNot() {
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'not') {
-            const loc = this.peek().loc
-            this.advance()
-            return new AST.NotExpression(this.parseNot(), loc)
-        }
-        
-        return this.parseEquality()
-    }
-
-    parseEquality() {
-        let left = this.parseComparison()
-        
-        while (this.match('EQUAL', 'NOT_EQUAL', 'CASE_EQUAL', 'MATCH', 'NOT_MATCH')) {
-            const op = this.advance()
-            const right = this.parseComparison()
-            if (op.type === 'MATCH') {
-                left = new AST.MatchExpression(left, right, left.loc)
-            } else if (op.type === 'NOT_MATCH') {
-                left = new AST.NotMatchExpression(left, right, left.loc)
-            } else {
-                left = new AST.BinaryExpression(op.value, left, right, left.loc)
-            }
-        }
-        
-        return left
-    }
-
-    parseComparison() {
-        let left = this.parseBitwiseOr()
-        
-        while (this.match('LT', 'GT', 'LTE', 'GTE', 'SPACESHIP')) {
-            const op = this.advance()
-            const right = this.parseBitwiseOr()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseBitwiseOr() {
-        let left = this.parseBitwiseXor()
-        
-        while (this.match('PIPE')) {
-            this.advance()
-            const right = this.parseBitwiseXor()
-            left = new AST.BinaryExpression('|', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseBitwiseXor() {
-        let left = this.parseBitwiseAnd()
-        
-        while (this.match('CARET')) {
-            this.advance()
-            const right = this.parseBitwiseAnd()
-            left = new AST.BinaryExpression('^', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseBitwiseAnd() {
-        let left = this.parseShift()
-        
-        while (this.match('AMPERSAND') && !this.isBlockArg()) {
-            this.advance()
-            const right = this.parseShift()
-            left = new AST.BinaryExpression('&', left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    isBlockArg() {
-        return this.peek(1).type === 'IDENTIFIER' || this.peek(1).type === 'COLON'
-    }
-
-    parseShift() {
-        let left = this.parseRange()
-        
-        while (this.match('LSHIFT', 'RSHIFT')) {
-            const op = this.advance()
-            const right = this.parseRange()
-            left = new AST.BinaryExpression(op.value, left, right, left.loc)
-        }
-        
-        return left
-    }
-
-    parseRange() {
-        let left = this.parseAdditive()
-        
-        if (this.match('INCLUSIVE_RANGE', 'EXCLUSIVE_RANGE')) {
-            const exclusive = this.advance().type === 'EXCLUSIVE_RANGE'
-            const right = this.parseAdditive()
-            return new AST.RangeLiteral(left, right, exclusive, 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')) {
-            this.advance()
-            return new AST.UnaryExpression('!', this.parseUnary(), true, loc)
-        }
-        
-        if (this.match('TILDE')) {
-            this.advance()
-            return new AST.UnaryExpression('~', this.parseUnary(), true, loc)
-        }
-        
-        if (this.match('PLUS')) {
-            this.advance()
-            return new AST.UnaryExpression('+', this.parseUnary(), true, loc)
-        }
-        
-        if (this.match('MINUS')) {
-            this.advance()
-            return new AST.UnaryExpression('-', this.parseUnary(), true, loc)
-        }
-        
-        if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'defined?') {
-            this.advance()
-            const arg = this.match('LPAREN') ? (this.advance(), this.parseExpression(), this.expect('RPAREN'), this.parseExpression()) : this.parseUnary()
-            return new AST.DefinedExpression(arg, loc)
-        }
-        
-        return this.parseCall()
-    }
-
-    parseCall() {
-        let expr = this.parsePrimary()
-        
-        while (true) {
-            if (this.match('DOT')) {
-                this.advance()
-                const method = this.advance().value
-                expr = this.parseMethodCall(expr, method, false)
-            } else if (this.match('SAFE_NAV')) {
-                this.advance()
-                const method = this.advance().value
-                expr = this.parseMethodCall(expr, method, true)
-            } else if (this.match('SCOPE')) {
-                this.advance()
-                if (this.match('CONSTANT')) {
-                    expr = new AST.ScopedConstant(expr, this.advance().value)
-                } else {
-                    const method = this.advance().value
-                    expr = this.parseMethodCall(expr, method, false)
-                }
-            } else if (this.match('LBRACKET')) {
-                this.advance()
-                const index = this.parseExpression()
-                this.expect('RBRACKET')
-                
-                if (this.match('ASSIGN')) {
-                    this.advance()
-                    const value = this.parseExpression()
-                    expr = new AST.IndexAssignment(expr, index, value, expr.loc)
-                } else {
-                    expr = new AST.IndexAccess(expr, index, expr.loc)
-                }
-            } else if (this.match('LPAREN')) {
-                expr = this.parseMethodCall(null, expr, false)
-            } else {
-                break
-            }
-        }
-        
-        return expr
-    }
-
-    parseMethodCall(receiver, method, safeNavigation) {
-        const loc = (receiver || method).loc || this.peek().loc
-        const args = []
-        let block = null
-        
-        if (this.match('LPAREN')) {
-            this.advance()
-            while (!this.match('RPAREN', 'EOF')) {
-                if (this.match('TIMES')) {
-                    this.advance()
-                    args.push(new AST.SplatExpression(this.parseExpression()))
-                } else if (this.match('POW')) {
-                    this.advance()
-                    args.push(new AST.DoubleSplatExpression(this.parseExpression()))
-                } else if (this.match('AMPERSAND')) {
-                    this.advance()
-                    args.push(new AST.SplatExpression(this.parseExpression()))
-                } else {
-                    args.push(this.parseExpression())
-                }
-                if (this.match('COMMA')) this.advance()
-            }
-            this.expect('RPAREN')
-        } else if (!this.match('NEWLINE', 'EOF', 'KEYWORD', 'LBRACE', 'DOT', 'SAFE_NAV') && !this.peek().value?.match(/^(do|end|if|unless|while|until|rescue)$/)) {
-            while (!this.match('NEWLINE', 'EOF', 'LBRACE') && !this.isBlockKeyword()) {
-                if (this.match('TIMES')) {
-                    this.advance()
-                    args.push(new AST.SplatExpression(this.parseExpression()))
-                } else if (this.match('POW')) {
-                    this.advance()
-                    args.push(new AST.DoubleSplatExpression(this.parseExpression()))
-                } else if (this.match('AMPERSAND')) {
-                    this.advance()
-                    args.push(new AST.SplatExpression(this.parseExpression()))
-                } else {
-                    args.push(this.parseExpression())
-                }
-                if (this.match('COMMA')) this.advance()
-                else break
-            }
-        }
-        
-        if (this.match('LBRACE') || this.isBlockKeyword()) {
-            block = this.parseBlock()
-        }
-        
-        const methodName = typeof method === 'string' ? method : (method.name || method.value || method)
-        return new AST.MethodCall(receiver, methodName, args, block, safeNavigation, loc)
-    }
-
-    isBlockKeyword() {
-        return this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'do'
-    }
-
-    parseBlock() {
-        const loc = this.peek().loc
-        let useBraces = false
-        
-        if (this.match('LBRACE')) {
-            useBraces = true
-            this.advance()
-        } else if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'do') {
-            this.advance()
-        }
-        
-        const parameters = []
-        if (this.match('PIPE')) {
-            this.advance()
-            while (!this.match('PIPE', 'EOF')) {
-                parameters.push(this.parseBlockParameter())
-                if (this.match('COMMA')) this.advance()
-            }
-            this.expect('PIPE')
-        }
-        
-        this.skipNewlines()
-        
-        const body = []
-        if (useBraces) {
-            while (!this.match('RBRACE', 'EOF')) {
-                body.push(this.parseStatement())
-                this.skipNewlines()
-            }
-            this.expect('RBRACE')
-        } else {
-            while (!this.match('EOF')) {
-                const token = this.peek()
-                if (token.type === 'KEYWORD' && this.translateKeyword(token.value) === 'end') {
-                    this.advance()
-                    break
-                }
-                body.push(this.parseStatement())
-                this.skipNewlines()
-            }
-        }
-        
-        return new AST.Block(parameters, body, loc)
-    }
-
-    parseBlockParameter() {
-        const loc = this.peek().loc
-        let splat = false
-        let doubleSplat = false
-        let blockArg = false
-        
-        if (this.match('TIMES')) {
-            splat = true
-            this.advance()
-        } else if (this.match('POW')) {
-            doubleSplat = true
-            this.advance()
-        } else if (this.match('AMPERSAND')) {
-            blockArg = true
-            this.advance()
-        }
-        
-        const name = this.expect('IDENTIFIER').value
-        
-        let defaultValue = null
-        if (this.match('ASSIGN')) {
-            this.advance()
-            defaultValue = this.parseExpression()
-        }
-        
-        return new AST.BlockParameter(name, defaultValue, splat, doubleSplat, blockArg, loc)
-    }
-
-    parsePrimary() {
-        const token = this.peek()
-        const loc = token.loc
-        
-        if (token.type === 'NUMBER') {
-            this.advance()
-            return new AST.NumericLiteral(token.value, token.raw, loc)
-        }
-        
-        if (token.type === 'FLOAT') {
-            this.advance()
-            return new AST.FloatLiteral(token.value, token.raw, loc)
-        }
-        
-        if (token.type === 'RATIONAL') {
-            this.advance()
-            return new AST.RationalLiteral(token.value, token.raw, loc)
-        }
-        
-        if (token.type === 'COMPLEX') {
-            this.advance()
-            return new AST.ComplexLiteral(token.value, token.raw, loc)
-        }
-        
-        if (token.type === 'STRING') {
-            this.advance()
-            return new AST.StringLiteral(token.value, token.raw, false, loc)
-        }
-        
-        if (token.type === 'INTERPOLATED_STRING') {
-            this.advance()
-            const parts = token.parts.map(p => {
-                if (p.type === 'string') {
-                    return new AST.StringPart(p.value)
-                } else {
-                    const subParser = new RubyParser()
-                    const subAst = subParser.parse(p.value)
-                    return new AST.InterpolationPart(subAst.body[0]?.expression || subAst.body[0])
-                }
-            })
-            return new AST.InterpolatedString(parts, loc)
-        }
-        
-        if (token.type === 'SYMBOL') {
-            this.advance()
-            return new AST.Symbol(token.value, loc)
-        }
-        
-        if (token.type === 'REGEXP') {
-            this.advance()
-            return new AST.RegexpLiteral(token.pattern, token.flags, loc)
-        }
-        
-        if (token.type === 'PERCENT_LITERAL') {
-            this.advance()
-            return new AST.PercentArray(token.elements, token.literalType, loc)
-        }
-        
-        if (token.type === 'BACKTICK') {
-            this.advance()
-            return new AST.BacktickLiteral(token.value, loc)
-        }
-        
-        if (token.type === 'INSTANCE_VAR') {
-            this.advance()
-            return new AST.InstanceVariable(token.value, loc)
-        }
-        
-        if (token.type === 'CLASS_VAR') {
-            this.advance()
-            return new AST.ClassVariable(token.value, loc)
-        }
-        
-        if (token.type === 'GLOBAL_VAR') {
-            this.advance()
-            return new AST.GlobalVariable(token.value, loc)
-        }
-        
-        if (token.type === 'CONSTANT') {
-            return this.parseConstantPath()
-        }
-        
-        if (token.type === 'IDENTIFIER' || token.type === 'METHOD') {
-            this.advance()
-            const name = token.value
-            
-            if (this.match('LPAREN', 'LBRACE') || this.isBlockKeyword() || (!this.match('NEWLINE', 'EOF', 'DOT', 'ASSIGN') && this.peek().type === 'IDENTIFIER')) {
-                return this.parseMethodCall(null, name, false)
-            }
-            
-            return new AST.Identifier(name, 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 === 'nil') {
-                this.advance()
-                return new AST.NilLiteral(loc)
-            }
-            if (kw === 'self') {
-                this.advance()
-                return new AST.SelfExpression(loc)
-            }
-            if (kw === 'super') {
-                this.advance()
-                return this.parseSuperCall(loc)
-            }
-            if (kw === 'yield') {
-                this.advance()
-                return this.parseYieldExpression(loc)
-            }
-            if (kw === 'lambda') {
-                this.advance()
-                return this.parseLambda(loc)
-            }
-            if (kw === 'proc') {
-                this.advance()
-                return this.parseProc(loc)
-            }
-            if (kw === '__FILE__') {
-                this.advance()
-                return new AST.File(loc)
-            }
-            if (kw === '__LINE__') {
-                this.advance()
-                return new AST.Line(loc)
-            }
-            if (kw === '__ENCODING__') {
-                this.advance()
-                return new AST.Encoding(loc)
-            }
-        }
-        
-        if (this.match('LBRACKET')) {
-            return this.parseArrayLiteral()
-        }
-        
-        if (this.match('LBRACE')) {
-            return this.parseHashLiteral()
-        }
-        
-        if (this.match('LPAREN')) {
-            this.advance()
-            const expr = this.parseExpression()
-            this.expect('RPAREN')
-            return new AST.ParenthesizedExpression(expr, loc)
-        }
-        
-        if (this.match('LAMBDA_ARROW')) {
-            return this.parseStabbyLambda()
-        }
-        
-        throw new Error(`Token inattendu ${token.type} à ligne ${loc?.line}`)
-    }
-
-    parseSuperCall(loc) {
-        let args = null
-        let block = null
-        
-        if (this.match('LPAREN')) {
-            this.advance()
-            args = []
-            while (!this.match('RPAREN', 'EOF')) {
-                args.push(this.parseExpression())
-                if (this.match('COMMA')) this.advance()
-            }
-            this.expect('RPAREN')
-        }
-        
-        if (this.match('LBRACE') || this.isBlockKeyword()) {
-            block = this.parseBlock()
-        }
-        
-        return new AST.SuperCall(args, block, loc)
-    }
-
-    parseYieldExpression(loc) {
-        const args = []
-        
-        if (this.match('LPAREN')) {
-            this.advance()
-            while (!this.match('RPAREN', 'EOF')) {
-                args.push(this.parseExpression())
-                if (this.match('COMMA')) this.advance()
-            }
-            this.expect('RPAREN')
-        } else if (!this.match('NEWLINE', 'EOF')) {
-            args.push(this.parseExpression())
-            while (this.match('COMMA')) {
-                this.advance()
-                args.push(this.parseExpression())
-            }
-        }
-        
-        return new AST.YieldExpression(args, loc)
-    }
-
-    parseLambda(loc) {
-        const block = this.parseBlock()
-        return new AST.LambdaLiteral(block.parameters, block.body, loc)
-    }
-
-    parseProc(loc) {
-        const block = this.parseBlock()
-        return new AST.ProcLiteral(block.parameters, block.body, loc)
-    }
-
-    parseStabbyLambda() {
-        const loc = this.peek().loc
-        this.advance()
-        
-        const parameters = []
-        if (this.match('LPAREN')) {
-            this.advance()
-            while (!this.match('RPAREN', 'EOF')) {
-                parameters.push(this.parseMethodParameter())
-                if (this.match('COMMA')) this.advance()
-            }
-            this.expect('RPAREN')
-        }
-        
-        const body = []
-        if (this.match('LBRACE')) {
-            this.advance()
-            while (!this.match('RBRACE', 'EOF')) {
-                body.push(this.parseStatement())
-                this.skipNewlines()
-            }
-            this.expect('RBRACE')
-        } else if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'do') {
-            this.advance()
-            this.skipNewlines()
-            while (!this.match('EOF')) {
-                if (this.match('KEYWORD') && this.translateKeyword(this.peek().value) === 'end') {
-                    this.advance()
-                    break
-                }
-                body.push(this.parseStatement())
-                this.skipNewlines()
-            }
-        }
-        
-        return new AST.LambdaLiteral(parameters, body, loc)
-    }
-
-    parseArrayLiteral() {
-        const loc = this.peek().loc
-        this.expect('LBRACKET')
-        const elements = []
-        
-        while (!this.match('RBRACKET', 'EOF')) {
-            this.skipNewlines()
-            if (this.match('TIMES')) {
-                this.advance()
-                elements.push(new AST.SplatExpression(this.parseExpression()))
-            } else {
-                elements.push(this.parseExpression())
-            }
-            this.skipNewlines()
-            if (this.match('COMMA')) this.advance()
-        }
-        
-        this.expect('RBRACKET')
-        return new AST.ArrayLiteral(elements, loc)
-    }
-
-    parseHashLiteral() {
-        const loc = this.peek().loc
-        this.expect('LBRACE')
-        const pairs = []
-        
-        while (!this.match('RBRACE', 'EOF')) {
-            this.skipNewlines()
-            
-            if (this.match('POW')) {
-                this.advance()
-                pairs.push(new AST.DoubleSplatExpression(this.parseExpression()))
-            } else {
-                let key
-                if (this.match('IDENTIFIER', 'METHOD', 'KEYWORD') && this.peek(1).type === 'COLON') {
-                    key = new AST.Symbol(this.advance().value)
-                    this.advance()
-                } else {
-                    key = this.parseExpression()
-                    if (this.match('HASH_ROCKET')) {
-                        this.advance()
-                    } else if (this.match('COLON')) {
-                        this.advance()
-                    }
-                }
-                const value = this.parseExpression()
-                pairs.push(new AST.HashPair(key, value))
-            }
-            
-            this.skipNewlines()
-            if (this.match('COMMA')) this.advance()
-        }
-        
-        this.expect('RBRACE')
-        return new AST.HashLiteral(pairs, loc)
-    }
-
-    parseAssignmentTarget() {
-        if (this.match('IDENTIFIER')) {
-            return new AST.Identifier(this.advance().value)
-        }
-        if (this.match('INSTANCE_VAR')) {
-            return new AST.InstanceVariable(this.advance().value)
-        }
-        if (this.match('CLASS_VAR')) {
-            return new AST.ClassVariable(this.advance().value)
-        }
-        if (this.match('GLOBAL_VAR')) {
-            return new AST.GlobalVariable(this.advance().value)
-        }
-        if (this.match('CONSTANT')) {
-            return this.parseConstantPath()
-        }
-        
-        return this.parseExpression()
-    }
-}
-
-class RubyCodeGenerator {
-    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')
-    }
-
-    generateMethodDefinition(node) {
-        let result = this.indent()
-        result += 'def '
-        if (node.singleton) {
-            result += this.generate(node.singleton) + '.'
-        }
-        result += node.name
-        if (node.parameters.length) {
-            result += '(' + node.parameters.map(p => this.generate(p)).join(', ') + ')'
-        }
-        result += '\n'
-        this.indentLevel++
-        result += node.body.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        result += '\n' + this.indent() + 'end'
-        return result
-    }
-
-    generateMethodParameter(node) {
-        let result = ''
-        if (node.splat) result += '*'
-        if (node.doubleSplat) result += '**'
-        if (node.blockArg) result += '&'
-        result += node.name
-        if (node.keyword) result += ':'
-        if (node.defaultValue) result += ' = ' + this.generate(node.defaultValue)
-        return result
-    }
-
-    generateClassDefinition(node) {
-        let result = this.indent() + 'class ' + this.generate(node.name)
-        if (node.superclass) result += ' < ' + this.generate(node.superclass)
-        result += '\n'
-        this.indentLevel++
-        result += node.body.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        result += '\n' + this.indent() + 'end'
-        return result
-    }
-
-    generateSingletonClass(node) {
-        let result = this.indent() + 'class << ' + this.generate(node.object) + '\n'
-        this.indentLevel++
-        result += node.body.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        result += '\n' + this.indent() + 'end'
-        return result
-    }
-
-    generateModuleDefinition(node) {
-        let result = this.indent() + 'module ' + this.generate(node.name) + '\n'
-        this.indentLevel++
-        result += node.body.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        result += '\n' + this.indent() + 'end'
-        return result
-    }
-
-    generateConstant(node) { return node.name }
-    generateScopedConstant(node) {
-        if (node.scope) return this.generate(node.scope) + '::' + node.name
-        return '::' + node.name
-    }
-
-    generateIfStatement(node) {
-        if (node.modifier) {
-            return this.indent() + this.generate(node.consequent[0]) + ' if ' + this.generate(node.test)
-        }
-        let result = this.indent() + 'if ' + this.generate(node.test) + '\n'
-        this.indentLevel++
-        result += node.consequent.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        if (node.alternate) {
-            if (node.alternate.type === 'IfStatement') {
-                result += '\n' + this.indent() + 'els' + this.generate(node.alternate).trim()
-            } else if (Array.isArray(node.alternate)) {
-                result += '\n' + this.indent() + 'else\n'
-                this.indentLevel++
-                result += node.alternate.map(s => this.generate(s)).join('\n')
-                this.indentLevel--
-            }
-        }
-        result += '\n' + this.indent() + 'end'
-        return result
-    }
-
-    generateUnlessStatement(node) {
-        if (node.modifier) {
-            return this.indent() + this.generate(node.consequent[0]) + ' unless ' + this.generate(node.test)
-        }
-        let result = this.indent() + 'unless ' + this.generate(node.test) + '\n'
-        this.indentLevel++
-        result += node.consequent.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        if (node.alternate) {
-            result += '\n' + this.indent() + 'else\n'
-            this.indentLevel++
-            result += node.alternate.map(s => this.generate(s)).join('\n')
-            this.indentLevel--
-        }
-        result += '\n' + this.indent() + 'end'
-        return result
-    }
-
-    generateCaseStatement(node) {
-        let result = this.indent() + 'case'
-        if (node.expression) result += ' ' + this.generate(node.expression)
-        result += '\n'
-        result += node.whens.map(w => this.generate(w)).join('\n')
-        if (node.elseBody) {
-            result += '\n' + this.indent() + 'else\n'
-            this.indentLevel++
-            result += node.elseBody.map(s => this.generate(s)).join('\n')
-            this.indentLevel--
-        }
-        result += '\n' + this.indent() + 'end'
-        return result
-    }
-
-    generateWhenClause(node) {
-        let result = this.indent() + 'when ' + node.conditions.map(c => this.generate(c)).join(', ') + '\n'
-        this.indentLevel++
-        result += node.body.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        return result
-    }
-
-    generateWhileStatement(node) {
-        if (node.modifier) {
-            return this.indent() + this.generate(node.body[0]) + ' while ' + this.generate(node.test)
-        }
-        let result = this.indent() + 'while ' + this.generate(node.test) + '\n'
-        this.indentLevel++
-        result += node.body.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        result += '\n' + this.indent() + 'end'
-        return result
-    }
-
-    generateUntilStatement(node) {
-        if (node.modifier) {
-            return this.indent() + this.generate(node.body[0]) + ' until ' + this.generate(node.test)
-        }
-        let result = this.indent() + 'until ' + this.generate(node.test) + '\n'
-        this.indentLevel++
-        result += node.body.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        result += '\n' + this.indent() + 'end'
-        return result
-    }
-
-    generateForStatement(node) {
-        let result = this.indent() + 'for ' + this.generate(node.variable) + ' in ' + this.generate(node.iterable) + '\n'
-        this.indentLevel++
-        result += node.body.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        result += '\n' + this.indent() + 'end'
-        return result
-    }
-
-    generateLoopStatement(node) {
-        let result = this.indent() + 'loop do\n'
-        this.indentLevel++
-        result += node.body.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        result += '\n' + this.indent() + 'end'
-        return result
-    }
-
-    generateBeginBlock(node) {
-        let result = this.indent() + 'begin\n'
-        this.indentLevel++
-        result += node.body.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        result += node.rescues.map(r => '\n' + this.generate(r)).join('')
-        if (node.elseBody) {
-            result += '\n' + this.indent() + 'else\n'
-            this.indentLevel++
-            result += node.elseBody.map(s => this.generate(s)).join('\n')
-            this.indentLevel--
-        }
-        if (node.ensure) {
-            result += '\n' + this.generate(node.ensure)
-        }
-        result += '\n' + this.indent() + 'end'
-        return result
-    }
-
-    generateRescueClause(node) {
-        let result = this.indent() + 'rescue'
-        if (node.exceptionTypes.length) {
-            result += ' ' + node.exceptionTypes.map(e => this.generate(e)).join(', ')
-        }
-        if (node.variable) result += ' => ' + this.generate(node.variable)
-        result += '\n'
-        this.indentLevel++
-        result += node.body.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        return result
-    }
-
-    generateEnsureClause(node) {
-        let result = this.indent() + 'ensure\n'
-        this.indentLevel++
-        result += node.body.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        return result
-    }
-
-    generateReturnStatement(node) {
-        return this.indent() + 'return' + (node.value ? ' ' + this.generate(node.value) : '')
-    }
-    generateBreakStatement(node) {
-        return this.indent() + 'break' + (node.value ? ' ' + this.generate(node.value) : '')
-    }
-    generateNextStatement(node) {
-        return this.indent() + 'next' + (node.value ? ' ' + this.generate(node.value) : '')
-    }
-    generateRedoStatement() { return this.indent() + 'redo' }
-    generateRetryStatement() { return this.indent() + 'retry' }
-
-    generateRaiseStatement(node) {
-        let result = this.indent() + 'raise'
-        if (node.exception) result += ' ' + this.generate(node.exception)
-        if (node.message) result += ', ' + this.generate(node.message)
-        return result
-    }
-
-    generateRequireStatement(node) {
-        return this.indent() + (node.relative ? 'require_relative' : 'require') + ' ' + this.generate(node.path)
-    }
-    generateLoadStatement(node) {
-        return this.indent() + 'load ' + this.generate(node.path) + (node.wrap ? ', true' : '')
-    }
-
-    generateIncludeStatement(node) {
-        return this.indent() + 'include ' + node.modules.map(m => this.generate(m)).join(', ')
-    }
-    generateExtendStatement(node) {
-        return this.indent() + 'extend ' + node.modules.map(m => this.generate(m)).join(', ')
-    }
-    generatePrependStatement(node) {
-        return this.indent() + 'prepend ' + node.modules.map(m => this.generate(m)).join(', ')
-    }
-
-    generateAttrAccessor(node) {
-        return this.indent() + node.accessorType + ' ' + node.attributes.map(a => this.generate(a)).join(', ')
-    }
-
-    generateAliasStatement(node) {
-        return this.indent() + 'alias ' + this.generate(node.newName) + ' ' + this.generate(node.oldName)
-    }
-    generateUndefStatement(node) {
-        return this.indent() + 'undef ' + node.methods.map(m => this.generate(m)).join(', ')
-    }
-
-    generateExpressionStatement(node) {
-        return this.indent() + this.generate(node.expression)
-    }
-
-    generateMethodCall(node) {
-        let result = ''
-        if (node.receiver) {
-            result = this.generate(node.receiver)
-            result += node.safeNavigation ? '&.' : '.'
-        }
-        result += node.method
-        if (node.arguments.length || node.block) {
-            if (node.arguments.length) {
-                result += '(' + node.arguments.map(a => this.generate(a)).join(', ') + ')'
-            }
-            if (node.block) {
-                result += ' ' + this.generate(node.block)
-            }
-        }
-        return result
-    }
-
-    generateBlock(node) {
-        if (node.body.length === 1 && node.body[0].type === 'ExpressionStatement') {
-            let result = '{ '
-            if (node.parameters.length) {
-                result += '|' + node.parameters.map(p => this.generate(p)).join(', ') + '| '
-            }
-            result += this.generate(node.body[0].expression) + ' }'
-            return result
-        }
-        
-        let result = 'do'
-        if (node.parameters.length) {
-            result += ' |' + node.parameters.map(p => this.generate(p)).join(', ') + '|'
-        }
-        result += '\n'
-        this.indentLevel++
-        result += node.body.map(s => this.generate(s)).join('\n')
-        this.indentLevel--
-        result += '\n' + this.indent() + 'end'
-        return result
-    }
-
-    generateBlockParameter(node) {
-        let result = ''
-        if (node.splat) result += '*'
-        if (node.doubleSplat) result += '**'
-        if (node.blockArg) result += '&'
-        result += node.name
-        if (node.defaultValue) result += ' = ' + this.generate(node.defaultValue)
-        return result
-    }
-
-    generateLambdaLiteral(node) {
-        let result = '-> '
-        if (node.parameters.length) {
-            result += '(' + node.parameters.map(p => this.generate(p)).join(', ') + ') '
-        }
-        result += '{ '
-        result += node.body.map(s => this.generate(s).trim()).join('; ')
-        result += ' }'
-        return result
-    }
-
-    generateProcLiteral(node) {
-        let result = 'proc { '
-        if (node.parameters.length) {
-            result += '|' + node.parameters.map(p => this.generate(p)).join(', ') + '| '
-        }
-        result += node.body.map(s => this.generate(s).trim()).join('; ')
-        result += ' }'
-        return result
-    }
-
-    generateBinaryExpression(node) {
-        return `${this.generate(node.left)} ${node.operator} ${this.generate(node.right)}`
-    }
-    generateUnaryExpression(node) {
-        return node.prefix ? `${node.operator}${this.generate(node.argument)}` : `${this.generate(node.argument)}${node.operator}`
-    }
-    generateAssignmentExpression(node) {
-        return `${this.generate(node.left)} ${node.operator} ${this.generate(node.right)}`
-    }
-    generateLogicalExpression(node) {
-        const op = node.operator === '&&' ? '&&' : '||'
-        return `${this.generate(node.left)} ${op} ${this.generate(node.right)}`
-    }
-    generateConditionalExpression(node) {
-        return `${this.generate(node.test)} ? ${this.generate(node.consequent)} : ${this.generate(node.alternate)}`
-    }
-
-    generateIndexAccess(node) {
-        return `${this.generate(node.object)}[${this.generate(node.index)}]`
-    }
-    generateIndexAssignment(node) {
-        return `${this.generate(node.object)}[${this.generate(node.index)}] = ${this.generate(node.value)}`
-    }
-
-    generateSuperCall(node) {
-        let result = 'super'
-        if (node.arguments) {
-            result += '(' + node.arguments.map(a => this.generate(a)).join(', ') + ')'
-        }
-        return result
-    }
-
-    generateYieldExpression(node) {
-        let result = 'yield'
-        if (node.arguments.length) {
-            result += ' ' + node.arguments.map(a => this.generate(a)).join(', ')
-        }
-        return result
-    }
-
-    generateSelfExpression() { return 'self' }
-    generateDefinedExpression(node) { return `defined?(${this.generate(node.expression)})` }
-    generateNotExpression(node) { return `not ${this.generate(node.argument)}` }
-
-    generateSplatExpression(node) { return '*' + this.generate(node.argument) }
-    generateDoubleSplatExpression(node) { return '**' + this.generate(node.argument) }
-
-    generateRangeLiteral(node) {
-        return `${this.generate(node.start)}${node.exclusive ? '...' : '..'}${this.generate(node.end)}`
-    }
-
-    generateArrayLiteral(node) {
-        return '[' + node.elements.map(e => this.generate(e)).join(', ') + ']'
-    }
-
-    generateHashLiteral(node) {
-        return '{ ' + node.pairs.map(p => this.generate(p)).join(', ') + ' }'
-    }
-
-    generateHashPair(node) {
-        if (node.key.type === 'Symbol') {
-            return `${node.key.value}: ${this.generate(node.value)}`
-        }
-        return `${this.generate(node.key)} => ${this.generate(node.value)}`
-    }
-
-    generateIdentifier(node) { return node.name }
-    generateInstanceVariable(node) { return '@' + node.name }
-    generateClassVariable(node) { return '@@' + node.name }
-    generateGlobalVariable(node) { return '$' + node.name }
-    generateSymbol(node) { return ':' + node.value }
-
-    generateStringLiteral(node) { return node.raw || `"${node.value}"` }
-    generateInterpolatedString(node) {
-        let result = '"'
-        for (const part of node.parts) {
-            if (part.type === 'StringPart') {
-                result += part.value
-            } else {
-                result += '#{' + this.generate(part.expression) + '}'
-            }
-        }
-        result += '"'
-        return result
-    }
-
-    generateNumericLiteral(node) { return node.raw || String(node.value) }
-    generateFloatLiteral(node) { return node.raw || String(node.value) }
-    generateRationalLiteral(node) { return node.raw }
-    generateComplexLiteral(node) { return node.raw }
-    generateBooleanLiteral(node) { return node.value ? 'true' : 'false' }
-    generateNilLiteral() { return 'nil' }
-
-    generateRegexpLiteral(node) { return `/${node.pattern}/${node.flags}` }
-    generatePercentArray(node) { return `%${node.type}(${node.elements.join(' ')})` }
-    generateBacktickLiteral(node) { return '`' + node.command + '`' }
-
-    generateMatchExpression(node) { return `${this.generate(node.left)} =~ ${this.generate(node.right)}` }
-    generateNotMatchExpression(node) { return `${this.generate(node.left)} !~ ${this.generate(node.right)}` }
-
-    generateParenthesizedExpression(node) { return '(' + this.generate(node.expression) + ')' }
-
-    generateFile() { return '__FILE__' }
-    generateLine() { return '__LINE__' }
-    generateEncoding() { return '__ENCODING__' }
-}
-
-module.exports = {
-    RubyLexer,
-    RubyParser,
-    RubyCodeGenerator,
-    RUBY_KEYWORDS,
-    RUBY_METHODS
-}