ether-code 0.1.7 → 0.1.9

package/ether-parser.js

@@ -0,0 +1,3059 @@
+const fs = require('fs')
+const { EtherLexer, Token, TokenType } = require('./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')
+  }
+
+  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()
+    if (tokenVal === value.toLowerCase()) {
+      return this.advance()
+    }
+    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()
+    
+    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 rule = this.parseCSSRule()
+      if (rule) {
+        stylesheet.rules.push(rule)
+      }
+      this.skipNewlines()
+    }
+    
+    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)
+      }
+    }
+    
+    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.COLON || token.type === TokenType.EOF) {
+        break
+      }
+      
+      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 {
+        break
+      }
+    }
+    
+    return parts.join(' ').replace(/\s+([,>+~])\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': 'h1',
+      'paragraphe': 'p',
+      'lien': 'a',
+      '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 property = token.value
+    this.advance()
+    
+    let hasColon = this.match(TokenType.COLON)
+    let hasEquals = !hasColon && this.match(TokenType.EQUALS)
+    
+    if (!hasColon && !hasEquals) {
+      return null
+    }
+    
+    const valueParts = []
+    
+    while (!this.isAtEnd()) {
+      const current = this.current()
+      
+      if (!current || current.type === TokenType.NEWLINE || 
+          current.type === TokenType.DEDENT || current.type === TokenType.EOF) {
+        break
+      }
+      
+      if (current.type === TokenType.IDENTIFIER) {
+        valueParts.push(current.value)
+      } else if (current.type === TokenType.NUMBER || current.type === TokenType.INTEGER || 
+                 current.type === TokenType.FLOAT) {
+        valueParts.push(current.value)
+      } else if (current.type === TokenType.STRING) {
+        valueParts.push(current.value)
+      } else if (current.type === TokenType.HEX || current.type === TokenType.HASH) {
+        const next = this.peek(1)
+        if (next && (next.type === TokenType.IDENTIFIER || next.type === TokenType.NUMBER)) {
+          this.advance()
+          valueParts.push('#' + next.value)
+        } else {
+          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) {
+        valueParts.push('/')
+      } else {
+        break
+      }
+      
+      this.advance()
+    }
+    
+    return {
+      type: 'Declaration',
+      property: property,
+      value: valueParts.join(' ').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)
+      }
+    }
+    
+    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') {
+      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) {
+    return query
+      .replace(/ecran/gi, 'screen')
+      .replace(/imprimante/gi, 'print')
+      .replace(/tous/gi, 'all')
+      .replace(/largeur min/gi, 'min-width')
+      .replace(/largeur max/gi, 'max-width')
+      .replace(/hauteur min/gi, 'min-height')
+      .replace(/hauteur max/gi, 'max-height')
+      .replace(/orientation/gi, 'orientation')
+      .replace(/paysage/gi, 'landscape')
+      .replace(/portrait/gi, 'portrait')
+      .replace(/et/gi, 'and')
+      .replace(/ou/gi, 'or')
+      .replace(/pas/gi, 'not')
+  }
+
+  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()
+    const tag = this.translateHTMLTag(tagToken.value)
+    this.advance()
+    
+    const attributes = {}
+    let inlineText = null
+    
+    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) {
+        const attrName = current.value
+        const nextToken = this.peek(1)
+        
+        if (nextToken && (nextToken.type === TokenType.EQUALS || nextToken.type === TokenType.COLON)) {
+          this.advance()
+          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) {
+              attributes[attrName] = valueToken.value
+            }
+            this.advance()
+          }
+        } else {
+          attributes[attrName] = true
+          this.advance()
+        }
+      } else {
+        break
+      }
+    }
+    
+    this.skipNewlines()
+    
+    const children = []
+    
+    if (inlineText) {
+      children.push({
+        type: 'Text',
+        content: inlineText
+      })
+    }
+    
+    if (this.match(TokenType.INDENT)) {
+      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()
+      }
+    }
+    
+    return {
+      type: 'Element',
+      tag: tag,
+      attributes: attributes,
+      children: children
+    }
+  }
+
+  translateHTMLTag(tag) {
+    const map = this.reverseMaps.html || {}
+    const lower = tag.toLowerCase()
+    
+    const translations = {
+      'document': 'html',
+      'page': 'html',
+      'tete': 'head',
+      'corps': 'body',
+      'entete': 'header',
+      'piedpage': 'footer',
+      'navigation': 'nav',
+      'principal': 'main',
+      'section': 'section',
+      'article': 'article',
+      'cote': 'aside',
+      'titre': 'h1',
+      'titre1': 'h1',
+      'titre2': 'h2',
+      'titre3': 'h3',
+      'titre4': 'h4',
+      'titre5': 'h5',
+      'titre6': 'h6',
+      'sous titre': 'h2',
+      'paragraphe': 'p',
+      'texte': 'span',
+      'division': 'div',
+      'bloc': 'div',
+      'lien': 'a',
+      'image': 'img',
+      'liste': 'ul',
+      'liste ordonnee': 'ol',
+      'element': 'li',
+      'tableau': 'table',
+      'ligne': 'tr',
+      'cellule': 'td',
+      'entete cellule': 'th',
+      'formulaire': 'form',
+      'champ': 'input',
+      'zone texte': 'textarea',
+      'bouton': 'button',
+      'selection': 'select',
+      'option': 'option',
+      'etiquette': 'label',
+      'gras': 'strong',
+      'italique': 'em',
+      'souligne': 'u',
+      'barre': 's',
+      'code': 'code',
+      'preformate': 'pre',
+      'citation': 'blockquote',
+      'retour ligne': 'br',
+      'saut ligne': 'br',
+      'ligne horizontale': 'hr',
+      'video': 'video',
+      'audio': 'audio',
+      'source': 'source',
+      'cadre': 'iframe',
+      'canvas': 'canvas',
+      'toile': 'canvas',
+      'figure': 'figure',
+      'legende': 'figcaption',
+      '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',
+      'carte': 'map',
+      'zone': 'area'
+    }
+    
+    return translations[lower] || map[lower] || tag
+  }
+
+  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)
+    }
+    
+    return this.parseExpression(lang)
+  }
+
+  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()
+    
+    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)) {
+        const param = this.parseParameter(lang)
+        if (param) {
+          params.push(param)
+        }
+        this.match(TokenType.COMMA)
+      }
+    } 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
+    }
+  }
+
+  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',
+      'date': 'Date',
+      '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) {
+    const keyword = 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)
+      } 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) {
+    this.advance()
+    
+    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()
+    }
+    
+    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 = []
+    
+    if (this.match(TokenType.INDENT)) {
+      while (!this.isAtEnd()) {
+        const current = this.current()
+        
+        if (current && current.type === TokenType.DEDENT) {
+          this.advance()
+          break
+        }
+        
+        const statement = this.parseStatement(lang)
+        if (statement) {
+          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.match(TokenType.DOUBLE_EQUALS) || this.matchValue('egal') || this.matchValue('egale')) {
+        const right = this.parseComparison(lang)
+        left = { type: 'BinaryExpression', operator: '===', left, right }
+      } else if (this.match(TokenType.NOT_EQUALS) || this.matchValue('different')) {
+        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.match(TokenType.LT) || this.matchValue('inferieur')) {
+        const right = this.parseAdditive(lang)
+        left = { type: 'BinaryExpression', operator: '<', left, right }
+      } else if (this.match(TokenType.GT) || this.matchValue('superieur')) {
+        const right = this.parseAdditive(lang)
+        left = { type: 'BinaryExpression', operator: '>', left, right }
+      } else if (this.match(TokenType.LTE) || this.matchValue('inferieur ou egal')) {
+        const right = this.parseAdditive(lang)
+        left = { type: 'BinaryExpression', operator: '<=', left, right }
+      } else if (this.match(TokenType.GTE) || this.matchValue('superieur ou egal')) {
+        const right = this.parseAdditive(lang)
+        left = { type: 'BinaryExpression', operator: '>=', left, right }
+      } else {
+        break
+      }
+    }
+    
+    return left
+  }
+
+  parseAdditive(lang) {
+    let left = this.parseMultiplicative(lang)
+    
+    while (true) {
+      if (this.match(TokenType.PLUS) || this.matchValue('plus')) {
+        const right = this.parseMultiplicative(lang)
+        left = { type: 'BinaryExpression', operator: '+', left, right }
+      } else if (this.match(TokenType.MINUS) || this.matchValue('moins')) {
+        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')) {
+        const right = this.parseUnary(lang)
+        left = { type: 'BinaryExpression', operator: '*', left, right }
+      } else if (this.match(TokenType.SLASH) || this.matchValue('divise')) {
+        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 {
+        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 }
+    }
+    
+    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)) {
+          args.push(this.parseExpression(lang))
+          this.match(TokenType.COMMA)
+        }
+        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: 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 === '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 }
+      }
+      
+      this.advance()
+      return { type: 'Identifier', name: 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)
+      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: 'ArrayLiteral', elements }
+  }
+
+  parseObjectLiteral(lang) {
+    this.expect(TokenType.LBRACE)
+    const properties = []
+    
+    while (!this.isAtEnd() && !this.match(TokenType.RBRACE)) {
+      const keyToken = this.current()
+      if (!keyToken) break
+      
+      let key
+      if (keyToken.type === TokenType.STRING) {
+        key = keyToken.value.replace(/^["']|["']$/g, '')
+      } else if (keyToken.type === TokenType.IDENTIFIER) {
+        key = keyToken.value
+      } else {
+        break
+      }
+      this.advance()
+      
+      this.match(TokenType.COLON) || this.match(TokenType.EQUALS)
+      
+      const value = this.parseExpression(lang)
+      properties.push({ key, value })
+      
+      this.match(TokenType.COMMA)
+    }
+    
+    return { type: 'ObjectLiteral', properties }
+  }
+
+  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
+}