ether-code 0.1.9 → 0.2.3

package/lexer/ether-lexer.js

@@ -0,0 +1,869 @@
+class Token {
+  constructor(type, value, line, column, indent = 0) {
+    this.type = type
+    this.value = value
+    this.line = line
+    this.column = column
+    this.indent = indent
+  }
+
+  toString() {
+    return `Token(${this.type}, ${JSON.stringify(this.value)}, L${this.line}:${this.column})`
+  }
+}
+
+const TokenType = {
+  IDENTIFIER: 'IDENTIFIER',
+  STRING: 'STRING',
+  BLOCK_STRING: 'BLOCK_STRING',
+  NUMBER: 'NUMBER',
+  INTEGER: 'INTEGER',
+  FLOAT: 'FLOAT',
+  HEX: 'HEX',
+  
+  COLON: 'COLON',
+  DOUBLE_COLON: 'DOUBLE_COLON',
+  EQUALS: 'EQUALS',
+  DOUBLE_EQUALS: 'DOUBLE_EQUALS',
+  NOT_EQUALS: 'NOT_EQUALS',
+  COMMA: 'COMMA',
+  DOT: 'DOT',
+  SPREAD: 'SPREAD',
+  ARROW: 'ARROW',
+  FAT_ARROW: 'FAT_ARROW',
+  
+  PLUS: 'PLUS',
+  MINUS: 'MINUS',
+  STAR: 'STAR',
+  DOUBLE_STAR: 'DOUBLE_STAR',
+  SLASH: 'SLASH',
+  DOUBLE_SLASH: 'DOUBLE_SLASH',
+  PERCENT: 'PERCENT',
+  
+  BANG: 'BANG',
+  QUESTION: 'QUESTION',
+  AMPERSAND: 'AMPERSAND',
+  DOUBLE_AMPERSAND: 'DOUBLE_AMPERSAND',
+  PIPE: 'PIPE',
+  DOUBLE_PIPE: 'DOUBLE_PIPE',
+  CARET: 'CARET',
+  TILDE: 'TILDE',
+  
+  LT: 'LT',
+  GT: 'GT',
+  LTE: 'LTE',
+  GTE: 'GTE',
+  SPACESHIP: 'SPACESHIP',
+  
+  AT: 'AT',
+  HASH: 'HASH',
+  UNDERSCORE: 'UNDERSCORE',
+  BACKSLASH: 'BACKSLASH',
+  
+  LPAREN: 'LPAREN',
+  RPAREN: 'RPAREN',
+  LBRACKET: 'LBRACKET',
+  RBRACKET: 'RBRACKET',
+  LBRACE: 'LBRACE',
+  RBRACE: 'RBRACE',
+  
+  NEWLINE: 'NEWLINE',
+  INDENT: 'INDENT',
+  DEDENT: 'DEDENT',
+  
+  LANG_BLOCK: 'LANG_BLOCK',
+  
+  COMMENT: 'COMMENT',
+  BLOCK_COMMENT: 'BLOCK_COMMENT',
+  
+  EOF: 'EOF',
+  ERROR: 'ERROR'
+}
+
+const LANG_BLOCKS = [
+  'html', 'css', 'style', 'script', 'js', 'javascript',
+  'php', 'python', 'py', 'ruby', 'rb',
+  'sql', 'graphql', 'gql',
+  'node', 'nodejs', 'ts', 'typescript',
+  'react', 'jsx', 'tsx',
+  'json', 'xml', 'yaml', 'markdown', 'md'
+]
+
+class EtherLexer {
+  constructor(source, options = {}) {
+    this.source = source
+    this.pos = 0
+    this.line = 1
+    this.column = 1
+    this.tokens = []
+    this.indentStack = [0]
+    this.currentIndent = 0
+    this.atLineStart = true
+    
+    this.options = {
+      trackComments: options.trackComments || false,
+      allowUnicode: options.allowUnicode !== false,
+      tabSize: options.tabSize || 2
+    }
+  }
+
+  peek(offset = 0) {
+    const idx = this.pos + offset
+    return idx < this.source.length ? this.source[idx] : null
+  }
+
+  advance() {
+    const char = this.source[this.pos]
+    this.pos++
+    if (char === '\n') {
+      this.line++
+      this.column = 1
+      this.atLineStart = true
+    } else {
+      this.column++
+    }
+    return char
+  }
+
+  match(expected) {
+    if (this.peek() === expected) {
+      this.advance()
+      return true
+    }
+    return false
+  }
+
+  matchSequence(seq) {
+    for (let i = 0; i < seq.length; i++) {
+      if (this.peek(i) !== seq[i]) return false
+    }
+    for (let i = 0; i < seq.length; i++) {
+      this.advance()
+    }
+    return true
+  }
+
+  isAtEnd() {
+    return this.pos >= this.source.length
+  }
+
+  isDigit(char) {
+    if (!char) return false
+    return char >= '0' && char <= '9'
+  }
+
+  isHexDigit(char) {
+    if (!char) return false
+    return this.isDigit(char) || (char >= 'a' && char <= 'f') || (char >= 'A' && char <= 'F')
+  }
+
+  isAlpha(char) {
+    if (!char) return false
+    const code = char.charCodeAt(0)
+    if ((code >= 65 && code <= 90) || (code >= 97 && code <= 122)) return true
+    if (char === '_') return true
+    if (this.options.allowUnicode) {
+      if (code >= 0x00C0 && code <= 0x024F) return true
+      if (code >= 0x0400 && code <= 0x04FF) return true
+      if (code >= 0x4E00 && code <= 0x9FFF) return true
+      if (code >= 0x3040 && code <= 0x30FF) return true
+      if (code >= 0x0600 && code <= 0x06FF) return true
+      if (code >= 0x0370 && code <= 0x03FF) return true
+    }
+    return false
+  }
+
+  isAlphaNumeric(char) {
+    return this.isAlpha(char) || this.isDigit(char)
+  }
+
+  isWhitespace(char) {
+    if (!char) return false
+    return char === ' ' || char === '\t' || char === '\r'
+  }
+
+  addToken(type, value, startColumn = null) {
+    const col = startColumn !== null ? startColumn : this.column
+    this.tokens.push(new Token(type, value, this.line, col, this.currentIndent))
+  }
+
+  tokenize() {
+    while (!this.isAtEnd()) {
+      this.scanToken()
+    }
+
+    while (this.indentStack.length > 1) {
+      this.indentStack.pop()
+      this.tokens.push(new Token(TokenType.DEDENT, '', this.line, this.column, 0))
+    }
+
+    this.tokens.push(new Token(TokenType.EOF, '', this.line, this.column, 0))
+    return this.tokens
+  }
+
+  scanToken() {
+    if (this.atLineStart) {
+      this.handleIndentation()
+      if (this.isAtEnd()) return
+    }
+
+    const char = this.peek()
+
+    if (char === '\n') {
+      this.advance()
+      this.addToken(TokenType.NEWLINE, '\n')
+      return
+    }
+
+    if (this.isWhitespace(char)) {
+      this.advance()
+      return
+    }
+
+    if (char === '#') {
+      this.scanComment()
+      return
+    }
+
+    if (char === '/' && this.peek(1) === '/') {
+      this.scanComment()
+      return
+    }
+
+    if (char === '/' && this.peek(1) === '*') {
+      this.scanBlockComment()
+      return
+    }
+
+    if (char === '"' || char === "'") {
+      this.scanString(char)
+      return
+    }
+
+    if (char === '`') {
+      this.scanTemplateString()
+      return
+    }
+
+    if (this.isDigit(char) || (char === '-' && this.isDigit(this.peek(1)))) {
+      this.scanNumber()
+      return
+    }
+
+    if (this.isAlpha(char)) {
+      this.scanIdentifier()
+      return
+    }
+
+    this.scanOperator()
+  }
+
+  handleIndentation() {
+    let indent = 0
+    while (!this.isAtEnd() && (this.peek() === ' ' || this.peek() === '\t')) {
+      if (this.peek() === '\t') {
+        indent += this.options.tabSize
+      } else {
+        indent++
+      }
+      this.advance()
+    }
+
+    if (this.isAtEnd() || this.peek() === '\n' || this.peek() === '#') {
+      this.atLineStart = false
+      return
+    }
+
+    if (this.peek() === '/' && this.peek(1) === '/') {
+      this.atLineStart = false
+      return
+    }
+
+    this.currentIndent = indent
+    this.atLineStart = false
+
+    const currentLevel = this.indentStack[this.indentStack.length - 1]
+
+    if (indent > currentLevel) {
+      this.indentStack.push(indent)
+      this.tokens.push(new Token(TokenType.INDENT, indent, this.line, 1, indent))
+    } else if (indent < currentLevel) {
+      while (this.indentStack.length > 1 && this.indentStack[this.indentStack.length - 1] > indent) {
+        this.indentStack.pop()
+        this.tokens.push(new Token(TokenType.DEDENT, '', this.line, 1, indent))
+      }
+      if (this.indentStack[this.indentStack.length - 1] !== indent) {
+        this.tokens.push(new Token(TokenType.ERROR, 'Indentation incohérente', this.line, 1, indent))
+      }
+    }
+  }
+
+  scanComment() {
+    const startLine = this.line
+    const startCol = this.column
+    let comment = ''
+
+    if (this.peek() === '#') {
+      this.advance()
+    } else {
+      this.advance()
+      this.advance()
+    }
+
+    while (!this.isAtEnd() && this.peek() !== '\n') {
+      comment += this.advance()
+    }
+
+    if (this.options.trackComments) {
+      this.tokens.push(new Token(TokenType.COMMENT, comment.trim(), startLine, startCol, this.currentIndent))
+    }
+  }
+
+  scanBlockComment() {
+    const startLine = this.line
+    const startCol = this.column
+    let comment = ''
+
+    this.advance()
+    this.advance()
+
+    while (!this.isAtEnd()) {
+      if (this.peek() === '*' && this.peek(1) === '/') {
+        this.advance()
+        this.advance()
+        break
+      }
+      comment += this.advance()
+    }
+
+    if (this.options.trackComments) {
+      this.tokens.push(new Token(TokenType.BLOCK_COMMENT, comment.trim(), startLine, startCol, this.currentIndent))
+    }
+  }
+
+  scanString(quote) {
+    const startLine = this.line
+    const startCol = this.column
+    let value = ''
+    let isBlock = false
+
+    this.advance()
+
+    if (this.peek() === quote && this.peek(1) === quote) {
+      this.advance()
+      this.advance()
+      isBlock = true
+    }
+
+    while (!this.isAtEnd()) {
+      if (isBlock) {
+        if (this.peek() === quote && this.peek(1) === quote && this.peek(2) === quote) {
+          this.advance()
+          this.advance()
+          this.advance()
+          break
+        }
+      } else {
+        if (this.peek() === quote) {
+          this.advance()
+          break
+        }
+        if (this.peek() === '\n') {
+          this.tokens.push(new Token(TokenType.ERROR, 'Chaîne non terminée', startLine, startCol, this.currentIndent))
+          return
+        }
+      }
+
+      if (this.peek() === '\\' && !isBlock) {
+        this.advance()
+        const escaped = this.advance()
+        switch (escaped) {
+          case 'n': value += '\n'; break
+          case 't': value += '\t'; break
+          case 'r': value += '\r'; break
+          case '\\': value += '\\'; break
+          case "'": value += "'"; break
+          case '"': value += '"'; break
+          case '0': value += '\0'; break
+          case 'x':
+            let hex = ''
+            for (let i = 0; i < 2 && this.isHexDigit(this.peek()); i++) {
+              hex += this.advance()
+            }
+            value += String.fromCharCode(parseInt(hex, 16))
+            break
+          case 'u':
+            let unicode = ''
+            if (this.peek() === '{') {
+              this.advance()
+              while (this.isHexDigit(this.peek())) {
+                unicode += this.advance()
+              }
+              if (this.peek() === '}') this.advance()
+            } else {
+              for (let i = 0; i < 4 && this.isHexDigit(this.peek()); i++) {
+                unicode += this.advance()
+              }
+            }
+            value += String.fromCodePoint(parseInt(unicode, 16))
+            break
+          default:
+            value += escaped
+        }
+      } else {
+        value += this.advance()
+      }
+    }
+
+    this.tokens.push(new Token(
+      isBlock ? TokenType.BLOCK_STRING : TokenType.STRING,
+      value,
+      startLine,
+      startCol,
+      this.currentIndent
+    ))
+  }
+
+  scanTemplateString() {
+    const startLine = this.line
+    const startCol = this.column
+    let value = ''
+
+    this.advance()
+
+    while (!this.isAtEnd() && this.peek() !== '`') {
+      if (this.peek() === '\\') {
+        this.advance()
+        value += this.advance()
+      } else {
+        value += this.advance()
+      }
+    }
+
+    if (this.peek() === '`') {
+      this.advance()
+    }
+
+    this.tokens.push(new Token(TokenType.BLOCK_STRING, value, startLine, startCol, this.currentIndent))
+  }
+
+  scanNumber() {
+    const startLine = this.line
+    const startCol = this.column
+    let value = ''
+    let type = TokenType.INTEGER
+
+    if (this.peek() === '-') {
+      value += this.advance()
+    }
+
+    if (this.peek() === '0' && (this.peek(1) === 'x' || this.peek(1) === 'X')) {
+      value += this.advance()
+      value += this.advance()
+      while (this.isHexDigit(this.peek())) {
+        value += this.advance()
+      }
+      this.tokens.push(new Token(TokenType.HEX, value, startLine, startCol, this.currentIndent))
+      return
+    }
+
+    if (this.peek() === '0' && (this.peek(1) === 'b' || this.peek(1) === 'B')) {
+      this.advance()
+      this.advance()
+      let binValue = ''
+      while (this.peek() === '0' || this.peek() === '1') {
+        binValue += this.advance()
+      }
+      this.tokens.push(new Token(TokenType.INTEGER, parseInt(binValue, 2), startLine, startCol, this.currentIndent))
+      return
+    }
+
+    if (this.peek() === '0' && (this.peek(1) === 'o' || this.peek(1) === 'O')) {
+      this.advance()
+      this.advance()
+      let octValue = ''
+      while (this.peek() >= '0' && this.peek() <= '7') {
+        octValue += this.advance()
+      }
+      this.tokens.push(new Token(TokenType.INTEGER, parseInt(octValue, 8), startLine, startCol, this.currentIndent))
+      return
+    }
+
+    while (this.isDigit(this.peek()) || this.peek() === '_') {
+      if (this.peek() !== '_') {
+        value += this.advance()
+      } else {
+        this.advance()
+      }
+    }
+
+    if (this.peek() === '.' && this.isDigit(this.peek(1))) {
+      type = TokenType.FLOAT
+      value += this.advance()
+      while (this.isDigit(this.peek()) || this.peek() === '_') {
+        if (this.peek() !== '_') {
+          value += this.advance()
+        } else {
+          this.advance()
+        }
+      }
+    }
+
+    if (this.peek() === 'e' || this.peek() === 'E') {
+      type = TokenType.FLOAT
+      value += this.advance()
+      if (this.peek() === '+' || this.peek() === '-') {
+        value += this.advance()
+      }
+      while (this.isDigit(this.peek())) {
+        value += this.advance()
+      }
+    }
+
+    if (type === TokenType.FLOAT) {
+      this.tokens.push(new Token(type, parseFloat(value), startLine, startCol, this.currentIndent))
+    } else {
+      this.tokens.push(new Token(type, parseInt(value, 10), startLine, startCol, this.currentIndent))
+    }
+  }
+
+  scanIdentifier() {
+    const startLine = this.line
+    const startCol = this.column
+    let value = ''
+
+    while (this.isAlphaNumeric(this.peek()) || this.peek() === '-' || this.peek() === '_') {
+      value += this.advance()
+    }
+
+    let keepLooking = true
+    while (keepLooking && this.peek() === ' ') {
+      const savedPos = this.pos
+      const savedLine = this.line
+      const savedCol = this.column
+      
+      this.advance()
+      
+      let nextWord = ''
+      while (this.isAlphaNumeric(this.peek()) || this.peek() === '-' || this.peek() === '_') {
+        nextWord += this.advance()
+      }
+      
+      if (nextWord) {
+        const combined = value + ' ' + nextWord
+        if (this.isCompoundKeyword(combined) || this.couldBeCompoundStart(combined)) {
+          value = combined
+        } else {
+          this.pos = savedPos
+          this.line = savedLine
+          this.column = savedCol
+          keepLooking = false
+        }
+      } else {
+        this.pos = savedPos
+        this.line = savedLine
+        this.column = savedCol
+        keepLooking = false
+      }
+    }
+
+    const lowerValue = value.toLowerCase()
+    if (this.peek() === ':' && LANG_BLOCKS.includes(lowerValue)) {
+      this.advance()
+      this.tokens.push(new Token(TokenType.LANG_BLOCK, lowerValue, startLine, startCol, this.currentIndent))
+      return
+    }
+
+    this.tokens.push(new Token(TokenType.IDENTIFIER, value, startLine, startCol, this.currentIndent))
+  }
+
+  couldBeCompoundStart(partial) {
+    const normalized = this.normalizeAccents(partial)
+    const compounds = [
+      'retour a la ligne', 'a la soumission', 'a la reinitialisation',
+      'inferieur ou egal', 'superieur ou egal',
+      'gauche a droite', 'droite a gauche',
+      'mettre a jour', 'case a cocher'
+    ]
+    return compounds.some(c => c.startsWith(normalized + ' '))
+  }
+
+  normalizeAccents(str) {
+    const accentsMap = {
+      'à': 'a', 'â': 'a', 'ä': 'a', 'á': 'a',
+      'è': 'e', 'ê': 'e', 'ë': 'e', 'é': 'e',
+      'ì': 'i', 'î': 'i', 'ï': 'i', 'í': 'i',
+      'ò': 'o', 'ô': 'o', 'ö': 'o', 'ó': 'o',
+      'ù': 'u', 'û': 'u', 'ü': 'u', 'ú': 'u',
+      'ç': 'c', 'ñ': 'n'
+    }
+    return str.toLowerCase().split('').map(c => accentsMap[c] || c).join('')
+  }
+
+  isCompoundKeyword(phrase) {
+    const normalized = this.normalizeAccents(phrase)
+    const compounds = [
+      'en ligne', 'hors ligne', 'au survol', 'au clic', 'au focus',
+      'au double clic', 'au changement', 'a la soumission',
+      'retour a la ligne', 'lecture seule', 'zone texte',
+      'case a cocher', 'bouton radio', 'premiere lettre',
+      'premiere ligne', 'inferieur ou egal',
+      'superieur ou egal',
+      'espace de noms', 'element liste', 'racine carree',
+      'nouvelle fenetre', 'gauche a droite',
+      'droite a gauche',
+      'definir defaut', 'mettre a jour',
+      'cle primaire', 'cle etrangere',
+      'non nul', 'par defaut',
+      'au focus dans', 'pointeur bas', 'pointeur haut',
+      'obtenir contenu', 'erreur type', 'erreur syntaxe',
+      'nettoyer gauche', 'nettoyer droite', 'vers date',
+      'si null', 'creer role',
+      'a la reinitialisation'
+    ]
+    return compounds.includes(normalized)
+  }
+
+  scanOperator() {
+    const startLine = this.line
+    const startCol = this.column
+    const char = this.advance()
+
+    switch (char) {
+      case ':':
+        if (this.match(':')) {
+          this.tokens.push(new Token(TokenType.DOUBLE_COLON, '::', startLine, startCol, this.currentIndent))
+        } else {
+          this.tokens.push(new Token(TokenType.COLON, ':', startLine, startCol, this.currentIndent))
+        }
+        break
+
+      case '=':
+        if (this.match('=')) {
+          if (this.match('=')) {
+            this.tokens.push(new Token(TokenType.DOUBLE_EQUALS, '===', startLine, startCol, this.currentIndent))
+          } else {
+            this.tokens.push(new Token(TokenType.DOUBLE_EQUALS, '==', startLine, startCol, this.currentIndent))
+          }
+        } else if (this.match('>')) {
+          this.tokens.push(new Token(TokenType.FAT_ARROW, '=>', startLine, startCol, this.currentIndent))
+        } else {
+          this.tokens.push(new Token(TokenType.EQUALS, '=', startLine, startCol, this.currentIndent))
+        }
+        break
+
+      case '!':
+        if (this.match('=')) {
+          if (this.match('=')) {
+            this.tokens.push(new Token(TokenType.NOT_EQUALS, '!==', startLine, startCol, this.currentIndent))
+          } else {
+            this.tokens.push(new Token(TokenType.NOT_EQUALS, '!=', startLine, startCol, this.currentIndent))
+          }
+        } else {
+          this.tokens.push(new Token(TokenType.BANG, '!', startLine, startCol, this.currentIndent))
+        }
+        break
+
+      case ',':
+        this.tokens.push(new Token(TokenType.COMMA, ',', startLine, startCol, this.currentIndent))
+        break
+
+      case '.':
+        if (this.match('.')) {
+          if (this.match('.')) {
+            this.tokens.push(new Token(TokenType.SPREAD, '...', startLine, startCol, this.currentIndent))
+          } else {
+            this.tokens.push(new Token(TokenType.DOT, '.', startLine, startCol, this.currentIndent))
+            this.tokens.push(new Token(TokenType.DOT, '.', startLine, startCol + 1, this.currentIndent))
+          }
+        } else {
+          this.tokens.push(new Token(TokenType.DOT, '.', startLine, startCol, this.currentIndent))
+        }
+        break
+
+      case '+':
+        if (this.match('+')) {
+          this.tokens.push(new Token(TokenType.PLUS, '++', startLine, startCol, this.currentIndent))
+        } else if (this.match('=')) {
+          this.tokens.push(new Token(TokenType.PLUS, '+=', startLine, startCol, this.currentIndent))
+        } else {
+          this.tokens.push(new Token(TokenType.PLUS, '+', startLine, startCol, this.currentIndent))
+        }
+        break
+
+      case '-':
+        if (this.match('-')) {
+          this.tokens.push(new Token(TokenType.MINUS, '--', startLine, startCol, this.currentIndent))
+        } else if (this.match('>')) {
+          this.tokens.push(new Token(TokenType.ARROW, '->', startLine, startCol, this.currentIndent))
+        } else if (this.match('=')) {
+          this.tokens.push(new Token(TokenType.MINUS, '-=', startLine, startCol, this.currentIndent))
+        } else {
+          this.tokens.push(new Token(TokenType.MINUS, '-', startLine, startCol, this.currentIndent))
+        }
+        break
+
+      case '*':
+        if (this.match('*')) {
+          if (this.match('=')) {
+            this.tokens.push(new Token(TokenType.DOUBLE_STAR, '**=', startLine, startCol, this.currentIndent))
+          } else {
+            this.tokens.push(new Token(TokenType.DOUBLE_STAR, '**', startLine, startCol, this.currentIndent))
+          }
+        } else if (this.match('=')) {
+          this.tokens.push(new Token(TokenType.STAR, '*=', startLine, startCol, this.currentIndent))
+        } else {
+          this.tokens.push(new Token(TokenType.STAR, '*', startLine, startCol, this.currentIndent))
+        }
+        break
+
+      case '/':
+        if (this.match('=')) {
+          this.tokens.push(new Token(TokenType.SLASH, '/=', startLine, startCol, this.currentIndent))
+        } else if (this.match('/')) {
+          this.tokens.push(new Token(TokenType.DOUBLE_SLASH, '//', startLine, startCol, this.currentIndent))
+        } else {
+          this.tokens.push(new Token(TokenType.SLASH, '/', startLine, startCol, this.currentIndent))
+        }
+        break
+
+      case '%':
+        if (this.match('=')) {
+          this.tokens.push(new Token(TokenType.PERCENT, '%=', startLine, startCol, this.currentIndent))
+        } else {
+          this.tokens.push(new Token(TokenType.PERCENT, '%', startLine, startCol, this.currentIndent))
+        }
+        break
+
+      case '<':
+        if (this.match('=')) {
+          if (this.match('>')) {
+            this.tokens.push(new Token(TokenType.SPACESHIP, '<=>', startLine, startCol, this.currentIndent))
+          } else {
+            this.tokens.push(new Token(TokenType.LTE, '<=', startLine, startCol, this.currentIndent))
+          }
+        } else if (this.match('<')) {
+          this.tokens.push(new Token(TokenType.LT, '<<', startLine, startCol, this.currentIndent))
+        } else {
+          this.tokens.push(new Token(TokenType.LT, '<', startLine, startCol, this.currentIndent))
+        }
+        break
+
+      case '>':
+        if (this.match('=')) {
+          this.tokens.push(new Token(TokenType.GTE, '>=', startLine, startCol, this.currentIndent))
+        } else if (this.match('>')) {
+          if (this.match('>')) {
+            this.tokens.push(new Token(TokenType.GT, '>>>', startLine, startCol, this.currentIndent))
+          } else {
+            this.tokens.push(new Token(TokenType.GT, '>>', startLine, startCol, this.currentIndent))
+          }
+        } else {
+          this.tokens.push(new Token(TokenType.GT, '>', startLine, startCol, this.currentIndent))
+        }
+        break
+
+      case '&':
+        if (this.match('&')) {
+          this.tokens.push(new Token(TokenType.DOUBLE_AMPERSAND, '&&', startLine, startCol, this.currentIndent))
+        } else if (this.match('=')) {
+          this.tokens.push(new Token(TokenType.AMPERSAND, '&=', startLine, startCol, this.currentIndent))
+        } else {
+          this.tokens.push(new Token(TokenType.AMPERSAND, '&', startLine, startCol, this.currentIndent))
+        }
+        break
+
+      case '|':
+        if (this.match('|')) {
+          this.tokens.push(new Token(TokenType.DOUBLE_PIPE, '||', startLine, startCol, this.currentIndent))
+        } else if (this.match('=')) {
+          this.tokens.push(new Token(TokenType.PIPE, '|=', startLine, startCol, this.currentIndent))
+        } else if (this.match('>')) {
+          this.tokens.push(new Token(TokenType.PIPE, '|>', startLine, startCol, this.currentIndent))
+        } else {
+          this.tokens.push(new Token(TokenType.PIPE, '|', startLine, startCol, this.currentIndent))
+        }
+        break
+
+      case '^':
+        if (this.match('=')) {
+          this.tokens.push(new Token(TokenType.CARET, '^=', startLine, startCol, this.currentIndent))
+        } else {
+          this.tokens.push(new Token(TokenType.CARET, '^', startLine, startCol, this.currentIndent))
+        }
+        break
+
+      case '~':
+        this.tokens.push(new Token(TokenType.TILDE, '~', startLine, startCol, this.currentIndent))
+        break
+
+      case '?':
+        if (this.match('?')) {
+          if (this.match('=')) {
+            this.tokens.push(new Token(TokenType.QUESTION, '??=', startLine, startCol, this.currentIndent))
+          } else {
+            this.tokens.push(new Token(TokenType.QUESTION, '??', startLine, startCol, this.currentIndent))
+          }
+        } else if (this.match('.')) {
+          this.tokens.push(new Token(TokenType.QUESTION, '?.', startLine, startCol, this.currentIndent))
+        } else {
+          this.tokens.push(new Token(TokenType.QUESTION, '?', startLine, startCol, this.currentIndent))
+        }
+        break
+
+      case '@':
+        this.tokens.push(new Token(TokenType.AT, '@', startLine, startCol, this.currentIndent))
+        break
+
+      case '#':
+        this.tokens.push(new Token(TokenType.HASH, '#', startLine, startCol, this.currentIndent))
+        break
+
+      case '\\':
+        this.tokens.push(new Token(TokenType.BACKSLASH, '\\', startLine, startCol, this.currentIndent))
+        break
+
+      case '(':
+        this.tokens.push(new Token(TokenType.LPAREN, '(', startLine, startCol, this.currentIndent))
+        break
+
+      case ')':
+        this.tokens.push(new Token(TokenType.RPAREN, ')', startLine, startCol, this.currentIndent))
+        break
+
+      case '[':
+        this.tokens.push(new Token(TokenType.LBRACKET, '[', startLine, startCol, this.currentIndent))
+        break
+
+      case ']':
+        this.tokens.push(new Token(TokenType.RBRACKET, ']', startLine, startCol, this.currentIndent))
+        break
+
+      case '{':
+        this.tokens.push(new Token(TokenType.LBRACE, '{', startLine, startCol, this.currentIndent))
+        break
+
+      case '}':
+        this.tokens.push(new Token(TokenType.RBRACE, '}', startLine, startCol, this.currentIndent))
+        break
+
+      case ';':
+        break
+
+      default:
+        this.tokens.push(new Token(TokenType.ERROR, `Caractère inattendu: ${char}`, startLine, startCol, this.currentIndent))
+    }
+  }
+
+  static tokenize(source, options = {}) {
+    const lexer = new EtherLexer(source, options)
+    return lexer.tokenize()
+  }
+}
+
+module.exports = {
+  EtherLexer,
+  Token,
+  TokenType,
+  LANG_BLOCKS
+}