starlight-cli 1.0.33 → 1.0.35

package/dist/index.js

@@ -1747,11 +1747,54 @@ async evalWhile(node, env) {
 }
 
 async evalFor(node, env) {
+  // --- Python-style for x in iterable ---
+  if (node.type === 'ForInStatement') {
+    const iterable = await this.evaluate(node.iterable, env);
+
+    if (iterable == null || typeof iterable !== 'object') {
+      throw new Error('Cannot iterate over non-iterable');
+    }
+
+    // Handle arrays
+    if (Array.isArray(iterable)) {
+      for (let i = 0; i < iterable.length; i++) {
+        const loopEnv = new Environment(env);
+        loopEnv.define(node.variable, iterable[i]);
+
+        try {
+          await this.evaluate(node.body, loopEnv);
+        } catch (e) {
+          if (e instanceof BreakSignal) break;
+          if (e instanceof ContinueSignal) continue;
+          throw e;
+        }
+      }
+    } else {
+      // Handle objects: iterate over keys
+      for (const key of Object.keys(iterable)) {
+        const loopEnv = new Environment(env);
+        loopEnv.define(node.variable, key);
+
+        try {
+          await this.evaluate(node.body, loopEnv);
+        } catch (e) {
+          if (e instanceof BreakSignal) break;
+          if (e instanceof ContinueSignal) continue;
+          throw e;
+        }
+      }
+    }
+
+    return null;
+  }
+
   const local = new Environment(env);
   if (node.init) await this.evaluate(node.init, local);
+
   while (!node.test || await this.evaluate(node.test, local)) {
-    try { await this.evaluate(node.body, local); }
-    catch (e) {
+    try {
+      await this.evaluate(node.body, local);
+    } catch (e) {
       if (e instanceof BreakSignal) break;
       if (e instanceof ContinueSignal) {
         if (node.update) await this.evaluate(node.update, local);
@@ -1759,8 +1802,10 @@ async evalFor(node, env) {
       }
       throw e;
     }
+
     if (node.update) await this.evaluate(node.update, local);
   }
+
   return null;
 }
 
@@ -2113,164 +2158,231 @@ class Parser {
   }
 
   varDeclaration() {
-    this.eat('LET');
-    const id = this.current.value;
-    this.eat('IDENTIFIER');
+  this.eat('LET');
+  const id = this.current.value;
+  this.eat('IDENTIFIER');
+
+  let expr = null;
+  if (this.current.type === 'EQUAL') {
     this.eat('EQUAL');
-    const expr = this.expression();
-    if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
-    return { type: 'VarDeclaration', id, expr };
+    expr = this.expression();
   }
 
-  sldeployStatement() {
-    this.eat('SLDEPLOY');
-    const expr = this.expression();
-    if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
-    return { type: 'SldeployStatement', expr };
-  }
+  // semicolon optional
+  if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
 
-  defineStatement() {
-    this.eat('DEFINE');
-    const id = this.current.value;
-    this.eat('IDENTIFIER');
-    let expr = null;
-    if (this.current.type === 'EQUAL') {
-      this.eat('EQUAL');
-      expr = this.expression();
-    }
-    if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
-    return { type: 'DefineStatement', id, expr };
+  return { type: 'VarDeclaration', id, expr };
+}
+
+sldeployStatement() {
+  this.eat('SLDEPLOY');
+  const expr = this.expression();
+  if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
+  return { type: 'SldeployStatement', expr };
+}
+
+defineStatement() {
+  this.eat('DEFINE');
+  const id = this.current.value;
+  this.eat('IDENTIFIER');
+
+  let expr = null;
+  if (this.current.type === 'EQUAL') {
+    this.eat('EQUAL');
+    expr = this.expression();
   }
+
+  if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
+
+  return { type: 'DefineStatement', id, expr };
+}
+
 asyncFuncDeclaration() {
   const name = this.current.value;
   this.eat('IDENTIFIER');
-  this.eat('LPAREN');
-  const params = [];
-  if (this.current.type !== 'RPAREN') {
-    params.push(this.current.value);
-    this.eat('IDENTIFIER');
-    while (this.current.type === 'COMMA') {
-      this.eat('COMMA');
+
+  let params = [];
+  if (this.current.type === 'LPAREN') {
+    this.eat('LPAREN');
+    if (this.current.type !== 'RPAREN') {
+      params.push(this.current.value);
+      this.eat('IDENTIFIER');
+      while (this.current.type === 'COMMA') {
+        this.eat('COMMA');
+        params.push(this.current.value);
+        this.eat('IDENTIFIER');
+      }
+    }
+    this.eat('RPAREN');
+  } else {
+    // no parentheses: single param as Python style
+    if (this.current.type === 'IDENTIFIER') {
       params.push(this.current.value);
       this.eat('IDENTIFIER');
     }
   }
-  this.eat('RPAREN');
+
   const body = this.block();
   return { type: 'FunctionDeclaration', name, params, body, async: true };
 }
 
-  ifStatement() {
-    this.eat('IF');
+ifStatement() {
+  this.eat('IF');
+
+  let test;
+  if (this.current.type === 'LPAREN') {
     this.eat('LPAREN');
-    const test = this.expression();
+    test = this.expression();
     this.eat('RPAREN');
-    const consequent = this.block();
-    let alternate = null;
-    if (this.current.type === 'ELSE') {
-      this.eat('ELSE');
-      if (this.current.type === 'IF') alternate = this.ifStatement();
-      else alternate = this.block();
-    }
-    return { type: 'IfStatement', test, consequent, alternate };
+  } else {
+    // python style: no parentheses
+    test = this.expression();
   }
 
-  whileStatement() {
-    this.eat('WHILE');
+  const consequent = this.block();
+
+  let alternate = null;
+  if (this.current.type === 'ELSE') {
+    this.eat('ELSE');
+    if (this.current.type === 'IF') alternate = this.ifStatement();
+    else alternate = this.block();
+  }
+
+  return { type: 'IfStatement', test, consequent, alternate };
+}
+
+whileStatement() {
+  this.eat('WHILE');
+
+  let test;
+  if (this.current.type === 'LPAREN') {
     this.eat('LPAREN');
-    const test = this.expression();
+    test = this.expression();
     this.eat('RPAREN');
-    const body = this.block();
-    return { type: 'WhileStatement', test, body };
+  } else {
+    test = this.expression();
   }
-  importStatement() {
-    this.eat('IMPORT');
 
-    let specifiers = [];
+  const body = this.block();
+  return { type: 'WhileStatement', test, body };
+}
+
+importStatement() {
+  this.eat('IMPORT');
+
+  let specifiers = [];
+  if (this.current.type === 'STAR') {
+    this.eat('STAR');
+    this.eat('AS');
+    const name = this.current.value;
+    this.eat('IDENTIFIER');
+    specifiers.push({ type: 'NamespaceImport', local: name });
+  } else if (this.current.type === 'LBRACE') {
+    this.eat('LBRACE');
+    while (this.current.type !== 'RBRACE') {
+      const importedName = this.current.value;
+      this.eat('IDENTIFIER');
 
-    if (this.current.type === 'STAR') {
-        this.eat('STAR');
+      let localName = importedName;
+      if (this.current.type === 'AS') {
         this.eat('AS');
-        const name = this.current.value;
-        this.eat('IDENTIFIER');
-        specifiers.push({ type: 'NamespaceImport', local: name });
-    }
-    else if (this.current.type === 'LBRACE') {
-        this.eat('LBRACE');
-        while (this.current.type !== 'RBRACE') {
-            const importedName = this.current.value;
-            this.eat('IDENTIFIER');
-            let localName = importedName;
-            if (this.current.type === 'AS') {
-                this.eat('AS');
-                localName = this.current.value;
-                this.eat('IDENTIFIER');
-            }
-            specifiers.push({ type: 'NamedImport', imported: importedName, local: localName });
-            if (this.current.type === 'COMMA') this.eat('COMMA');
-        }
-        this.eat('RBRACE');
-    }
-    else if (this.current.type === 'IDENTIFIER') {
-        const localName = this.current.value;
+        localName = this.current.value;
         this.eat('IDENTIFIER');
-        specifiers.push({ type: 'DefaultImport', local: localName });
-    } else {
-        throw new Error(`Unexpected token in import statement at line ${this.current.line}, column ${this.current.column}`);
+      }
+
+      specifiers.push({ type: 'NamedImport', imported: importedName, local: localName });
+      if (this.current.type === 'COMMA') this.eat('COMMA');
     }
+    this.eat('RBRACE');
+  } else if (this.current.type === 'IDENTIFIER') {
+    const localName = this.current.value;
+    this.eat('IDENTIFIER');
+    specifiers.push({ type: 'DefaultImport', local: localName });
+  } else {
+    throw new Error(`Unexpected token in import at line ${this.current.line}, column ${this.current.column}`);
+  }
 
-    this.eat('FROM');
-    const pathToken = this.current;
-    if (pathToken.type !== 'STRING') throw new Error(`Expected string literal after from in import at line ${this.current.line}, column ${this.current.column}`);
-    this.eat('STRING');
+  this.eat('FROM');
+  const pathToken = this.current;
+  if (pathToken.type !== 'STRING') throw new Error(`Expected string after FROM at line ${this.current.line}, column ${this.current.column}`);
+  this.eat('STRING');
 
-    if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
+  if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
 
-    return { type: 'ImportStatement', path: pathToken.value, specifiers };
+  return { type: 'ImportStatement', path: pathToken.value, specifiers };
 }
+forStatement() {
+  this.eat('FOR');
 
+  // --- Python-style: for variable in iterable ---
+  if (this.current.type === 'IDENTIFIER' && this.peekType() === 'IN') {
+    const variable = this.current.value; // loop variable
+    this.eat('IDENTIFIER');
+
+    this.eat('IN');
+    const iterable = this.expression(); // the array/object to loop over
 
-  forStatement() {
-    this.eat('FOR');
+    const body = this.block();
+    return { type: 'ForInStatement', variable, iterable, body };
+  }
+
+  // --- C-style: for(init; test; update) ---
+  let init = null;
+  let test = null;
+  let update = null;
+
+  if (this.current.type === 'LPAREN') {
     this.eat('LPAREN');
 
-    let init = null;
+    // init
     if (this.current.type !== 'SEMICOLON') {
       init = this.current.type === 'LET' ? this.varDeclaration() : this.expressionStatement();
     } else {
       this.eat('SEMICOLON');
     }
 
-    let test = null;
+    // test
     if (this.current.type !== 'SEMICOLON') test = this.expression();
     this.eat('SEMICOLON');
 
-    let update = null;
+    // update
     if (this.current.type !== 'RPAREN') update = this.expression();
     this.eat('RPAREN');
-
-    const body = this.block();
-    return { type: 'ForStatement', init, test, update, body };
+  } else {
+    // fallback: single expression (could be used for Python-style with "in", already handled above)
+    init = this.expression();
+    if (this.current.type === 'IN') {
+      this.eat('IN');
+      test = this.expression(); // iterable
+    }
   }
 
-  breakStatement() {
-    this.eat('BREAK');
-    if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
-    return { type: 'BreakStatement' };
-  }
+  const body = this.block();
+  return { type: 'ForStatement', init, test, update, body };
+}
 
-  continueStatement() {
-    this.eat('CONTINUE');
-    if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
-    return { type: 'ContinueStatement' };
-  }
+breakStatement() {
+  this.eat('BREAK');
+  // Python-style: no semicolon needed, ignore if present
+  if (this.current.type === 'SEMICOLON') this.advance();
+  return { type: 'BreakStatement' };
+}
 
-  funcDeclaration() {
-    this.eat('FUNC');
-    const name = this.current.value;
-    this.eat('IDENTIFIER');
+continueStatement() {
+  this.eat('CONTINUE');
+  // Python-style: no semicolon needed, ignore if present
+  if (this.current.type === 'SEMICOLON') this.advance();
+  return { type: 'ContinueStatement' };
+}
+
+funcDeclaration() {
+  this.eat('FUNC');
+  const name = this.current.value;
+  this.eat('IDENTIFIER');
+
+  let params = [];
+  if (this.current.type === 'LPAREN') {
     this.eat('LPAREN');
-    const params = [];
     if (this.current.type !== 'RPAREN') {
       params.push(this.current.value);
       this.eat('IDENTIFIER');
@@ -2281,176 +2393,203 @@ asyncFuncDeclaration() {
       }
     }
     this.eat('RPAREN');
-    const body = this.block();
-    return { type: 'FunctionDeclaration', name, params, body };
+  } else {
+    // Python-style: single param without parentheses
+    if (this.current.type === 'IDENTIFIER') {
+      params.push(this.current.value);
+      this.eat('IDENTIFIER');
+    }
   }
 
-  returnStatement() {
-    this.eat('RETURN');
-    let argument = null;
-    if (this.current.type !== 'SEMICOLON') argument = this.expression();
-    if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
-    return { type: 'ReturnStatement', argument };
+  const body = this.block();
+  return { type: 'FunctionDeclaration', name, params, body };
+}
+
+returnStatement() {
+  this.eat('RETURN');
+
+  let argument = null;
+  if (this.current.type !== 'SEMICOLON') {
+    argument = this.expression();
   }
 
-  block() {
-    this.eat('LBRACE');
-    const body = [];
-    while (this.current.type !== 'RBRACE') {
-      body.push(this.statement());
-    }
-    this.eat('RBRACE');
-    return { type: 'BlockStatement', body };
+  // semicolon optional
+  if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
+
+  return { type: 'ReturnStatement', argument };
+}
+
+block() {
+  this.eat('LBRACE');
+  const body = [];
+  while (this.current.type !== 'RBRACE') {
+    body.push(this.statement());
   }
+  this.eat('RBRACE');
+  return { type: 'BlockStatement', body };
+}
+
+expressionStatement() {
+  const expr = this.expression();
+  // semicolon optional
+  if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
+  return { type: 'ExpressionStatement', expression: expr };
+}
+
+expression() {
+  return this.assignment();
+}
+
+assignment() {
+  const node = this.logicalOr();
+  const compoundOps = ['PLUSEQ', 'MINUSEQ', 'STAREQ', 'SLASHEQ', 'MODEQ'];
 
-  expressionStatement() {
-    const expr = this.expression();
-    if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
-    return { type: 'ExpressionStatement', expression: expr };
+  if (compoundOps.includes(this.current.type)) {
+    const op = this.current.type;
+    this.eat(op);
+    const right = this.assignment();
+    return { type: 'CompoundAssignment', operator: op, left: node, right };
   }
 
-  expression() {
-    return this.assignment();
+  if (this.current.type === 'EQUAL') {
+    this.eat('EQUAL');
+    const right = this.assignment();
+    return { type: 'AssignmentExpression', left: node, right };
   }
 
-  assignment() {
-    const node = this.logicalOr();
-    const compoundOps = ['PLUSEQ', 'MINUSEQ', 'STAREQ', 'SLASHEQ', 'MODEQ'];
-    if (compoundOps.includes(this.current.type)) {
-      const op = this.current.type;
-      this.eat(op);
-      const right = this.assignment();
-      return { type: 'CompoundAssignment', operator: op, left: node, right };
-    }
+  return node;
+}
 
-    if (this.current.type === 'EQUAL') {
-      this.eat('EQUAL');
-      const right = this.assignment();
-      return { type: 'AssignmentExpression', left: node, right };
-    }
+logicalOr() {
+  let node = this.logicalAnd();
+  while (this.current.type === 'OR') {
+    const op = this.current.type;
+    this.eat(op);
+    node = { type: 'LogicalExpression', operator: op, left: node, right: this.logicalAnd() };
+  }
+  return node;
+}
 
-    return node;
+logicalAnd() {
+  let node = this.equality();
+  while (this.current.type === 'AND') {
+    const op = this.current.type;
+    this.eat(op);
+    node = { type: 'LogicalExpression', operator: op, left: node, right: this.equality() };
   }
+  return node;
+}
+equality() {
+  let node = this.comparison();
+  while (['EQEQ', 'NOTEQ'].includes(this.current.type)) {
+    const op = this.current.type;
+    this.eat(op);
+    node = { type: 'BinaryExpression', operator: op, left: node, right: this.comparison() };
+  }
+  return node;
+}
 
-  logicalOr() {
-    let node = this.logicalAnd();
-    while (this.current.type === 'OR') {
-      const op = this.current.type;
-      this.eat(op);
-      node = { type: 'LogicalExpression', operator: op, left: node, right: this.logicalAnd() };
-    }
-    return node;
+comparison() {
+  let node = this.term();
+  while (['LT', 'LTE', 'GT', 'GTE'].includes(this.current.type)) {
+    const op = this.current.type;
+    this.eat(op);
+    node = { type: 'BinaryExpression', operator: op, left: node, right: this.term() };
   }
+  return node;
+}
 
-  logicalAnd() {
-    let node = this.equality();
-    while (this.current.type === 'AND') {
-      const op = this.current.type;
-      this.eat(op);
-      node = { type: 'LogicalExpression', operator: op, left: node, right: this.equality() };
-    }
-    return node;
+term() {
+  let node = this.factor();
+  while (['PLUS', 'MINUS'].includes(this.current.type)) {
+    const op = this.current.type;
+    this.eat(op);
+    node = { type: 'BinaryExpression', operator: op, left: node, right: this.factor() };
   }
+  return node;
+}
 
-  equality() {
-    let node = this.comparison();
-    while (['EQEQ', 'NOTEQ'].includes(this.current.type)) {
-      const op = this.current.type;
-      this.eat(op);
-      node = { type: 'BinaryExpression', operator: op, left: node, right: this.comparison() };
-    }
-    return node;
+factor() {
+  let node = this.unary();
+  while (['STAR', 'SLASH', 'MOD'].includes(this.current.type)) {
+    const op = this.current.type;
+    this.eat(op);
+    node = { type: 'BinaryExpression', operator: op, left: node, right: this.unary() };
   }
+  return node;
+}
 
-  comparison() {
-    let node = this.term();
-    while (['LT', 'LTE', 'GT', 'GTE'].includes(this.current.type)) {
-      const op = this.current.type;
-      this.eat(op);
-      node = { type: 'BinaryExpression', operator: op, left: node, right: this.term() };
-    }
-    return node;
+unary() {
+  if (['NOT', 'MINUS', 'PLUS'].includes(this.current.type)) {
+    const op = this.current.type;
+    this.eat(op);
+    return { type: 'UnaryExpression', operator: op, argument: this.unary() };
   }
 
-  term() {
-    let node = this.factor();
-    while (['PLUS', 'MINUS'].includes(this.current.type)) {
-      const op = this.current.type;
-      this.eat(op);
-      node = { type: 'BinaryExpression', operator: op, left: node, right: this.factor() };
-    }
-    return node;
+  // Python-like: ignore ++ and -- if not used
+  if (this.current.type === 'PLUSPLUS' || this.current.type === 'MINUSMINUS') {
+    const op = this.current.type;
+    this.eat(op);
+    const argument = this.unary();
+    return { type: 'UpdateExpression', operator: op, argument, prefix: true };
   }
 
-  factor() {
-    let node = this.unary();
-    while (['STAR', 'SLASH', 'MOD'].includes(this.current.type)) {
-      const op = this.current.type;
-      this.eat(op);
-      node = { type: 'BinaryExpression', operator: op, left: node, right: this.unary() };
+  return this.postfix();
+}
+
+postfix() {
+  let node = this.primary();
+  while (true) {
+    if (this.current.type === 'LBRACKET') {
+      this.eat('LBRACKET');
+      const index = this.expression();
+      if (this.current.type === 'RBRACKET') this.eat('RBRACKET');
+      node = { type: 'IndexExpression', object: node, indexer: index };
+      continue;
     }
-    return node;
-  }
 
-  unary() {
-    if (['NOT', 'MINUS', 'PLUS'].includes(this.current.type)) {
-      const op = this.current.type;
-      this.eat(op);
-      return { type: 'UnaryExpression', operator: op, argument: this.unary() };
+    if (this.current.type === 'LPAREN') {
+      this.eat('LPAREN');
+      const args = [];
+      while (this.current.type !== 'RPAREN' && this.current.type !== 'EOF') {
+        args.push(this.expression());
+        if (this.current.type === 'COMMA') this.eat('COMMA'); // optional comma
+      }
+      if (this.current.type === 'RPAREN') this.eat('RPAREN');
+      node = { type: 'CallExpression', callee: node, arguments: args };
+      continue;
     }
+
+    if (this.current.type === 'DOT') {
+      this.eat('DOT');
+      const property = this.current.value || '';
+      if (this.current.type === 'IDENTIFIER') this.eat('IDENTIFIER');
+      node = { type: 'MemberExpression', object: node, property };
+      continue;
+    }
+
     if (this.current.type === 'PLUSPLUS' || this.current.type === 'MINUSMINUS') {
       const op = this.current.type;
       this.eat(op);
-      const argument = this.unary();
-      return { type: 'UpdateExpression', operator: op, argument, prefix: true };
+      node = { type: 'UpdateExpression', operator: op, argument: node, prefix: false };
+      continue;
     }
-    return this.postfix();
-  }
 
-  postfix() {
-    let node = this.primary();
-    while (true) {
-      if (this.current.type === 'LBRACKET') {
-        this.eat('LBRACKET');
-        const index = this.expression();
-        this.eat('RBRACKET');
-        node = { type: 'IndexExpression', object: node, indexer: index };
-        continue;
-      }
-      if (this.current.type === 'LPAREN') {
-        this.eat('LPAREN');
-        const args = [];
-        if (this.current.type !== 'RPAREN') {
-          args.push(this.expression());
-          while (this.current.type === 'COMMA') {
-            this.eat('COMMA');
-            args.push(this.expression());
-          }
-        }
-        this.eat('RPAREN');
-        node = { type: 'CallExpression', callee: node, arguments: args };
-        continue;
-      }
-      if (this.current.type === 'DOT') {
-        this.eat('DOT');
-        if (this.current.type !== 'IDENTIFIER') throw new Error(`Expected property name after dot at line ${this.current.line}, column ${this.current.column}`);
-        const property = this.current.value;
-        this.eat('IDENTIFIER');
-        node = { type: 'MemberExpression', object: node, property };
-        continue;
-      }
-      if (this.current.type === 'PLUSPLUS' || this.current.type === 'MINUSMINUS') {
-        const op = this.current.type;
-        this.eat(op);
-        node = { type: 'UpdateExpression', operator: op, argument: node, prefix: false };
-        continue;
-      }
-      break;
+    // Python-style: implicit function calls (if identifier followed by identifier)
+    if (node.type === 'Identifier' && this.current.type === 'IDENTIFIER') {
+      const argNode = { type: 'Identifier', name: this.current.value };
+      this.eat('IDENTIFIER');
+      node = { type: 'CallExpression', callee: node, arguments: [argNode] };
+      continue;
     }
-    return node;
+
+    break;
   }
+  return node;
+}
+
 arrowFunction(params) {
-  this.eat('ARROW');
+  if (this.current.type === 'ARROW') this.eat('ARROW');
   const body = this.expression();
   return {
     type: 'ArrowFunctionExpression',
@@ -2459,126 +2598,114 @@ arrowFunction(params) {
   };
 }
 
+
   primary() {
-    const t = this.current;
-
-    if (t.type === 'NUMBER') { this.eat('NUMBER'); return { type: 'Literal', value: t.value }; }
-    if (t.type === 'STRING') { this.eat('STRING'); return { type: 'Literal', value: t.value }; }
-    if (t.type === 'TRUE') { this.eat('TRUE'); return { type: 'Literal', value: true }; }
-    if (t.type === 'FALSE') { this.eat('FALSE'); return { type: 'Literal', value: false }; }
-    if (t.type === 'NULL') { this.eat('NULL'); return { type: 'Literal', value: null }; }
-if (t.type === 'AWAIT') {
+  const t = this.current;
+
+  if (t.type === 'NUMBER') { this.eat('NUMBER'); return { type: 'Literal', value: t.value }; }
+  if (t.type === 'STRING') { this.eat('STRING'); return { type: 'Literal', value: t.value }; }
+  if (t.type === 'TRUE') { this.eat('TRUE'); return { type: 'Literal', value: true }; }
+  if (t.type === 'FALSE') { this.eat('FALSE'); return { type: 'Literal', value: false }; }
+  if (t.type === 'NULL') { this.eat('NULL'); return { type: 'Literal', value: null }; }
+
+  if (t.type === 'AWAIT') {
     this.eat('AWAIT');
     const argument = this.expression(); 
     return { type: 'AwaitExpression', argument };
   }
-if (t.type === 'NEW') {
-        this.eat('NEW');
-        const callee = this.primary(); // the class or function being called
-        this.eat('LPAREN');
-        const args = [];
-        if (this.current.type !== 'RPAREN') {
-            args.push(this.expression());
-            while (this.current.type === 'COMMA') {
-                this.eat('COMMA');
-                args.push(this.expression());
-            }
-        }
-        this.eat('RPAREN');
-        return { type: 'NewExpression', callee, arguments: args };
-    }
 
-    if (t.type === 'ASK') {
-      this.eat('ASK');
-      this.eat('LPAREN');
-      const args = [];
-      if (this.current.type !== 'RPAREN') {
-        args.push(this.expression());
-        while (this.current.type === 'COMMA') {
-          this.eat('COMMA');
-          args.push(this.expression());
-        }
+  if (t.type === 'NEW') {
+    this.eat('NEW');
+    const callee = this.primary();
+    this.eat('LPAREN');
+    const args = [];
+    if (this.current.type !== 'RPAREN') {
+      args.push(this.expression());
+      while (this.current.type === 'COMMA') {
+        this.eat('COMMA');
+        if (this.current.type !== 'RPAREN') args.push(this.expression());
       }
-      this.eat('RPAREN');
-      return { type: 'CallExpression', callee: { type: 'Identifier', name: 'ask' }, arguments: args };
     }
+    this.eat('RPAREN');
+    return { type: 'NewExpression', callee, arguments: args };
+  }
 
-    if (t.type === 'IDENTIFIER') {
-  const name = t.value;
-  this.eat('IDENTIFIER');
-
-  if (this.current.type === 'ARROW') {
-    return this.arrowFunction([name]);
+  if (t.type === 'ASK') {
+    this.eat('ASK');
+    this.eat('LPAREN');
+    const args = [];
+    if (this.current.type !== 'RPAREN') {
+      args.push(this.expression());
+      while (this.current.type === 'COMMA') {
+        this.eat('COMMA');
+        if (this.current.type !== 'RPAREN') args.push(this.expression());
+      }
+    }
+    this.eat('RPAREN');
+    return { type: 'CallExpression', callee: { type: 'Identifier', name: 'ask' }, arguments: args };
   }
 
-  return { type: 'Identifier', name };
-}
+  if (t.type === 'IDENTIFIER') {
+    const name = t.value;
+    this.eat('IDENTIFIER');
 
+    if (this.current.type === 'ARROW') {
+      return this.arrowFunction([name]);
+    }
 
-   if (t.type === 'LPAREN') {
-  this.eat('LPAREN');
+    return { type: 'Identifier', name };
+  }
 
-  const params = [];
+  if (t.type === 'LPAREN') {
+    this.eat('LPAREN');
+    const elements = [];
 
-  if (this.current.type !== 'RPAREN') {
-    params.push(this.current.value);
-    this.eat('IDENTIFIER');
-    while (this.current.type === 'COMMA') {
-      this.eat('COMMA');
-      params.push(this.current.value);
-      this.eat('IDENTIFIER');
+    if (this.current.type !== 'RPAREN') {
+      elements.push(this.expression());
+      while (this.current.type === 'COMMA') {
+        this.eat('COMMA');
+        if (this.current.type !== 'RPAREN') elements.push(this.expression());
+      }
     }
-  }
 
-  this.eat('RPAREN');
+    this.eat('RPAREN');
 
-  if (this.current.type === 'ARROW') {
-    return this.arrowFunction(params);
-  }
+    if (this.current.type === 'ARROW') return this.arrowFunction(elements);
 
-  if (params.length === 1) {
-    return { type: 'Identifier', name: params[0] };
+    return elements.length === 1 ? elements[0] : { type: 'ArrayExpression', elements };
   }
 
-  throw new Error(
-    `Invalid grouped expression at line ${this.current.line}, column ${this.current.column}`
-  );
-}
-
-
-    if (t.type === 'LBRACKET') {
-      this.eat('LBRACKET');
-      const elements = [];
-      if (this.current.type !== 'RBRACKET') {
-        elements.push(this.expression());
-        while (this.current.type === 'COMMA') {
-          this.eat('COMMA');
-          elements.push(this.expression());
-        }
+  if (t.type === 'LBRACKET') {
+    this.eat('LBRACKET');
+    const elements = [];
+    if (this.current.type !== 'RBRACKET') {
+      elements.push(this.expression());
+      while (this.current.type === 'COMMA') {
+        this.eat('COMMA');
+        if (this.current.type !== 'RBRACKET') elements.push(this.expression());
       }
-      this.eat('RBRACKET');
-      return { type: 'ArrayExpression', elements };
     }
+    this.eat('RBRACKET');
+    return { type: 'ArrayExpression', elements };
+  }
 
-    if (t.type === 'LBRACE') {
-      this.eat('LBRACE');
-      const props = [];
-      while (this.current.type !== 'RBRACE') {
-        let key;
-        if (this.current.type === 'STRING') { key = this.current.value; this.eat('STRING'); }
-        else if (this.current.type === 'IDENTIFIER') { key = this.current.value; this.eat('IDENTIFIER'); }
-        else throw new Error(`Invalid object key at line ${this.current.line}, column ${this.current.column}`);
-        this.eat('COLON');
-        const value = this.expression();
-        props.push({ key, value });
-        if (this.current.type === 'COMMA') this.eat('COMMA');
-      }
-      this.eat('RBRACE');
-      return { type: 'ObjectExpression', props };
+  if (t.type === 'LBRACE') {
+    this.eat('LBRACE');
+    const props = [];
+    while (this.current.type !== 'RBRACE') {
+      const key = this.expression(); // Flexible key: can be any expression
+      this.eat('COLON');
+      const value = this.expression();
+      props.push({ key, value });
+      if (this.current.type === 'COMMA') this.eat('COMMA'); // optional trailing comma
     }
-
-    throw new Error(`Unexpected token in primary: ${t.type} at line ${this.current.line}, column ${this.current.column}`);
+    this.eat('RBRACE');
+    return { type: 'ObjectExpression', props };
   }
+
+  throw new Error(`Unexpected token in primary: ${t.type} at line ${this.current.line}, column ${this.current.column}`);
+}
+
 }
 
 module.exports = Parser;