@devalade/algolang 1.0.0

package/dist/index.js

@@ -0,0 +1,3275 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/lexer/lexer.ts
+class Lexer {
+  source;
+  position = 0;
+  line = 1;
+  column = 1;
+  keywords;
+  constructor(source) {
+    this.source = source;
+    this.keywords = new Map([
+      ["PROGRAMME", "PROGRAMME" /* PROGRAM */],
+      ["DEBUT", "DEBUT" /* BEGIN */],
+      ["FIN", "FIN" /* END */],
+      ["VAR", "VAR" /* VAR */],
+      ["ENTIER", "ENTIER" /* INTEGER */],
+      ["REEL", "REEL" /* REAL */],
+      ["BOOLEEN", "BOOLEEN" /* BOOLEAN */],
+      ["CHAINE", "CHAINE" /* STRING */],
+      ["SI", "SI" /* IF */],
+      ["ALORS", "ALORS" /* THEN */],
+      ["SINON", "SINON" /* ELSE */],
+      ["FINSI", "FINIF" /* ENDIF */],
+      ["TANTQUE", "TANTQUE" /* WHILE */],
+      ["FAIRE", "FAIRE" /* DO */],
+      ["POUR", "POUR" /* FOR */],
+      ["ALLANT", "ALLANT" /* ALLANT */],
+      ["DE", "DE" /* DE */],
+      ["A", "A" /* TO */],
+      ["REPETER", "REPETER" /* REPEAT */],
+      ["JUSQUA", "JUSQUA" /* UNTIL */],
+      ["LIRE", "LIRE" /* READ */],
+      ["ECRIRE", "ECRIRE" /* WRITE */],
+      ["VRAI", "VRAI" /* TRUE */],
+      ["FAUX", "FAUX" /* FALSE */],
+      ["ET", "ET" /* AND */],
+      ["OU", "OU" /* OR */],
+      ["NON", "NON" /* NOT */],
+      ["FINPOUR", "FINPOUR" /* ENDFOR */],
+      ["FINTANTQUE", "FINTANTQUE" /* ENDWHILE */]
+    ]);
+  }
+  tokenize() {
+    const tokens = [];
+    while (!this.isAtEnd()) {
+      const token = this.scanToken();
+      if (token.type !== "COMMENT" /* COMMENT */) {
+        tokens.push(token);
+      }
+    }
+    tokens.push({
+      type: "EOF" /* EOF */,
+      value: "",
+      line: this.line,
+      column: this.column,
+      position: this.position
+    });
+    return tokens;
+  }
+  scanToken() {
+    this.skipWhitespace();
+    if (this.isAtEnd()) {
+      return this.createToken("EOF" /* EOF */, "");
+    }
+    const char = this.currentChar();
+    if (char === "/" && this.peek() === "/") {
+      return this.scanLineComment();
+    }
+    if (char === "/" && this.peek() === "*") {
+      return this.scanBlockComment();
+    }
+    if (char === '"') {
+      return this.scanString();
+    }
+    if (this.isDigit(char)) {
+      return this.scanNumber();
+    }
+    if (this.isAlpha(char)) {
+      return this.scanIdentifier();
+    }
+    if (char === ":" && this.peek() === "=") {
+      const token = this.createToken("ASSIGN" /* ASSIGN */, ":=");
+      this.advance();
+      this.advance();
+      return token;
+    }
+    if (char === "<" && this.peek() === "=") {
+      const token = this.createToken("LESS_EQUAL" /* LESS_EQUAL */, "<=");
+      this.advance();
+      this.advance();
+      return token;
+    }
+    if (char === ">" && this.peek() === "=") {
+      const token = this.createToken("GREATER_EQUAL" /* GREATER_EQUAL */, ">=");
+      this.advance();
+      this.advance();
+      return token;
+    }
+    if (char === "<" && this.peek() === ">") {
+      const token = this.createToken("NOT_EQUAL" /* NOT_EQUAL */, "<>");
+      this.advance();
+      this.advance();
+      return token;
+    }
+    switch (char) {
+      case "+":
+        return this.createToken("PLUS" /* PLUS */, this.advance());
+      case "-":
+        return this.createToken("MINUS" /* MINUS */, this.advance());
+      case "*":
+        return this.createToken("MULTIPLY" /* MULTIPLY */, this.advance());
+      case "/":
+        return this.createToken("DIVIDE" /* DIVIDE */, this.advance());
+      case "=":
+        return this.createToken("EQUAL" /* EQUAL */, this.advance());
+      case "<":
+        return this.createToken("LESS_THAN" /* LESS_THAN */, this.advance());
+      case ">":
+        return this.createToken("GREATER_THAN" /* GREATER_THAN */, this.advance());
+      case ";":
+        return this.createToken("SEMICOLON" /* SEMICOLON */, this.advance());
+      case ":":
+        return this.createToken("COLON" /* COLON */, this.advance());
+      case ",":
+        return this.createToken("COMMA" /* COMMA */, this.advance());
+      case ".":
+        return this.createToken("DOT" /* DOT */, this.advance());
+      case "(":
+        return this.createToken("LEFT_PAREN" /* LEFT_PAREN */, this.advance());
+      case ")":
+        return this.createToken("RIGHT_PAREN" /* RIGHT_PAREN */, this.advance());
+      default:
+        throw new Error(`Caractère non reconnu '${char}' à la ligne ${this.line}, colonne ${this.column}`);
+    }
+  }
+  scanIdentifier() {
+    const start = this.position;
+    const startColumn = this.column;
+    while (!this.isAtEnd() && this.isAlphaNumeric(this.currentChar())) {
+      this.advance();
+    }
+    const value = this.source.substring(start, this.position);
+    const type = this.keywords.get(value.toUpperCase()) || "IDENTIFIER" /* IDENTIFIER */;
+    return {
+      type,
+      value,
+      line: this.line,
+      column: startColumn,
+      position: start
+    };
+  }
+  scanNumber() {
+    const start = this.position;
+    const startColumn = this.column;
+    let hasDecimal = false;
+    while (!this.isAtEnd() && (this.isDigit(this.currentChar()) || this.currentChar() === ".")) {
+      if (this.currentChar() === ".") {
+        if (hasDecimal) {
+          throw new Error(`Nombre invalide: trop de points décimaux à la ligne ${this.line}, colonne ${this.column}`);
+        }
+        hasDecimal = true;
+      }
+      this.advance();
+    }
+    const value = this.source.substring(start, this.position);
+    return {
+      type: "NUMBER" /* NUMBER */,
+      value,
+      line: this.line,
+      column: startColumn,
+      position: start
+    };
+  }
+  scanString() {
+    const start = this.position;
+    const startColumn = this.column;
+    this.advance();
+    let value = "";
+    while (!this.isAtEnd() && this.currentChar() !== '"') {
+      if (this.currentChar() === "\\") {
+        this.advance();
+        if (this.isAtEnd()) {
+          throw new Error(`Chaîne de caractères non terminée à la ligne ${this.line}, colonne ${this.column}`);
+        }
+        const escaped = this.currentChar();
+        switch (escaped) {
+          case "n":
+            value += `
+`;
+            break;
+          case "t":
+            value += "\t";
+            break;
+          case "r":
+            value += "\r";
+            break;
+          case "\\":
+            value += "\\";
+            break;
+          case '"':
+            value += '"';
+            break;
+          default:
+            value += escaped;
+            break;
+        }
+        this.advance();
+      } else {
+        value += this.currentChar();
+        this.advance();
+      }
+    }
+    if (this.isAtEnd()) {
+      throw new Error(`Chaîne de caractères non terminée à la ligne ${this.line}, colonne ${this.column}`);
+    }
+    this.advance();
+    return {
+      type: "STRING_LITERAL" /* STRING_LITERAL */,
+      value,
+      line: this.line,
+      column: startColumn,
+      position: start
+    };
+  }
+  scanLineComment() {
+    const start = this.position;
+    const startColumn = this.column;
+    while (!this.isAtEnd() && this.currentChar() !== `
+`) {
+      this.advance();
+    }
+    const value = this.source.substring(start, this.position);
+    return {
+      type: "COMMENT" /* COMMENT */,
+      value,
+      line: this.line,
+      column: startColumn,
+      position: start
+    };
+  }
+  scanBlockComment() {
+    const start = this.position;
+    const startColumn = this.column;
+    this.advance();
+    while (!this.isAtEnd() && !(this.currentChar() === "*" && this.peek() === "/")) {
+      if (this.currentChar() === `
+`) {
+        this.line++;
+        this.column = 1;
+      } else {
+        this.column++;
+      }
+      this.advance();
+    }
+    if (this.isAtEnd()) {
+      throw new Error(`Commentaire bloc non terminé commençant à la ligne ${this.line}, colonne ${this.column}`);
+    }
+    this.advance();
+    this.advance();
+    const value = this.source.substring(start, this.position);
+    return {
+      type: "COMMENT" /* COMMENT */,
+      value,
+      line: this.line,
+      column: startColumn,
+      position: start
+    };
+  }
+  skipWhitespace() {
+    while (!this.isAtEnd() && this.isWhitespace(this.currentChar())) {
+      if (this.currentChar() === `
+`) {
+        this.line++;
+        this.column = 1;
+      } else {
+        this.column++;
+      }
+      this.advance();
+    }
+  }
+  createToken(type, value) {
+    return {
+      type,
+      value,
+      line: this.line,
+      column: this.column,
+      position: this.position
+    };
+  }
+  advance() {
+    const char = this.source[this.position];
+    this.position++;
+    return char !== undefined ? char : "\x00";
+  }
+  currentChar() {
+    const char = this.source[this.position];
+    return char !== undefined ? char : "\x00";
+  }
+  peek() {
+    if (this.position + 1 >= this.source.length) {
+      return "\x00";
+    }
+    const char = this.source[this.position + 1];
+    return char !== undefined ? char : "\x00";
+  }
+  isAtEnd() {
+    return this.position >= this.source.length;
+  }
+  isDigit(char) {
+    return char >= "0" && char <= "9";
+  }
+  isAlpha(char) {
+    return char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char >= "À" && char <= "ÿ" || char === "_" || char === "'";
+  }
+  isAlphaNumeric(char) {
+    return this.isAlpha(char) || this.isDigit(char);
+  }
+  isWhitespace(char) {
+    return char === " " || char === "\t" || char === `
+` || char === "\r";
+  }
+}
+// src/parser/parser.ts
+class Parser {
+  tokens;
+  current = 0;
+  errors = [];
+  symbolTable;
+  reservedKeywords = new Set([
+    "programme",
+    "debut",
+    "fin",
+    "var",
+    "entier",
+    "reel",
+    "booleen",
+    "chaine",
+    "si",
+    "alors",
+    "sinon",
+    "finsi",
+    "tantque",
+    "faire",
+    "fintantque",
+    "pour",
+    "a",
+    "finpour",
+    "repeter",
+    "jusqua",
+    "lire",
+    "ecrire",
+    "vrai",
+    "faux",
+    "et",
+    "ou",
+    "non",
+    "fonction",
+    "procedure",
+    "retourner"
+  ]);
+  constructor(tokens) {
+    this.tokens = tokens;
+    this.symbolTable = {
+      symbols: new Map,
+      children: [],
+      scopeName: "global"
+    };
+  }
+  isReservedKeyword(identifier) {
+    return this.reservedKeywords.has(identifier.toLowerCase());
+  }
+  isKeywordToken(tokenType) {
+    return [
+      "PROGRAMME" /* PROGRAM */,
+      "DEBUT" /* BEGIN */,
+      "FIN" /* END */,
+      "VAR" /* VAR */,
+      "ENTIER" /* INTEGER */,
+      "REEL" /* REAL */,
+      "BOOLEEN" /* BOOLEAN */,
+      "CHAINE" /* STRING */,
+      "SI" /* IF */,
+      "ALORS" /* THEN */,
+      "SINON" /* ELSE */,
+      "TANTQUE" /* WHILE */,
+      "FAIRE" /* DO */,
+      "POUR" /* FOR */,
+      "ALLANT" /* ALLANT */,
+      "DE" /* DE */,
+      "A" /* TO */,
+      "REPETER" /* REPEAT */,
+      "JUSQUA" /* UNTIL */,
+      "LIRE" /* READ */,
+      "ECRIRE" /* WRITE */,
+      "VRAI" /* TRUE */,
+      "FAUX" /* FALSE */,
+      "ET" /* AND */,
+      "OU" /* OR */,
+      "NON" /* NOT */,
+      "FINPOUR" /* ENDFOR */,
+      "FINIF" /* ENDIF */,
+      "FINTANTQUE" /* ENDWHILE */
+    ].includes(tokenType);
+  }
+  createReservedKeywordError(identifier, token) {
+    this.errors.push({
+      type: "ERROR",
+      message: `Le nom '${identifier}' est un mot-clé réservé et ne peut pas être utilisé comme nom de variable`,
+      line: token.line,
+      column: token.column,
+      position: token.position,
+      code: "RESERVED_KEYWORD",
+      explanation: "Les mots-clés réservés sont utilisés par le langage AlgoLang pour définir la structure du programme et ne peuvent pas être utilisés comme noms de variables.",
+      suggestion: `Choisissez un autre nom plus descriptif, par exemple: '${identifier}Valeur', '${identifier}Temp', 'ma${identifier.charAt(0).toUpperCase() + identifier.slice(1)}'`
+    });
+  }
+  parse() {
+    try {
+      const program = this.parseProgram();
+      return {
+        ast: program,
+        errors: this.errors,
+        symbolTable: this.symbolTable
+      };
+    } catch (error) {
+      return {
+        ast: { type: "PROGRAM" /* PROGRAM */, children: [] },
+        errors: [
+          ...this.errors,
+          {
+            type: "ERROR",
+            message: error instanceof Error ? error.message : "Erreur de parsing inconnue",
+            line: 1,
+            column: 1,
+            position: 0,
+            code: "PARSE_ERROR"
+          }
+        ],
+        symbolTable: this.symbolTable
+      };
+    }
+  }
+  parseProgram() {
+    const programToken = this.expect("PROGRAMME" /* PROGRAM */, 'Le programme doit commencer par le mot-clé "programme"');
+    const identifier = this.expect("IDENTIFIER" /* IDENTIFIER */, "Le programme doit avoir un nom");
+    this.expect("SEMICOLON" /* SEMICOLON */, "Le nom du programme doit être suivi d'un point-virgule");
+    const block = this.parseBlock();
+    return {
+      type: "PROGRAM" /* PROGRAM */,
+      value: identifier.value,
+      children: [block],
+      token: programToken
+    };
+  }
+  parseBlock() {
+    const declarations = this.parseDeclarations();
+    const compoundStatement = this.parseCompoundStatement();
+    return {
+      type: "BLOCK" /* BLOCK */,
+      children: [declarations, compoundStatement]
+    };
+  }
+  parseDeclarations() {
+    const declarations = [];
+    while (this.check("VAR" /* VAR */)) {
+      this.advance();
+      while (!this.check("DEBUT" /* BEGIN */) && !this.isAtEnd()) {
+        const declaration = this.parseVariableDeclaration();
+        declarations.push(declaration);
+        if (!this.check("SEMICOLON" /* SEMICOLON */)) {
+          break;
+        }
+        this.advance();
+      }
+    }
+    return {
+      type: "BLOCK" /* BLOCK */,
+      children: declarations
+    };
+  }
+  parseVariableDeclaration() {
+    const identifiers = [];
+    do {
+      let identifier;
+      if (this.check("IDENTIFIER" /* IDENTIFIER */)) {
+        identifier = this.advance();
+      } else {
+        const currentToken = this.peek();
+        if (this.isKeywordToken(currentToken.type)) {
+          identifier = this.advance();
+          this.createReservedKeywordError(identifier.value, identifier);
+        } else {
+          this.expect("IDENTIFIER" /* IDENTIFIER */, "Identificateur attendu dans la déclaration de variable");
+          break;
+        }
+      }
+      if (this.isReservedKeyword(identifier.value)) {
+        this.createReservedKeywordError(identifier.value, identifier);
+      }
+      identifiers.push(identifier.value);
+      if (this.check("COMMA" /* COMMA */)) {
+        this.advance();
+      } else {
+        break;
+      }
+    } while (true);
+    this.expect("COLON" /* COLON */, "Deux-points attendus après les identificateurs");
+    const typeToken = this.expect(["ENTIER" /* INTEGER */, "REEL" /* REAL */, "BOOLEEN" /* BOOLEAN */, "CHAINE" /* STRING */], "Type de variable attendu");
+    const type = this.tokenTypeToDataType(typeToken.type);
+    for (const identifier of identifiers) {
+      if (this.symbolTable.symbols.has(identifier)) {
+        this.errors.push({
+          type: "ERROR",
+          message: `La variable '${identifier}' est déjà déclarée`,
+          line: typeToken.line,
+          column: typeToken.column,
+          position: typeToken.position,
+          code: "DUPLICATE_VARIABLE",
+          explanation: "Chaque variable doit avoir un nom unique dans son scope",
+          suggestion: `Choisissez un autre nom pour la variable '${identifier}'`
+        });
+      } else {
+        const symbolInfo = {
+          name: identifier,
+          type,
+          scope: this.symbolTable.scopeName,
+          line: typeToken.line,
+          column: typeToken.column
+        };
+        this.symbolTable.symbols.set(identifier, symbolInfo);
+      }
+    }
+    return {
+      type: "VAR_DECLARATION" /* VAR_DECLARATION */,
+      value: type,
+      children: identifiers.map((name) => ({
+        type: "VARIABLE" /* VARIABLE */,
+        value: name
+      })),
+      token: typeToken
+    };
+  }
+  parseCompoundStatement() {
+    this.expect("DEBUT" /* BEGIN */, `Le bloc d'instructions doit commencer par "debut"`);
+    const statements = [];
+    while (!this.check("FIN" /* END */) && !this.isAtEnd()) {
+      const statement = this.parseStatement();
+      statements.push(statement);
+      if (this.check("SEMICOLON" /* SEMICOLON */)) {
+        this.advance();
+      } else if (!this.check("FIN" /* END */) && !this.check("FINIF" /* ENDIF */) && !this.check("FINTANTQUE" /* ENDWHILE */)) {
+        this.errors.push({
+          type: "ERROR",
+          message: "Point-virgule attendu après l'instruction",
+          line: this.peek().line,
+          column: this.peek().column,
+          position: this.peek().position,
+          code: "MISSING_SEMICOLON"
+        });
+        break;
+      }
+    }
+    this.expect("FIN" /* END */, `Le bloc d'instructions doit se terminer par "fin"`);
+    return {
+      type: "COMPOUND_STATEMENT" /* COMPOUND_STATEMENT */,
+      children: statements
+    };
+  }
+  parseStatement() {
+    if (this.check("DEBUT" /* BEGIN */)) {
+      return this.parseCompoundStatement();
+    }
+    if (this.isKeywordToken(this.peek().type) && this.peekAhead(1)?.type === "ASSIGN" /* ASSIGN */) {
+      return this.parseAssignment();
+    }
+    if (this.check("SI" /* IF */)) {
+      return this.parseIfStatement();
+    }
+    if (this.check("TANTQUE" /* WHILE */)) {
+      return this.parseWhileStatement();
+    }
+    if (this.check("POUR" /* FOR */)) {
+      return this.parseForStatement();
+    }
+    if (this.check("REPETER" /* REPEAT */)) {
+      return this.parseRepeatStatement();
+    }
+    if (this.check("LIRE" /* READ */)) {
+      return this.parseReadStatement();
+    }
+    if (this.check("ECRIRE" /* WRITE */)) {
+      return this.parseWriteStatement();
+    }
+    return this.parseAssignment();
+  }
+  parseIfStatement(isElseIf = false) {
+    const ifToken = this.advance();
+    const condition = this.parseExpression();
+    this.expect("ALORS" /* THEN */, '"alors" attendu après la condition du si');
+    const thenStatements = [];
+    while (!this.check("SINON" /* ELSE */) && !this.check("FINIF" /* ENDIF */) && !this.check("FIN" /* END */) && !this.isAtEnd()) {
+      const statement = this.parseStatement();
+      thenStatements.push(statement);
+      if (this.check("SEMICOLON" /* SEMICOLON */)) {
+        this.advance();
+      }
+    }
+    const thenStatement = {
+      type: "COMPOUND_STATEMENT" /* COMPOUND_STATEMENT */,
+      children: thenStatements
+    };
+    let elseStatement;
+    if (this.check("SEMICOLON" /* SEMICOLON */) && this.peekAhead(1)?.type === "SINON" /* ELSE */) {
+      this.advance();
+    }
+    if (this.check("SINON" /* ELSE */)) {
+      this.advance();
+      if (this.check("SI" /* IF */)) {
+        elseStatement = this.parseIfStatement(true);
+      } else {
+        const elseStatements = [];
+        while (!this.check("FINIF" /* ENDIF */) && !this.check("FIN" /* END */) && !this.isAtEnd()) {
+          const statement = this.parseStatement();
+          elseStatements.push(statement);
+          if (this.check("SEMICOLON" /* SEMICOLON */)) {
+            this.advance();
+          }
+        }
+        elseStatement = {
+          type: "COMPOUND_STATEMENT" /* COMPOUND_STATEMENT */,
+          children: elseStatements
+        };
+      }
+    }
+    if (!isElseIf) {
+      if (this.check("SEMICOLON" /* SEMICOLON */) && this.peekAhead(1)?.type === "FINIF" /* ENDIF */) {
+        this.advance();
+      }
+      this.expect("FINIF" /* ENDIF */, '"finsi" attendu à la fin du bloc si');
+    }
+    return {
+      type: "IF_STATEMENT" /* IF_STATEMENT */,
+      children: [
+        condition,
+        thenStatement,
+        ...elseStatement ? [elseStatement] : []
+      ],
+      token: ifToken
+    };
+  }
+  parseWhileStatement() {
+    const whileToken = this.advance();
+    const condition = this.parseExpression();
+    this.expect("FAIRE" /* DO */, '"faire" attendu après la condition du tantque');
+    const bodyStatements = [];
+    while (!this.check("FINTANTQUE" /* ENDWHILE */) && !this.check("FIN" /* END */) && !this.isAtEnd()) {
+      const statement = this.parseStatement();
+      bodyStatements.push(statement);
+      if (this.check("SEMICOLON" /* SEMICOLON */)) {
+        this.advance();
+      }
+    }
+    this.expect("FINTANTQUE" /* ENDWHILE */, '"fintantque" attendu à la fin de la boucle tantque');
+    return {
+      type: "WHILE_STATEMENT" /* WHILE_STATEMENT */,
+      children: [
+        condition,
+        { type: "COMPOUND_STATEMENT" /* COMPOUND_STATEMENT */, children: bodyStatements }
+      ],
+      token: whileToken
+    };
+  }
+  parseForStatement() {
+    const forToken = this.advance();
+    const variable = this.expect("IDENTIFIER" /* IDENTIFIER */, 'Identificateur attendu après "pour"');
+    let startValue;
+    if (this.check("ALLANT" /* ALLANT */)) {
+      this.advance();
+      this.expect("DE" /* DE */, '"de" attendu après "allant" dans la boucle pour');
+      startValue = this.parseExpression();
+    } else if (this.check("ASSIGN" /* ASSIGN */)) {
+      this.advance();
+      startValue = this.parseExpression();
+    } else {
+      throw new Error('"allant de" ou ":=" attendu après la variable dans la boucle pour');
+    }
+    this.expect("A" /* TO */, '"a" attendu dans la boucle pour');
+    const endValue = this.parseExpression();
+    this.expect("FAIRE" /* DO */, '"faire" attendu dans la boucle pour');
+    const bodyStatements = [];
+    while (!this.check("FINPOUR" /* ENDFOR */) && !this.check("FIN" /* END */) && !this.isAtEnd()) {
+      const statement = this.parseStatement();
+      bodyStatements.push(statement);
+      if (this.check("SEMICOLON" /* SEMICOLON */)) {
+        this.advance();
+      }
+    }
+    this.expect("FINPOUR" /* ENDFOR */, '"finpour" attendu à la fin de la boucle pour');
+    return {
+      type: "FOR_STATEMENT" /* FOR_STATEMENT */,
+      children: [
+        { type: "VARIABLE" /* VARIABLE */, value: variable.value, token: variable },
+        startValue,
+        endValue,
+        { type: "COMPOUND_STATEMENT" /* COMPOUND_STATEMENT */, children: bodyStatements }
+      ],
+      token: forToken
+    };
+  }
+  parseReadStatement() {
+    const readToken = this.advance();
+    this.expect("LEFT_PAREN" /* LEFT_PAREN */, 'Parenthèse ouvrante attendue après "lire"');
+    let variable;
+    if (this.check("IDENTIFIER" /* IDENTIFIER */)) {
+      variable = this.advance();
+    } else {
+      const currentToken = this.peek();
+      if (this.isKeywordToken(currentToken.type)) {
+        variable = this.advance();
+        this.createReservedKeywordError(variable.value, variable);
+      } else {
+        this.expect("IDENTIFIER" /* IDENTIFIER */, 'Variable attendue dans "lire"');
+        throw new Error('Variable attendue dans "lire"');
+      }
+    }
+    this.expect("RIGHT_PAREN" /* RIGHT_PAREN */, 'Parenthèse fermante attendue dans "lire"');
+    return {
+      type: "READ_STATEMENT" /* READ_STATEMENT */,
+      children: [
+        { type: "VARIABLE" /* VARIABLE */, value: variable.value, token: variable }
+      ],
+      token: readToken
+    };
+  }
+  parseWriteStatement() {
+    const writeToken = this.advance();
+    this.expect("LEFT_PAREN" /* LEFT_PAREN */, 'Parenthèse ouvrante attendue après "ecrire"');
+    const expressions = [];
+    expressions.push(this.parseExpression());
+    while (this.check("COMMA" /* COMMA */)) {
+      this.advance();
+      expressions.push(this.parseExpression());
+    }
+    this.expect("RIGHT_PAREN" /* RIGHT_PAREN */, 'Parenthèse fermante attendue dans "ecrire"');
+    return {
+      type: "WRITE_STATEMENT" /* WRITE_STATEMENT */,
+      children: expressions,
+      token: writeToken
+    };
+  }
+  parseAssignment() {
+    let variable;
+    if (this.check("IDENTIFIER" /* IDENTIFIER */)) {
+      variable = this.advance();
+    } else {
+      const currentToken = this.peek();
+      if (this.isKeywordToken(currentToken.type)) {
+        variable = this.advance();
+        this.createReservedKeywordError(variable.value, variable);
+      } else {
+        this.expect("IDENTIFIER" /* IDENTIFIER */, "Variable attendue dans l'affectation");
+        throw new Error("Variable attendue dans l'affectation");
+      }
+    }
+    if (this.isReservedKeyword(variable.value)) {
+      this.createReservedKeywordError(variable.value, variable);
+    }
+    this.expect("ASSIGN" /* ASSIGN */, `":=" attendu dans l'affectation`);
+    const expression = this.parseExpression();
+    return {
+      type: "ASSIGNMENT" /* ASSIGNMENT */,
+      children: [
+        { type: "VARIABLE" /* VARIABLE */, value: variable.value, token: variable },
+        expression
+      ],
+      token: variable
+    };
+  }
+  parseExpression() {
+    return this.parseOrExpression();
+  }
+  parseOrExpression() {
+    let left = this.parseAndExpression();
+    while (this.check("OU" /* OR */)) {
+      const operator = this.advance();
+      const right = this.parseAndExpression();
+      left = {
+        type: "BINARY_OP" /* BINARY_OP */,
+        value: operator.value,
+        children: [left, right],
+        token: operator
+      };
+    }
+    return left;
+  }
+  parseAndExpression() {
+    let left = this.parseEqualityExpression();
+    while (this.check("ET" /* AND */)) {
+      const operator = this.advance();
+      const right = this.parseEqualityExpression();
+      left = {
+        type: "BINARY_OP" /* BINARY_OP */,
+        value: operator.value,
+        children: [left, right],
+        token: operator
+      };
+    }
+    return left;
+  }
+  parseEqualityExpression() {
+    let left = this.parseRelationalExpression();
+    while (this.check(["EQUAL" /* EQUAL */, "NOT_EQUAL" /* NOT_EQUAL */])) {
+      const operator = this.advance();
+      const right = this.parseRelationalExpression();
+      left = {
+        type: "BINARY_OP" /* BINARY_OP */,
+        value: operator.value,
+        children: [left, right],
+        token: operator
+      };
+    }
+    return left;
+  }
+  parseRelationalExpression() {
+    let left = this.parseAdditiveExpression();
+    while (this.check([
+      "LESS_THAN" /* LESS_THAN */,
+      "LESS_EQUAL" /* LESS_EQUAL */,
+      "GREATER_THAN" /* GREATER_THAN */,
+      "GREATER_EQUAL" /* GREATER_EQUAL */
+    ])) {
+      const operator = this.advance();
+      const right = this.parseAdditiveExpression();
+      left = {
+        type: "BINARY_OP" /* BINARY_OP */,
+        value: operator.value,
+        children: [left, right],
+        token: operator
+      };
+    }
+    return left;
+  }
+  parseAdditiveExpression() {
+    let left = this.parseMultiplicativeExpression();
+    while (this.check(["PLUS" /* PLUS */, "MINUS" /* MINUS */])) {
+      const operator = this.advance();
+      const right = this.parseMultiplicativeExpression();
+      left = {
+        type: "BINARY_OP" /* BINARY_OP */,
+        value: operator.value,
+        children: [left, right],
+        token: operator
+      };
+    }
+    return left;
+  }
+  parseMultiplicativeExpression() {
+    let left = this.parseUnaryExpression();
+    while (this.check(["MULTIPLY" /* MULTIPLY */, "DIVIDE" /* DIVIDE */])) {
+      const operator = this.advance();
+      const right = this.parseUnaryExpression();
+      left = {
+        type: "BINARY_OP" /* BINARY_OP */,
+        value: operator.value,
+        children: [left, right],
+        token: operator
+      };
+    }
+    return left;
+  }
+  parseUnaryExpression() {
+    if (this.check("NON" /* NOT */)) {
+      const nextToken = this.peekAhead();
+      if (nextToken && [
+        "RIGHT_PAREN" /* RIGHT_PAREN */,
+        "SEMICOLON" /* SEMICOLON */,
+        "COMMA" /* COMMA */,
+        "EOF" /* EOF */
+      ].includes(nextToken.type)) {
+        return this.parsePrimary();
+      }
+    }
+    if (this.check(["NON" /* NOT */, "MINUS" /* MINUS */])) {
+      const operator = this.advance();
+      const operand = this.parseUnaryExpression();
+      return {
+        type: "UNARY_OP" /* UNARY_OP */,
+        value: operator.value,
+        children: [operand],
+        token: operator
+      };
+    }
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    if (this.check("NUMBER" /* NUMBER */)) {
+      const token2 = this.advance();
+      return {
+        type: "LITERAL" /* LITERAL */,
+        value: parseFloat(token2.value),
+        token: token2
+      };
+    }
+    if (this.check(["VRAI" /* TRUE */, "FAUX" /* FALSE */])) {
+      const token2 = this.advance();
+      return {
+        type: "LITERAL" /* LITERAL */,
+        value: token2.value === "vrai",
+        token: token2
+      };
+    }
+    if (this.check("STRING_LITERAL" /* STRING_LITERAL */)) {
+      const token2 = this.advance();
+      return {
+        type: "LITERAL" /* LITERAL */,
+        value: token2.value,
+        token: token2
+      };
+    }
+    if (this.check("IDENTIFIER" /* IDENTIFIER */)) {
+      const token2 = this.advance();
+      if (this.isReservedKeyword(token2.value)) {
+        this.createReservedKeywordError(token2.value, token2);
+      }
+      return {
+        type: "VARIABLE" /* VARIABLE */,
+        value: token2.value,
+        token: token2
+      };
+    }
+    const currentToken = this.peek();
+    if (this.isKeywordToken(currentToken.type)) {
+      const token2 = this.advance();
+      this.createReservedKeywordError(token2.value, token2);
+      return {
+        type: "VARIABLE" /* VARIABLE */,
+        value: token2.value,
+        token: token2
+      };
+    }
+    if (this.check("LEFT_PAREN" /* LEFT_PAREN */)) {
+      this.advance();
+      const expression = this.parseExpression();
+      this.expect("RIGHT_PAREN" /* RIGHT_PAREN */, "Parenthèse fermante attendue");
+      return expression;
+    }
+    const token = this.peek();
+    this.errors.push({
+      type: "ERROR",
+      message: `Expression inattendue: ${token.value}`,
+      line: token.line,
+      column: token.column,
+      position: token.position,
+      code: "UNEXPECTED_TOKEN"
+    });
+    this.advance();
+    return {
+      type: "LITERAL" /* LITERAL */,
+      value: 0
+    };
+  }
+  parseRepeatStatement() {
+    const repeatToken = this.advance();
+    const statements = [];
+    while (!this.check("JUSQUA" /* UNTIL */) && !this.isAtEnd()) {
+      const statement = this.parseStatement();
+      statements.push(statement);
+      if (this.check("SEMICOLON" /* SEMICOLON */)) {
+        this.advance();
+      }
+    }
+    this.expect("JUSQUA" /* UNTIL */, '"jusqua" attendu à la fin de la boucle repeter');
+    const condition = this.parseExpression();
+    return {
+      type: "REPEAT_STATEMENT" /* REPEAT_STATEMENT */,
+      children: [...statements, condition],
+      token: repeatToken
+    };
+  }
+  check(type) {
+    if (this.isAtEnd())
+      return false;
+    if (Array.isArray(type)) {
+      return type.includes(this.peek().type);
+    }
+    return this.peek().type === type;
+  }
+  advance() {
+    if (!this.isAtEnd())
+      this.current++;
+    return this.previous();
+  }
+  isAtEnd() {
+    return this.peek().type === "EOF";
+  }
+  peek() {
+    return this.tokens[this.current] ?? {
+      type: "EOF" /* EOF */,
+      value: "",
+      line: 0,
+      column: 0,
+      position: 0
+    };
+  }
+  peekAhead(offset = 1) {
+    return this.tokens[this.current + offset];
+  }
+  previous() {
+    return this.tokens[this.current - 1] ?? {
+      type: "EOF" /* EOF */,
+      value: "",
+      line: 0,
+      column: 0,
+      position: 0
+    };
+  }
+  expect(type, message) {
+    if (this.check(type)) {
+      return this.advance();
+    }
+    const token = this.peek();
+    this.errors.push({
+      type: "ERROR",
+      message,
+      line: token.line,
+      column: token.column,
+      position: token.position,
+      code: "EXPECTED_TOKEN",
+      explanation: `Attendu: ${Array.isArray(type) ? type.join(" ou ") : type}, Trouvé: ${token.type}`,
+      suggestion: "Vérifiez la syntaxe de votre programme"
+    });
+    throw new Error(message);
+  }
+  tokenTypeToDataType(tokenType) {
+    switch (tokenType) {
+      case "ENTIER" /* INTEGER */:
+        return "ENTIER" /* INTEGER */;
+      case "REEL" /* REAL */:
+        return "REEL" /* REAL */;
+      case "BOOLEEN" /* BOOLEAN */:
+        return "BOOLEEN" /* BOOLEAN */;
+      case "CHAINE" /* STRING */:
+        return "CHAINE" /* STRING */;
+      default:
+        return "VIDE" /* VOID */;
+    }
+  }
+}
+// src/codegen/codegen.ts
+class CodeGenerator {
+  symbolTable;
+  errors = [];
+  indentLevel = 0;
+  constructor(symbolTable, _options) {
+    this.symbolTable = symbolTable;
+  }
+  generate(ast) {
+    try {
+      const output = this.generateJavaScript(ast);
+      return {
+        success: this.errors.length === 0,
+        output,
+        errors: this.errors,
+        warnings: [],
+        symbolTable: this.symbolTable,
+        ast
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: "",
+        errors: [
+          ...this.errors,
+          {
+            type: "ERROR",
+            message: error instanceof Error ? error.message : "Erreur inconnue lors de la génération de code",
+            line: 0,
+            column: 0,
+            position: 0,
+            code: "GENERATION_ERROR"
+          }
+        ],
+        warnings: []
+      };
+    }
+  }
+  generateJavaScript(ast) {
+    const lines = [];
+    lines.push("// Code généré par AlgoLang");
+    lines.push('import * as readline from "readline";');
+    lines.push("");
+    lines.push("const rl = readline.createInterface({");
+    lines.push("  input: process.stdin,");
+    lines.push("  output: process.stdout");
+    lines.push("});");
+    lines.push("");
+    const programCode = this.generateNode(ast);
+    lines.push(programCode);
+    lines.push("");
+    lines.push("// Fonctions utilitaires pour les entrées/sorties");
+    lines.push("function lire(prompt) {");
+    lines.push("  return new Promise((resolve) => {");
+    lines.push("    rl.question(prompt, (answer) => {");
+    lines.push("      resolve(answer.trim());");
+    lines.push("    });");
+    lines.push("  });");
+    lines.push("}");
+    lines.push("");
+    lines.push("function ecrire(...args) {");
+    lines.push("  console.log(...args);");
+    lines.push("}");
+    lines.push("");
+    lines.push("// Point d'entrée principal");
+    lines.push("main().then(() => {");
+    lines.push("  rl.close();");
+    lines.push("});");
+    return lines.join(`
+`);
+  }
+  generateNode(node) {
+    switch (node.type) {
+      case "PROGRAM":
+        return this.generateProgram(node);
+      case "BLOCK":
+        return this.generateBlock(node);
+      case "VAR_DECLARATION":
+        return this.generateVariableDeclaration(node);
+      case "COMPOUND_STATEMENT":
+        return this.generateCompoundStatement(node);
+      case "ASSIGNMENT":
+        return this.generateAssignment(node);
+      case "IF_STATEMENT":
+        return this.generateIfStatement(node);
+      case "WHILE_STATEMENT":
+        return this.generateWhileStatement(node);
+      case "FOR_STATEMENT":
+        return this.generateForStatement(node);
+      case "REPEAT_STATEMENT":
+        return this.generateRepeatStatement(node);
+      case "READ_STATEMENT":
+        return this.generateReadStatement(node);
+      case "WRITE_STATEMENT":
+        return this.generateWriteStatement(node);
+      case "BINARY_OP":
+        return this.generateBinaryOp(node);
+      case "UNARY_OP":
+        return this.generateUnaryOp(node);
+      case "LITERAL":
+        return this.generateLiteral(node);
+      case "VARIABLE":
+        return this.generateVariable(node);
+      default:
+        this.errors.push({
+          type: "ERROR",
+          message: `Type de nœud non supporté: ${node.type}`,
+          line: 0,
+          column: 0,
+          position: 0,
+          code: "UNSUPPORTED_NODE_TYPE"
+        });
+        return "";
+    }
+  }
+  generateProgram(node) {
+    const lines = [];
+    lines.push(`// Programme: ${node.value}`);
+    lines.push("async function main() {");
+    this.indentLevel++;
+    if (node.children && node.children.length > 0) {
+      for (const child of node.children) {
+        const childCode = this.generateNode(child);
+        if (childCode) {
+          lines.push(this.indent(childCode));
+        }
+      }
+    }
+    this.indentLevel--;
+    lines.push("}");
+    return lines.join(`
+`);
+  }
+  generateBlock(node) {
+    const lines = [];
+    if (node.children) {
+      for (const child of node.children) {
+        const childCode = this.generateNode(child);
+        if (childCode) {
+          lines.push(this.indent(childCode));
+        }
+      }
+    }
+    return lines.join(`
+`);
+  }
+  generateVariableDeclaration(node) {
+    const lines = [];
+    const varType = this.mapAlgoLangTypeToJS(node.value);
+    if (node.children) {
+      const variableNames = node.children.map((child) => child.value).join(", ");
+      lines.push(`let ${variableNames}; // ${varType}`);
+    }
+    return lines.join(`
+`);
+  }
+  generateCompoundStatement(node) {
+    const lines = [];
+    if (node.children) {
+      for (const child of node.children) {
+        const childCode = this.generateNode(child);
+        if (childCode) {
+          lines.push(this.indent(childCode));
+        }
+      }
+    }
+    return lines.join(`
+`);
+  }
+  generateAssignment(node) {
+    if (!node.children || node.children.length < 2) {
+      return "";
+    }
+    const variable = node.children[0];
+    const expression = node.children[1];
+    if (!variable || !expression) {
+      return "";
+    }
+    const variableName = variable.value;
+    const expressionCode = this.generateNode(expression);
+    return `${variableName} = ${expressionCode};`;
+  }
+  generateIfStatement(node) {
+    if (!node.children || node.children.length < 2) {
+      return "";
+    }
+    const condition = node.children[0];
+    const thenStatement = node.children[1];
+    const elseStatement = node.children[2];
+    if (!condition || !thenStatement) {
+      return "";
+    }
+    const conditionCode = this.generateNode(condition);
+    const thenCode = this.generateNode(thenStatement);
+    let code = `if (${conditionCode}) {
+`;
+    this.indentLevel++;
+    code += this.indent(thenCode) + `
+`;
+    this.indentLevel--;
+    code += "}";
+    if (elseStatement) {
+      const elseCode = this.generateNode(elseStatement);
+      code += ` else {
+`;
+      this.indentLevel++;
+      code += this.indent(elseCode) + `
+`;
+      this.indentLevel--;
+      code += "}";
+    }
+    return code;
+  }
+  generateWhileStatement(node) {
+    if (!node.children || node.children.length < 2) {
+      return "";
+    }
+    const condition = node.children[0];
+    const body = node.children[1];
+    if (!condition || !body) {
+      return "";
+    }
+    const conditionCode = this.generateNode(condition);
+    const bodyCode = this.generateNode(body);
+    let code = `while (${conditionCode}) {
+`;
+    this.indentLevel++;
+    code += this.indent(bodyCode) + `
+`;
+    this.indentLevel--;
+    code += "}";
+    return code;
+  }
+  generateForStatement(node) {
+    if (!node.children || node.children.length < 4) {
+      return "";
+    }
+    const variable = node.children[0];
+    const startValue = node.children[1];
+    const endValue = node.children[2];
+    const body = node.children[3];
+    if (!variable || !startValue || !endValue || !body) {
+      return "";
+    }
+    const variableName = variable.value;
+    const startCode = this.generateNode(startValue);
+    const endCode = this.generateNode(endValue);
+    const bodyCode = this.generateNode(body);
+    let code = `for (let ${variableName} = ${startCode}; ${variableName} <= ${endCode}; ${variableName}++) {
+`;
+    this.indentLevel++;
+    code += this.indent(bodyCode) + `
+`;
+    this.indentLevel--;
+    code += "}";
+    return code;
+  }
+  generateRepeatStatement(node) {
+    if (!node.children || node.children.length < 2) {
+      return "";
+    }
+    const conditionIndex = node.children.length - 1;
+    const condition = node.children[conditionIndex];
+    const bodyStatements = node.children.slice(0, conditionIndex);
+    if (!condition || bodyStatements.length === 0) {
+      return "";
+    }
+    const conditionCode = this.generateNode(condition);
+    let code = `do {
+`;
+    this.indentLevel++;
+    for (const statement of bodyStatements) {
+      const statementCode = this.generateNode(statement);
+      if (statementCode) {
+        code += this.indent(statementCode) + `
+`;
+      }
+    }
+    this.indentLevel--;
+    code += "} while (!(" + conditionCode + "));";
+    return code;
+  }
+  generateReadStatement(node) {
+    if (!node.children || node.children.length === 0) {
+      return "";
+    }
+    const variable = node.children[0];
+    if (!variable) {
+      return "";
+    }
+    const variableName = variable.value;
+    const symbolInfo = this.symbolTable.symbols.get(variableName);
+    let conversion = "";
+    if (symbolInfo) {
+      switch (symbolInfo.type) {
+        case "ENTIER":
+        case "REEL":
+          conversion = "parseInt(";
+          break;
+        case "BOOLEEN":
+          conversion = "(";
+          break;
+        default:
+          conversion = "";
+      }
+    }
+    if (conversion) {
+      return `${variableName} = ${conversion}await lire(""));`;
+    } else {
+      return `${variableName} = await lire("");`;
+    }
+  }
+  generateWriteStatement(node) {
+    if (!node.children || node.children.length === 0) {
+      return "";
+    }
+    const expressionCodes = [];
+    for (const child of node.children) {
+      if (child) {
+        const expressionCode = this.generateNode(child);
+        expressionCodes.push(expressionCode);
+      }
+    }
+    if (expressionCodes.length === 1) {
+      return `ecrire(${expressionCodes[0]});`;
+    }
+    const concatenated = expressionCodes.join(", ");
+    return `ecrire(${concatenated});`;
+  }
+  generateBinaryOp(node) {
+    if (!node.children || node.children.length < 2) {
+      return "";
+    }
+    const left = node.children[0];
+    const right = node.children[1];
+    const operator = node.value;
+    if (!left || !right) {
+      return "";
+    }
+    const leftCode = this.generateNode(left);
+    const rightCode = this.generateNode(right);
+    const jsOperator = this.mapOperator(operator);
+    return `(${leftCode} ${jsOperator} ${rightCode})`;
+  }
+  generateUnaryOp(node) {
+    if (!node.children || node.children.length === 0) {
+      return "";
+    }
+    const operand = node.children[0];
+    const operator = node.value;
+    if (!operand) {
+      return "";
+    }
+    const operandCode = this.generateNode(operand);
+    if (operator === "non") {
+      return `!(${operandCode})`;
+    } else if (operator === "-") {
+      return `-${operandCode}`;
+    }
+    return operandCode;
+  }
+  generateLiteral(node) {
+    if (node.value === undefined || node.value === null) {
+      return "null";
+    }
+    if (typeof node.value === "boolean") {
+      return node.value ? "true" : "false";
+    }
+    if (typeof node.value === "number") {
+      return node.value.toString();
+    }
+    if (typeof node.value === "string") {
+      return `"${node.value}"`;
+    }
+    return node.value?.toString() ?? "null";
+  }
+  generateVariable(node) {
+    return node.value;
+  }
+  mapAlgoLangTypeToJS(algoLangType) {
+    switch (algoLangType) {
+      case "ENTIER":
+        return "number";
+      case "REEL":
+        return "number";
+      case "BOOLEEN":
+        return "boolean";
+      case "CHAINE":
+        return "string";
+      default:
+        return "any";
+    }
+  }
+  mapOperator(operator) {
+    switch (operator) {
+      case ":=":
+        return "=";
+      case "=":
+        return "===";
+      case "<>":
+        return "!==";
+      case "<":
+        return "<";
+      case "<=":
+        return "<=";
+      case ">":
+        return ">";
+      case ">=":
+        return ">=";
+      case "et":
+        return "&&";
+      case "ou":
+        return "||";
+      case "non":
+        return "!";
+      default:
+        return operator;
+    }
+  }
+  indent(code) {
+    return "  ".repeat(this.indentLevel) + code;
+  }
+}
+// src/lexer/lexer.ts
+class Lexer2 {
+  source;
+  position = 0;
+  line = 1;
+  column = 1;
+  keywords;
+  constructor(source) {
+    this.source = source;
+    this.keywords = new Map([
+      ["PROGRAMME", "PROGRAMME" /* PROGRAM */],
+      ["DEBUT", "DEBUT" /* BEGIN */],
+      ["FIN", "FIN" /* END */],
+      ["VAR", "VAR" /* VAR */],
+      ["ENTIER", "ENTIER" /* INTEGER */],
+      ["REEL", "REEL" /* REAL */],
+      ["BOOLEEN", "BOOLEEN" /* BOOLEAN */],
+      ["CHAINE", "CHAINE" /* STRING */],
+      ["SI", "SI" /* IF */],
+      ["ALORS", "ALORS" /* THEN */],
+      ["SINON", "SINON" /* ELSE */],
+      ["FINSI", "FINIF" /* ENDIF */],
+      ["TANTQUE", "TANTQUE" /* WHILE */],
+      ["FAIRE", "FAIRE" /* DO */],
+      ["POUR", "POUR" /* FOR */],
+      ["ALLANT", "ALLANT" /* ALLANT */],
+      ["DE", "DE" /* DE */],
+      ["A", "A" /* TO */],
+      ["REPETER", "REPETER" /* REPEAT */],
+      ["JUSQUA", "JUSQUA" /* UNTIL */],
+      ["LIRE", "LIRE" /* READ */],
+      ["ECRIRE", "ECRIRE" /* WRITE */],
+      ["VRAI", "VRAI" /* TRUE */],
+      ["FAUX", "FAUX" /* FALSE */],
+      ["ET", "ET" /* AND */],
+      ["OU", "OU" /* OR */],
+      ["NON", "NON" /* NOT */],
+      ["FINPOUR", "FINPOUR" /* ENDFOR */],
+      ["FINTANTQUE", "FINTANTQUE" /* ENDWHILE */]
+    ]);
+  }
+  tokenize() {
+    const tokens = [];
+    while (!this.isAtEnd()) {
+      const token = this.scanToken();
+      if (token.type !== "COMMENT" /* COMMENT */) {
+        tokens.push(token);
+      }
+    }
+    tokens.push({
+      type: "EOF" /* EOF */,
+      value: "",
+      line: this.line,
+      column: this.column,
+      position: this.position
+    });
+    return tokens;
+  }
+  scanToken() {
+    this.skipWhitespace();
+    if (this.isAtEnd()) {
+      return this.createToken("EOF" /* EOF */, "");
+    }
+    const char = this.currentChar();
+    if (char === "/" && this.peek() === "/") {
+      return this.scanLineComment();
+    }
+    if (char === "/" && this.peek() === "*") {
+      return this.scanBlockComment();
+    }
+    if (char === '"') {
+      return this.scanString();
+    }
+    if (this.isDigit(char)) {
+      return this.scanNumber();
+    }
+    if (this.isAlpha(char)) {
+      return this.scanIdentifier();
+    }
+    if (char === ":" && this.peek() === "=") {
+      const token = this.createToken("ASSIGN" /* ASSIGN */, ":=");
+      this.advance();
+      this.advance();
+      return token;
+    }
+    if (char === "<" && this.peek() === "=") {
+      const token = this.createToken("LESS_EQUAL" /* LESS_EQUAL */, "<=");
+      this.advance();
+      this.advance();
+      return token;
+    }
+    if (char === ">" && this.peek() === "=") {
+      const token = this.createToken("GREATER_EQUAL" /* GREATER_EQUAL */, ">=");
+      this.advance();
+      this.advance();
+      return token;
+    }
+    if (char === "<" && this.peek() === ">") {
+      const token = this.createToken("NOT_EQUAL" /* NOT_EQUAL */, "<>");
+      this.advance();
+      this.advance();
+      return token;
+    }
+    switch (char) {
+      case "+":
+        return this.createToken("PLUS" /* PLUS */, this.advance());
+      case "-":
+        return this.createToken("MINUS" /* MINUS */, this.advance());
+      case "*":
+        return this.createToken("MULTIPLY" /* MULTIPLY */, this.advance());
+      case "/":
+        return this.createToken("DIVIDE" /* DIVIDE */, this.advance());
+      case "=":
+        return this.createToken("EQUAL" /* EQUAL */, this.advance());
+      case "<":
+        return this.createToken("LESS_THAN" /* LESS_THAN */, this.advance());
+      case ">":
+        return this.createToken("GREATER_THAN" /* GREATER_THAN */, this.advance());
+      case ";":
+        return this.createToken("SEMICOLON" /* SEMICOLON */, this.advance());
+      case ":":
+        return this.createToken("COLON" /* COLON */, this.advance());
+      case ",":
+        return this.createToken("COMMA" /* COMMA */, this.advance());
+      case ".":
+        return this.createToken("DOT" /* DOT */, this.advance());
+      case "(":
+        return this.createToken("LEFT_PAREN" /* LEFT_PAREN */, this.advance());
+      case ")":
+        return this.createToken("RIGHT_PAREN" /* RIGHT_PAREN */, this.advance());
+      default:
+        throw new Error(`Caractère non reconnu '${char}' à la ligne ${this.line}, colonne ${this.column}`);
+    }
+  }
+  scanIdentifier() {
+    const start = this.position;
+    const startColumn = this.column;
+    while (!this.isAtEnd() && this.isAlphaNumeric(this.currentChar())) {
+      this.advance();
+    }
+    const value = this.source.substring(start, this.position);
+    const type = this.keywords.get(value.toUpperCase()) || "IDENTIFIER" /* IDENTIFIER */;
+    return {
+      type,
+      value,
+      line: this.line,
+      column: startColumn,
+      position: start
+    };
+  }
+  scanNumber() {
+    const start = this.position;
+    const startColumn = this.column;
+    let hasDecimal = false;
+    while (!this.isAtEnd() && (this.isDigit(this.currentChar()) || this.currentChar() === ".")) {
+      if (this.currentChar() === ".") {
+        if (hasDecimal) {
+          throw new Error(`Nombre invalide: trop de points décimaux à la ligne ${this.line}, colonne ${this.column}`);
+        }
+        hasDecimal = true;
+      }
+      this.advance();
+    }
+    const value = this.source.substring(start, this.position);
+    return {
+      type: "NUMBER" /* NUMBER */,
+      value,
+      line: this.line,
+      column: startColumn,
+      position: start
+    };
+  }
+  scanString() {
+    const start = this.position;
+    const startColumn = this.column;
+    this.advance();
+    let value = "";
+    while (!this.isAtEnd() && this.currentChar() !== '"') {
+      if (this.currentChar() === "\\") {
+        this.advance();
+        if (this.isAtEnd()) {
+          throw new Error(`Chaîne de caractères non terminée à la ligne ${this.line}, colonne ${this.column}`);
+        }
+        const escaped = this.currentChar();
+        switch (escaped) {
+          case "n":
+            value += `
+`;
+            break;
+          case "t":
+            value += "\t";
+            break;
+          case "r":
+            value += "\r";
+            break;
+          case "\\":
+            value += "\\";
+            break;
+          case '"':
+            value += '"';
+            break;
+          default:
+            value += escaped;
+            break;
+        }
+        this.advance();
+      } else {
+        value += this.currentChar();
+        this.advance();
+      }
+    }
+    if (this.isAtEnd()) {
+      throw new Error(`Chaîne de caractères non terminée à la ligne ${this.line}, colonne ${this.column}`);
+    }
+    this.advance();
+    return {
+      type: "STRING_LITERAL" /* STRING_LITERAL */,
+      value,
+      line: this.line,
+      column: startColumn,
+      position: start
+    };
+  }
+  scanLineComment() {
+    const start = this.position;
+    const startColumn = this.column;
+    while (!this.isAtEnd() && this.currentChar() !== `
+`) {
+      this.advance();
+    }
+    const value = this.source.substring(start, this.position);
+    return {
+      type: "COMMENT" /* COMMENT */,
+      value,
+      line: this.line,
+      column: startColumn,
+      position: start
+    };
+  }
+  scanBlockComment() {
+    const start = this.position;
+    const startColumn = this.column;
+    this.advance();
+    while (!this.isAtEnd() && !(this.currentChar() === "*" && this.peek() === "/")) {
+      if (this.currentChar() === `
+`) {
+        this.line++;
+        this.column = 1;
+      } else {
+        this.column++;
+      }
+      this.advance();
+    }
+    if (this.isAtEnd()) {
+      throw new Error(`Commentaire bloc non terminé commençant à la ligne ${this.line}, colonne ${this.column}`);
+    }
+    this.advance();
+    this.advance();
+    const value = this.source.substring(start, this.position);
+    return {
+      type: "COMMENT" /* COMMENT */,
+      value,
+      line: this.line,
+      column: startColumn,
+      position: start
+    };
+  }
+  skipWhitespace() {
+    while (!this.isAtEnd() && this.isWhitespace(this.currentChar())) {
+      if (this.currentChar() === `
+`) {
+        this.line++;
+        this.column = 1;
+      } else {
+        this.column++;
+      }
+      this.advance();
+    }
+  }
+  createToken(type, value) {
+    return {
+      type,
+      value,
+      line: this.line,
+      column: this.column,
+      position: this.position
+    };
+  }
+  advance() {
+    const char = this.source[this.position];
+    this.position++;
+    return char !== undefined ? char : "\x00";
+  }
+  currentChar() {
+    const char = this.source[this.position];
+    return char !== undefined ? char : "\x00";
+  }
+  peek() {
+    if (this.position + 1 >= this.source.length) {
+      return "\x00";
+    }
+    const char = this.source[this.position + 1];
+    return char !== undefined ? char : "\x00";
+  }
+  isAtEnd() {
+    return this.position >= this.source.length;
+  }
+  isDigit(char) {
+    return char >= "0" && char <= "9";
+  }
+  isAlpha(char) {
+    return char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char >= "À" && char <= "ÿ" || char === "_" || char === "'";
+  }
+  isAlphaNumeric(char) {
+    return this.isAlpha(char) || this.isDigit(char);
+  }
+  isWhitespace(char) {
+    return char === " " || char === "\t" || char === `
+` || char === "\r";
+  }
+}
+
+// src/parser/parser.ts
+class Parser2 {
+  tokens;
+  current = 0;
+  errors = [];
+  symbolTable;
+  reservedKeywords = new Set([
+    "programme",
+    "debut",
+    "fin",
+    "var",
+    "entier",
+    "reel",
+    "booleen",
+    "chaine",
+    "si",
+    "alors",
+    "sinon",
+    "finsi",
+    "tantque",
+    "faire",
+    "fintantque",
+    "pour",
+    "a",
+    "finpour",
+    "repeter",
+    "jusqua",
+    "lire",
+    "ecrire",
+    "vrai",
+    "faux",
+    "et",
+    "ou",
+    "non",
+    "fonction",
+    "procedure",
+    "retourner"
+  ]);
+  constructor(tokens) {
+    this.tokens = tokens;
+    this.symbolTable = {
+      symbols: new Map,
+      children: [],
+      scopeName: "global"
+    };
+  }
+  isReservedKeyword(identifier) {
+    return this.reservedKeywords.has(identifier.toLowerCase());
+  }
+  isKeywordToken(tokenType) {
+    return [
+      "PROGRAMME" /* PROGRAM */,
+      "DEBUT" /* BEGIN */,
+      "FIN" /* END */,
+      "VAR" /* VAR */,
+      "ENTIER" /* INTEGER */,
+      "REEL" /* REAL */,
+      "BOOLEEN" /* BOOLEAN */,
+      "CHAINE" /* STRING */,
+      "SI" /* IF */,
+      "ALORS" /* THEN */,
+      "SINON" /* ELSE */,
+      "TANTQUE" /* WHILE */,
+      "FAIRE" /* DO */,
+      "POUR" /* FOR */,
+      "ALLANT" /* ALLANT */,
+      "DE" /* DE */,
+      "A" /* TO */,
+      "REPETER" /* REPEAT */,
+      "JUSQUA" /* UNTIL */,
+      "LIRE" /* READ */,
+      "ECRIRE" /* WRITE */,
+      "VRAI" /* TRUE */,
+      "FAUX" /* FALSE */,
+      "ET" /* AND */,
+      "OU" /* OR */,
+      "NON" /* NOT */,
+      "FINPOUR" /* ENDFOR */,
+      "FINIF" /* ENDIF */,
+      "FINTANTQUE" /* ENDWHILE */
+    ].includes(tokenType);
+  }
+  createReservedKeywordError(identifier, token) {
+    this.errors.push({
+      type: "ERROR",
+      message: `Le nom '${identifier}' est un mot-clé réservé et ne peut pas être utilisé comme nom de variable`,
+      line: token.line,
+      column: token.column,
+      position: token.position,
+      code: "RESERVED_KEYWORD",
+      explanation: "Les mots-clés réservés sont utilisés par le langage AlgoLang pour définir la structure du programme et ne peuvent pas être utilisés comme noms de variables.",
+      suggestion: `Choisissez un autre nom plus descriptif, par exemple: '${identifier}Valeur', '${identifier}Temp', 'ma${identifier.charAt(0).toUpperCase() + identifier.slice(1)}'`
+    });
+  }
+  parse() {
+    try {
+      const program = this.parseProgram();
+      return {
+        ast: program,
+        errors: this.errors,
+        symbolTable: this.symbolTable
+      };
+    } catch (error) {
+      return {
+        ast: { type: "PROGRAM" /* PROGRAM */, children: [] },
+        errors: [
+          ...this.errors,
+          {
+            type: "ERROR",
+            message: error instanceof Error ? error.message : "Erreur de parsing inconnue",
+            line: 1,
+            column: 1,
+            position: 0,
+            code: "PARSE_ERROR"
+          }
+        ],
+        symbolTable: this.symbolTable
+      };
+    }
+  }
+  parseProgram() {
+    const programToken = this.expect("PROGRAMME" /* PROGRAM */, 'Le programme doit commencer par le mot-clé "programme"');
+    const identifier = this.expect("IDENTIFIER" /* IDENTIFIER */, "Le programme doit avoir un nom");
+    this.expect("SEMICOLON" /* SEMICOLON */, "Le nom du programme doit être suivi d'un point-virgule");
+    const block = this.parseBlock();
+    return {
+      type: "PROGRAM" /* PROGRAM */,
+      value: identifier.value,
+      children: [block],
+      token: programToken
+    };
+  }
+  parseBlock() {
+    const declarations = this.parseDeclarations();
+    const compoundStatement = this.parseCompoundStatement();
+    return {
+      type: "BLOCK" /* BLOCK */,
+      children: [declarations, compoundStatement]
+    };
+  }
+  parseDeclarations() {
+    const declarations = [];
+    while (this.check("VAR" /* VAR */)) {
+      this.advance();
+      while (!this.check("DEBUT" /* BEGIN */) && !this.isAtEnd()) {
+        const declaration = this.parseVariableDeclaration();
+        declarations.push(declaration);
+        if (!this.check("SEMICOLON" /* SEMICOLON */)) {
+          break;
+        }
+        this.advance();
+      }
+    }
+    return {
+      type: "BLOCK" /* BLOCK */,
+      children: declarations
+    };
+  }
+  parseVariableDeclaration() {
+    const identifiers = [];
+    do {
+      let identifier;
+      if (this.check("IDENTIFIER" /* IDENTIFIER */)) {
+        identifier = this.advance();
+      } else {
+        const currentToken = this.peek();
+        if (this.isKeywordToken(currentToken.type)) {
+          identifier = this.advance();
+          this.createReservedKeywordError(identifier.value, identifier);
+        } else {
+          this.expect("IDENTIFIER" /* IDENTIFIER */, "Identificateur attendu dans la déclaration de variable");
+          break;
+        }
+      }
+      if (this.isReservedKeyword(identifier.value)) {
+        this.createReservedKeywordError(identifier.value, identifier);
+      }
+      identifiers.push(identifier.value);
+      if (this.check("COMMA" /* COMMA */)) {
+        this.advance();
+      } else {
+        break;
+      }
+    } while (true);
+    this.expect("COLON" /* COLON */, "Deux-points attendus après les identificateurs");
+    const typeToken = this.expect(["ENTIER" /* INTEGER */, "REEL" /* REAL */, "BOOLEEN" /* BOOLEAN */, "CHAINE" /* STRING */], "Type de variable attendu");
+    const type = this.tokenTypeToDataType(typeToken.type);
+    for (const identifier of identifiers) {
+      if (this.symbolTable.symbols.has(identifier)) {
+        this.errors.push({
+          type: "ERROR",
+          message: `La variable '${identifier}' est déjà déclarée`,
+          line: typeToken.line,
+          column: typeToken.column,
+          position: typeToken.position,
+          code: "DUPLICATE_VARIABLE",
+          explanation: "Chaque variable doit avoir un nom unique dans son scope",
+          suggestion: `Choisissez un autre nom pour la variable '${identifier}'`
+        });
+      } else {
+        const symbolInfo = {
+          name: identifier,
+          type,
+          scope: this.symbolTable.scopeName,
+          line: typeToken.line,
+          column: typeToken.column
+        };
+        this.symbolTable.symbols.set(identifier, symbolInfo);
+      }
+    }
+    return {
+      type: "VAR_DECLARATION" /* VAR_DECLARATION */,
+      value: type,
+      children: identifiers.map((name) => ({
+        type: "VARIABLE" /* VARIABLE */,
+        value: name
+      })),
+      token: typeToken
+    };
+  }
+  parseCompoundStatement() {
+    this.expect("DEBUT" /* BEGIN */, `Le bloc d'instructions doit commencer par "debut"`);
+    const statements = [];
+    while (!this.check("FIN" /* END */) && !this.isAtEnd()) {
+      const statement = this.parseStatement();
+      statements.push(statement);
+      if (this.check("SEMICOLON" /* SEMICOLON */)) {
+        this.advance();
+      } else if (!this.check("FIN" /* END */) && !this.check("FINIF" /* ENDIF */) && !this.check("FINTANTQUE" /* ENDWHILE */)) {
+        this.errors.push({
+          type: "ERROR",
+          message: "Point-virgule attendu après l'instruction",
+          line: this.peek().line,
+          column: this.peek().column,
+          position: this.peek().position,
+          code: "MISSING_SEMICOLON"
+        });
+        break;
+      }
+    }
+    this.expect("FIN" /* END */, `Le bloc d'instructions doit se terminer par "fin"`);
+    return {
+      type: "COMPOUND_STATEMENT" /* COMPOUND_STATEMENT */,
+      children: statements
+    };
+  }
+  parseStatement() {
+    if (this.check("DEBUT" /* BEGIN */)) {
+      return this.parseCompoundStatement();
+    }
+    if (this.isKeywordToken(this.peek().type) && this.peekAhead(1)?.type === "ASSIGN" /* ASSIGN */) {
+      return this.parseAssignment();
+    }
+    if (this.check("SI" /* IF */)) {
+      return this.parseIfStatement();
+    }
+    if (this.check("TANTQUE" /* WHILE */)) {
+      return this.parseWhileStatement();
+    }
+    if (this.check("POUR" /* FOR */)) {
+      return this.parseForStatement();
+    }
+    if (this.check("REPETER" /* REPEAT */)) {
+      return this.parseRepeatStatement();
+    }
+    if (this.check("LIRE" /* READ */)) {
+      return this.parseReadStatement();
+    }
+    if (this.check("ECRIRE" /* WRITE */)) {
+      return this.parseWriteStatement();
+    }
+    return this.parseAssignment();
+  }
+  parseIfStatement(isElseIf = false) {
+    const ifToken = this.advance();
+    const condition = this.parseExpression();
+    this.expect("ALORS" /* THEN */, '"alors" attendu après la condition du si');
+    const thenStatements = [];
+    while (!this.check("SINON" /* ELSE */) && !this.check("FINIF" /* ENDIF */) && !this.check("FIN" /* END */) && !this.isAtEnd()) {
+      const statement = this.parseStatement();
+      thenStatements.push(statement);
+      if (this.check("SEMICOLON" /* SEMICOLON */)) {
+        this.advance();
+      }
+    }
+    const thenStatement = {
+      type: "COMPOUND_STATEMENT" /* COMPOUND_STATEMENT */,
+      children: thenStatements
+    };
+    let elseStatement;
+    if (this.check("SEMICOLON" /* SEMICOLON */) && this.peekAhead(1)?.type === "SINON" /* ELSE */) {
+      this.advance();
+    }
+    if (this.check("SINON" /* ELSE */)) {
+      this.advance();
+      if (this.check("SI" /* IF */)) {
+        elseStatement = this.parseIfStatement(true);
+      } else {
+        const elseStatements = [];
+        while (!this.check("FINIF" /* ENDIF */) && !this.check("FIN" /* END */) && !this.isAtEnd()) {
+          const statement = this.parseStatement();
+          elseStatements.push(statement);
+          if (this.check("SEMICOLON" /* SEMICOLON */)) {
+            this.advance();
+          }
+        }
+        elseStatement = {
+          type: "COMPOUND_STATEMENT" /* COMPOUND_STATEMENT */,
+          children: elseStatements
+        };
+      }
+    }
+    if (!isElseIf) {
+      if (this.check("SEMICOLON" /* SEMICOLON */) && this.peekAhead(1)?.type === "FINIF" /* ENDIF */) {
+        this.advance();
+      }
+      this.expect("FINIF" /* ENDIF */, '"finsi" attendu à la fin du bloc si');
+    }
+    return {
+      type: "IF_STATEMENT" /* IF_STATEMENT */,
+      children: [
+        condition,
+        thenStatement,
+        ...elseStatement ? [elseStatement] : []
+      ],
+      token: ifToken
+    };
+  }
+  parseWhileStatement() {
+    const whileToken = this.advance();
+    const condition = this.parseExpression();
+    this.expect("FAIRE" /* DO */, '"faire" attendu après la condition du tantque');
+    const bodyStatements = [];
+    while (!this.check("FINTANTQUE" /* ENDWHILE */) && !this.check("FIN" /* END */) && !this.isAtEnd()) {
+      const statement = this.parseStatement();
+      bodyStatements.push(statement);
+      if (this.check("SEMICOLON" /* SEMICOLON */)) {
+        this.advance();
+      }
+    }
+    this.expect("FINTANTQUE" /* ENDWHILE */, '"fintantque" attendu à la fin de la boucle tantque');
+    return {
+      type: "WHILE_STATEMENT" /* WHILE_STATEMENT */,
+      children: [
+        condition,
+        { type: "COMPOUND_STATEMENT" /* COMPOUND_STATEMENT */, children: bodyStatements }
+      ],
+      token: whileToken
+    };
+  }
+  parseForStatement() {
+    const forToken = this.advance();
+    const variable = this.expect("IDENTIFIER" /* IDENTIFIER */, 'Identificateur attendu après "pour"');
+    let startValue;
+    if (this.check("ALLANT" /* ALLANT */)) {
+      this.advance();
+      this.expect("DE" /* DE */, '"de" attendu après "allant" dans la boucle pour');
+      startValue = this.parseExpression();
+    } else if (this.check("ASSIGN" /* ASSIGN */)) {
+      this.advance();
+      startValue = this.parseExpression();
+    } else {
+      throw new Error('"allant de" ou ":=" attendu après la variable dans la boucle pour');
+    }
+    this.expect("A" /* TO */, '"a" attendu dans la boucle pour');
+    const endValue = this.parseExpression();
+    this.expect("FAIRE" /* DO */, '"faire" attendu dans la boucle pour');
+    const bodyStatements = [];
+    while (!this.check("FINPOUR" /* ENDFOR */) && !this.check("FIN" /* END */) && !this.isAtEnd()) {
+      const statement = this.parseStatement();
+      bodyStatements.push(statement);
+      if (this.check("SEMICOLON" /* SEMICOLON */)) {
+        this.advance();
+      }
+    }
+    this.expect("FINPOUR" /* ENDFOR */, '"finpour" attendu à la fin de la boucle pour');
+    return {
+      type: "FOR_STATEMENT" /* FOR_STATEMENT */,
+      children: [
+        { type: "VARIABLE" /* VARIABLE */, value: variable.value, token: variable },
+        startValue,
+        endValue,
+        { type: "COMPOUND_STATEMENT" /* COMPOUND_STATEMENT */, children: bodyStatements }
+      ],
+      token: forToken
+    };
+  }
+  parseReadStatement() {
+    const readToken = this.advance();
+    this.expect("LEFT_PAREN" /* LEFT_PAREN */, 'Parenthèse ouvrante attendue après "lire"');
+    let variable;
+    if (this.check("IDENTIFIER" /* IDENTIFIER */)) {
+      variable = this.advance();
+    } else {
+      const currentToken = this.peek();
+      if (this.isKeywordToken(currentToken.type)) {
+        variable = this.advance();
+        this.createReservedKeywordError(variable.value, variable);
+      } else {
+        this.expect("IDENTIFIER" /* IDENTIFIER */, 'Variable attendue dans "lire"');
+        throw new Error('Variable attendue dans "lire"');
+      }
+    }
+    this.expect("RIGHT_PAREN" /* RIGHT_PAREN */, 'Parenthèse fermante attendue dans "lire"');
+    return {
+      type: "READ_STATEMENT" /* READ_STATEMENT */,
+      children: [
+        { type: "VARIABLE" /* VARIABLE */, value: variable.value, token: variable }
+      ],
+      token: readToken
+    };
+  }
+  parseWriteStatement() {
+    const writeToken = this.advance();
+    this.expect("LEFT_PAREN" /* LEFT_PAREN */, 'Parenthèse ouvrante attendue après "ecrire"');
+    const expressions = [];
+    expressions.push(this.parseExpression());
+    while (this.check("COMMA" /* COMMA */)) {
+      this.advance();
+      expressions.push(this.parseExpression());
+    }
+    this.expect("RIGHT_PAREN" /* RIGHT_PAREN */, 'Parenthèse fermante attendue dans "ecrire"');
+    return {
+      type: "WRITE_STATEMENT" /* WRITE_STATEMENT */,
+      children: expressions,
+      token: writeToken
+    };
+  }
+  parseAssignment() {
+    let variable;
+    if (this.check("IDENTIFIER" /* IDENTIFIER */)) {
+      variable = this.advance();
+    } else {
+      const currentToken = this.peek();
+      if (this.isKeywordToken(currentToken.type)) {
+        variable = this.advance();
+        this.createReservedKeywordError(variable.value, variable);
+      } else {
+        this.expect("IDENTIFIER" /* IDENTIFIER */, "Variable attendue dans l'affectation");
+        throw new Error("Variable attendue dans l'affectation");
+      }
+    }
+    if (this.isReservedKeyword(variable.value)) {
+      this.createReservedKeywordError(variable.value, variable);
+    }
+    this.expect("ASSIGN" /* ASSIGN */, `":=" attendu dans l'affectation`);
+    const expression = this.parseExpression();
+    return {
+      type: "ASSIGNMENT" /* ASSIGNMENT */,
+      children: [
+        { type: "VARIABLE" /* VARIABLE */, value: variable.value, token: variable },
+        expression
+      ],
+      token: variable
+    };
+  }
+  parseExpression() {
+    return this.parseOrExpression();
+  }
+  parseOrExpression() {
+    let left = this.parseAndExpression();
+    while (this.check("OU" /* OR */)) {
+      const operator = this.advance();
+      const right = this.parseAndExpression();
+      left = {
+        type: "BINARY_OP" /* BINARY_OP */,
+        value: operator.value,
+        children: [left, right],
+        token: operator
+      };
+    }
+    return left;
+  }
+  parseAndExpression() {
+    let left = this.parseEqualityExpression();
+    while (this.check("ET" /* AND */)) {
+      const operator = this.advance();
+      const right = this.parseEqualityExpression();
+      left = {
+        type: "BINARY_OP" /* BINARY_OP */,
+        value: operator.value,
+        children: [left, right],
+        token: operator
+      };
+    }
+    return left;
+  }
+  parseEqualityExpression() {
+    let left = this.parseRelationalExpression();
+    while (this.check(["EQUAL" /* EQUAL */, "NOT_EQUAL" /* NOT_EQUAL */])) {
+      const operator = this.advance();
+      const right = this.parseRelationalExpression();
+      left = {
+        type: "BINARY_OP" /* BINARY_OP */,
+        value: operator.value,
+        children: [left, right],
+        token: operator
+      };
+    }
+    return left;
+  }
+  parseRelationalExpression() {
+    let left = this.parseAdditiveExpression();
+    while (this.check([
+      "LESS_THAN" /* LESS_THAN */,
+      "LESS_EQUAL" /* LESS_EQUAL */,
+      "GREATER_THAN" /* GREATER_THAN */,
+      "GREATER_EQUAL" /* GREATER_EQUAL */
+    ])) {
+      const operator = this.advance();
+      const right = this.parseAdditiveExpression();
+      left = {
+        type: "BINARY_OP" /* BINARY_OP */,
+        value: operator.value,
+        children: [left, right],
+        token: operator
+      };
+    }
+    return left;
+  }
+  parseAdditiveExpression() {
+    let left = this.parseMultiplicativeExpression();
+    while (this.check(["PLUS" /* PLUS */, "MINUS" /* MINUS */])) {
+      const operator = this.advance();
+      const right = this.parseMultiplicativeExpression();
+      left = {
+        type: "BINARY_OP" /* BINARY_OP */,
+        value: operator.value,
+        children: [left, right],
+        token: operator
+      };
+    }
+    return left;
+  }
+  parseMultiplicativeExpression() {
+    let left = this.parseUnaryExpression();
+    while (this.check(["MULTIPLY" /* MULTIPLY */, "DIVIDE" /* DIVIDE */])) {
+      const operator = this.advance();
+      const right = this.parseUnaryExpression();
+      left = {
+        type: "BINARY_OP" /* BINARY_OP */,
+        value: operator.value,
+        children: [left, right],
+        token: operator
+      };
+    }
+    return left;
+  }
+  parseUnaryExpression() {
+    if (this.check("NON" /* NOT */)) {
+      const nextToken = this.peekAhead();
+      if (nextToken && [
+        "RIGHT_PAREN" /* RIGHT_PAREN */,
+        "SEMICOLON" /* SEMICOLON */,
+        "COMMA" /* COMMA */,
+        "EOF" /* EOF */
+      ].includes(nextToken.type)) {
+        return this.parsePrimary();
+      }
+    }
+    if (this.check(["NON" /* NOT */, "MINUS" /* MINUS */])) {
+      const operator = this.advance();
+      const operand = this.parseUnaryExpression();
+      return {
+        type: "UNARY_OP" /* UNARY_OP */,
+        value: operator.value,
+        children: [operand],
+        token: operator
+      };
+    }
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    if (this.check("NUMBER" /* NUMBER */)) {
+      const token2 = this.advance();
+      return {
+        type: "LITERAL" /* LITERAL */,
+        value: parseFloat(token2.value),
+        token: token2
+      };
+    }
+    if (this.check(["VRAI" /* TRUE */, "FAUX" /* FALSE */])) {
+      const token2 = this.advance();
+      return {
+        type: "LITERAL" /* LITERAL */,
+        value: token2.value === "vrai",
+        token: token2
+      };
+    }
+    if (this.check("STRING_LITERAL" /* STRING_LITERAL */)) {
+      const token2 = this.advance();
+      return {
+        type: "LITERAL" /* LITERAL */,
+        value: token2.value,
+        token: token2
+      };
+    }
+    if (this.check("IDENTIFIER" /* IDENTIFIER */)) {
+      const token2 = this.advance();
+      if (this.isReservedKeyword(token2.value)) {
+        this.createReservedKeywordError(token2.value, token2);
+      }
+      return {
+        type: "VARIABLE" /* VARIABLE */,
+        value: token2.value,
+        token: token2
+      };
+    }
+    const currentToken = this.peek();
+    if (this.isKeywordToken(currentToken.type)) {
+      const token2 = this.advance();
+      this.createReservedKeywordError(token2.value, token2);
+      return {
+        type: "VARIABLE" /* VARIABLE */,
+        value: token2.value,
+        token: token2
+      };
+    }
+    if (this.check("LEFT_PAREN" /* LEFT_PAREN */)) {
+      this.advance();
+      const expression = this.parseExpression();
+      this.expect("RIGHT_PAREN" /* RIGHT_PAREN */, "Parenthèse fermante attendue");
+      return expression;
+    }
+    const token = this.peek();
+    this.errors.push({
+      type: "ERROR",
+      message: `Expression inattendue: ${token.value}`,
+      line: token.line,
+      column: token.column,
+      position: token.position,
+      code: "UNEXPECTED_TOKEN"
+    });
+    this.advance();
+    return {
+      type: "LITERAL" /* LITERAL */,
+      value: 0
+    };
+  }
+  parseRepeatStatement() {
+    const repeatToken = this.advance();
+    const statements = [];
+    while (!this.check("JUSQUA" /* UNTIL */) && !this.isAtEnd()) {
+      const statement = this.parseStatement();
+      statements.push(statement);
+      if (this.check("SEMICOLON" /* SEMICOLON */)) {
+        this.advance();
+      }
+    }
+    this.expect("JUSQUA" /* UNTIL */, '"jusqua" attendu à la fin de la boucle repeter');
+    const condition = this.parseExpression();
+    return {
+      type: "REPEAT_STATEMENT" /* REPEAT_STATEMENT */,
+      children: [...statements, condition],
+      token: repeatToken
+    };
+  }
+  check(type) {
+    if (this.isAtEnd())
+      return false;
+    if (Array.isArray(type)) {
+      return type.includes(this.peek().type);
+    }
+    return this.peek().type === type;
+  }
+  advance() {
+    if (!this.isAtEnd())
+      this.current++;
+    return this.previous();
+  }
+  isAtEnd() {
+    return this.peek().type === "EOF";
+  }
+  peek() {
+    return this.tokens[this.current] ?? {
+      type: "EOF" /* EOF */,
+      value: "",
+      line: 0,
+      column: 0,
+      position: 0
+    };
+  }
+  peekAhead(offset = 1) {
+    return this.tokens[this.current + offset];
+  }
+  previous() {
+    return this.tokens[this.current - 1] ?? {
+      type: "EOF" /* EOF */,
+      value: "",
+      line: 0,
+      column: 0,
+      position: 0
+    };
+  }
+  expect(type, message) {
+    if (this.check(type)) {
+      return this.advance();
+    }
+    const token = this.peek();
+    this.errors.push({
+      type: "ERROR",
+      message,
+      line: token.line,
+      column: token.column,
+      position: token.position,
+      code: "EXPECTED_TOKEN",
+      explanation: `Attendu: ${Array.isArray(type) ? type.join(" ou ") : type}, Trouvé: ${token.type}`,
+      suggestion: "Vérifiez la syntaxe de votre programme"
+    });
+    throw new Error(message);
+  }
+  tokenTypeToDataType(tokenType) {
+    switch (tokenType) {
+      case "ENTIER" /* INTEGER */:
+        return "ENTIER" /* INTEGER */;
+      case "REEL" /* REAL */:
+        return "REEL" /* REAL */;
+      case "BOOLEEN" /* BOOLEAN */:
+        return "BOOLEEN" /* BOOLEAN */;
+      case "CHAINE" /* STRING */:
+        return "CHAINE" /* STRING */;
+      default:
+        return "VIDE" /* VOID */;
+    }
+  }
+}
+
+// src/codegen/codegen.ts
+class CodeGenerator2 {
+  symbolTable;
+  errors = [];
+  indentLevel = 0;
+  constructor(symbolTable, _options) {
+    this.symbolTable = symbolTable;
+  }
+  generate(ast) {
+    try {
+      const output = this.generateJavaScript(ast);
+      return {
+        success: this.errors.length === 0,
+        output,
+        errors: this.errors,
+        warnings: [],
+        symbolTable: this.symbolTable,
+        ast
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: "",
+        errors: [
+          ...this.errors,
+          {
+            type: "ERROR",
+            message: error instanceof Error ? error.message : "Erreur inconnue lors de la génération de code",
+            line: 0,
+            column: 0,
+            position: 0,
+            code: "GENERATION_ERROR"
+          }
+        ],
+        warnings: []
+      };
+    }
+  }
+  generateJavaScript(ast) {
+    const lines = [];
+    lines.push("// Code généré par AlgoLang");
+    lines.push('import * as readline from "readline";');
+    lines.push("");
+    lines.push("const rl = readline.createInterface({");
+    lines.push("  input: process.stdin,");
+    lines.push("  output: process.stdout");
+    lines.push("});");
+    lines.push("");
+    const programCode = this.generateNode(ast);
+    lines.push(programCode);
+    lines.push("");
+    lines.push("// Fonctions utilitaires pour les entrées/sorties");
+    lines.push("function lire(prompt) {");
+    lines.push("  return new Promise((resolve) => {");
+    lines.push("    rl.question(prompt, (answer) => {");
+    lines.push("      resolve(answer.trim());");
+    lines.push("    });");
+    lines.push("  });");
+    lines.push("}");
+    lines.push("");
+    lines.push("function ecrire(...args) {");
+    lines.push("  console.log(...args);");
+    lines.push("}");
+    lines.push("");
+    lines.push("// Point d'entrée principal");
+    lines.push("main().then(() => {");
+    lines.push("  rl.close();");
+    lines.push("});");
+    return lines.join(`
+`);
+  }
+  generateNode(node) {
+    switch (node.type) {
+      case "PROGRAM":
+        return this.generateProgram(node);
+      case "BLOCK":
+        return this.generateBlock(node);
+      case "VAR_DECLARATION":
+        return this.generateVariableDeclaration(node);
+      case "COMPOUND_STATEMENT":
+        return this.generateCompoundStatement(node);
+      case "ASSIGNMENT":
+        return this.generateAssignment(node);
+      case "IF_STATEMENT":
+        return this.generateIfStatement(node);
+      case "WHILE_STATEMENT":
+        return this.generateWhileStatement(node);
+      case "FOR_STATEMENT":
+        return this.generateForStatement(node);
+      case "REPEAT_STATEMENT":
+        return this.generateRepeatStatement(node);
+      case "READ_STATEMENT":
+        return this.generateReadStatement(node);
+      case "WRITE_STATEMENT":
+        return this.generateWriteStatement(node);
+      case "BINARY_OP":
+        return this.generateBinaryOp(node);
+      case "UNARY_OP":
+        return this.generateUnaryOp(node);
+      case "LITERAL":
+        return this.generateLiteral(node);
+      case "VARIABLE":
+        return this.generateVariable(node);
+      default:
+        this.errors.push({
+          type: "ERROR",
+          message: `Type de nœud non supporté: ${node.type}`,
+          line: 0,
+          column: 0,
+          position: 0,
+          code: "UNSUPPORTED_NODE_TYPE"
+        });
+        return "";
+    }
+  }
+  generateProgram(node) {
+    const lines = [];
+    lines.push(`// Programme: ${node.value}`);
+    lines.push("async function main() {");
+    this.indentLevel++;
+    if (node.children && node.children.length > 0) {
+      for (const child of node.children) {
+        const childCode = this.generateNode(child);
+        if (childCode) {
+          lines.push(this.indent(childCode));
+        }
+      }
+    }
+    this.indentLevel--;
+    lines.push("}");
+    return lines.join(`
+`);
+  }
+  generateBlock(node) {
+    const lines = [];
+    if (node.children) {
+      for (const child of node.children) {
+        const childCode = this.generateNode(child);
+        if (childCode) {
+          lines.push(this.indent(childCode));
+        }
+      }
+    }
+    return lines.join(`
+`);
+  }
+  generateVariableDeclaration(node) {
+    const lines = [];
+    const varType = this.mapAlgoLangTypeToJS(node.value);
+    if (node.children) {
+      const variableNames = node.children.map((child) => child.value).join(", ");
+      lines.push(`let ${variableNames}; // ${varType}`);
+    }
+    return lines.join(`
+`);
+  }
+  generateCompoundStatement(node) {
+    const lines = [];
+    if (node.children) {
+      for (const child of node.children) {
+        const childCode = this.generateNode(child);
+        if (childCode) {
+          lines.push(this.indent(childCode));
+        }
+      }
+    }
+    return lines.join(`
+`);
+  }
+  generateAssignment(node) {
+    if (!node.children || node.children.length < 2) {
+      return "";
+    }
+    const variable = node.children[0];
+    const expression = node.children[1];
+    if (!variable || !expression) {
+      return "";
+    }
+    const variableName = variable.value;
+    const expressionCode = this.generateNode(expression);
+    return `${variableName} = ${expressionCode};`;
+  }
+  generateIfStatement(node) {
+    if (!node.children || node.children.length < 2) {
+      return "";
+    }
+    const condition = node.children[0];
+    const thenStatement = node.children[1];
+    const elseStatement = node.children[2];
+    if (!condition || !thenStatement) {
+      return "";
+    }
+    const conditionCode = this.generateNode(condition);
+    const thenCode = this.generateNode(thenStatement);
+    let code = `if (${conditionCode}) {
+`;
+    this.indentLevel++;
+    code += this.indent(thenCode) + `
+`;
+    this.indentLevel--;
+    code += "}";
+    if (elseStatement) {
+      const elseCode = this.generateNode(elseStatement);
+      code += ` else {
+`;
+      this.indentLevel++;
+      code += this.indent(elseCode) + `
+`;
+      this.indentLevel--;
+      code += "}";
+    }
+    return code;
+  }
+  generateWhileStatement(node) {
+    if (!node.children || node.children.length < 2) {
+      return "";
+    }
+    const condition = node.children[0];
+    const body = node.children[1];
+    if (!condition || !body) {
+      return "";
+    }
+    const conditionCode = this.generateNode(condition);
+    const bodyCode = this.generateNode(body);
+    let code = `while (${conditionCode}) {
+`;
+    this.indentLevel++;
+    code += this.indent(bodyCode) + `
+`;
+    this.indentLevel--;
+    code += "}";
+    return code;
+  }
+  generateForStatement(node) {
+    if (!node.children || node.children.length < 4) {
+      return "";
+    }
+    const variable = node.children[0];
+    const startValue = node.children[1];
+    const endValue = node.children[2];
+    const body = node.children[3];
+    if (!variable || !startValue || !endValue || !body) {
+      return "";
+    }
+    const variableName = variable.value;
+    const startCode = this.generateNode(startValue);
+    const endCode = this.generateNode(endValue);
+    const bodyCode = this.generateNode(body);
+    let code = `for (let ${variableName} = ${startCode}; ${variableName} <= ${endCode}; ${variableName}++) {
+`;
+    this.indentLevel++;
+    code += this.indent(bodyCode) + `
+`;
+    this.indentLevel--;
+    code += "}";
+    return code;
+  }
+  generateRepeatStatement(node) {
+    if (!node.children || node.children.length < 2) {
+      return "";
+    }
+    const conditionIndex = node.children.length - 1;
+    const condition = node.children[conditionIndex];
+    const bodyStatements = node.children.slice(0, conditionIndex);
+    if (!condition || bodyStatements.length === 0) {
+      return "";
+    }
+    const conditionCode = this.generateNode(condition);
+    let code = `do {
+`;
+    this.indentLevel++;
+    for (const statement of bodyStatements) {
+      const statementCode = this.generateNode(statement);
+      if (statementCode) {
+        code += this.indent(statementCode) + `
+`;
+      }
+    }
+    this.indentLevel--;
+    code += "} while (!(" + conditionCode + "));";
+    return code;
+  }
+  generateReadStatement(node) {
+    if (!node.children || node.children.length === 0) {
+      return "";
+    }
+    const variable = node.children[0];
+    if (!variable) {
+      return "";
+    }
+    const variableName = variable.value;
+    const symbolInfo = this.symbolTable.symbols.get(variableName);
+    let conversion = "";
+    if (symbolInfo) {
+      switch (symbolInfo.type) {
+        case "ENTIER":
+        case "REEL":
+          conversion = "parseInt(";
+          break;
+        case "BOOLEEN":
+          conversion = "(";
+          break;
+        default:
+          conversion = "";
+      }
+    }
+    if (conversion) {
+      return `${variableName} = ${conversion}await lire(""));`;
+    } else {
+      return `${variableName} = await lire("");`;
+    }
+  }
+  generateWriteStatement(node) {
+    if (!node.children || node.children.length === 0) {
+      return "";
+    }
+    const expressionCodes = [];
+    for (const child of node.children) {
+      if (child) {
+        const expressionCode = this.generateNode(child);
+        expressionCodes.push(expressionCode);
+      }
+    }
+    if (expressionCodes.length === 1) {
+      return `ecrire(${expressionCodes[0]});`;
+    }
+    const concatenated = expressionCodes.join(", ");
+    return `ecrire(${concatenated});`;
+  }
+  generateBinaryOp(node) {
+    if (!node.children || node.children.length < 2) {
+      return "";
+    }
+    const left = node.children[0];
+    const right = node.children[1];
+    const operator = node.value;
+    if (!left || !right) {
+      return "";
+    }
+    const leftCode = this.generateNode(left);
+    const rightCode = this.generateNode(right);
+    const jsOperator = this.mapOperator(operator);
+    return `(${leftCode} ${jsOperator} ${rightCode})`;
+  }
+  generateUnaryOp(node) {
+    if (!node.children || node.children.length === 0) {
+      return "";
+    }
+    const operand = node.children[0];
+    const operator = node.value;
+    if (!operand) {
+      return "";
+    }
+    const operandCode = this.generateNode(operand);
+    if (operator === "non") {
+      return `!(${operandCode})`;
+    } else if (operator === "-") {
+      return `-${operandCode}`;
+    }
+    return operandCode;
+  }
+  generateLiteral(node) {
+    if (node.value === undefined || node.value === null) {
+      return "null";
+    }
+    if (typeof node.value === "boolean") {
+      return node.value ? "true" : "false";
+    }
+    if (typeof node.value === "number") {
+      return node.value.toString();
+    }
+    if (typeof node.value === "string") {
+      return `"${node.value}"`;
+    }
+    return node.value?.toString() ?? "null";
+  }
+  generateVariable(node) {
+    return node.value;
+  }
+  mapAlgoLangTypeToJS(algoLangType) {
+    switch (algoLangType) {
+      case "ENTIER":
+        return "number";
+      case "REEL":
+        return "number";
+      case "BOOLEEN":
+        return "boolean";
+      case "CHAINE":
+        return "string";
+      default:
+        return "any";
+    }
+  }
+  mapOperator(operator) {
+    switch (operator) {
+      case ":=":
+        return "=";
+      case "=":
+        return "===";
+      case "<>":
+        return "!==";
+      case "<":
+        return "<";
+      case "<=":
+        return "<=";
+      case ">":
+        return ">";
+      case ">=":
+        return ">=";
+      case "et":
+        return "&&";
+      case "ou":
+        return "||";
+      case "non":
+        return "!";
+      default:
+        return operator;
+    }
+  }
+  indent(code) {
+    return "  ".repeat(this.indentLevel) + code;
+  }
+}
+
+// src/compiler.ts
+class AlgoLangCompiler {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      target: "javascript",
+      optimizationLevel: 1,
+      debugMode: false,
+      pedagogicalMode: true,
+      ...options
+    };
+  }
+  compile(sourceCode, filePath = "<input>") {
+    const startTime = performance.now();
+    try {
+      const context = {
+        sourceCode,
+        filePath,
+        symbolTable: {
+          symbols: new Map,
+          children: [],
+          scopeName: "global"
+        },
+        currentScope: {
+          symbols: new Map,
+          children: [],
+          scopeName: "global"
+        },
+        errors: [],
+        warnings: []
+      };
+      const lexer = new Lexer2(sourceCode);
+      let tokens;
+      try {
+        tokens = lexer.tokenize();
+        if (this.options.debugMode) {
+          console.log("Tokens générés:", tokens.length);
+        }
+      } catch (error) {
+        return this.createErrorOutput(error instanceof Error ? error.message : "Erreur lors de l'analyse lexicale", context, Date.now() - startTime);
+      }
+      const parser = new Parser2(tokens);
+      let parseResult;
+      try {
+        parseResult = parser.parse();
+        context.symbolTable = parseResult.symbolTable;
+        context.errors.push(...parseResult.errors);
+        if (this.options.debugMode) {
+          console.log("AST généré avec", parseResult.errors.length, "erreurs");
+        }
+      } catch (error) {
+        return this.createErrorOutput(error instanceof Error ? error.message : "Erreur lors de l'analyse syntaxique", context, Date.now() - startTime);
+      }
+      const codeGenerator = new CodeGenerator2(context.symbolTable, this.options);
+      let compiledOutput;
+      try {
+        compiledOutput = codeGenerator.generate(parseResult.ast);
+        context.errors.push(...compiledOutput.errors);
+        context.warnings.push(...compiledOutput.warnings);
+        if (this.options.debugMode) {
+          console.log("Code généré avec succès");
+        }
+      } catch (error) {
+        return this.createErrorOutput(error instanceof Error ? error.message : "Erreur lors de la génération de code", context, Date.now() - startTime);
+      }
+      const finalOutput = this.postProcess(compiledOutput, context);
+      return {
+        ...finalOutput,
+        output: finalOutput.output,
+        errors: context.errors,
+        warnings: context.warnings,
+        symbolTable: context.symbolTable,
+        ast: parseResult.ast,
+        success: context.errors.length === 0,
+        executionTime: performance.now() - startTime
+      };
+    } catch (error) {
+      return this.createErrorOutput(error instanceof Error ? error.message : "Erreur inconnue lors de la compilation", {
+        sourceCode,
+        filePath,
+        symbolTable: {
+          symbols: new Map,
+          children: [],
+          scopeName: "global"
+        },
+        currentScope: {
+          symbols: new Map,
+          children: [],
+          scopeName: "global"
+        },
+        errors: [],
+        warnings: []
+      }, Date.now() - startTime);
+    }
+  }
+  postProcess(output, context) {
+    let processedOutput = output.output;
+    if (this.options.optimizationLevel >= 1) {
+      processedOutput = this.applyBasicOptimizations(processedOutput);
+    }
+    if (this.options.optimizationLevel >= 2) {
+      processedOutput = this.applyAdvancedOptimizations(processedOutput);
+    }
+    if (this.options.optimizationLevel >= 3) {
+      processedOutput = this.applyAggressiveOptimizations(processedOutput);
+    }
+    if (this.options.pedagogicalMode) {
+      processedOutput = this.addPedagogicalComments(processedOutput, context);
+    }
+    return {
+      ...output,
+      output: processedOutput
+    };
+  }
+  applyBasicOptimizations(code) {
+    return code.replace(/\n\s*\n\s*\n/g, `
+
+`);
+  }
+  applyAdvancedOptimizations(code) {
+    return code;
+  }
+  applyAggressiveOptimizations(code) {
+    return code;
+  }
+  addPedagogicalComments(code, context) {
+    const lines = code.split(`
+`);
+    const commentedLines = [];
+    commentedLines.push("// ===============================================");
+    commentedLines.push("// Code généré par AlgoLang - Compilateur Éducatif");
+    commentedLines.push("// Fichier source: " + context.filePath);
+    commentedLines.push("// Variables déclarées: " + context.symbolTable.symbols.size);
+    commentedLines.push("// Erreurs de compilation: " + context.errors.length);
+    commentedLines.push("// Avertissements: " + context.warnings.length);
+    commentedLines.push("// ===============================================");
+    commentedLines.push("");
+    for (const line of lines) {
+      commentedLines.push(line);
+      if (line.includes("function main()")) {
+        commentedLines.push("// Point d'entrée principal");
+      } else if (line.includes("let ")) {
+        commentedLines.push("// Déclaration de variable");
+      } else if (line.includes("if (")) {
+        commentedLines.push("// Structure conditionnelle : exécute le code si la condition est vraie");
+      } else if (line.includes("while (")) {
+        commentedLines.push("// Boucle conditionnelle : répète tant que la condition est vraie");
+      } else if (line.includes("for (")) {
+        commentedLines.push("// Boucle itérative : répète pour un nombre défini d'itérations");
+      }
+    }
+    return commentedLines.join(`
+`);
+  }
+  createErrorOutput(message, context, executionTime) {
+    return {
+      success: false,
+      output: "",
+      errors: [
+        ...context.errors,
+        {
+          type: "ERROR",
+          message,
+          line: 0,
+          column: 0,
+          position: 0,
+          code: "COMPILATION_ERROR"
+        }
+      ],
+      warnings: context.warnings,
+      executionTime
+    };
+  }
+  validateSyntax(sourceCode) {
+    try {
+      const lexer = new Lexer2(sourceCode);
+      const tokens = lexer.tokenize();
+      const parser = new Parser2(tokens);
+      const result = parser.parse();
+      return {
+        valid: result.errors.length === 0,
+        errors: result.errors
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [
+          {
+            type: "ERROR",
+            message: error instanceof Error ? error.message : "Erreur de syntaxe inconnue",
+            line: 0,
+            column: 0,
+            position: 0,
+            code: "SYNTAX_ERROR"
+          }
+        ]
+      };
+    }
+  }
+  getSymbolTable(sourceCode) {
+    try {
+      const lexer = new Lexer2(sourceCode);
+      const tokens = lexer.tokenize();
+      const parser = new Parser2(tokens);
+      const result = parser.parse();
+      return result.symbolTable;
+    } catch (error) {
+      return {
+        symbols: new Map,
+        children: [],
+        scopeName: "global"
+      };
+    }
+  }
+  formatError(error) {
+    let formatted = `❌ Erreur [${error.code}]: ${error.message}`;
+    if (error.line > 0) {
+      formatted += ` (ligne ${error.line}`;
+      if (error.column > 0) {
+        formatted += `, colonne ${error.column}`;
+      }
+      formatted += ")";
+    }
+    if (this.options.pedagogicalMode && error.explanation) {
+      formatted += `
+
+\uD83D\uDCA1 Explication: ${error.explanation}`;
+    }
+    if (this.options.pedagogicalMode && error.suggestion) {
+      formatted += `
+
+\uD83D\uDD27 Suggestion: ${error.suggestion}`;
+    }
+    return formatted;
+  }
+}
+// src/types/index.ts
+var TokenType2;
+((TokenType3) => {
+  TokenType3["PROGRAM"] = "PROGRAMME";
+  TokenType3["BEGIN"] = "DEBUT";
+  TokenType3["END"] = "FIN";
+  TokenType3["VAR"] = "VAR";
+  TokenType3["INTEGER"] = "ENTIER";
+  TokenType3["REAL"] = "REEL";
+  TokenType3["BOOLEAN"] = "BOOLEEN";
+  TokenType3["STRING"] = "CHAINE";
+  TokenType3["IF"] = "SI";
+  TokenType3["THEN"] = "ALORS";
+  TokenType3["ELSE"] = "SINON";
+  TokenType3["WHILE"] = "TANTQUE";
+  TokenType3["DO"] = "FAIRE";
+  TokenType3["FOR"] = "POUR";
+  TokenType3["ALLANT"] = "ALLANT";
+  TokenType3["DE"] = "DE";
+  TokenType3["TO"] = "A";
+  TokenType3["REPEAT"] = "REPETER";
+  TokenType3["UNTIL"] = "JUSQUA";
+  TokenType3["READ"] = "LIRE";
+  TokenType3["WRITE"] = "ECRIRE";
+  TokenType3["TRUE"] = "VRAI";
+  TokenType3["FALSE"] = "FAUX";
+  TokenType3["AND"] = "ET";
+  TokenType3["OR"] = "OU";
+  TokenType3["NOT"] = "NON";
+  TokenType3["ENDFOR"] = "FINPOUR";
+  TokenType3["ENDIF"] = "FINIF";
+  TokenType3["ENDWHILE"] = "FINTANTQUE";
+  TokenType3["PLUS"] = "PLUS";
+  TokenType3["MINUS"] = "MINUS";
+  TokenType3["MULTIPLY"] = "MULTIPLY";
+  TokenType3["DIVIDE"] = "DIVIDE";
+  TokenType3["ASSIGN"] = "ASSIGN";
+  TokenType3["EQUAL"] = "EQUAL";
+  TokenType3["NOT_EQUAL"] = "NOT_EQUAL";
+  TokenType3["LESS_THAN"] = "LESS_THAN";
+  TokenType3["LESS_EQUAL"] = "LESS_EQUAL";
+  TokenType3["GREATER_THAN"] = "GREATER_THAN";
+  TokenType3["GREATER_EQUAL"] = "GREATER_EQUAL";
+  TokenType3["SEMICOLON"] = "SEMICOLON";
+  TokenType3["COLON"] = "COLON";
+  TokenType3["COMMA"] = "COMMA";
+  TokenType3["DOT"] = "DOT";
+  TokenType3["LEFT_PAREN"] = "LEFT_PAREN";
+  TokenType3["RIGHT_PAREN"] = "RIGHT_PAREN";
+  TokenType3["NUMBER"] = "NUMBER";
+  TokenType3["IDENTIFIER"] = "IDENTIFIER";
+  TokenType3["STRING_LITERAL"] = "STRING_LITERAL";
+  TokenType3["EOF"] = "EOF";
+  TokenType3["NEWLINE"] = "NEWLINE";
+  TokenType3["COMMENT"] = "COMMENT";
+})(TokenType2 ||= {});
+var NodeType2;
+((NodeType3) => {
+  NodeType3["PROGRAM"] = "PROGRAM";
+  NodeType3["VAR_DECLARATION"] = "VAR_DECLARATION";
+  NodeType3["TYPE_SPECIFIER"] = "TYPE_SPECIFIER";
+  NodeType3["ASSIGNMENT"] = "ASSIGNMENT";
+  NodeType3["IF_STATEMENT"] = "IF_STATEMENT";
+  NodeType3["WHILE_STATEMENT"] = "WHILE_STATEMENT";
+  NodeType3["FOR_STATEMENT"] = "FOR_STATEMENT";
+  NodeType3["REPEAT_STATEMENT"] = "REPEAT_STATEMENT";
+  NodeType3["READ_STATEMENT"] = "READ_STATEMENT";
+  NodeType3["WRITE_STATEMENT"] = "WRITE_STATEMENT";
+  NodeType3["COMPOUND_STATEMENT"] = "COMPOUND_STATEMENT";
+  NodeType3["BINARY_OP"] = "BINARY_OP";
+  NodeType3["UNARY_OP"] = "UNARY_OP";
+  NodeType3["LITERAL"] = "LITERAL";
+  NodeType3["VARIABLE"] = "VARIABLE";
+  NodeType3["BLOCK"] = "BLOCK";
+  NodeType3["PARAMETER_LIST"] = "PARAMETER_LIST";
+})(NodeType2 ||= {});
+var DataType2;
+((DataType3) => {
+  DataType3["INTEGER"] = "ENTIER";
+  DataType3["REAL"] = "REEL";
+  DataType3["BOOLEAN"] = "BOOLEEN";
+  DataType3["STRING"] = "CHAINE";
+  DataType3["VOID"] = "VIDE";
+})(DataType2 ||= {});
+export {
+  TokenType2 as TokenType,
+  Parser,
+  NodeType2 as NodeType,
+  Lexer,
+  DataType2 as DataType,
+  CodeGenerator,
+  AlgoLangCompiler
+};