ether-code 0.7.6 → 0.7.7

package/ether-parser.js

@@ -1,4335 +0,0 @@
-const fs = require('fs')
-const { EtherLexer, Token, TokenType } = require('./lexer/ether-lexer')
-
-class EtherParser {
-  constructor(options = {}) {
-    this.tokens = []
-    this.pos = 0
-    this.currentIndent = 0
-    this.i18n = {}
-    this.reverseMaps = {}
-    this.targetLang = options.targetLang || 'auto'
-    
-    this.loadAllI18n(options.i18nDir || './i18n')
-    this.initCompoundTerms()
-  }
-
-  initCompoundTerms() {
-    this.compoundOperators = {
-      'strictement egal': '===',
-      'strictement égal': '===',
-      'strictement different': '!==',
-      'strictement différent': '!==',
-      'superieur ou egal': '>=',
-      'supérieur ou égal': '>=',
-      'inferieur ou egal': '<=',
-      'inférieur ou égal': '<=',
-      'coalescence nulle': '??',
-      'chainage optionnel': '?.',
-      'chaînage optionnel': '?.'
-    }
-    
-    this.compoundKeywords = {
-      'sinon si': 'else if',
-      'tant que': 'while',
-      'pour chaque': 'forEach',
-      'fonction asynchrone': 'async function',
-      'fonction async': 'async function',
-      'fonction generatrice': 'function*',
-      'fonction génératrice': 'function*',
-      'variable globale': 'var'
-    }
-
-    this.jsTranslations = {
-      'variable': 'let',
-      'constante': 'const',
-      'fonction': 'function',
-      'retourner': 'return',
-      'si': 'if',
-      'sinon': 'else',
-      'pour': 'for',
-      'de': 'of',
-      'dans': 'in',
-      'selon': 'switch',
-      'cas': 'case',
-      'defaut': 'default',
-      'sortir': 'break',
-      'continuer': 'continue',
-      'essayer': 'try',
-      'attraper': 'catch',
-      'finalement': 'finally',
-      'lancer': 'throw',
-      'nouveau': 'new',
-      'supprimer': 'delete',
-      'vrai': 'true',
-      'faux': 'false',
-      'nul': 'null',
-      'indefini': 'undefined',
-      'ceci': 'this',
-      'classe': 'class',
-      'etendre': 'extends',
-      'super': 'super',
-      'constructeur': 'constructor',
-      'statique': 'static',
-      'obtenir': 'get',
-      'definir': 'set',
-      'asynchrone': 'async',
-      'attendre': 'await',
-      'importer': 'import',
-      'exporter': 'export',
-      'depuis': 'from',
-      'comme': 'as',
-      'addition': '+',
-      'soustraction': '-',
-      'multiplication': '*',
-      'division': '/',
-      'modulo': '%',
-      'puissance': '**',
-      'increment': '++',
-      'decrement': '--',
-      'egal': '==',
-      'different': '!=',
-      'superieur': '>',
-      'inferieur': '<',
-      'et': '&&',
-      'ou': '||',
-      'non': '!',
-      'document': 'document',
-      'fenetre': 'window',
-      'console': 'console',
-      'journal': 'console.log',
-      'erreur': 'console.error',
-      'avertir': 'console.warn',
-      'info': 'console.info',
-      'promesse': 'Promise',
-      'resoudre': 'resolve',
-      'rejeter': 'reject',
-      'alors': 'then',
-      'tout': 'all',
-      'course': 'race',
-      'json': 'JSON',
-      'serialiser': 'stringify',
-      'analyser': 'parse',
-      'math': 'Math',
-      'aleatoire': 'random',
-      'arrondir': 'round',
-      'plancher': 'floor',
-      'plafond': 'ceil',
-      'absolu': 'abs',
-      'maximum': 'max',
-      'minimum': 'min',
-      
-      'maintenant': 'now',
-      
-      'ensemble': 'Set',
-      'symbole': 'Symbol',
-      'objet': 'Object',
-      'selecteur': 'querySelector',
-      'sur': 'addEventListener',
-      'longueur': 'length',
-      'taille': 'size',
-      'recuperer': 'fetch',
-      'transformer': 'map',
-      'filtrer': 'filter',
-      'reduire': 'reduce',
-      'trouver': 'find',
-      'certains': 'some',
-      'tous': 'every',
-      'inclut': 'includes',
-      'joindre': 'join',
-      'inverser': 'reverse',
-      'trier': 'sort',
-      'decouper': 'slice',
-      'concatener': 'concat',
-      'ajouter': 'push',
-      'retirer': 'pop',
-      'diviser': 'split',
-      'remplacer': 'replace',
-      'rogner': 'trim',
-      'repeter': 'repeat'
-    }
-  }
-
-  normalizeAccents(str) {
-    return str.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '')
-  }
-
-  tryMatchCompoundOperator() {
-    const current = this.current()
-    if (!current || current.type !== TokenType.IDENTIFIER) return null
-    
-    const val1 = this.normalizeAccents(String(current.value))
-    const next = this.peek(1)
-    const next2 = this.peek(2)
-    
-    if (next && next.type === TokenType.IDENTIFIER) {
-      const val2 = this.normalizeAccents(String(next.value))
-      
-      if (next2 && next2.type === TokenType.IDENTIFIER) {
-        const val3 = this.normalizeAccents(String(next2.value))
-        const compound3 = `${val1} ${val2} ${val3}`
-        if (this.compoundOperators[compound3]) {
-          this.advance()
-          this.advance()
-          this.advance()
-          return this.compoundOperators[compound3]
-        }
-      }
-      
-      const compound2 = `${val1} ${val2}`
-      if (this.compoundOperators[compound2]) {
-        this.advance()
-        this.advance()
-        return this.compoundOperators[compound2]
-      }
-    }
-    
-    return null
-  }
-
-  tryMatchCompoundKeyword() {
-    const current = this.current()
-    if (!current || current.type !== TokenType.IDENTIFIER) return null
-    
-    const val1 = this.normalizeAccents(String(current.value))
-    const next = this.peek(1)
-    
-    if (next && next.type === TokenType.IDENTIFIER) {
-      const val2 = this.normalizeAccents(String(next.value))
-      const compound2 = `${val1} ${val2}`
-      if (this.compoundKeywords[compound2]) {
-        this.advance()
-        this.advance()
-        return this.compoundKeywords[compound2]
-      }
-    }
-    
-    return null
-  }
-
-  translateJSIdentifier(word) {
-    if (!word) return word
-    const lower = this.normalizeAccents(String(word))
-    return this.jsTranslations[lower] || word
-  }
-
-  loadAllI18n(dir) {
-    const files = [
-      'i18n-css.json', 'i18n-html.json', 'i18n-js.json',
-      'i18n-php.json', 'i18n-python.json', 'i18n-sql.json',
-      'i18n-ruby.json', 'i18n-node.json', 'i18n-react.json',
-      'i18n-ts.json', 'i18n-graphql.json'
-    ]
-    
-    for (const file of files) {
-      const lang = file.replace('i18n-', '').replace('.json', '')
-      const path = `${dir}/${file}`
-      
-      try {
-        if (fs.existsSync(path)) {
-          this.i18n[lang] = JSON.parse(fs.readFileSync(path, 'utf-8'))
-          this.buildReverseMap(lang)
-        }
-      } catch (e) {
-      }
-    }
-  }
-
-  buildReverseMap(lang) {
-    this.reverseMaps[lang] = {}
-    const data = this.i18n[lang]
-    
-    const processSection = (section, targetKey = lang) => {
-      if (!section || typeof section !== 'object') return
-      
-      for (const [key, translations] of Object.entries(section)) {
-        if (translations && typeof translations === 'object') {
-          if (translations.fr) {
-            const frTerms = Array.isArray(translations.fr) ? translations.fr : [translations.fr]
-            const target = translations[targetKey] || translations.css || translations.html || translations.js || translations.value
-            
-            for (const term of frTerms) {
-              if (typeof term === 'string') {
-                this.reverseMaps[lang][term.toLowerCase()] = target
-              }
-            }
-          }
-        }
-      }
-    }
-    
-    for (const [sectionName, sectionData] of Object.entries(data)) {
-      processSection(sectionData)
-    }
-  }
-
-  peek(offset = 0) {
-    const idx = this.pos + offset
-    return idx < this.tokens.length ? this.tokens[idx] : null
-  }
-
-  current() {
-    return this.tokens[this.pos] || null
-  }
-
-  advance() {
-    const token = this.tokens[this.pos]
-    this.pos++
-    return token
-  }
-
-  expect(type) {
-    const token = this.current()
-    if (!token || token.type !== type) {
-      throw new Error(`Attendu ${type}, reçu ${token ? token.type : 'EOF'}`)
-    }
-    return this.advance()
-  }
-
-  match(type) {
-    if (this.current() && this.current().type === type) {
-      return this.advance()
-    }
-    return null
-  }
-
-  matchValue(value) {
-    const token = this.current()
-    if (!token || token.value === null || token.value === undefined) return null
-    const tokenVal = String(token.value).toLowerCase()
-    const valueLower = value.toLowerCase()
-    
-    if (tokenVal === valueLower) {
-      return this.advance()
-    }
-    
-    if (valueLower.includes(' ')) {
-      const parts = valueLower.split(' ')
-      if (tokenVal === parts[0]) {
-        const savedPos = this.pos
-        const tokens = [this.advance()]
-        let matched = true
-        
-        for (let i = 1; i < parts.length && matched; i++) {
-          const nextToken = this.current()
-          if (nextToken && String(nextToken.value).toLowerCase() === parts[i]) {
-            tokens.push(this.advance())
-          } else {
-            matched = false
-          }
-        }
-        
-        if (matched) {
-          return tokens[tokens.length - 1]
-        } else {
-          this.pos = savedPos
-        }
-      }
-    }
-    
-    return null
-  }
-
-  isAtEnd() {
-    return this.pos >= this.tokens.length || (this.current() && this.current().type === TokenType.EOF)
-  }
-
-  skipNewlines() {
-    while (this.match(TokenType.NEWLINE)) {}
-  }
-
-  detectTargetLanguage(source) {
-    const lower = source.toLowerCase()
-    
-    const targetMatch = source.match(/\/\/\s*cible\s*:\s*(\w+)/i)
-    if (targetMatch) {
-      const target = targetMatch[1].toLowerCase()
-      const langMap = {
-        'js': 'js', 'javascript': 'js',
-        'css': 'css', 'style': 'css',
-        'html': 'html', 'page': 'html',
-        'ts': 'ts', 'typescript': 'ts',
-        'react': 'react', 'jsx': 'react',
-        'php': 'php',
-        'python': 'python', 'py': 'python',
-        'ruby': 'ruby', 'rb': 'ruby',
-        'sql': 'sql',
-        'node': 'node', 'nodejs': 'node',
-        'graphql': 'graphql', 'gql': 'graphql'
-      }
-      if (langMap[target]) {
-        return langMap[target]
-      }
-    }
-    
-    if (/^\s*(document|page|<!doctype|<html|tete|corps|entete|navigation|section|article)/m.test(lower)) {
-      return 'html'
-    }
-    
-    if (/^\s*(\.|#|@media|@keyframes|corps|html|body|fond|marge|remplissage|largeur|hauteur)/m.test(lower)) {
-      if (!/fonction|si\s|pour\s|tant que/.test(lower)) {
-        return 'css'
-      }
-    }
-    
-    if (/^\s*(composant|etat|effet|memo|contexte|utiliser\s+(etat|effet|memo)|retourner\s*\(?\s*<)/m.test(lower)) {
-      return 'react'
-    }
-    
-    if (/<[a-z]+|jsx|tsx/i.test(lower) && /fonction|composant/.test(lower)) {
-      return 'react'
-    }
-    
-    if (/^\s*(creer table|inserer|selectionner|mettre a jour|supprimer|table|base de donnees)/m.test(lower)) {
-      return 'sql'
-    }
-    
-    if (/^\s*(type|interface|enum|generique|<[A-Z]\w*>)/m.test(lower)) {
-      return 'ts'
-    }
-    
-    if (/^\s*(schema|type\s+\w+\s*{|query|mutation|subscription|input\s+\w+)/m.test(lower)) {
-      return 'graphql'
-    }
-    
-    if (/^\s*(<\?php|\$\w+|echo|inclure|require)/m.test(lower)) {
-      return 'php'
-    }
-    
-    if (/^\s*(def\s+\w+|classe\s+\w+|importer\s|de\s+\w+\s+importer)/m.test(lower) && !/fin\s*$|faire\s*$/m.test(lower)) {
-      return 'python'
-    }
-    
-    if (/^\s*(classe\s+\w+|def\s+\w+|fin\s*$|faire\s*$|module\s+\w+)/m.test(lower)) {
-      return 'ruby'
-    }
-    
-    if (/^\s*(const\s+\w+\s*=\s*require|module\.exports|exporter\s+defaut)/m.test(lower)) {
-      return 'node'
-    }
-    
-    if (/fonction|variable|constante|si\s|pour\s|tant que|retourner/.test(lower)) {
-      return 'js'
-    }
-    
-    return 'js'
-  }
-
-  parse(source, targetLang = null) {
-    const lexer = new EtherLexer(source)
-    this.tokens = lexer.tokenize()
-    this.pos = 0
-    
-    const detectedLang = targetLang || this.targetLang
-    const lang = detectedLang === 'auto' ? this.detectTargetLanguage(source) : detectedLang
-    
-    switch (lang) {
-      case 'css':
-        return this.parseCSS()
-      case 'html':
-        return this.parseHTML()
-      case 'js':
-      case 'javascript':
-        return this.parseJS()
-      case 'ts':
-      case 'typescript':
-        return this.parseTS()
-      case 'react':
-      case 'jsx':
-        return this.parseReact()
-      case 'php':
-        return this.parsePHP()
-      case 'python':
-      case 'py':
-        return this.parsePython()
-      case 'ruby':
-      case 'rb':
-        return this.parseRuby()
-      case 'sql':
-        return this.parseSQL()
-      case 'node':
-      case 'nodejs':
-        return this.parseNode()
-      case 'graphql':
-      case 'gql':
-        return this.parseGraphQL()
-      default:
-        return this.parseJS()
-    }
-  }
-
-  parseCSS() {
-    const stylesheet = {
-      type: 'StyleSheet',
-      rules: []
-    }
-    
-    this.skipNewlines()
-    
-    while (!this.isAtEnd()) {
-      const startPos = this.pos
-      const rule = this.parseCSSRule()
-      if (rule) {
-        stylesheet.rules.push(rule)
-      }
-      this.skipNewlines()
-      if (this.pos === startPos && !this.isAtEnd()) {
-        this.advance()
-      }
-    }
-    
-    return stylesheet
-  }
-
-  parseCSSRule() {
-    this.skipNewlines()
-    const token = this.current()
-    if (!token || token.type === TokenType.EOF) return null
-    
-    if (token.type === TokenType.AT) {
-      return this.parseCSSAtRule()
-    }
-    
-    const selector = this.parseCSSSelector()
-    if (!selector) return null
-    
-    this.skipNewlines()
-    this.match(TokenType.INDENT)
-    
-    const declarations = []
-    const nestedRules = []
-    
-    while (!this.isAtEnd()) {
-      const current = this.current()
-      
-      if (current && current.type === TokenType.DEDENT) {
-        this.advance()
-        break
-      }
-      
-      if (current && current.type === TokenType.NEWLINE) {
-        this.advance()
-        continue
-      }
-      
-      if (!current || current.type === TokenType.EOF) break
-      
-      if (current.type === TokenType.IDENTIFIER) {
-        const value = current.value.toLowerCase()
-        
-        if (value.startsWith('au ') || value === 'au survol' || value === 'au clic' || 
-            value === 'au focus' || value === 'actif' || value === 'visite' ||
-            value.startsWith('premier') || value.startsWith('dernier') ||
-            value.startsWith('avant') || value.startsWith('apres')) {
-          const pseudoRule = this.parseCSSPseudoBlock(selector)
-          if (pseudoRule) nestedRules.push(pseudoRule)
-          continue
-        }
-      }
-      
-      const decl = this.parseCSSDeclaration()
-      if (decl) {
-        declarations.push(decl)
-      } else {
-        this.advance()
-      }
-    }
-    
-    return {
-      type: 'Rule',
-      selector: selector,
-      declarations: declarations,
-      nestedRules: nestedRules
-    }
-  }
-
-  parseCSSSelector() {
-    const parts = []
-    
-    while (!this.isAtEnd()) {
-      const token = this.current()
-      
-      if (!token || token.type === TokenType.NEWLINE || token.type === TokenType.INDENT || 
-          token.type === TokenType.EOF) {
-        break
-      }
-      
-      if (token.type === TokenType.DOUBLE_COLON) {
-        this.advance()
-        const pseudoName = this.current()
-        if (pseudoName && pseudoName.type === TokenType.IDENTIFIER) {
-          parts.push('::' + pseudoName.value)
-          this.advance()
-        }
-      } else if (token.type === TokenType.COLON) {
-        this.advance()
-        const next = this.current()
-        if (next && next.type === TokenType.COLON) {
-          this.advance()
-          const pseudoName = this.current()
-          if (pseudoName && pseudoName.type === TokenType.IDENTIFIER) {
-            parts.push('::' + pseudoName.value)
-            this.advance()
-          }
-        } else if (next && next.type === TokenType.IDENTIFIER) {
-          parts.push(':' + next.value)
-          this.advance()
-        } else {
-          break
-        }
-      } else if (token.type === TokenType.DOT) {
-        this.advance()
-        const name = this.current()
-        if (name && name.type === TokenType.IDENTIFIER) {
-          parts.push('.' + name.value)
-          this.advance()
-        }
-      } else if (token.type === TokenType.HASH) {
-        this.advance()
-        const name = this.current()
-        if (name && name.type === TokenType.IDENTIFIER) {
-          parts.push('#' + name.value)
-          this.advance()
-        }
-      } else if (token.type === TokenType.IDENTIFIER) {
-        parts.push(this.translateCSSSelector(token.value))
-        this.advance()
-      } else if (token.type === TokenType.STAR) {
-        parts.push('*')
-        this.advance()
-      } else if (token.type === TokenType.COMMA) {
-        parts.push(',')
-        this.advance()
-      } else if (token.type === TokenType.GT) {
-        parts.push('>')
-        this.advance()
-      } else if (token.type === TokenType.PLUS) {
-        parts.push('+')
-        this.advance()
-      } else if (token.type === TokenType.TILDE) {
-        parts.push('~')
-        this.advance()
-      } else if (token.type === TokenType.LBRACKET) {
-        let attrSelector = '['
-        this.advance()
-        while (!this.isAtEnd()) {
-          const attrToken = this.current()
-          if (!attrToken || attrToken.type === TokenType.RBRACKET) {
-            attrSelector += ']'
-            this.advance()
-            break
-          }
-          attrSelector += attrToken.value
-          this.advance()
-        }
-        parts.push(attrSelector)
-      } else if (token.type === TokenType.EQUALS) {
-        break
-      } else {
-        break
-      }
-    }
-    
-    return parts.join(' ').replace(/\s+([,>+~])\s+/g, ' $1 ').replace(/\s+(::?)/g, '$1').trim()
-  }
-
-  translateCSSSelector(selector) {
-    const map = this.reverseMaps.css || {}
-    const lower = selector.toLowerCase()
-    
-    const selectorTranslations = {
-      'corps': 'body',
-      'html': 'html',
-      'document': 'html',
-      'tete': 'head',
-      'titre': 'title',
-      'titre1': 'h1',
-      'titre2': 'h2',
-      'titre3': 'h3',
-      'titre4': 'h4',
-      'titre5': 'h5',
-      'titre6': 'h6',
-      'paragraphe': 'p',
-      'lien': 'a',
-      'ressource': 'link',
-      'lien externe': 'link',
-      'image': 'img',
-      'bouton': 'button',
-      'formulaire': 'form',
-      'champ': 'input',
-      'liste': 'ul',
-      'liste ordonnee': 'ol',
-      'element liste': 'li',
-      'tableau': 'table',
-      'ligne': 'tr',
-      'cellule': 'td',
-      'entete': 'header',
-      'piedpage': 'footer',
-      'navigation': 'nav',
-      'section': 'section',
-      'article': 'article',
-      'cote': 'aside',
-      'principal': 'main',
-      'division': 'div',
-      'portee': 'span'
-    }
-    
-    return selectorTranslations[lower] || map[lower] || selector
-  }
-
-  parseCSSDeclaration() {
-    this.skipNewlines()
-    const token = this.current()
-    if (!token || token.type !== TokenType.IDENTIFIER) return null
-    
-    const compoundProperties = {
-      'marge': ['dedans', 'autour', 'haut', 'bas', 'gauche', 'droite'],
-      'marge dedans': ['haut', 'bas', 'gauche', 'droite'],
-      'marge autour': ['haut', 'bas', 'gauche', 'droite'],
-      'remplissage': ['haut', 'bas', 'gauche', 'droite'],
-      'taille': ['police'],
-      'poids': ['police'],
-      'style': ['police', 'liste'],
-      'hauteur': ['ligne', 'min', 'max', 'minimum', 'maximum'],
-      'largeur': ['min', 'max', 'minimum', 'maximum'],
-      'alignement': ['texte'],
-      'decoration': ['texte'],
-      'transformation': ['texte'],
-      'ombre': ['texte', 'boite', 'boîte'],
-      'espacement': ['lettres'],
-      'bordure': ['haut', 'bas', 'gauche', 'droite', 'couleur', 'style', 'largeur', 'arrondi'],
-      'couleur': ['bordure', 'fond', 'texte', 'remplissage'],
-      'arrondi': ['haut', 'bas'],
-      'arrondi haut': ['gauche', 'droite'],
-      'arrondi bas': ['gauche', 'droite'],
-      'fond': ['couleur', 'image', 'position', 'taille', 'repetition', 'attachement'],
-      'direction': ['flex'],
-      'enveloppe': ['flex'],
-      'justifier': ['contenu'],
-      'aligner': ['elements', 'éléments', 'contenu'],
-      'colonnes': ['grille'],
-      'lignes': ['grille'],
-      'espace': ['ligne', 'colonne', 'blanc'],
-      'débordement': ['x', 'y'],
-      'debordement': ['x', 'y'],
-      'événements': ['pointeur'],
-      'evenements': ['pointeur'],
-      'modèle': ['boite', 'boîte'],
-      'modele': ['boite', 'boîte'],
-      'filtre': ['fond'],
-      'decoupe': ['fond'],
-      'découpe': ['fond'],
-      'origine': ['transformation', 'perspective'],
-      'liste': ['style', 'type', 'position', 'image'],
-    }
-    
-    let property = token.value
-    this.advance()
-    
-    let nextToken = this.current()
-    while (nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const propLower = property.toLowerCase()
-      if (compoundProperties[propLower] && compoundProperties[propLower].includes(nextToken.value.toLowerCase())) {
-        property = property + ' ' + nextToken.value
-        this.advance()
-        nextToken = this.current()
-      } else {
-        break
-      }
-    }
-    
-    let hasColon = this.match(TokenType.COLON)
-    let hasEquals = !hasColon && this.match(TokenType.EQUALS)
-    
-    if (!hasColon && !hasEquals) {
-      return null
-    }
-    
-    const valueParts = []
-    let lastType = null
-    
-    while (!this.isAtEnd()) {
-      const current = this.current()
-      
-      if (!current || current.type === TokenType.NEWLINE || 
-          current.type === TokenType.DEDENT || current.type === TokenType.EOF) {
-        break
-      }
-      
-      let needsSpace = valueParts.length > 0
-      
-      if (current.type === TokenType.LPAREN || current.type === TokenType.COMMA ||
-          current.type === TokenType.RPAREN || current.type === TokenType.PERCENT ||
-          lastType === TokenType.LPAREN || lastType === TokenType.MINUS ||
-          lastType === TokenType.HASH || lastType === TokenType.COLON) {
-        needsSpace = false
-      }
-      
-      if (lastType === TokenType.NUMBER || lastType === TokenType.INTEGER || lastType === TokenType.FLOAT) {
-        if (current.type === TokenType.IDENTIFIER) {
-          const units = ['px', 'em', 'rem', '%', 'vw', 'vh', 'vmin', 'vmax', 'ch', 'ex', 'cm', 'mm', 'in', 'pt', 'pc', 'deg', 'rad', 'turn', 'ms', 's', 'fr', 'cqw', 'cqh']
-          if (units.includes(current.value.toLowerCase())) {
-            needsSpace = false
-          }
-        }
-      }
-      
-      if (current.type === TokenType.IDENTIFIER) {
-        if (needsSpace) valueParts.push(' ')
-        valueParts.push(current.value)
-      } else if (current.type === TokenType.NUMBER || current.type === TokenType.INTEGER || 
-                 current.type === TokenType.FLOAT) {
-        if (needsSpace && lastType !== TokenType.HASH) valueParts.push(' ')
-        valueParts.push(current.value)
-      } else if (current.type === TokenType.STRING) {
-        if (needsSpace) valueParts.push(' ')
-        valueParts.push('"' + current.value + '"')
-      } else if (current.type === TokenType.HEX) {
-        if (needsSpace) valueParts.push(' ')
-        valueParts.push(current.value)
-      } else if (current.type === TokenType.HASH) {
-        if (needsSpace) valueParts.push(' ')
-        valueParts.push('#')
-      } else if (current.type === TokenType.COMMA) {
-        valueParts.push(',')
-      } else if (current.type === TokenType.LPAREN) {
-        valueParts.push('(')
-      } else if (current.type === TokenType.RPAREN) {
-        valueParts.push(')')
-      } else if (current.type === TokenType.PERCENT) {
-        valueParts.push('%')
-      } else if (current.type === TokenType.SLASH) {
-        if (needsSpace) valueParts.push(' ')
-        valueParts.push('/')
-      } else if (current.type === TokenType.MINUS) {
-        if (current.value === '--') {
-          valueParts.push('--')
-        } else if (lastType === TokenType.LPAREN) {
-          valueParts.push(current.value)
-        } else {
-          valueParts.push(' ' + current.value)
-        }
-      } else if (current.type === TokenType.PLUS) {
-        valueParts.push(' +')
-      } else if (current.type === TokenType.COLON) {
-        valueParts.push(':')
-      } else if (current.type === TokenType.DOT) {
-        valueParts.push('.')
-      } else {
-        break
-      }
-      
-      lastType = current.type
-      this.advance()
-    }
-    
-    return {
-      type: 'Declaration',
-      property: property,
-      value: valueParts.join('')
-        .replace(/,\s*/g, ', ')
-        .replace(/\s+/g, ' ')
-        .trim()
-    }
-  }
-
-  parseCSSPseudoBlock(parentSelector) {
-    const pseudoToken = this.current()
-    const pseudoClass = this.translatePseudoClass(pseudoToken.value)
-    this.advance()
-    
-    this.skipNewlines()
-    this.match(TokenType.INDENT)
-    
-    const declarations = []
-    
-    while (!this.isAtEnd()) {
-      const current = this.current()
-      
-      if (current && current.type === TokenType.DEDENT) {
-        this.advance()
-        break
-      }
-      
-      if (current && current.type === TokenType.NEWLINE) {
-        this.advance()
-        continue
-      }
-      
-      if (!current || current.type === TokenType.EOF) break
-      
-      const decl = this.parseCSSDeclaration()
-      if (decl) {
-        declarations.push(decl)
-      } else {
-        this.advance()
-      }
-    }
-    
-    return {
-      type: 'Rule',
-      selector: `${parentSelector}${pseudoClass}`,
-      declarations: declarations
-    }
-  }
-
-  translatePseudoClass(value) {
-    const map = {
-      'au survol': ':hover',
-      'au clic': ':active',
-      'actif': ':active',
-      'au focus': ':focus',
-      'focus': ':focus',
-      'visite': ':visited',
-      'premier enfant': ':first-child',
-      'dernier enfant': ':last-child',
-      'premier de type': ':first-of-type',
-      'dernier de type': ':last-of-type',
-      'enfant unique': ':only-child',
-      'unique de type': ':only-of-type',
-      'vide': ':empty',
-      'cible': ':target',
-      'coche': ':checked',
-      'desactive': ':disabled',
-      'active': ':enabled',
-      'requis': ':required',
-      'optionnel': ':optional',
-      'valide': ':valid',
-      'invalide': ':invalid',
-      'lecture seule': ':read-only',
-      'lecture ecriture': ':read-write',
-      'avant': '::before',
-      'apres': '::after',
-      'premiere lettre': '::first-letter',
-      'premiere ligne': '::first-line',
-      'selection': '::selection',
-      'placeholder': '::placeholder',
-      'marqueur': '::marker'
-    }
-    
-    const lower = value.toLowerCase()
-    return map[lower] || ':' + lower.replace(/\s+/g, '-')
-  }
-
-  parseCSSAtRule() {
-    this.advance()
-    const nameToken = this.current()
-    
-    if (!nameToken) return null
-    
-    const name = nameToken.value.toLowerCase()
-    this.advance()
-    
-    if (name === 'media' || name === 'requete media' || name === 'ecran' || name === 'si') {
-      return this.parseCSSMediaQuery()
-    }
-    
-    if (name === 'keyframes' || name === 'images cles' || name === 'animation') {
-      return this.parseCSSKeyframes()
-    }
-    
-    if (name === 'import' || name === 'importer') {
-      return this.parseCSSImport()
-    }
-    
-    if (name === 'font-face' || name === 'police') {
-      return this.parseCSSFontFace()
-    }
-    
-    return null
-  }
-
-  parseCSSMediaQuery() {
-    const queryParts = []
-    
-    while (!this.isAtEnd()) {
-      const token = this.current()
-      
-      if (!token || token.type === TokenType.NEWLINE || token.type === TokenType.INDENT) {
-        break
-      }
-      
-      queryParts.push(token.value)
-      this.advance()
-    }
-    
-    this.skipNewlines()
-    this.match(TokenType.INDENT)
-    
-    const rules = []
-    
-    while (!this.isAtEnd()) {
-      const current = this.current()
-      
-      if (current && current.type === TokenType.DEDENT) {
-        this.advance()
-        break
-      }
-      
-      const rule = this.parseCSSRule()
-      if (rule) {
-        rules.push(rule)
-      }
-      
-      this.skipNewlines()
-    }
-    
-    return {
-      type: 'MediaQuery',
-      query: this.translateMediaQuery(queryParts.join(' ')),
-      rules: rules
-    }
-  }
-
-  translateMediaQuery(query) {
-    let result = query
-    
-    result = result.replace(/ecran\s+tres\s+petit/gi, 'screen and (max-width: 480px)')
-    result = result.replace(/ecran\s+petit/gi, 'screen and (max-width: 768px)')
-    result = result.replace(/ecran\s+moyen/gi, 'screen and (max-width: 1024px)')
-    result = result.replace(/ecran\s+large/gi, 'screen and (min-width: 1025px) and (max-width: 1280px)')
-    result = result.replace(/ecran\s+tres\s+large/gi, 'screen and (min-width: 1281px)')
-    
-    result = result
-      .replace(/ecran/gi, 'screen')
-      .replace(/imprimante/gi, 'print')
-      .replace(/tous/gi, 'all')
-      .replace(/largeur\s+min/gi, 'min-width')
-      .replace(/largeur\s+max/gi, 'max-width')
-      .replace(/hauteur\s+min/gi, 'min-height')
-      .replace(/hauteur\s+max/gi, 'max-height')
-      .replace(/orientation/gi, 'orientation')
-      .replace(/paysage/gi, 'landscape')
-      .replace(/portrait/gi, 'portrait')
-      .replace(/\bet\b/gi, 'and')
-      .replace(/\bou\b/gi, 'or')
-      .replace(/\bpas\b/gi, 'not')
-    
-    return result
-  }
-
-  parseCSSKeyframes() {
-    const nameToken = this.current()
-    const name = nameToken ? nameToken.value : 'animation'
-    if (nameToken) this.advance()
-    
-    this.skipNewlines()
-    this.match(TokenType.INDENT)
-    
-    const keyframes = []
-    
-    while (!this.isAtEnd()) {
-      const current = this.current()
-      
-      if (current && current.type === TokenType.DEDENT) {
-        this.advance()
-        break
-      }
-      
-      if (current && current.type === TokenType.NEWLINE) {
-        this.advance()
-        continue
-      }
-      
-      const keyframe = this.parseCSSKeyframe()
-      if (keyframe) {
-        keyframes.push(keyframe)
-      }
-    }
-    
-    return {
-      type: 'Keyframes',
-      name: name,
-      keyframes: keyframes
-    }
-  }
-
-  parseCSSKeyframe() {
-    const token = this.current()
-    if (!token) return null
-    
-    let selector = token.value
-    
-    const selectorMap = {
-      'debut': 'from',
-      'fin': 'to',
-      'de': 'from',
-      'a': 'to',
-      'vers': 'to'
-    }
-    
-    selector = selectorMap[selector.toLowerCase()] || selector
-    this.advance()
-    
-    this.skipNewlines()
-    this.match(TokenType.INDENT)
-    
-    const declarations = []
-    
-    while (!this.isAtEnd()) {
-      const current = this.current()
-      
-      if (current && current.type === TokenType.DEDENT) {
-        this.advance()
-        break
-      }
-      
-      if (current && current.type === TokenType.NEWLINE) {
-        this.advance()
-        continue
-      }
-      
-      const decl = this.parseCSSDeclaration()
-      if (decl) {
-        declarations.push(decl)
-      }
-    }
-    
-    return {
-      type: 'Keyframe',
-      selector: selector,
-      declarations: declarations
-    }
-  }
-
-  parseCSSImport() {
-    const urlToken = this.current()
-    const url = urlToken ? urlToken.value.replace(/['"]/g, '') : ''
-    if (urlToken) this.advance()
-    
-    return {
-      type: 'Import',
-      url: url
-    }
-  }
-
-  parseCSSFontFace() {
-    this.skipNewlines()
-    this.match(TokenType.INDENT)
-    
-    const declarations = []
-    
-    while (!this.isAtEnd()) {
-      const current = this.current()
-      
-      if (current && current.type === TokenType.DEDENT) {
-        this.advance()
-        break
-      }
-      
-      if (current && current.type === TokenType.NEWLINE) {
-        this.advance()
-        continue
-      }
-      
-      const decl = this.parseCSSDeclaration()
-      if (decl) {
-        declarations.push(decl)
-      }
-    }
-    
-    return {
-      type: 'FontFace',
-      declarations: declarations
-    }
-  }
-
-  parseHTML() {
-    const document = {
-      type: 'Document',
-      children: []
-    }
-    
-    this.skipNewlines()
-    
-    while (!this.isAtEnd()) {
-      const node = this.parseHTMLNode()
-      if (node) {
-        document.children.push(node)
-      }
-      this.skipNewlines()
-    }
-    
-    return document
-  }
-
-  parseHTMLNode() {
-    this.skipNewlines()
-    const token = this.current()
-    
-    if (!token || token.type === TokenType.EOF) return null
-    
-    if (token.type === TokenType.IDENTIFIER) {
-      return this.parseHTMLElement()
-    }
-    
-    if (token.type === TokenType.STRING) {
-      this.advance()
-      return {
-        type: 'Text',
-        content: token.value.replace(/^["']|["']$/g, '')
-      }
-    }
-    
-    this.advance()
-    return null
-  }
-
-  parseHTMLElement() {
-    const tagToken = this.current()
-    let tagName = this.normalizeAccents(tagToken.value)
-    const originalTagName = tagName
-    this.advance()
-    
-    const includeKeywords = ['inclure', 'requiert', 'include', 'require', 'importer']
-    if (includeKeywords.includes(tagName)) {
-      let includePath = null
-      
-      if (this.current() && this.current().type === TokenType.COLON) {
-        this.advance()
-      }
-      
-      const pathToken = this.current()
-      if (pathToken && pathToken.type === TokenType.STRING) {
-        includePath = pathToken.value.replace(/^["']|["']$/g, '')
-        this.advance()
-      } else if (pathToken && pathToken.type === TokenType.IDENTIFIER) {
-        let pathParts = [pathToken.value]
-        this.advance()
-        while (this.current() && (this.current().type === TokenType.SLASH || this.current().type === TokenType.DOT || this.current().type === TokenType.IDENTIFIER)) {
-          if (this.current().type === TokenType.SLASH) {
-            pathParts.push('/')
-          } else if (this.current().type === TokenType.DOT) {
-            pathParts.push('.')
-          } else {
-            pathParts.push(this.current().value)
-          }
-          this.advance()
-        }
-        includePath = pathParts.join('')
-      }
-      
-      this.skipNewlines()
-      
-      return {
-        type: 'Include',
-        path: includePath,
-        resolved: false
-      }
-    }
-    
-    const nextToken = this.current()
-    if ((tagName === 'titre' || tagName === 'heading') && nextToken && (nextToken.type === TokenType.NUMBER || nextToken.type === TokenType.INTEGER)) {
-      const num = parseInt(nextToken.value)
-      if (num >= 1 && num <= 6) {
-        tagName = `titre${num}`
-        this.advance()
-      }
-    }
-    
-    if ((tagName === 'liste' || tagName === 'list') && nextToken) {
-      if (nextToken.type === TokenType.IDENTIFIER) {
-        const nextVal = this.normalizeAccents(nextToken.value)
-        if (nextVal === 'ordonnee' || nextVal === 'ordered') {
-          tagName = 'liste ordonnee'
-          this.advance()
-        } else if (nextVal === 'non') {
-          this.advance()
-          const thirdToken = this.current()
-          if (thirdToken && thirdToken.type === TokenType.IDENTIFIER && this.normalizeAccents(thirdToken.value) === 'ordonnee') {
-            tagName = 'liste non ordonnee'
-            this.advance()
-          }
-        }
-      }
-    }
-    
-    if ((tagName === 'element' || tagName === 'item') && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      if (this.normalizeAccents(nextToken.value) === 'liste' || this.normalizeAccents(nextToken.value) === 'list') {
-        tagName = 'element liste'
-        this.advance()
-      }
-    }
-    
-    if ((tagName === 'zone' || tagName === 'area') && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      if (this.normalizeAccents(nextToken.value) === 'texte' || this.normalizeAccents(nextToken.value) === 'text') {
-        tagName = 'zone texte'
-        this.advance()
-      }
-    }
-    
-    if ((tagName === 'retour' || tagName === 'saut') && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      if (this.normalizeAccents(nextToken.value) === 'ligne' || this.normalizeAccents(nextToken.value) === 'line') {
-        tagName = 'retour ligne'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'ligne' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      if (this.normalizeAccents(nextToken.value) === 'horizontale') {
-        tagName = 'ligne horizontale'
-        this.advance()
-      }
-    }
-    
-    if ((tagName === 'cellule' || tagName === 'cell') && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      if (this.normalizeAccents(nextToken.value) === 'entete' || this.normalizeAccents(nextToken.value) === 'header') {
-        tagName = 'entete cellule'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'groupe' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'titres') {
-        tagName = 'groupe titres'
-        this.advance()
-      } else if (next === 'options') {
-        tagName = 'groupe options'
-        this.advance()
-      } else if (next === 'colonnes') {
-        tagName = 'groupe colonnes'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'entete' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'tableau' || next === 'table') {
-        tagName = 'entete tableau'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'corps' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'tableau' || next === 'table') {
-        tagName = 'corps tableau'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'pied' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'tableau' || next === 'table') {
-        tagName = 'pied tableau'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'legende' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'tableau' || next === 'table') {
-        tagName = 'legende tableau'
-        this.advance()
-      } else if (next === 'figure') {
-        tagName = 'legende figure'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'ensemble' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'champs' || next === 'fields') {
-        tagName = 'ensemble champs'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'liste' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'donnees' || next === 'data') {
-        tagName = 'liste donnees'
-        this.advance()
-      } else if (next === 'description') {
-        tagName = 'liste description'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'image' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'reactive' || next === 'responsive') {
-        tagName = 'image reactive'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'cadre' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'en') {
-        this.advance()
-        const thirdToken = this.current()
-        if (thirdToken && thirdToken.type === TokenType.IDENTIFIER && thirdToken.value.toLowerCase() === 'ligne') {
-          tagName = 'cadre en ligne'
-          this.advance()
-        }
-      }
-    }
-    
-    if (tagName === 'citation' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'bloc' || next === 'block') {
-        tagName = 'citation bloc'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'reference' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'citation') {
-        tagName = 'reference citation'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'sans' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'script') {
-        tagName = 'sans script'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'isolation' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'bidi') {
-        tagName = 'isolation bidi'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'remplacement' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'bidi') {
-        tagName = 'remplacement bidi'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'annotation' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'ruby' || next === 'rubis') {
-        tagName = 'annotation ruby'
-        this.advance()
-      }
-    }
-    
-    if ((tagName === 'parentheses' || tagName === 'parenthèses') && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'ruby' || next === 'rubis') {
-        tagName = 'parentheses ruby'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'carte' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'image') {
-        tagName = 'carte image'
-        this.advance()
-      }
-    }
-    
-    if ((tagName === 'texte' || tagName === 'text') && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'alternatif' || next === 'alt') {
-        tagName = 'texte alternatif'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'entree' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'clavier') {
-        tagName = 'entree clavier'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'sortie' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'exemple') {
-        tagName = 'sortie exemple'
-        this.advance()
-      }
-    }
-    
-    if (tagName === 'definition' && nextToken && nextToken.type === TokenType.IDENTIFIER) {
-      const next = this.normalizeAccents(nextToken.value)
-      if (next === 'description') {
-        tagName = 'definition description'
-        this.advance()
-      }
-    }
-    
-    const tag = this.translateHTMLTag(tagName)
-    
-    const attributes = {}
-    let inlineText = null
-    
-    const compoundAttrs = {
-      'texte': ['alternatif'],
-      'longueur': ['max', 'min'],
-      'valeur': ['max', 'min'],
-      'zone': ['depot'],
-      'mode': ['saisie'],
-      'verification': ['orthographe'],
-      'ordre': ['tabulation'],
-      'action': ['formulaire'],
-      'methode': ['formulaire'],
-      'encodage': ['formulaire'],
-      'validation': ['formulaire', 'auto'],
-      'cible': ['formulaire', 'popover'],
-      'lecture': ['seule', 'auto'],
-      'nouvelle': ['fenetre'],
-      'a': ['popup'],
-      'jeu': ['caracteres', 'caractères'],
-      'equivalent': ['http'],
-      'équivalent': ['http'],
-      'fusion': ['colonnes', 'lignes'],
-      'plein': ['ecran', 'écran'],
-      'bac': ['sable'],
-      'origine': ['croisee', 'croisée'],
-      'sources': ['reactives', 'réactives']
-    }
-    
-    while (!this.isAtEnd()) {
-      const current = this.current()
-      
-      if (!current || current.type === TokenType.NEWLINE || 
-          current.type === TokenType.INDENT || current.type === TokenType.EOF) {
-        break
-      }
-      
-      if (current.type === TokenType.STRING) {
-        inlineText = current.value.replace(/^["']|["']$/g, '')
-        this.advance()
-        break
-      }
-      
-      if (current.type === TokenType.IDENTIFIER) {
-        let attrName = current.value.toLowerCase()
-        this.advance()
-        
-        if (compoundAttrs[attrName]) {
-          const nextTok = this.current()
-          if (nextTok && nextTok.type === TokenType.IDENTIFIER) {
-            const nextVal = nextTok.value.toLowerCase()
-            if (compoundAttrs[attrName].includes(nextVal)) {
-              attrName = attrName + ' ' + nextVal
-              this.advance()
-            }
-          }
-        }
-        
-        const nextToken = this.current()
-        
-        if (nextToken && (nextToken.type === TokenType.EQUALS || nextToken.type === TokenType.COLON)) {
-          this.advance()
-          const valueToken = this.current()
-          if (valueToken) {
-            if (valueToken.type === TokenType.STRING) {
-              attributes[attrName] = valueToken.value.replace(/^["']|["']$/g, '')
-            } else if (valueToken.type === TokenType.IDENTIFIER || 
-                       valueToken.type === TokenType.NUMBER || valueToken.type === TokenType.INTEGER) {
-              attributes[attrName] = valueToken.value
-            }
-            this.advance()
-          }
-          
-          if (this.current() && this.current().type === TokenType.COMMA) {
-            this.advance()
-          }
-        } else {
-          attributes[attrName] = true
-          
-          if (this.current() && this.current().type === TokenType.COMMA) {
-            this.advance()
-          }
-        }
-      } else if (current.type === TokenType.COMMA) {
-        this.advance()
-      } else {
-        break
-      }
-    }
-    
-    this.skipNewlines()
-    
-    const children = []
-    
-    if (inlineText) {
-      children.push({
-        type: 'Text',
-        content: inlineText
-      })
-    }
-    
-    const rawContentTags = ['script', 'style']
-    const isRawContent = rawContentTags.includes(tag)
-    const isScript = tag === 'script'
-    
-    if (this.match(TokenType.INDENT)) {
-      if (isRawContent) {
-        let rawText = []
-        while (!this.isAtEnd()) {
-          const current = this.current()
-          
-          if (current && current.type === TokenType.DEDENT) {
-            this.advance()
-            break
-          }
-          
-          if (current && current.type === TokenType.NEWLINE) {
-            rawText.push('\n')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.INDENT) {
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.STRING) {
-            if (isScript) {
-              rawText.push("'" + current.value.replace(/'/g, "\\'") + "'")
-            } else {
-              rawText.push(current.value)
-            }
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.LPAREN) {
-            rawText.push('(')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.RPAREN) {
-            rawText.push(')')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.LBRACKET) {
-            rawText.push('[')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.RBRACKET) {
-            rawText.push(']')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.LBRACE) {
-            rawText.push('{')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.RBRACE) {
-            rawText.push('}')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.DOT) {
-            rawText.push('.')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.COMMA) {
-            rawText.push(',')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.COLON) {
-            rawText.push(':')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.EQUALS) {
-            rawText.push('=')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.DOUBLE_EQUALS) {
-            rawText.push('==')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.NOT_EQUALS) {
-            rawText.push('!=')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.BANG) {
-            rawText.push('!')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.PLUS) {
-            rawText.push(current.value)
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.MINUS) {
-            rawText.push(current.value)
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.STAR) {
-            rawText.push(current.value)
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.SLASH) {
-            rawText.push('/')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.PERCENT) {
-            rawText.push('%')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.AMPERSAND) {
-            rawText.push('&')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.DOUBLE_AMPERSAND) {
-            rawText.push('&&')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.PIPE) {
-            rawText.push('|')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.DOUBLE_PIPE) {
-            rawText.push('||')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.LT) {
-            rawText.push('<')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.GT) {
-            rawText.push('>')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.LTE) {
-            rawText.push('<=')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.GTE) {
-            rawText.push('>=')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.QUESTION) {
-            rawText.push('?')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.FAT_ARROW) {
-            rawText.push('=>')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.ARROW) {
-            rawText.push('->')
-            this.advance()
-            continue
-          }
-          
-          if (current && current.type === TokenType.SEMICOLON) {
-            rawText.push(';')
-            this.advance()
-            continue
-          }
-          
-          if (current) {
-            rawText.push(String(current.value))
-            this.advance()
-          }
-        }
-        
-        const textContent = rawText.join('').trim()
-        if (textContent) {
-          children.push({
-            type: 'Text',
-            content: textContent
-          })
-        }
-      } else {
-        while (!this.isAtEnd()) {
-          const current = this.current()
-          
-          if (current && current.type === TokenType.DEDENT) {
-            this.advance()
-            break
-          }
-          
-          const child = this.parseHTMLNode()
-          if (child) {
-            children.push(child)
-          }
-          
-          this.skipNewlines()
-        }
-      }
-    }
-    
-    if (originalTagName === 'document') {
-      return {
-        type: 'Doctype',
-        children: children
-      }
-    }
-    
-    return {
-      type: 'Element',
-      tag: tag,
-      attributes: attributes,
-      children: children
-    }
-  }
-
-  translateHTMLTag(tag) {
-    const map = this.reverseMaps.html || {}
-    const lower = this.normalizeAccents(tag)
-    const withSpaces = lower.replace(/-/g, ' ')
-    
-    const translations = {
-      'document': 'html',
-      'page': 'html',
-      'tete': 'head',
-      'corps': 'body',
-      'entete': 'header',
-      'piedpage': 'footer',
-      'pied': 'footer',
-      'navigation': 'nav',
-      'nav': 'nav',
-      'principal': 'main',
-      'section': 'section',
-      'article': 'article',
-      'cote': 'aside',
-      'aside': 'aside',
-      'titre': 'title',
-      'titre1': 'h1',
-      'titre2': 'h2',
-      'titre3': 'h3',
-      'titre4': 'h4',
-      'titre5': 'h5',
-      'titre6': 'h6',
-      'titre 1': 'h1',
-      'titre 2': 'h2',
-      'titre 3': 'h3',
-      'titre 4': 'h4',
-      'titre 5': 'h5',
-      'titre 6': 'h6',
-      'heading 1': 'h1',
-      'heading 2': 'h2',
-      'heading 3': 'h3',
-      'heading 4': 'h4',
-      'heading 5': 'h5',
-      'heading 6': 'h6',
-      'groupe titres': 'hgroup',
-      'heading group': 'hgroup',
-      'sous titre': 'h2',
-      'paragraphe': 'p',
-      'texte': 'span',
-      'division': 'div',
-      'div': 'div',
-      'bloc': 'div',
-      'span': 'span',
-      'lien': 'a',
-      'ressource': 'link',
-      'lien externe': 'link',
-      'image': 'img',
-      'liste': 'ul',
-      'liste ordonnee': 'ol',
-      'liste non ordonnee': 'ul',
-      'element': 'li',
-      'element liste': 'li',
-      'tableau': 'table',
-      'ligne': 'tr',
-      'cellule': 'td',
-      'entete cellule': 'th',
-      'formulaire': 'form',
-      'champ': 'input',
-      'entree': 'input',
-      'input': 'input',
-      'zone texte': 'textarea',
-      'bouton': 'button',
-      'selection': 'select',
-      'option': 'option',
-      'etiquette': 'label',
-      'gras': 'strong',
-      'fort': 'strong',
-      'italique': 'em',
-      'emphase': 'em',
-      'souligne': 'u',
-      'barre': 's',
-      'code': 'code',
-      'pre': 'pre',
-      'preformate': 'pre',
-      'citation': 'blockquote',
-      'retour ligne': 'br',
-      'saut ligne': 'br',
-      'br': 'br',
-      'ligne horizontale': 'hr',
-      'hr': 'hr',
-      'video': 'video',
-      'audio': 'audio',
-      'source': 'source',
-      'cadre': 'iframe',
-      'canvas': 'canvas',
-      'toile': 'canvas',
-      'figure': 'figure',
-      'legende': 'legend',
-      'legende figure': 'figcaption',
-      'legende tableau': 'caption',
-      'legende ensemble': 'legend',
-      'figure caption': 'figcaption',
-      'table caption': 'caption',
-      'entete tableau': 'thead',
-      'table header': 'thead',
-      'corps tableau': 'tbody',
-      'table body': 'tbody',
-      'pied tableau': 'tfoot',
-      'table footer': 'tfoot',
-      'ensemble champs': 'fieldset',
-      'fieldset': 'fieldset',
-      'liste donnees': 'datalist',
-      'datalist': 'datalist',
-      'liste description': 'dl',
-      'description list': 'dl',
-      'definition description': 'dd',
-      'image reactive': 'picture',
-      'picture': 'picture',
-      'cadre en ligne': 'iframe',
-      'inline frame': 'iframe',
-      'iframe': 'iframe',
-      'citation bloc': 'blockquote',
-      'blockquote': 'blockquote',
-      'reference citation': 'cite',
-      'groupe options': 'optgroup',
-      'option group': 'optgroup',
-      'groupe colonnes': 'colgroup',
-      'column group': 'colgroup',
-      'colonne': 'col',
-      'column': 'col',
-      'entree clavier': 'kbd',
-      'keyboard input': 'kbd',
-      'sortie exemple': 'samp',
-      'sample output': 'samp',
-      'texte alternatif': 'alt',
-      'resultat': 'output',
-      'result': 'output',
-      'piste': 'track',
-      'track': 'track',
-      'insere': 'ins',
-      'inserted': 'ins',
-      'supprime': 'del',
-      'deleted': 'del',
-      'donnee': 'data',
-      'retour ligne possible': 'wbr',
-      'word break': 'wbr',
-      'carte image': 'map',
-      'image map': 'map',
-      'script': 'script',
-      'details': 'details',
-      'resume': 'summary',
-      'dialogue': 'dialog',
-      'modele': 'template',
-      'emplacement': 'slot',
-      'temps': 'time',
-      'marque': 'mark',
-      'metre': 'meter',
-      'progression': 'progress',
-      'sortie': 'output',
-      'donnees': 'data',
-      'clavier': 'kbd',
-      'exemple': 'samp',
-      'variable': 'var',
-      'abreviation': 'abbr',
-      'indice': 'sub',
-      'exposant': 'sup',
-      'petit': 'small',
-      'cite': 'cite',
-      'definition': 'dfn',
-      'adresse': 'address',
-      'rubis': 'ruby',
-      'texte rubis': 'rt',
-      'parenthese rubis': 'rp',
-      'bidirectionnel': 'bdi',
-      'direction': 'bdo',
-      'cesure': 'wbr',
-      'noscript': 'noscript',
-      'sans script': 'noscript',
-      'isolation bidi': 'bdi',
-      'remplacement bidi': 'bdo',
-      'annotation ruby': 'rt',
-      'annotation rubis': 'rt',
-      'parentheses ruby': 'rp',
-      'parenthèses ruby': 'rp',
-      'parentheses rubis': 'rp',
-      'terme': 'dt',
-      'menu': 'menu',
-      'recherche': 'search',
-      'objet': 'object',
-      'integrer': 'embed',
-      'svg': 'svg',
-      'math': 'math',
-      
-      'zone': 'area'
-    }
-    
-    const result = translations[lower] || translations[withSpaces] || map[lower] || map[withSpaces] || tag
-    return result.replace(/^<!DOCTYPE\s+/i, '').replace(/^<|>$/g, '').trim() || 'div'
-  }
-
-  parseJS() {
-    return this.parseProgram('js')
-  }
-
-  parseTS() {
-    return this.parseProgram('ts')
-  }
-
-  parseReact() {
-    return this.parseProgram('react')
-  }
-
-  parsePHP() {
-    return this.parseProgram('php')
-  }
-
-  parsePython() {
-    return this.parseProgram('python')
-  }
-
-  parseRuby() {
-    return this.parseProgram('ruby')
-  }
-
-  parseNode() {
-    return this.parseProgram('node')
-  }
-
-  parseSQL() {
-    return this.parseSQLProgram()
-  }
-
-  parseGraphQL() {
-    return this.parseGraphQLProgram()
-  }
-
-  parseProgram(lang) {
-    const program = {
-      type: 'Program',
-      lang: lang,
-      body: []
-    }
-    
-    this.skipNewlines()
-    
-    while (!this.isAtEnd()) {
-      const statement = this.parseStatement(lang)
-      if (statement) {
-        program.body.push(statement)
-      }
-      this.skipNewlines()
-    }
-    
-    return program
-  }
-
-  parseStatement(lang) {
-    this.skipNewlines()
-    const token = this.current()
-    
-    if (!token || token.type === TokenType.EOF) return null
-    
-    const value = token.value != null ? String(token.value).toLowerCase() : ''
-    
-    if (this.isVariableDeclaration(value)) {
-      return this.parseVariableDeclaration(lang)
-    }
-    
-    if (this.isFunctionDeclaration(value)) {
-      return this.parseFunctionDeclaration(lang)
-    }
-    
-    if (this.isClassDeclaration(value)) {
-      return this.parseClassDeclaration(lang)
-    }
-    
-    if (this.isConditional(value)) {
-      return this.parseConditional(lang)
-    }
-    
-    if (this.isLoop(value)) {
-      return this.parseLoop(lang)
-    }
-    
-    if (this.isReturn(value)) {
-      return this.parseReturn(lang)
-    }
-    
-    if (this.isImport(value)) {
-      return this.parseImport(lang)
-    }
-    
-    if (this.isExport(value)) {
-      return this.parseExport(lang)
-    }
-    
-    const expr = this.parseExpression(lang)
-    if (expr) {
-      return {
-        type: 'ExpressionStatement',
-        expression: expr
-      }
-    }
-    return null
-  }
-
-  isVariableDeclaration(value) {
-    const keywords = ['variable', 'var', 'constante', 'const', 'soit', 'let', 'definir']
-    return keywords.includes(value)
-  }
-
-  isFunctionDeclaration(value) {
-    const keywords = ['fonction', 'func', 'fn', 'methode', 'def', 'procedure']
-    return keywords.includes(value)
-  }
-
-  isClassDeclaration(value) {
-    const keywords = ['classe', 'class', 'type', 'interface', 'struct', 'structure']
-    return keywords.includes(value)
-  }
-
-  isConditional(value) {
-    const keywords = ['si', 'if', 'sinon', 'else', 'sinon si', 'elif', 'selon', 'switch', 'cas', 'case']
-    return keywords.includes(value)
-  }
-
-  isLoop(value) {
-    const keywords = ['pour', 'for', 'tant que', 'while', 'faire', 'do', 'repeter', 'boucle', 'loop', 'chaque', 'each', 'pour chaque', 'foreach']
-    return keywords.includes(value)
-  }
-
-  isReturn(value) {
-    const keywords = ['retourner', 'return', 'renvoyer', 'rendre']
-    return keywords.includes(value)
-  }
-
-  isImport(value) {
-    const keywords = ['importer', 'import', 'depuis', 'from', 'require', 'inclure', 'include', 'utiliser', 'use']
-    return keywords.includes(value)
-  }
-
-  isExport(value) {
-    const keywords = ['exporter', 'export', 'publier', 'public']
-    return keywords.includes(value)
-  }
-
-  parseVariableDeclaration(lang) {
-    const kindToken = this.advance()
-    const kind = this.translateVariableKind(kindToken.value, lang)
-    
-    const nameToken = this.current()
-    if (!nameToken || nameToken.type !== TokenType.IDENTIFIER) {
-      return null
-    }
-    const name = nameToken.value
-    this.advance()
-    
-    let typeAnnotation = null
-    if (this.match(TokenType.COLON)) {
-      typeAnnotation = this.parseType(lang)
-    }
-    
-    let init = null
-    if (this.match(TokenType.EQUALS)) {
-      init = this.parseExpression(lang)
-    }
-    
-    return {
-      type: 'VariableDeclaration',
-      kind: kind,
-      name: name,
-      typeAnnotation: typeAnnotation,
-      init: init
-    }
-  }
-
-  translateVariableKind(value, lang) {
-    const lower = value.toLowerCase()
-    
-    if (lower === 'constante' || lower === 'const') {
-      return 'const'
-    }
-    if (lower === 'variable' || lower === 'var') {
-      if (lang === 'js' || lang === 'ts' || lang === 'react') {
-        return 'let'
-      }
-      return 'var'
-    }
-    if (lower === 'soit' || lower === 'let') {
-      return 'let'
-    }
-    
-    return 'let'
-  }
-
-  parseFunctionDeclaration(lang) {
-    this.advance()
-    
-    let isAsync = false
-    let isGenerator = false
-    
-    const modifierToken = this.current()
-    if (modifierToken && modifierToken.type === TokenType.IDENTIFIER) {
-      const modVal = this.normalizeAccents(modifierToken.value.toLowerCase())
-      if (modVal === 'asynchrone' || modVal === 'async') {
-        isAsync = true
-        this.advance()
-      } else if (modVal === 'generatrice' || modVal === 'generator' || modVal === 'generateur') {
-        isGenerator = true
-        this.advance()
-      }
-    }
-    
-    const nameToken = this.current()
-    if (!nameToken || nameToken.type !== TokenType.IDENTIFIER) {
-      return null
-    }
-    const name = nameToken.value
-    this.advance()
-    
-    const params = []
-    if (this.match(TokenType.LPAREN)) {
-      while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
-        while (this.match(TokenType.NEWLINE) || this.match(TokenType.INDENT) || this.match(TokenType.DEDENT)) {}
-        if (this.check(TokenType.RPAREN)) break
-        const param = this.parseParameter(lang)
-        if (param) {
-          params.push(param)
-        }
-        this.match(TokenType.COMMA)
-        while (this.match(TokenType.NEWLINE) || this.match(TokenType.INDENT) || this.match(TokenType.DEDENT)) {}
-      }
-    } else {
-      while (!this.isAtEnd()) {
-        const token = this.current()
-        if (!token || token.type === TokenType.NEWLINE || token.type === TokenType.COLON || token.type === TokenType.ARROW) {
-          break
-        }
-        if (token.type === TokenType.IDENTIFIER) {
-          const param = this.parseParameter(lang)
-          if (param) {
-            params.push(param)
-          }
-        } else {
-          break
-        }
-        this.match(TokenType.COMMA)
-      }
-    }
-    
-    let returnType = null
-    if (this.match(TokenType.COLON) || this.match(TokenType.ARROW)) {
-      returnType = this.parseType(lang)
-    }
-    
-    this.skipNewlines()
-    const body = this.parseBlock(lang)
-    
-    return {
-      type: 'FunctionDeclaration',
-      name: name,
-      params: params,
-      returnType: returnType,
-      body: body,
-      async: isAsync,
-      generator: isGenerator
-    }
-  }
-
-  parseFunctionExpression(lang) {
-    this.advance()
-    
-    let name = null
-    const nameToken = this.current()
-    if (nameToken && nameToken.type === TokenType.IDENTIFIER && !this.check(TokenType.LPAREN)) {
-      const nextToken = this.peek(1)
-      if (nextToken && nextToken.type === TokenType.LPAREN) {
-        name = nameToken.value
-        this.advance()
-      }
-    }
-    
-    const params = []
-    if (this.match(TokenType.LPAREN)) {
-      while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
-        while (this.match(TokenType.NEWLINE) || this.match(TokenType.INDENT) || this.match(TokenType.DEDENT)) {}
-        if (this.check(TokenType.RPAREN)) break
-        const param = this.parseParameter(lang)
-        if (param) {
-          params.push(param)
-        }
-        this.match(TokenType.COMMA)
-        while (this.match(TokenType.NEWLINE) || this.match(TokenType.INDENT) || this.match(TokenType.DEDENT)) {}
-      }
-    }
-    
-    let returnType = null
-    if (this.match(TokenType.COLON) || this.match(TokenType.ARROW)) {
-      returnType = this.parseType(lang)
-    }
-    
-    this.skipNewlines()
-    const body = this.parseBlock(lang)
-    
-    return {
-      type: 'FunctionExpression',
-      name: name,
-      params: params,
-      returnType: returnType,
-      body: body
-    }
-  }
-
-  parseParameter(lang) {
-    const nameToken = this.current()
-    if (!nameToken || nameToken.type !== TokenType.IDENTIFIER) {
-      return null
-    }
-    const name = nameToken.value
-    this.advance()
-    
-    let typeAnnotation = null
-    if (this.match(TokenType.COLON)) {
-      typeAnnotation = this.parseType(lang)
-    }
-    
-    let defaultValue = null
-    if (this.match(TokenType.EQUALS)) {
-      defaultValue = this.parseExpression(lang)
-    }
-    
-    return {
-      type: 'Parameter',
-      name: name,
-      typeAnnotation: typeAnnotation,
-      default: defaultValue
-    }
-  }
-
-  parseType(lang) {
-    const token = this.current()
-    if (!token) return null
-    
-    const typeName = this.translateType(token.value, lang)
-    this.advance()
-    
-    let generic = null
-    if (this.match(TokenType.LT)) {
-      generic = []
-      while (!this.isAtEnd() && !this.match(TokenType.GT)) {
-        const innerType = this.parseType(lang)
-        if (innerType) {
-          generic.push(innerType)
-        }
-        this.match(TokenType.COMMA)
-      }
-    }
-    
-    let isArray = false
-    if (this.match(TokenType.LBRACKET)) {
-      this.match(TokenType.RBRACKET)
-      isArray = true
-    }
-    
-    return {
-      type: 'TypeAnnotation',
-      name: typeName,
-      generic: generic,
-      isArray: isArray
-    }
-  }
-
-  translateType(value, lang) {
-    const lower = value.toLowerCase()
-    
-    const types = {
-      'chaine': 'string',
-      'texte': 'string',
-      'nombre': 'number',
-      'entier': lang === 'ts' ? 'number' : 'int',
-      'decimal': lang === 'ts' ? 'number' : 'float',
-      'flottant': lang === 'ts' ? 'number' : 'float',
-      'booleen': 'boolean',
-      'bool': 'boolean',
-      'vrai faux': 'boolean',
-      'tableau': 'Array',
-      'liste': lang === 'python' ? 'list' : 'Array',
-      'objet': 'object',
-      'dictionnaire': lang === 'python' ? 'dict' : 'object',
-      'nul': 'null',
-      'rien': 'void',
-      'vide': 'void',
-      'indefini': 'undefined',
-      'quelconque': 'any',
-      'jamais': 'never',
-      'inconnu': 'unknown',
-      'symbole': 'symbol',
-      
-      'promesse': 'Promise',
-      'fonction': 'Function'
-    }
-    
-    return types[lower] || value
-  }
-
-  parseClassDeclaration(lang) {
-    this.advance()
-    
-    const nameToken = this.current()
-    if (!nameToken || nameToken.type !== TokenType.IDENTIFIER) {
-      return null
-    }
-    const name = nameToken.value
-    this.advance()
-    
-    let extends_ = null
-    if (this.matchValue('etend') || this.matchValue('herite') || this.matchValue('extends')) {
-      const parentToken = this.current()
-      if (parentToken) {
-        extends_ = parentToken.value
-        this.advance()
-      }
-    }
-    
-    let implements_ = []
-    if (this.matchValue('implemente') || this.matchValue('implements')) {
-      while (!this.isAtEnd()) {
-        const implToken = this.current()
-        if (!implToken || implToken.type !== TokenType.IDENTIFIER) break
-        implements_.push(implToken.value)
-        this.advance()
-        if (!this.match(TokenType.COMMA)) break
-      }
-    }
-    
-    this.skipNewlines()
-    const body = this.parseBlock(lang)
-    
-    return {
-      type: 'ClassDeclaration',
-      name: name,
-      extends: extends_,
-      implements: implements_,
-      body: body
-    }
-  }
-
-  parseConditional(lang, isElseIf = false) {
-    if (!isElseIf) {
-      this.advance()
-    }
-    const condition = this.parseExpression(lang)
-    
-    this.skipNewlines()
-    const consequent = this.parseBlock(lang)
-    
-    let alternate = null
-    this.skipNewlines()
-    
-    if (this.matchValue('sinon')) {
-      if (this.matchValue('si')) {
-        alternate = this.parseConditional(lang, true)
-      } else {
-        this.skipNewlines()
-        alternate = this.parseBlock(lang)
-      }
-    }
-    
-    return {
-      type: 'IfStatement',
-      condition: condition,
-      consequent: consequent,
-      alternate: alternate
-    }
-  }
-
-  parseLoop(lang) {
-    const keyword = this.advance()
-    const keywordValue = keyword.value.toLowerCase()
-    
-    if (keywordValue === 'pour' || keywordValue === 'for' || keywordValue === 'pour chaque' || keywordValue === 'chaque') {
-      return this.parseForLoop(lang)
-    }
-    
-    if (keywordValue === 'tant que' || keywordValue === 'while') {
-      return this.parseWhileLoop(lang)
-    }
-    
-    if (keywordValue === 'faire' || keywordValue === 'do') {
-      return this.parseDoWhileLoop(lang)
-    }
-    
-    return this.parseWhileLoop(lang)
-  }
-
-  parseForLoop(lang) {
-    let variable = null
-    let iterable = null
-    let start = null
-    let end = null
-    let step = null
-    
-    const varToken = this.current()
-    if (varToken && varToken.type === TokenType.IDENTIFIER) {
-      variable = varToken.value
-      this.advance()
-    }
-    
-    if (this.matchValue('dans') || this.matchValue('de') || this.matchValue('in')) {
-      iterable = this.parseExpression(lang)
-    } else if (this.matchValue('de') || this.matchValue('from')) {
-      start = this.parseExpression(lang)
-      
-      if (this.matchValue('a') || this.matchValue('jusque') || this.matchValue('to')) {
-        end = this.parseExpression(lang)
-      }
-      
-      if (this.matchValue('par') || this.matchValue('step')) {
-        step = this.parseExpression(lang)
-      }
-    }
-    
-    this.skipNewlines()
-    const body = this.parseBlock(lang)
-    
-    return {
-      type: 'ForStatement',
-      variable: variable,
-      iterable: iterable,
-      start: start,
-      end: end,
-      step: step,
-      body: body
-    }
-  }
-
-  parseWhileLoop(lang) {
-    const condition = this.parseExpression(lang)
-    
-    this.skipNewlines()
-    const body = this.parseBlock(lang)
-    
-    return {
-      type: 'WhileStatement',
-      condition: condition,
-      body: body
-    }
-  }
-
-  parseDoWhileLoop(lang) {
-    this.skipNewlines()
-    const body = this.parseBlock(lang)
-    
-    this.skipNewlines()
-    if (this.matchValue('tant que') || this.matchValue('while')) {
-      const condition = this.parseExpression(lang)
-      
-      return {
-        type: 'DoWhileStatement',
-        condition: condition,
-        body: body
-      }
-    }
-    
-    return {
-      type: 'DoWhileStatement',
-      condition: { type: 'Literal', value: true },
-      body: body
-    }
-  }
-
-  parseReturn(lang) {
-    this.advance()
-    
-    const value = this.parseExpression(lang)
-    
-    return {
-      type: 'ReturnStatement',
-      value: value
-    }
-  }
-
-  parseImport(lang) {
-    const importToken = this.current()
-    const importKeyword = importToken ? importToken.value.toLowerCase() : ''
-    this.advance()
-    
-    const includeKeywords = ['inclure', 'requiert', 'include', 'require']
-    
-    if (this.current() && this.current().type === TokenType.COLON) {
-      this.advance()
-    }
-    
-    const nextToken = this.current()
-    if (includeKeywords.includes(importKeyword) && nextToken && nextToken.type === TokenType.STRING) {
-      const includePath = nextToken.value.replace(/^["']|["']$/g, '')
-      this.advance()
-      
-      if (includePath.endsWith('.eth') || includePath.endsWith('.ether') || 
-          !includePath.includes('.') || includePath.match(/\.(html|php|js|css)$/i)) {
-        return {
-          type: 'Include',
-          path: includePath,
-          resolved: false
-        }
-      }
-    }
-    
-    const imports = []
-    let source = null
-    let defaultImport = null
-    
-    const token = this.current()
-    
-    if (token && token.type === TokenType.LBRACE) {
-      this.advance()
-      while (!this.isAtEnd() && !this.match(TokenType.RBRACE)) {
-        const nameToken = this.current()
-        if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
-          let imported = nameToken.value
-          let local = imported
-          this.advance()
-          
-          if (this.matchValue('comme') || this.matchValue('as')) {
-            const aliasToken = this.current()
-            if (aliasToken && aliasToken.type === TokenType.IDENTIFIER) {
-              local = aliasToken.value
-              this.advance()
-            }
-          }
-          
-          imports.push({ imported, local })
-        }
-        this.match(TokenType.COMMA)
-      }
-    } else if (token && token.type === TokenType.IDENTIFIER) {
-      defaultImport = token.value
-      this.advance()
-    } else if (token && token.type === TokenType.STRING) {
-      source = token.value.replace(/^["']|["']$/g, '')
-      this.advance()
-      
-      if (includeKeywords.includes(importKeyword)) {
-        if (source.endsWith('.eth') || source.endsWith('.ether') || 
-            !source.includes('.') || source.match(/\.(html|php|js|css)$/i)) {
-          return {
-            type: 'Include',
-            path: source,
-            resolved: false
-          }
-        }
-      }
-    }
-    
-    if (this.matchValue('depuis') || this.matchValue('de') || this.matchValue('from')) {
-      const sourceToken = this.current()
-      if (sourceToken && sourceToken.type === TokenType.STRING) {
-        source = sourceToken.value.replace(/^["']|["']$/g, '')
-        this.advance()
-      }
-    }
-    
-    return {
-      type: 'ImportDeclaration',
-      imports: imports,
-      defaultImport: defaultImport,
-      source: source
-    }
-  }
-
-  parseExport(lang) {
-    this.advance()
-    
-    let isDefault = false
-    if (this.matchValue('defaut') || this.matchValue('default')) {
-      isDefault = true
-    }
-    
-    const declaration = this.parseStatement(lang)
-    
-    return {
-      type: 'ExportDeclaration',
-      isDefault: isDefault,
-      declaration: declaration
-    }
-  }
-
-  parseBlock(lang) {
-    const body = []
-    
-    const hasBrace = this.match(TokenType.LBRACE)
-    this.skipNewlines()
-    
-    if (hasBrace) {
-      this.match(TokenType.INDENT)
-    }
-    
-    if (hasBrace || this.match(TokenType.INDENT)) {
-      while (!this.isAtEnd()) {
-        this.skipNewlines()
-        
-        const current = this.current()
-        
-        if (current && current.type === TokenType.DEDENT) {
-          this.advance()
-          if (hasBrace) {
-            this.skipNewlines()
-            this.match(TokenType.RBRACE)
-          }
-          break
-        }
-        
-        if (hasBrace && current && current.type === TokenType.RBRACE) {
-          this.advance()
-          break
-        }
-        
-        if (current && current.type === TokenType.COMMA) {
-          break
-        }
-        
-        if (current && current.type === TokenType.RPAREN) {
-          break
-        }
-        
-        if (current && (current.type === TokenType.INDENT || current.type === TokenType.NEWLINE)) {
-          this.advance()
-          continue
-        }
-        
-        const statement = this.parseStatement(lang)
-        if (statement && statement.expression?.value !== null) {
-          body.push(statement)
-        } else if (statement && statement.type !== 'ExpressionStatement') {
-          body.push(statement)
-        }
-        
-        this.skipNewlines()
-      }
-    }
-    
-    return {
-      type: 'BlockStatement',
-      body: body
-    }
-  }
-
-  parseExpression(lang) {
-    return this.parseAssignment(lang)
-  }
-
-  parseAssignment(lang) {
-    const left = this.parseLogicalOr(lang)
-    
-    if (this.match(TokenType.EQUALS)) {
-      const right = this.parseAssignment(lang)
-      return {
-        type: 'AssignmentExpression',
-        operator: '=',
-        left: left,
-        right: right
-      }
-    }
-    
-    return left
-  }
-
-  parseLogicalOr(lang) {
-    let left = this.parseLogicalAnd(lang)
-    
-    while (this.match(TokenType.DOUBLE_PIPE) || this.matchValue('ou')) {
-      const right = this.parseLogicalAnd(lang)
-      left = {
-        type: 'BinaryExpression',
-        operator: '||',
-        left: left,
-        right: right
-      }
-    }
-    
-    return left
-  }
-
-  parseLogicalAnd(lang) {
-    let left = this.parseEquality(lang)
-    
-    while (this.match(TokenType.DOUBLE_AMPERSAND) || this.matchValue('et')) {
-      const right = this.parseEquality(lang)
-      left = {
-        type: 'BinaryExpression',
-        operator: '&&',
-        left: left,
-        right: right
-      }
-    }
-    
-    return left
-  }
-
-  parseEquality(lang) {
-    let left = this.parseComparison(lang)
-    
-    while (true) {
-      if (this.matchValue('strictement egal') || this.matchValue('strictement égal')) {
-        const right = this.parseComparison(lang)
-        left = { type: 'BinaryExpression', operator: '===', left, right }
-      } else if (this.matchValue('strictement different') || this.matchValue('strictement différent')) {
-        const right = this.parseComparison(lang)
-        left = { type: 'BinaryExpression', operator: '!==', left, right }
-      } else if (this.match(TokenType.DOUBLE_EQUALS) || this.matchValue('egal') || this.matchValue('egale') || this.matchValue('égal')) {
-        const right = this.parseComparison(lang)
-        left = { type: 'BinaryExpression', operator: '===', left, right }
-      } else if (this.match(TokenType.NOT_EQUALS) || this.matchValue('different') || this.matchValue('différent')) {
-        const right = this.parseComparison(lang)
-        left = { type: 'BinaryExpression', operator: '!==', left, right }
-      } else {
-        break
-      }
-    }
-    
-    return left
-  }
-
-  parseComparison(lang) {
-    let left = this.parseAdditive(lang)
-    
-    while (true) {
-      if (this.matchValue('superieur ou egal') || this.matchValue('supérieur ou égal') || this.match(TokenType.GTE)) {
-        const right = this.parseAdditive(lang)
-        left = { type: 'BinaryExpression', operator: '>=', left, right }
-      } else if (this.matchValue('inferieur ou egal') || this.matchValue('inférieur ou égal') || this.match(TokenType.LTE)) {
-        const right = this.parseAdditive(lang)
-        left = { type: 'BinaryExpression', operator: '<=', left, right }
-      } else if (this.match(TokenType.LT) || this.matchValue('inferieur') || this.matchValue('inférieur')) {
-        const right = this.parseAdditive(lang)
-        left = { type: 'BinaryExpression', operator: '<', left, right }
-      } else if (this.match(TokenType.GT) || this.matchValue('superieur') || this.matchValue('supérieur')) {
-        const right = this.parseAdditive(lang)
-        left = { type: 'BinaryExpression', operator: '>', left, right }
-      } else if (this.matchValue('instance de') || this.matchValue('instanceof')) {
-        const right = this.parseAdditive(lang)
-        left = { type: 'BinaryExpression', operator: 'instanceof', left, right }
-      } else {
-        break
-      }
-    }
-    
-    return left
-  }
-
-  parseAdditive(lang) {
-    let left = this.parseMultiplicative(lang)
-    
-    while (true) {
-      if (this.match(TokenType.PLUS) || this.matchValue('plus') || this.matchValue('addition')) {
-        const right = this.parseMultiplicative(lang)
-        left = { type: 'BinaryExpression', operator: '+', left, right }
-      } else if (this.match(TokenType.MINUS) || this.matchValue('moins') || this.matchValue('soustraction')) {
-        const right = this.parseMultiplicative(lang)
-        left = { type: 'BinaryExpression', operator: '-', left, right }
-      } else {
-        break
-      }
-    }
-    
-    return left
-  }
-
-  parseMultiplicative(lang) {
-    let left = this.parseUnary(lang)
-    
-    while (true) {
-      if (this.match(TokenType.STAR) || this.matchValue('fois') || this.matchValue('multiplie') || this.matchValue('multiplication')) {
-        const right = this.parseUnary(lang)
-        left = { type: 'BinaryExpression', operator: '*', left, right }
-      } else if (this.match(TokenType.SLASH) || this.matchValue('divise') || this.matchValue('division')) {
-        const right = this.parseUnary(lang)
-        left = { type: 'BinaryExpression', operator: '/', left, right }
-      } else if (this.match(TokenType.PERCENT) || this.matchValue('modulo')) {
-        const right = this.parseUnary(lang)
-        left = { type: 'BinaryExpression', operator: '%', left, right }
-      } else if (this.match(TokenType.DOUBLE_STAR) || this.matchValue('puissance')) {
-        const right = this.parseUnary(lang)
-        left = { type: 'BinaryExpression', operator: '**', left, right }
-      } else {
-        break
-      }
-    }
-    
-    return left
-  }
-
-  parseUnary(lang) {
-    if (this.match(TokenType.BANG) || this.matchValue('non') || this.matchValue('pas')) {
-      const operand = this.parseUnary(lang)
-      return { type: 'UnaryExpression', operator: '!', operand }
-    }
-    
-    if (this.match(TokenType.MINUS)) {
-      const operand = this.parseUnary(lang)
-      return { type: 'UnaryExpression', operator: '-', operand }
-    }
-    
-    if (this.matchValue('type de') || this.matchValue('typeof')) {
-      const operand = this.parseUnary(lang)
-      return { type: 'UnaryExpression', operator: 'typeof', operand }
-    }
-    
-    if (this.matchValue('nouveau') || this.matchValue('new') || this.matchValue('nouvelle')) {
-      const callee = this.parseCall(lang)
-      if (callee.type === 'CallExpression') {
-        return { type: 'NewExpression', callee: callee.callee, arguments: callee.arguments }
-      }
-      return { type: 'NewExpression', callee, arguments: [] }
-    }
-    
-    return this.parseCall(lang)
-  }
-
-  parseCall(lang) {
-    let expr = this.parsePrimary(lang)
-    
-    while (true) {
-      if (this.match(TokenType.LPAREN)) {
-        const args = []
-        while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
-          while (this.match(TokenType.NEWLINE) || this.match(TokenType.INDENT) || this.match(TokenType.DEDENT)) {}
-          if (this.check(TokenType.RPAREN)) break
-          args.push(this.parseExpression(lang))
-          this.match(TokenType.COMMA)
-          while (this.match(TokenType.NEWLINE) || this.match(TokenType.INDENT) || this.match(TokenType.DEDENT)) {}
-        }
-        expr = { type: 'CallExpression', callee: expr, arguments: args }
-      } else if (this.match(TokenType.DOT)) {
-        const property = this.current()
-        if (property && property.type === TokenType.IDENTIFIER) {
-          this.advance()
-          expr = { type: 'MemberExpression', object: expr, property: { type: 'Identifier', name: property.value } }
-        }
-      } else if (this.match(TokenType.LBRACKET)) {
-        const index = this.parseExpression(lang)
-        this.expect(TokenType.RBRACKET)
-        expr = { type: 'IndexExpression', object: expr, index }
-      } else {
-        break
-      }
-    }
-    
-    return expr
-  }
-
-  parsePrimary(lang) {
-    const token = this.current()
-    
-    if (!token) {
-      return { type: 'Literal', value: null }
-    }
-    
-    if (token.type === TokenType.NUMBER || token.type === TokenType.INTEGER || token.type === TokenType.FLOAT) {
-      this.advance()
-      return { type: 'Literal', value: parseFloat(token.value) }
-    }
-    
-    if (token.type === TokenType.STRING) {
-      this.advance()
-      return { type: 'Literal', value: token.value.replace(/^["']|["']$/g, '') }
-    }
-    
-    if (token.type === TokenType.IDENTIFIER) {
-      const value = token.value.toLowerCase()
-      
-      if (value === 'fonction' || value === 'function') {
-        return this.parseFunctionExpression(lang)
-      }
-      
-      if (value === 'vrai' || value === 'true') {
-        this.advance()
-        return { type: 'Literal', value: true }
-      }
-      
-      if (value === 'faux' || value === 'false') {
-        this.advance()
-        return { type: 'Literal', value: false }
-      }
-      
-      if (value === 'nul' || value === 'null' || value === 'rien') {
-        this.advance()
-        return { type: 'Literal', value: null }
-      }
-      
-      if (value === 'indefini' || value === 'undefined') {
-        this.advance()
-        return { type: 'Literal', value: undefined }
-      }
-      
-      const translated = this.translateJSIdentifier(token.value)
-      this.advance()
-      
-      if (translated && translated.includes('.')) {
-        const parts = translated.split('.')
-        let expr = { type: 'Identifier', name: parts[0] }
-        for (let i = 1; i < parts.length; i++) {
-          expr = { type: 'MemberExpression', object: expr, property: { type: 'Identifier', name: parts[i] } }
-        }
-        return expr
-      }
-      
-      return { type: 'Identifier', name: translated || token.value }
-    }
-    
-    if (token.type === TokenType.LBRACKET) {
-      return this.parseArrayLiteral(lang)
-    }
-    
-    if (token.type === TokenType.LBRACE) {
-      return this.parseObjectLiteral(lang)
-    }
-    
-    if (token.type === TokenType.LPAREN) {
-      this.advance()
-      const expr = this.parseExpression(lang)
-      this.expect(TokenType.RPAREN)
-      expr.parenthesized = true
-      return expr
-    }
-    
-    this.advance()
-    return { type: 'Literal', value: null }
-  }
-
-  parseArrayLiteral(lang) {
-    this.expect(TokenType.LBRACKET)
-    const elements = []
-    
-    while (!this.isAtEnd() && !this.match(TokenType.RBRACKET)) {
-      elements.push(this.parseExpression(lang))
-      this.match(TokenType.COMMA)
-    }
-    
-    return { type: 'ArrayExpression', elements }
-  }
-
-  parseObjectLiteral(lang) {
-    this.expect(TokenType.LBRACE)
-    const properties = []
-    
-    this.skipWhitespace()
-    
-    while (!this.isAtEnd() && !this.check(TokenType.RBRACE)) {
-      this.skipWhitespace()
-      
-      const keyToken = this.current()
-      if (!keyToken || keyToken.type === TokenType.RBRACE) break
-      
-      let key
-      if (keyToken.type === TokenType.STRING) {
-        const keyValue = keyToken.value.replace(/^["']|["']$/g, '')
-        key = { type: 'Literal', value: keyValue }
-        this.advance()
-      } else if (keyToken.type === TokenType.IDENTIFIER) {
-        key = { type: 'Identifier', name: keyToken.value }
-        this.advance()
-      } else {
-        break
-      }
-      
-      this.match(TokenType.COLON) || this.match(TokenType.EQUALS)
-      
-      const value = this.parseExpression(lang)
-      properties.push({ key, value })
-      
-      this.match(TokenType.COMMA)
-      this.skipWhitespace()
-    }
-    
-    this.match(TokenType.RBRACE)
-    
-    return { type: 'ObjectExpression', properties }
-  }
-  
-  skipWhitespace() {
-    while (this.match(TokenType.NEWLINE) || this.match(TokenType.INDENT) || this.match(TokenType.DEDENT)) {}
-  }
-  
-  check(type) {
-    const token = this.current()
-    return token && token.type === type
-  }
-
-  parseSQLProgram() {
-    const program = {
-      type: 'SQLProgram',
-      statements: []
-    }
-    
-    this.skipNewlines()
-    
-    while (!this.isAtEnd()) {
-      const statement = this.parseSQLStatement()
-      if (statement) {
-        program.statements.push(statement)
-      }
-      this.skipNewlines()
-    }
-    
-    return program
-  }
-
-  parseSQLStatement() {
-    this.skipNewlines()
-    const token = this.current()
-    
-    if (!token || token.type === TokenType.EOF) return null
-    
-    const value = token.value ? token.value.toLowerCase() : ''
-    
-    if (value === 'selectionner' || value === 'select' || value === 'choisir') {
-      return this.parseSQLSelect()
-    }
-    
-    if (value === 'inserer' || value === 'insert' || value === 'ajouter') {
-      return this.parseSQLInsert()
-    }
-    
-    if (value === 'mettre' || value === 'update' || value === 'modifier') {
-      return this.parseSQLUpdate()
-    }
-    
-    if (value === 'supprimer' || value === 'delete' || value === 'effacer') {
-      return this.parseSQLDelete()
-    }
-    
-    if (value === 'creer' || value === 'create') {
-      return this.parseSQLCreate()
-    }
-    
-    if (value === 'detruire' || value === 'drop') {
-      return this.parseSQLDrop()
-    }
-    
-    if (value === 'modifier' || value === 'alter') {
-      return this.parseSQLAlter()
-    }
-    
-    this.advance()
-    return null
-  }
-
-  parseSQLSelect() {
-    this.advance()
-    
-    const columns = []
-    
-    while (!this.isAtEnd()) {
-      const token = this.current()
-      
-      if (!token || token.type === TokenType.EOF) break
-      
-      const value = token.value ? token.value.toLowerCase() : ''
-      if (value === 'depuis' || value === 'de' || value === 'from') break
-      
-      if (token.type === TokenType.STAR) {
-        columns.push('*')
-        this.advance()
-      } else if (token.type === TokenType.IDENTIFIER) {
-        columns.push(token.value)
-        this.advance()
-      } else if (token.type === TokenType.COMMA) {
-        this.advance()
-      } else {
-        break
-      }
-    }
-    
-    let table = null
-    if (this.matchValue('depuis') || this.matchValue('de') || this.matchValue('from')) {
-      const tableToken = this.current()
-      if (tableToken && tableToken.type === TokenType.IDENTIFIER) {
-        table = tableToken.value
-        this.advance()
-      }
-    }
-    
-    let where = null
-    if (this.matchValue('ou') || this.matchValue('where')) {
-      where = this.parseSQLWhere()
-    }
-    
-    let orderBy = null
-    if (this.matchValue('trier') || this.matchValue('ordonner') || this.matchValue('order')) {
-      if (this.matchValue('par') || this.matchValue('by')) {
-        orderBy = this.parseSQLOrderBy()
-      }
-    }
-    
-    let limit = null
-    if (this.matchValue('limiter') || this.matchValue('limit')) {
-      const limitToken = this.current()
-      if (limitToken && (limitToken.type === TokenType.NUMBER || limitToken.type === TokenType.INTEGER)) {
-        limit = parseInt(limitToken.value)
-        this.advance()
-      }
-    }
-    
-    return {
-      type: 'SelectStatement',
-      columns: columns,
-      table: table,
-      where: where,
-      orderBy: orderBy,
-      limit: limit
-    }
-  }
-
-  parseSQLWhere() {
-    const conditions = []
-    
-    while (!this.isAtEnd()) {
-      const token = this.current()
-      
-      if (!token || token.type === TokenType.EOF) break
-      
-      const value = token.value ? token.value.toLowerCase() : ''
-      if (value === 'trier' || value === 'ordonner' || value === 'order' || 
-          value === 'limiter' || value === 'limit' || value === 'grouper') break
-      
-      if (token.type === TokenType.IDENTIFIER) {
-        const field = token.value
-        this.advance()
-        
-        const opToken = this.current()
-        let operator = '='
-        
-        if (opToken) {
-          if (opToken.type === TokenType.EQUALS || opToken.type === TokenType.DOUBLE_EQUALS) {
-            operator = '='
-            this.advance()
-          } else if (opToken.type === TokenType.NOT_EQUALS) {
-            operator = '<>'
-            this.advance()
-          } else if (opToken.type === TokenType.LT) {
-            operator = '<'
-            this.advance()
-          } else if (opToken.type === TokenType.GT) {
-            operator = '>'
-            this.advance()
-          } else if (opToken.type === TokenType.LTE) {
-            operator = '<='
-            this.advance()
-          } else if (opToken.type === TokenType.GTE) {
-            operator = '>='
-            this.advance()
-          } else if (opToken.value && opToken.value.toLowerCase() === 'egal') {
-            operator = '='
-            this.advance()
-          }
-        }
-        
-        const valueToken = this.current()
-        let condValue = null
-        
-        if (valueToken) {
-          if (valueToken.type === TokenType.STRING) {
-            condValue = valueToken.value
-          } else if (valueToken.type === TokenType.NUMBER || valueToken.type === TokenType.INTEGER) {
-            condValue = parseFloat(valueToken.value)
-          } else if (valueToken.type === TokenType.IDENTIFIER) {
-            condValue = valueToken.value
-          }
-          this.advance()
-        }
-        
-        conditions.push({ field, operator, value: condValue })
-      } else if (value === 'et' || value === 'and') {
-        conditions.push({ type: 'AND' })
-        this.advance()
-      } else if (value === 'ou' || value === 'or') {
-        conditions.push({ type: 'OR' })
-        this.advance()
-      } else {
-        this.advance()
-      }
-    }
-    
-    return conditions
-  }
-
-  parseSQLOrderBy() {
-    const orders = []
-    
-    while (!this.isAtEnd()) {
-      const token = this.current()
-      
-      if (!token || token.type === TokenType.EOF) break
-      
-      const value = token.value ? token.value.toLowerCase() : ''
-      if (value === 'limiter' || value === 'limit' || value === 'grouper') break
-      
-      if (token.type === TokenType.IDENTIFIER) {
-        const field = token.value
-        this.advance()
-        
-        let direction = 'ASC'
-        const dirToken = this.current()
-        
-        if (dirToken) {
-          const dirValue = dirToken.value ? dirToken.value.toLowerCase() : ''
-          if (dirValue === 'desc' || dirValue === 'descendant' || dirValue === 'decroissant') {
-            direction = 'DESC'
-            this.advance()
-          } else if (dirValue === 'asc' || dirValue === 'ascendant' || dirValue === 'croissant') {
-            direction = 'ASC'
-            this.advance()
-          }
-        }
-        
-        orders.push({ field, direction })
-      } else if (token.type === TokenType.COMMA) {
-        this.advance()
-      } else {
-        break
-      }
-    }
-    
-    return orders
-  }
-
-  parseSQLInsert() {
-    this.advance()
-    
-    if (this.matchValue('dans') || this.matchValue('into') || this.matchValue('in')) {
-    }
-    
-    const tableToken = this.current()
-    let table = null
-    if (tableToken && tableToken.type === TokenType.IDENTIFIER) {
-      table = tableToken.value
-      this.advance()
-    }
-    
-    const columns = []
-    if (this.match(TokenType.LPAREN)) {
-      while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
-        const colToken = this.current()
-        if (colToken && colToken.type === TokenType.IDENTIFIER) {
-          columns.push(colToken.value)
-          this.advance()
-        }
-        this.match(TokenType.COMMA)
-      }
-    }
-    
-    const values = []
-    if (this.matchValue('valeurs') || this.matchValue('values')) {
-      if (this.match(TokenType.LPAREN)) {
-        while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
-          const valToken = this.current()
-          if (valToken) {
-            if (valToken.type === TokenType.STRING) {
-              values.push(valToken.value)
-            } else if (valToken.type === TokenType.NUMBER || valToken.type === TokenType.INTEGER) {
-              values.push(parseFloat(valToken.value))
-            } else if (valToken.type === TokenType.IDENTIFIER) {
-              const v = valToken.value.toLowerCase()
-              if (v === 'vrai' || v === 'true') values.push(true)
-              else if (v === 'faux' || v === 'false') values.push(false)
-              else if (v === 'nul' || v === 'null') values.push(null)
-              else values.push(valToken.value)
-            }
-            this.advance()
-          }
-          this.match(TokenType.COMMA)
-        }
-      }
-    }
-    
-    return {
-      type: 'InsertStatement',
-      table: table,
-      columns: columns,
-      values: values
-    }
-  }
-
-  parseSQLUpdate() {
-    this.advance()
-    
-    if (this.matchValue('a jour') || this.matchValue('jour')) {
-    }
-    
-    const tableToken = this.current()
-    let table = null
-    if (tableToken && tableToken.type === TokenType.IDENTIFIER) {
-      table = tableToken.value
-      this.advance()
-    }
-    
-    const assignments = []
-    if (this.matchValue('definir') || this.matchValue('set') || this.matchValue('avec')) {
-      while (!this.isAtEnd()) {
-        const colToken = this.current()
-        
-        if (!colToken || colToken.type === TokenType.EOF) break
-        
-        const value = colToken.value ? colToken.value.toLowerCase() : ''
-        if (value === 'ou' || value === 'where') break
-        
-        if (colToken.type === TokenType.IDENTIFIER) {
-          const column = colToken.value
-          this.advance()
-          
-          if (this.match(TokenType.EQUALS) || this.match(TokenType.COLON)) {
-            const valToken = this.current()
-            let val = null
-            
-            if (valToken) {
-              if (valToken.type === TokenType.STRING) {
-                val = valToken.value
-              } else if (valToken.type === TokenType.NUMBER || valToken.type === TokenType.INTEGER) {
-                val = parseFloat(valToken.value)
-              } else if (valToken.type === TokenType.IDENTIFIER) {
-                val = valToken.value
-              }
-              this.advance()
-            }
-            
-            assignments.push({ column, value: val })
-          }
-        }
-        
-        this.match(TokenType.COMMA)
-      }
-    }
-    
-    let where = null
-    if (this.matchValue('ou') || this.matchValue('where')) {
-      where = this.parseSQLWhere()
-    }
-    
-    return {
-      type: 'UpdateStatement',
-      table: table,
-      assignments: assignments,
-      where: where
-    }
-  }
-
-  parseSQLDelete() {
-    this.advance()
-    
-    if (this.matchValue('de') || this.matchValue('depuis') || this.matchValue('from')) {
-    }
-    
-    const tableToken = this.current()
-    let table = null
-    if (tableToken && tableToken.type === TokenType.IDENTIFIER) {
-      table = tableToken.value
-      this.advance()
-    }
-    
-    let where = null
-    if (this.matchValue('ou') || this.matchValue('where')) {
-      where = this.parseSQLWhere()
-    }
-    
-    return {
-      type: 'DeleteStatement',
-      table: table,
-      where: where
-    }
-  }
-
-  parseSQLCreate() {
-    this.advance()
-    
-    if (this.matchValue('table')) {
-      return this.parseSQLCreateTable()
-    }
-    
-    if (this.matchValue('base') || this.matchValue('database')) {
-      this.matchValue('de')
-      this.matchValue('donnees')
-      return this.parseSQLCreateDatabase()
-    }
-    
-    if (this.matchValue('index')) {
-      return this.parseSQLCreateIndex()
-    }
-    
-    return null
-  }
-
-  parseSQLCreateTable() {
-    const nameToken = this.current()
-    let name = null
-    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
-      name = nameToken.value
-      this.advance()
-    }
-    
-    const columns = []
-    
-    if (this.match(TokenType.LPAREN)) {
-      while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
-        const col = this.parseSQLColumnDef()
-        if (col) {
-          columns.push(col)
-        }
-        this.match(TokenType.COMMA)
-      }
-    } else {
-      this.skipNewlines()
-      this.match(TokenType.INDENT)
-      
-      while (!this.isAtEnd()) {
-        const current = this.current()
-        
-        if (current && current.type === TokenType.DEDENT) {
-          this.advance()
-          break
-        }
-        
-        if (current && current.type === TokenType.NEWLINE) {
-          this.advance()
-          continue
-        }
-        
-        const col = this.parseSQLColumnDef()
-        if (col) {
-          columns.push(col)
-        }
-      }
-    }
-    
-    return {
-      type: 'CreateTableStatement',
-      name: name,
-      columns: columns
-    }
-  }
-
-  parseSQLColumnDef() {
-    const nameToken = this.current()
-    if (!nameToken || nameToken.type !== TokenType.IDENTIFIER) {
-      return null
-    }
-    const name = nameToken.value
-    this.advance()
-    
-    this.match(TokenType.COLON)
-    
-    const typeToken = this.current()
-    let dataType = 'TEXT'
-    if (typeToken && typeToken.type === TokenType.IDENTIFIER) {
-      dataType = this.translateSQLType(typeToken.value)
-      this.advance()
-    }
-    
-    let size = null
-    if (this.match(TokenType.LPAREN)) {
-      const sizeToken = this.current()
-      if (sizeToken && (sizeToken.type === TokenType.NUMBER || sizeToken.type === TokenType.INTEGER)) {
-        size = parseInt(sizeToken.value)
-        this.advance()
-      }
-      this.match(TokenType.RPAREN)
-    }
-    
-    const constraints = []
-    
-    while (!this.isAtEnd()) {
-      const token = this.current()
-      
-      if (!token || token.type === TokenType.COMMA || token.type === TokenType.RPAREN ||
-          token.type === TokenType.NEWLINE || token.type === TokenType.DEDENT) {
-        break
-      }
-      
-      const value = token.value ? token.value.toLowerCase() : ''
-      
-      if (value === 'cle' || value === 'key') {
-        this.advance()
-        if (this.matchValue('primaire') || this.matchValue('primary')) {
-          constraints.push('PRIMARY KEY')
-        }
-      } else if (value === 'primaire' || value === 'primary') {
-        this.advance()
-        constraints.push('PRIMARY KEY')
-      } else if (value === 'unique') {
-        this.advance()
-        constraints.push('UNIQUE')
-      } else if (value === 'non' || value === 'not') {
-        this.advance()
-        if (this.matchValue('nul') || this.matchValue('null')) {
-          constraints.push('NOT NULL')
-        }
-      } else if (value === 'auto' || value === 'autoincrement') {
-        this.advance()
-        if (this.matchValue('increment')) {
-        }
-        constraints.push('AUTO_INCREMENT')
-      } else if (value === 'defaut' || value === 'default') {
-        this.advance()
-        const defToken = this.current()
-        if (defToken) {
-          constraints.push(`DEFAULT ${defToken.value}`)
-          this.advance()
-        }
-      } else if (value === 'reference' || value === 'references') {
-        this.advance()
-        const refTable = this.current()
-        if (refTable && refTable.type === TokenType.IDENTIFIER) {
-          let ref = `REFERENCES ${refTable.value}`
-          this.advance()
-          if (this.match(TokenType.LPAREN)) {
-            const refCol = this.current()
-            if (refCol) {
-              ref += `(${refCol.value})`
-              this.advance()
-            }
-            this.match(TokenType.RPAREN)
-          }
-          constraints.push(ref)
-        }
-      } else {
-        this.advance()
-      }
-    }
-    
-    return {
-      name: name,
-      type: dataType,
-      size: size,
-      constraints: constraints
-    }
-  }
-
-  translateSQLType(value) {
-    const lower = value.toLowerCase()
-    
-    const types = {
-      'entier': 'INT',
-      'nombre': 'INT',
-      'texte': 'TEXT',
-      'chaine': 'VARCHAR',
-      'caracteres': 'VARCHAR',
-      'decimal': 'DECIMAL',
-      'flottant': 'FLOAT',
-      'double': 'DOUBLE',
-      'booleen': 'BOOLEAN',
-      'date': 'DATE',
-      'heure': 'TIME',
-      'horodatage': 'TIMESTAMP',
-      'dateheure': 'DATETIME',
-      'blob': 'BLOB',
-      'binaire': 'BINARY',
-      'json': 'JSON',
-      'uuid': 'UUID',
-      'petit entier': 'SMALLINT',
-      'grand entier': 'BIGINT',
-      'tres petit entier': 'TINYINT'
-    }
-    
-    return types[lower] || value.toUpperCase()
-  }
-
-  parseSQLCreateDatabase() {
-    const nameToken = this.current()
-    let name = null
-    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
-      name = nameToken.value
-      this.advance()
-    }
-    
-    return {
-      type: 'CreateDatabaseStatement',
-      name: name
-    }
-  }
-
-  parseSQLCreateIndex() {
-    let unique = false
-    if (this.matchValue('unique')) {
-      unique = true
-    }
-    
-    const nameToken = this.current()
-    let name = null
-    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
-      name = nameToken.value
-      this.advance()
-    }
-    
-    if (this.matchValue('sur') || this.matchValue('on')) {
-    }
-    
-    const tableToken = this.current()
-    let table = null
-    if (tableToken && tableToken.type === TokenType.IDENTIFIER) {
-      table = tableToken.value
-      this.advance()
-    }
-    
-    const columns = []
-    if (this.match(TokenType.LPAREN)) {
-      while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
-        const colToken = this.current()
-        if (colToken && colToken.type === TokenType.IDENTIFIER) {
-          columns.push(colToken.value)
-          this.advance()
-        }
-        this.match(TokenType.COMMA)
-      }
-    }
-    
-    return {
-      type: 'CreateIndexStatement',
-      name: name,
-      table: table,
-      columns: columns,
-      unique: unique
-    }
-  }
-
-  parseSQLDrop() {
-    this.advance()
-    
-    if (this.matchValue('table')) {
-      const nameToken = this.current()
-      let name = null
-      if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
-        name = nameToken.value
-        this.advance()
-      }
-      return { type: 'DropTableStatement', name }
-    }
-    
-    if (this.matchValue('base') || this.matchValue('database')) {
-      this.matchValue('de')
-      this.matchValue('donnees')
-      const nameToken = this.current()
-      let name = null
-      if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
-        name = nameToken.value
-        this.advance()
-      }
-      return { type: 'DropDatabaseStatement', name }
-    }
-    
-    if (this.matchValue('index')) {
-      const nameToken = this.current()
-      let name = null
-      if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
-        name = nameToken.value
-        this.advance()
-      }
-      return { type: 'DropIndexStatement', name }
-    }
-    
-    return null
-  }
-
-  parseSQLAlter() {
-    this.advance()
-    
-    if (this.matchValue('table')) {
-      const nameToken = this.current()
-      let name = null
-      if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
-        name = nameToken.value
-        this.advance()
-      }
-      
-      const actions = []
-      
-      if (this.matchValue('ajouter') || this.matchValue('add')) {
-        if (this.matchValue('colonne') || this.matchValue('column')) {
-        }
-        const col = this.parseSQLColumnDef()
-        if (col) {
-          actions.push({ type: 'ADD', column: col })
-        }
-      }
-      
-      if (this.matchValue('supprimer') || this.matchValue('drop')) {
-        if (this.matchValue('colonne') || this.matchValue('column')) {
-        }
-        const colToken = this.current()
-        if (colToken && colToken.type === TokenType.IDENTIFIER) {
-          actions.push({ type: 'DROP', column: colToken.value })
-          this.advance()
-        }
-      }
-      
-      if (this.matchValue('modifier') || this.matchValue('modify')) {
-        if (this.matchValue('colonne') || this.matchValue('column')) {
-        }
-        const col = this.parseSQLColumnDef()
-        if (col) {
-          actions.push({ type: 'MODIFY', column: col })
-        }
-      }
-      
-      return {
-        type: 'AlterTableStatement',
-        name: name,
-        actions: actions
-      }
-    }
-    
-    return null
-  }
-
-  parseGraphQLProgram() {
-    const program = {
-      type: 'GraphQLProgram',
-      definitions: []
-    }
-    
-    this.skipNewlines()
-    
-    while (!this.isAtEnd()) {
-      const def = this.parseGraphQLDefinition()
-      if (def) {
-        program.definitions.push(def)
-      }
-      this.skipNewlines()
-    }
-    
-    return program
-  }
-
-  parseGraphQLDefinition() {
-    this.skipNewlines()
-    const token = this.current()
-    
-    if (!token || token.type === TokenType.EOF) return null
-    
-    const value = token.value ? token.value.toLowerCase() : ''
-    
-    if (value === 'type' || value === 'modele') {
-      return this.parseGraphQLType()
-    }
-    
-    if (value === 'input' || value === 'entree') {
-      return this.parseGraphQLInput()
-    }
-    
-    if (value === 'enum' || value === 'enumeration') {
-      return this.parseGraphQLEnum()
-    }
-    
-    if (value === 'interface') {
-      return this.parseGraphQLInterface()
-    }
-    
-    if (value === 'query' || value === 'requete') {
-      return this.parseGraphQLQuery()
-    }
-    
-    if (value === 'mutation') {
-      return this.parseGraphQLMutation()
-    }
-    
-    if (value === 'subscription' || value === 'abonnement') {
-      return this.parseGraphQLSubscription()
-    }
-    
-    if (value === 'schema') {
-      return this.parseGraphQLSchema()
-    }
-    
-    this.advance()
-    return null
-  }
-
-  parseGraphQLType() {
-    this.advance()
-    
-    const nameToken = this.current()
-    let name = null
-    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
-      name = nameToken.value
-      this.advance()
-    }
-    
-    let implements_ = []
-    if (this.matchValue('implemente') || this.matchValue('implements')) {
-      while (!this.isAtEnd()) {
-        const implToken = this.current()
-        if (!implToken || implToken.type !== TokenType.IDENTIFIER) break
-        
-        const v = implToken.value.toLowerCase()
-        if (v === '{' || this.peek()?.type === TokenType.LBRACE) break
-        
-        implements_.push(implToken.value)
-        this.advance()
-        
-        if (!this.match(TokenType.AMPERSAND) && !this.match(TokenType.COMMA)) break
-      }
-    }
-    
-    this.skipNewlines()
-    const fields = this.parseGraphQLFields()
-    
-    return {
-      type: 'TypeDefinition',
-      name: name,
-      implements: implements_,
-      fields: fields
-    }
-  }
-
-  parseGraphQLInput() {
-    this.advance()
-    
-    const nameToken = this.current()
-    let name = null
-    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
-      name = nameToken.value
-      this.advance()
-    }
-    
-    this.skipNewlines()
-    const fields = this.parseGraphQLFields()
-    
-    return {
-      type: 'InputDefinition',
-      name: name,
-      fields: fields
-    }
-  }
-
-  parseGraphQLEnum() {
-    this.advance()
-    
-    const nameToken = this.current()
-    let name = null
-    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
-      name = nameToken.value
-      this.advance()
-    }
-    
-    const values = []
-    
-    if (this.match(TokenType.LBRACE)) {
-      while (!this.isAtEnd() && !this.match(TokenType.RBRACE)) {
-        this.skipNewlines()
-        const valToken = this.current()
-        if (valToken && valToken.type === TokenType.IDENTIFIER) {
-          values.push(valToken.value)
-          this.advance()
-        }
-        this.skipNewlines()
-      }
-    } else {
-      this.skipNewlines()
-      this.match(TokenType.INDENT)
-      
-      while (!this.isAtEnd()) {
-        const current = this.current()
-        
-        if (current && current.type === TokenType.DEDENT) {
-          this.advance()
-          break
-        }
-        
-        if (current && current.type === TokenType.NEWLINE) {
-          this.advance()
-          continue
-        }
-        
-        if (current && current.type === TokenType.IDENTIFIER) {
-          values.push(current.value)
-          this.advance()
-        }
-      }
-    }
-    
-    return {
-      type: 'EnumDefinition',
-      name: name,
-      values: values
-    }
-  }
-
-  parseGraphQLInterface() {
-    this.advance()
-    
-    const nameToken = this.current()
-    let name = null
-    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
-      name = nameToken.value
-      this.advance()
-    }
-    
-    this.skipNewlines()
-    const fields = this.parseGraphQLFields()
-    
-    return {
-      type: 'InterfaceDefinition',
-      name: name,
-      fields: fields
-    }
-  }
-
-  parseGraphQLFields() {
-    const fields = []
-    
-    if (this.match(TokenType.LBRACE)) {
-      while (!this.isAtEnd() && !this.match(TokenType.RBRACE)) {
-        this.skipNewlines()
-        const field = this.parseGraphQLField()
-        if (field) {
-          fields.push(field)
-        }
-        this.skipNewlines()
-      }
-    } else {
-      this.skipNewlines()
-      this.match(TokenType.INDENT)
-      
-      while (!this.isAtEnd()) {
-        const current = this.current()
-        
-        if (current && current.type === TokenType.DEDENT) {
-          this.advance()
-          break
-        }
-        
-        if (current && current.type === TokenType.NEWLINE) {
-          this.advance()
-          continue
-        }
-        
-        const field = this.parseGraphQLField()
-        if (field) {
-          fields.push(field)
-        }
-      }
-    }
-    
-    return fields
-  }
-
-  parseGraphQLField() {
-    const nameToken = this.current()
-    if (!nameToken || nameToken.type !== TokenType.IDENTIFIER) {
-      return null
-    }
-    const name = nameToken.value
-    this.advance()
-    
-    const args = []
-    if (this.match(TokenType.LPAREN)) {
-      while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
-        const arg = this.parseGraphQLArg()
-        if (arg) {
-          args.push(arg)
-        }
-        this.match(TokenType.COMMA)
-      }
-    }
-    
-    this.match(TokenType.COLON)
-    
-    const fieldType = this.parseGraphQLTypeRef()
-    
-    const directives = []
-    while (this.match(TokenType.AT)) {
-      const dirToken = this.current()
-      if (dirToken && dirToken.type === TokenType.IDENTIFIER) {
-        directives.push(dirToken.value)
-        this.advance()
-      }
-    }
-    
-    return {
-      name: name,
-      args: args,
-      type: fieldType,
-      directives: directives
-    }
-  }
-
-  parseGraphQLArg() {
-    const nameToken = this.current()
-    if (!nameToken || nameToken.type !== TokenType.IDENTIFIER) {
-      return null
-    }
-    const name = nameToken.value
-    this.advance()
-    
-    this.match(TokenType.COLON)
-    
-    const argType = this.parseGraphQLTypeRef()
-    
-    let defaultValue = null
-    if (this.match(TokenType.EQUALS)) {
-      const valToken = this.current()
-      if (valToken) {
-        if (valToken.type === TokenType.STRING) {
-          defaultValue = valToken.value
-        } else if (valToken.type === TokenType.NUMBER || valToken.type === TokenType.INTEGER) {
-          defaultValue = parseFloat(valToken.value)
-        } else if (valToken.type === TokenType.IDENTIFIER) {
-          defaultValue = valToken.value
-        }
-        this.advance()
-      }
-    }
-    
-    return {
-      name: name,
-      type: argType,
-      default: defaultValue
-    }
-  }
-
-  parseGraphQLTypeRef() {
-    let isArray = false
-    
-    if (this.match(TokenType.LBRACKET)) {
-      isArray = true
-    }
-    
-    const typeToken = this.current()
-    let typeName = 'String'
-    if (typeToken && typeToken.type === TokenType.IDENTIFIER) {
-      typeName = this.translateGraphQLType(typeToken.value)
-      this.advance()
-    }
-    
-    let isRequired = false
-    if (this.match(TokenType.BANG)) {
-      isRequired = true
-    }
-    
-    if (isArray) {
-      this.match(TokenType.RBRACKET)
-      if (this.match(TokenType.BANG)) {
-        isRequired = true
-      }
-    }
-    
-    return {
-      name: typeName,
-      isArray: isArray,
-      isRequired: isRequired
-    }
-  }
-
-  translateGraphQLType(value) {
-    const lower = value.toLowerCase()
-    
-    const types = {
-      'chaine': 'String',
-      'texte': 'String',
-      'entier': 'Int',
-      'nombre': 'Int',
-      'flottant': 'Float',
-      'decimal': 'Float',
-      'booleen': 'Boolean',
-      'identifiant': 'ID',
-      'id': 'ID'
-    }
-    
-    return types[lower] || value
-  }
-
-  parseGraphQLQuery() {
-    this.advance()
-    
-    const nameToken = this.current()
-    let name = null
-    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
-      name = nameToken.value
-      this.advance()
-    }
-    
-    const args = []
-    if (this.match(TokenType.LPAREN)) {
-      while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
-        const arg = this.parseGraphQLArg()
-        if (arg) {
-          args.push(arg)
-        }
-        this.match(TokenType.COMMA)
-      }
-    }
-    
-    this.match(TokenType.COLON)
-    const returnType = this.parseGraphQLTypeRef()
-    
-    return {
-      type: 'QueryDefinition',
-      name: name,
-      args: args,
-      returnType: returnType
-    }
-  }
-
-  parseGraphQLMutation() {
-    this.advance()
-    
-    const nameToken = this.current()
-    let name = null
-    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
-      name = nameToken.value
-      this.advance()
-    }
-    
-    const args = []
-    if (this.match(TokenType.LPAREN)) {
-      while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
-        const arg = this.parseGraphQLArg()
-        if (arg) {
-          args.push(arg)
-        }
-        this.match(TokenType.COMMA)
-      }
-    }
-    
-    this.match(TokenType.COLON)
-    const returnType = this.parseGraphQLTypeRef()
-    
-    return {
-      type: 'MutationDefinition',
-      name: name,
-      args: args,
-      returnType: returnType
-    }
-  }
-
-  parseGraphQLSubscription() {
-    this.advance()
-    
-    const nameToken = this.current()
-    let name = null
-    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
-      name = nameToken.value
-      this.advance()
-    }
-    
-    const args = []
-    if (this.match(TokenType.LPAREN)) {
-      while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
-        const arg = this.parseGraphQLArg()
-        if (arg) {
-          args.push(arg)
-        }
-        this.match(TokenType.COMMA)
-      }
-    }
-    
-    this.match(TokenType.COLON)
-    const returnType = this.parseGraphQLTypeRef()
-    
-    return {
-      type: 'SubscriptionDefinition',
-      name: name,
-      args: args,
-      returnType: returnType
-    }
-  }
-
-  parseGraphQLSchema() {
-    this.advance()
-    
-    const operations = {}
-    
-    if (this.match(TokenType.LBRACE)) {
-      while (!this.isAtEnd() && !this.match(TokenType.RBRACE)) {
-        this.skipNewlines()
-        const opToken = this.current()
-        
-        if (opToken && opToken.type === TokenType.IDENTIFIER) {
-          const op = opToken.value.toLowerCase()
-          this.advance()
-          
-          this.match(TokenType.COLON)
-          
-          const typeToken = this.current()
-          if (typeToken && typeToken.type === TokenType.IDENTIFIER) {
-            if (op === 'query' || op === 'requete') {
-              operations.query = typeToken.value
-            } else if (op === 'mutation') {
-              operations.mutation = typeToken.value
-            } else if (op === 'subscription' || op === 'abonnement') {
-              operations.subscription = typeToken.value
-            }
-            this.advance()
-          }
-        }
-        
-        this.skipNewlines()
-      }
-    }
-    
-    return {
-      type: 'SchemaDefinition',
-      operations: operations
-    }
-  }
-}
-
-module.exports = {
-  EtherParser
-}