ether-code 0.7.8 → 0.8.0

package/parsers/ether-parser-js.js

@@ -0,0 +1,1262 @@
+const { EtherParserBase, TokenType } = require('./ether-parser-base')
+
+class EtherParserJS extends EtherParserBase {
+  constructor(options = {}) {
+    super(options)
+    this.initJSTranslations()
+    this.loadI18n(['i18n-js.json', 'i18n-ts.json', 'i18n-react.json', 'i18n-node.json', 'i18n-php.json'])
+  }
+
+  initJSTranslations() {
+    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'
+    }
+  }
+
+  translateJSIdentifier(word) {
+    if (!word) return word
+    const lower = this.normalizeAccents(String(word))
+    return this.jsTranslations[lower] || word
+  }
+
+  parse(source, lang = 'js') {
+    this.tokenize(source)
+    return this.parseProgram(lang)
+  }
+
+  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.isTry(value)) {
+      return this.parseTryStatement(lang)
+    }
+    
+    if (this.isThrow(value)) {
+      return this.parseThrowStatement(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', 'while', 'faire', 'do', 'repeter', 'boucle', 'loop', 'chaque', 'each', 'foreach']
+    if (keywords.includes(value)) return true
+    
+    if (value === 'tant') {
+      const next = this.peek(1)
+      if (next && this.normalizeAccents(String(next.value).toLowerCase()) === 'que') {
+        return true
+      }
+    }
+    
+    if (value === 'pour') {
+      const next = this.peek(1)
+      if (next && this.normalizeAccents(String(next.value).toLowerCase()) === 'chaque') {
+        return true
+      }
+    }
+    
+    return false
+  }
+
+  isTry(value) {
+    return ['essayer', 'try'].includes(value)
+  }
+
+  isThrow(value) {
+    return ['lancer', 'throw'].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 kindValue = kindToken.value.toLowerCase()
+    
+    let kind = 'let'
+    if (kindValue === 'constante' || kindValue === 'const') {
+      kind = 'const'
+    } else if (kindValue === 'var' || kindValue === 'variable globale') {
+      kind = 'var'
+    }
+    
+    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
+    }
+  }
+
+  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
+    }
+  }
+
+  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.parseClassBody(lang)
+    
+    return {
+      type: 'ClassDeclaration',
+      name: name,
+      extends: extends_,
+      implements: implements_,
+      body: body
+    }
+  }
+
+  parseClassBody(lang) {
+    const methods = []
+    
+    this.skipNewlines()
+    
+    if (!this.match(TokenType.INDENT)) {
+      return { type: 'ClassBody', body: methods }
+    }
+    
+    while (!this.isAtEnd()) {
+      this.skipNewlines()
+      
+      const current = this.current()
+      
+      if (current && current.type === TokenType.DEDENT) {
+        this.advance()
+        break
+      }
+      
+      if (current && (current.type === TokenType.INDENT || current.type === TokenType.NEWLINE)) {
+        this.advance()
+        continue
+      }
+      
+      const method = this.parseClassMember(lang)
+      if (method) {
+        methods.push(method)
+      }
+      
+      this.skipNewlines()
+    }
+    
+    return { type: 'ClassBody', body: methods }
+  }
+
+  parseClassMember(lang) {
+    let isStatic = false
+    let kind = 'method'
+    
+    const current = this.current()
+    if (!current || current.type !== TokenType.IDENTIFIER) {
+      return null
+    }
+    
+    const val = this.normalizeAccents(current.value.toLowerCase())
+    
+    if (val === 'statique' || val === 'static') {
+      isStatic = true
+      this.advance()
+    }
+    
+    const nameToken = this.current()
+    if (!nameToken || nameToken.type !== TokenType.IDENTIFIER) {
+      return null
+    }
+    
+    let name = nameToken.value
+    const nameLower = this.normalizeAccents(name.toLowerCase())
+    
+    if (nameLower === 'constructeur' || nameLower === 'constructor') {
+      name = 'constructor'
+      kind = 'constructor'
+    } else if (nameLower === 'obtenir' || nameLower === 'get') {
+      kind = 'get'
+      this.advance()
+      const actualName = this.current()
+      if (actualName && actualName.type === TokenType.IDENTIFIER) {
+        name = actualName.value
+      }
+    } else if (nameLower === 'definir' || nameLower === 'set') {
+      kind = 'set'
+      this.advance()
+      const actualName = this.current()
+      if (actualName && actualName.type === TokenType.IDENTIFIER) {
+        name = actualName.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)) {}
+      }
+    }
+    
+    this.skipNewlines()
+    const body = this.parseBlock(lang)
+    
+    return {
+      type: 'MethodDefinition',
+      key: { type: 'Identifier', name: name },
+      kind: kind,
+      static: isStatic,
+      params: params,
+      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()
+    let keywordValue = keyword.value.toLowerCase()
+    
+    if (keywordValue === 'tant') {
+      const next = this.current()
+      if (next && this.normalizeAccents(String(next.value).toLowerCase()) === 'que') {
+        this.advance()
+        keywordValue = 'tant que'
+      }
+    }
+    
+    if (keywordValue === 'pour') {
+      const next = this.current()
+      if (next && this.normalizeAccents(String(next.value).toLowerCase()) === 'chaque') {
+        this.advance()
+        keywordValue = 'pour chaque'
+      }
+    }
+    
+    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 kind = 'of'
+    
+    const varToken = this.current()
+    if (varToken && varToken.type === TokenType.IDENTIFIER) {
+      variable = varToken.value
+      this.advance()
+    }
+    
+    if (this.matchValue('dans') || this.matchValue('in')) {
+      kind = 'in'
+    } else if (this.matchValue('de') || this.matchValue('of')) {
+      kind = 'of'
+    }
+    
+    iterable = this.parseExpression(lang)
+    
+    this.skipNewlines()
+    const body = this.parseBlock(lang)
+    
+    return {
+      type: 'ForOfStatement',
+      left: { type: 'Identifier', name: variable },
+      right: iterable,
+      body: body,
+      kind: kind
+    }
+  }
+
+  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',
+      body: body,
+      condition: condition
+    }
+  }
+
+  parseTryStatement(lang) {
+    this.advance()
+    this.skipNewlines()
+    
+    const block = this.parseBlock(lang)
+    
+    let handler = null
+    this.skipNewlines()
+    
+    const current = this.current()
+    if (current && current.type === TokenType.IDENTIFIER) {
+      const val = this.normalizeAccents(current.value.toLowerCase())
+      if (val === 'attraper' || val === 'catch') {
+        this.advance()
+        
+        let param = null
+        const paramToken = this.current()
+        if (paramToken && paramToken.type === TokenType.IDENTIFIER) {
+          param = { type: 'Identifier', name: paramToken.value }
+          this.advance()
+        }
+        
+        this.skipNewlines()
+        const catchBlock = this.parseBlock(lang)
+        
+        handler = {
+          type: 'CatchClause',
+          param: param,
+          body: catchBlock
+        }
+      }
+    }
+    
+    let finalizer = null
+    this.skipNewlines()
+    
+    const finallyToken = this.current()
+    if (finallyToken && finallyToken.type === TokenType.IDENTIFIER) {
+      const val = this.normalizeAccents(finallyToken.value.toLowerCase())
+      if (val === 'finalement' || val === 'finally') {
+        this.advance()
+        this.skipNewlines()
+        finalizer = this.parseBlock(lang)
+      }
+    }
+    
+    return {
+      type: 'TryStatement',
+      block: block,
+      handler: handler,
+      finalizer: finalizer
+    }
+  }
+
+  parseThrowStatement(lang) {
+    this.advance()
+    const argument = this.parseExpression(lang)
+    return {
+      type: 'ThrowStatement',
+      argument: argument
+    }
+  }
+
+  parseReturn(lang) {
+    this.advance()
+    
+    const current = this.current()
+    if (!current || current.type === TokenType.NEWLINE || current.type === TokenType.DEDENT) {
+      return { type: 'ReturnStatement', value: null }
+    }
+    
+    const value = this.parseExpression(lang)
+    return {
+      type: 'ReturnStatement',
+      value: value
+    }
+  }
+
+  parseImport(lang) {
+    this.advance()
+    
+    const imports = []
+    let defaultImport = null
+    let namespaceImport = null
+    let source = null
+    
+    const first = this.current()
+    if (first && first.type === TokenType.IDENTIFIER) {
+      const val = first.value.toLowerCase()
+      
+      if (val !== 'depuis' && val !== 'from' && val !== 'de') {
+        if (this.peek(1) && this.peek(1).type === TokenType.COMMA) {
+          defaultImport = first.value
+          this.advance()
+          this.match(TokenType.COMMA)
+        } else if (this.peek(1) && (this.peek(1).value?.toLowerCase() === 'depuis' || this.peek(1).value?.toLowerCase() === 'from')) {
+          defaultImport = first.value
+          this.advance()
+        } else {
+          imports.push({ type: 'ImportSpecifier', imported: first.value, local: first.value })
+          this.advance()
+          
+          while (this.match(TokenType.COMMA)) {
+            const next = this.current()
+            if (next && next.type === TokenType.IDENTIFIER) {
+              imports.push({ type: 'ImportSpecifier', imported: next.value, local: next.value })
+              this.advance()
+            }
+          }
+        }
+      }
+    }
+    
+    if (this.match(TokenType.LBRACE)) {
+      while (!this.isAtEnd() && !this.match(TokenType.RBRACE)) {
+        const specToken = this.current()
+        if (specToken && specToken.type === TokenType.IDENTIFIER) {
+          let imported = specToken.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({ type: 'ImportSpecifier', imported, local })
+        }
+        this.match(TokenType.COMMA)
+      }
+    }
+    
+    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',
+      specifiers: imports,
+      defaultImport: defaultImport,
+      namespaceImport: namespaceImport,
+      source: source
+    }
+  }
+
+  parseExport(lang) {
+    this.advance()
+    
+    let isDefault = false
+    if (this.matchValue('defaut') || this.matchValue('default')) {
+      isDefault = true
+    }
+    
+    const current = this.current()
+    if (!current) return null
+    
+    const value = current.value?.toLowerCase() || ''
+    
+    if (this.isFunctionDeclaration(value)) {
+      const declaration = this.parseFunctionDeclaration(lang)
+      return {
+        type: 'ExportDeclaration',
+        default: isDefault,
+        declaration: declaration
+      }
+    }
+    
+    if (this.isClassDeclaration(value)) {
+      const declaration = this.parseClassDeclaration(lang)
+      return {
+        type: 'ExportDeclaration',
+        default: isDefault,
+        declaration: declaration
+      }
+    }
+    
+    if (this.isVariableDeclaration(value)) {
+      const declaration = this.parseVariableDeclaration(lang)
+      return {
+        type: 'ExportDeclaration',
+        default: isDefault,
+        declaration: declaration
+      }
+    }
+    
+    const expr = this.parseExpression(lang)
+    return {
+      type: 'ExportDeclaration',
+      default: isDefault,
+      declaration: expr
+    }
+  }
+
+  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('attendre') || this.matchValue('await')) {
+      const argument = this.parseUnary(lang)
+      return { type: 'AwaitExpression', argument: argument }
+    }
+    
+    if (this.matchValue('ceder') || this.matchValue('yield')) {
+      const argument = this.parseExpression(lang)
+      return { type: 'YieldExpression', argument: argument, delegate: false }
+    }
+    
+    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)) {
+      while (this.match(TokenType.NEWLINE) || this.match(TokenType.INDENT) || this.match(TokenType.DEDENT)) {}
+      if (this.check(TokenType.RBRACKET)) break
+      
+      if (this.match(TokenType.SPREAD)) {
+        const argument = this.parseExpression(lang)
+        elements.push({ type: 'SpreadElement', argument })
+      } else {
+        elements.push(this.parseExpression(lang))
+      }
+      this.match(TokenType.COMMA)
+      while (this.match(TokenType.NEWLINE) || this.match(TokenType.INDENT) || this.match(TokenType.DEDENT)) {}
+    }
+    
+    return { type: 'ArrayExpression', elements }
+  }
+
+  parseObjectLiteral(lang) {
+    this.expect(TokenType.LBRACE)
+    const properties = []
+    
+    this.skipWhitespace()
+    
+    while (!this.isAtEnd() && !this.check(TokenType.RBRACE)) {
+      this.skipWhitespace()
+      
+      if (this.match(TokenType.SPREAD)) {
+        const argument = this.parseExpression(lang)
+        properties.push({ type: 'SpreadElement', argument })
+        this.match(TokenType.COMMA)
+        this.skipWhitespace()
+        continue
+      }
+      
+      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 }
+  }
+}
+
+module.exports = { EtherParserJS }