starlight-cli 1.1.9 → 1.1.11

package/README.md

@@ -4,7 +4,7 @@
 Starlight is a lightweight, developer-oriented programming language designed for **server-side scripting, automation, and general-purpose programming**. It combines a clean, readable syntax inspired by JavaScript and Python with powerful runtime features such as async/await, modules, and interactive I/O.
 
  **Official Reference:**  
-https://developerdominex.github.io/starlight-programming-language/
+https://dominexmacedon.github.io/starlight-programming-language/learn.html
 
 ---
 

package/dist/index.js

@@ -10230,7 +10230,13 @@ class RuntimeError extends Error {
             const lines = source.split('\n');
             const srcLine = lines[node.line - 1] || '';
             output += `  ${srcLine}\n`;
-            output += `  ${' '.repeat(column - 1)}^\n`;
+            const caretPos =
+  typeof column === 'number' && column > 0
+    ? column - 1
+    : 0;
+
+output += `  ${' '.repeat(caretPos)}^\n`;
+;
         }
 
         super(output);
@@ -10292,6 +10298,34 @@ class Evaluator {
     this.global = new Environment();
     this.setupBuiltins();
   }
+async callFunction(fn, args, env, node = null) {
+  if (typeof fn === 'function') {
+    const val = await fn(...args);
+    return val === undefined ? null : val; // <<< enforce null
+  }
+
+  if (fn && typeof fn === 'object' && fn.body && fn.params) {
+    const callEnv = new Environment(fn.env);
+
+    for (let i = 0; i < fn.params.length; i++) {
+      const param = fn.params[i];
+      const name = typeof param === 'string' ? param : param.name;
+      callEnv.define(name, args[i]);
+    }
+
+    try {
+      const val = await this.evaluate(fn.body, callEnv);
+      return val === undefined ? null : val; // <<< enforce null
+    } catch (e) {
+      if (e instanceof ReturnValue) return e.value === undefined ? null : e.value; // <<< enforce null
+      throw e;
+    }
+  }
+
+  throw new RuntimeError('Value is not callable', node, this.source);
+}
+
+
 suggest(name, env) {
   const names = new Set();
   let current = env;
@@ -10365,6 +10399,7 @@ formatValue(value, seen = new Set()) {
 
 
   setupBuiltins() {
+    const evaluator = this;
     this.global.define('len', arg => {
         if (Array.isArray(arg) || typeof arg === 'string') return arg.length;
         if (arg && typeof arg === 'object') return Object.keys(arg).length;
@@ -10376,63 +10411,90 @@ formatValue(value, seen = new Set()) {
         if (Array.isArray(arg)) return 'array';
         return typeof arg;
     });
-    this.global.define('map', async (array, fn) => {
-  if (!Array.isArray(array)) {
-    throw new RuntimeError('map() expects an array', null, this.source);
-  }
-  if (typeof fn !== 'function') {
-    throw new RuntimeError('map() expects a function', null, this.source);
-  }
-
-  const result = [];
-  for (let i = 0; i < array.length; i++) {
-    result.push(await fn(array[i], i, array));
-  }
-  return result;
+this.global.define('isNaN', arg => {
+  return typeof arg !== 'number' || Number.isNaN(arg);
 });
-this.global.define('filter', async (array, fn) => {
-  if (!Array.isArray(array)) {
-    throw new RuntimeError('filter() expects an array', null, this.source);
-  }
-  if (typeof fn !== 'function') {
-    throw new RuntimeError('filter() expects a function', null, this.source);
+this.global.define('random', (min, max) => {
+  if (max === undefined) {
+    // Only one argument → random between 0 and min
+    return Math.floor(Math.random() * min);
   }
+  min = Number(min);
+  max = Number(max);
+  if (isNaN(min) || isNaN(max)) return 0;
+  return Math.floor(Math.random() * (max - min)) + min;
+});
 
-  const result = [];
-  for (let i = 0; i < array.length; i++) {
-    if (await fn(array[i], i, array)) {
-      result.push(array[i]);
+   this.global.define('map', async (array, fn) => {
+    if (!Array.isArray(array)) {
+      throw new RuntimeError('map() expects an array', null, evaluator.source);
     }
-  }
-  return result;
-});
-this.global.define('reduce', async (array, fn, initial) => {
-  if (!Array.isArray(array)) {
-    throw new RuntimeError('reduce() expects an array', null, this.source);
-  }
-  if (typeof fn !== 'function') {
-    throw new RuntimeError('reduce() expects a function', null, this.source);
-  }
 
-  let acc;
-  let startIndex = 0;
+    const result = [];
+    for (let i = 0; i < array.length; i++) {
+      result.push(
+        await evaluator.callFunction(
+          fn,
+          [array[i], i, array],
+          evaluator.global
+        )
+      );
+    }
+    return result;
+  });
 
-  if (initial !== undefined) {
-    acc = initial;
-  } else {
-    if (array.length === 0) {
-      throw new RuntimeError('reduce() of empty array with no initial value', null, this.source);
+  this.global.define('filter', async (array, fn) => {
+    if (!Array.isArray(array)) {
+      throw new RuntimeError('filter() expects an array', null, evaluator.source);
     }
-    acc = array[0];
-    startIndex = 1;
-  }
 
-  for (let i = startIndex; i < array.length; i++) {
-    acc = await fn(acc, array[i], i, array);
-  }
+    const result = [];
+    for (let i = 0; i < array.length; i++) {
+      if (
+        await evaluator.callFunction(
+          fn,
+          [array[i], i, array],
+          evaluator.global
+        )
+      ) {
+        result.push(array[i]);
+      }
+    }
+    return result;
+  });
 
-  return acc;
-});
+  this.global.define('reduce', async (array, fn, initial) => {
+    if (!Array.isArray(array)) {
+      throw new RuntimeError('reduce() expects an array', null, evaluator.source);
+    }
+
+    let acc;
+    let i = 0;
+
+    if (initial !== undefined) {
+      acc = initial;
+    } else {
+      if (array.length === 0) {
+        throw new RuntimeError(
+          'reduce() of empty array with no initial value',
+          null,
+          evaluator.source
+        );
+      }
+      acc = array[0];
+      i = 1;
+    }
+
+    for (; i < array.length; i++) {
+      acc = await evaluator.callFunction(
+        fn,
+        [acc, array[i], i, array],
+        evaluator.global
+      );
+    }
+
+    return acc;
+  });
 
     this.global.define('keys', arg => arg && typeof arg === 'object' ? Object.keys(arg) : []);
     this.global.define('values', arg => arg && typeof arg === 'object' ? Object.values(arg) : []);
@@ -10586,21 +10648,30 @@ case 'RaceClause':
   const callee = await this.evaluate(node.callee, env);
 
   if (typeof callee === 'object' && callee.body) {
-    const evaluator = this; 
-    const Constructor = function(...args) {
+    const evaluator = this;
+
+    const Constructor = function (...args) {
       const newEnv = new Environment(callee.env);
       newEnv.define('this', this);
+
       for (let i = 0; i < callee.params.length; i++) {
-        newEnv.define(callee.params[i], args[i]);
+        const param = callee.params[i];
+        const paramName = typeof param === 'string' ? param : param.name;
+        newEnv.define(paramName, args[i]);
       }
-      return evaluator.evaluate(callee.body, newEnv);
+
+      return (async () => {
+        await evaluator.evaluate(callee.body, newEnv);
+        return this;
+      })();
     };
 
     const args = [];
     for (const a of node.arguments) args.push(await this.evaluate(a, env));
-    return new Constructor(...args);
+    return await new Constructor(...args);
   }
 
+  // native JS constructor fallback
   if (typeof callee !== 'function') {
     throw new RuntimeError('NewExpression callee is not a function', node, this.source);
   }
@@ -10822,27 +10893,31 @@ evalArrowFunction(node, env) {
   return async function (...args) {
     const localEnv = new Environment(env);
 
+    // Bind parameters safely
     node.params.forEach((p, i) => {
-      localEnv.define(p.name, args[i]);
+      const paramName = typeof p === 'string' ? p : p.name;
+      localEnv.define(paramName, args[i]);
     });
 
     try {
       if (node.isBlock) {
+        // Block body
         const result = await evaluator.evaluate(node.body, localEnv);
-        return result ?? null;
+        return result === undefined ? null : result;  // ensure null instead of undefined
       } else {
-        return await evaluator.evaluate(node.body, localEnv);
+        // Expression body
+        const result = await evaluator.evaluate(node.body, localEnv);
+        return result === undefined ? null : result;  // ensure null instead of undefined
       }
     } catch (err) {
-      if (err instanceof ReturnValue) {
-        return err.value; 
-      }
+      if (err instanceof ReturnValue) return err.value === undefined ? null : err.value;
       throw err;
     }
   };
 }
 
 
+
 async evalAssignment(node, env) {
   const rightVal = await this.evaluate(node.right, env);
   const left = node.left;
@@ -11003,13 +11078,10 @@ async evalUnary(node, env) {
 
   }
 }
-
 async evalIf(node, env) {
-  const test = await this.evaluate(node.test, env);
+  let test = await this.evaluate(node.test, env);
 
-  if (typeof test !== 'boolean') {
-    throw new RuntimeError('If condition must evaluate to a boolean', node.test, this.source);
-  }
+  test = !!test;
 
   if (test) {
     return await this.evaluate(node.consequent, env);
@@ -11022,27 +11094,26 @@ async evalIf(node, env) {
   return null;
 }
 
-
 async evalWhile(node, env) {
   while (true) {
-    const test = await this.evaluate(node.test, env);
+    let test = await this.evaluate(node.test, env);
 
-    if (typeof test !== 'boolean') {
-      throw new RuntimeError('While condition must evaluate to a boolean', node.test, this.source);
-    }
+    test = !!test;
 
     if (!test) break;
 
     try {
       await this.evaluate(node.body, env);
     } catch (e) {
-      if (e instanceof BreakSignal) break;
-      if (e instanceof ContinueSignal) continue;
-      throw e;
+      if (e instanceof BreakSignal) break;     
+      if (e instanceof ContinueSignal) continue; 
+      throw e;                                
     }
   }
+
   return null;
 }
+
 async evalFor(node, env) {
   if (node.type === 'ForInStatement') {
     const iterable = await this.evaluate(node.iterable, env);
@@ -11183,24 +11254,40 @@ async evalIndex(node, env) {
 async evalObject(node, env) {
   const out = {};
   for (const p of node.props) {
-    if (!p.key || !p.value) {
-      throw new RuntimeError('Invalid object property', node, this.source);
+    if (!p.key) {
+      throw new RuntimeError('Object property must have a key', node, this.source);
     }
+
     const key = await this.evaluate(p.key, env);
-    const value = await this.evaluate(p.value, env);
-    out[key] = value; // dynamic property assignment
+    let value = null;
+
+    if (p.value) {
+      value = await this.evaluate(p.value, env);
+      if (value === undefined) value = null; // <- force null instead of undefined
+    }
+
+    out[key] = value;
   }
   return out;
 }
 
 
 
+
 async evalMember(node, env) {
   const obj = await this.evaluate(node.object, env);
 
-  if (obj == null) throw new RuntimeError('Member access of null or undefined', node, this.source);
+  if (obj == null) {
+    throw new RuntimeError('Member access of null or undefined', node, this.source);
+  }
+
+  const prop = obj[node.property];
 
-  return obj[node.property];
+  if (typeof prop === 'function') {
+    return prop.bind(obj);
+  }
+
+  return prop;
 }
 
 
@@ -11234,7 +11321,7 @@ async evalUpdate(node, env) {
 
 }
 
-module.exports = Evaluator;  
+module.exports = Evaluator;   
 
 /***/ }),
 
@@ -11271,7 +11358,7 @@ class Lexer {
       'break', 'continue', 'func', 'return',
       'true', 'false', 'null',
       'ask', 'define', 'import', 'from', 'as',
-      'async', 'await', 'new', 'in', 'do', 'track', 'start', 'race'
+      'async', 'await', 'new', 'in', 'do', 'track', 'start', 'race', 'not', 'and', 'or'
     ];
 }
 
@@ -11354,6 +11441,8 @@ class Lexer {
     }
 
 if (this.keywords.includes(result)) {
+  if (result === 'and') return { type: 'AND', value: 'and', line: startLine, column: startCol };
+  if (result === 'or')  return { type: 'OR', value: 'or', line: startLine, column: startCol };
   return { type: result.toUpperCase(), value: result, line: startLine, column: startCol };
 }
 
@@ -11469,7 +11558,7 @@ module.exports = Lexer;
 /***/ }),
 
 /***/ 222:
-/***/ ((module) => {
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 class ParseError extends Error {
   constructor(message, token, source) {
@@ -11729,14 +11818,18 @@ ifStatement() {
     test = this.expression();
   }
 
-  const consequent = this.block();
+  const consequent = this.statementOrBlock();
 
   let alternate = null;
   if (this.current.type === 'ELSE') {
-    this.eat('ELSE');
-    if (this.current.type === 'IF') alternate = this.ifStatement();
-    else alternate = this.block();
+  this.eat('ELSE');
+  if (this.current.type === 'IF') {
+    alternate = this.ifStatement();
+  } else {
+    alternate = this.statementOrBlock();
   }
+}
+
 
   return { 
     type: 'IfStatement', 
@@ -11747,18 +11840,51 @@ ifStatement() {
     column: t.column 
   };
 }
+parseExpressionOnly() {
+  return this.expression();
+}
 
 whileStatement() {
   const t = this.current; 
   this.eat('WHILE');
 
   let test;
+
   if (this.current.type === 'LPAREN') {
     this.eat('LPAREN');
     test = this.expression();
     this.eat('RPAREN');
-  } else {
-    test = this.expression();
+  } 
+  else {
+    const startPos = this.pos;
+    const startToken = this.current;
+
+    const exprTokens = [];
+    let braceFound = false;
+    let depth = 0;
+
+    while (this.current.type !== 'EOF') {
+      if (this.current.type === 'LBRACE' && depth === 0) {
+        braceFound = true;
+        break;
+      }
+      if (this.current.type === 'LPAREN') depth++;
+      if (this.current.type === 'RPAREN') depth--;
+      exprTokens.push(this.current);
+      this.advance();
+    }
+
+    if (!braceFound) {
+      throw new ParseError(
+        "Expected '{' after while condition",
+        this.current,
+        this.source
+      );
+    }
+
+    const Parser = __nccwpck_require__(222); 
+    const exprParser = new Parser(exprTokens, this.source);
+    test = exprParser.parseExpressionOnly(); 
   }
 
   const body = this.block();
@@ -11771,6 +11897,7 @@ whileStatement() {
   };
 }
 
+
 importStatement() {
   const t = this.current; 
   this.eat('IMPORT');
@@ -11970,6 +12097,12 @@ returnStatement() {
 
   return { type: 'ReturnStatement', argument, line: t.line, column: t.column };
 }
+statementOrBlock() {
+  if (this.current.type === 'LBRACE') {
+    return this.block();
+  }
+  return this.statement();
+}
 
 block() {
   const t = this.current; // LBRACE token
@@ -12179,13 +12312,7 @@ postfix() {
       continue;
     }
 
-    if (node.type === 'Identifier' && t.type === 'IDENTIFIER') {
-      const argNode = { type: 'Identifier', name: t.value, line: t.line, column: t.column };
-      this.eat('IDENTIFIER');
-      node = { type: 'CallExpression', callee: node, arguments: [argNode], line: node.line, column: node.column };
-      continue;
-    }
-
+   
     break;
   }
   return node;
@@ -12339,21 +12466,56 @@ arrowFunction(params) {
   }
 
   if (t.type === 'LBRACE') {
-    const startLine = t.line;
-    const startCol = t.column;
-    this.eat('LBRACE');
-    const props = [];
-    while (this.current.type !== 'RBRACE') {
-      const key = this.expression(); 
-      this.eat('COLON');
-      const value = this.expression();
-      props.push({ key, value });
-      if (this.current.type === 'COMMA') this.eat('COMMA');
+  const startLine = t.line;
+  const startCol = t.column;
+  this.eat('LBRACE');
+
+  const props = [];
+
+  while (this.current.type !== 'RBRACE') {
+    let key;
+
+    if (this.current.type === 'IDENTIFIER') {
+      const k = this.current;
+      this.eat('IDENTIFIER');
+      key = {
+        type: 'Literal',
+        value: k.value,
+        line: k.line,
+        column: k.column
+      };
     }
-    this.eat('RBRACE');
-    return { type: 'ObjectExpression', props, line: startLine, column: startCol };
+    else if (this.current.type === 'STRING') {
+      const k = this.current;
+      this.eat('STRING');
+      key = {
+        type: 'Literal',
+        value: k.value,
+        line: k.line,
+        column: k.column
+      };
+    }
+    else {
+      throw new ParseError(
+        'Invalid object key',
+        this.current,
+        this.source
+      );
+    }
+
+    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, line: startLine, column: startCol };
+}
+
+
   throw new ParseError(
     `Unexpected token '${t.type}'`,
     t,
@@ -12544,7 +12706,7 @@ const Lexer = __nccwpck_require__(211);
 const Parser = __nccwpck_require__(222);
 const Evaluator = __nccwpck_require__(112);
 
-const VERSION = '1.1.9';
+const VERSION = '1.1.11';
 
 const COLOR = {
     reset: '\x1b[0m',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starlight-cli",
-  "version": "1.1.9",
+  "version": "1.1.11",
   "description": "Starlight Programming Language CLI",
   "bin": {
     "starlight": "index.js"

package/src/evaluator.js

@@ -20,7 +20,13 @@ class RuntimeError extends Error {
             const lines = source.split('\n');
             const srcLine = lines[node.line - 1] || '';
             output += `  ${srcLine}\n`;
-            output += `  ${' '.repeat(column - 1)}^\n`;
+            const caretPos =
+  typeof column === 'number' && column > 0
+    ? column - 1
+    : 0;
+
+output += `  ${' '.repeat(caretPos)}^\n`;
+;
         }
 
         super(output);
@@ -82,6 +88,34 @@ class Evaluator {
     this.global = new Environment();
     this.setupBuiltins();
   }
+async callFunction(fn, args, env, node = null) {
+  if (typeof fn === 'function') {
+    const val = await fn(...args);
+    return val === undefined ? null : val; // <<< enforce null
+  }
+
+  if (fn && typeof fn === 'object' && fn.body && fn.params) {
+    const callEnv = new Environment(fn.env);
+
+    for (let i = 0; i < fn.params.length; i++) {
+      const param = fn.params[i];
+      const name = typeof param === 'string' ? param : param.name;
+      callEnv.define(name, args[i]);
+    }
+
+    try {
+      const val = await this.evaluate(fn.body, callEnv);
+      return val === undefined ? null : val; // <<< enforce null
+    } catch (e) {
+      if (e instanceof ReturnValue) return e.value === undefined ? null : e.value; // <<< enforce null
+      throw e;
+    }
+  }
+
+  throw new RuntimeError('Value is not callable', node, this.source);
+}
+
+
 suggest(name, env) {
   const names = new Set();
   let current = env;
@@ -155,6 +189,7 @@ formatValue(value, seen = new Set()) {
 
 
   setupBuiltins() {
+    const evaluator = this;
     this.global.define('len', arg => {
         if (Array.isArray(arg) || typeof arg === 'string') return arg.length;
         if (arg && typeof arg === 'object') return Object.keys(arg).length;
@@ -166,63 +201,90 @@ formatValue(value, seen = new Set()) {
         if (Array.isArray(arg)) return 'array';
         return typeof arg;
     });
-    this.global.define('map', async (array, fn) => {
-  if (!Array.isArray(array)) {
-    throw new RuntimeError('map() expects an array', null, this.source);
-  }
-  if (typeof fn !== 'function') {
-    throw new RuntimeError('map() expects a function', null, this.source);
-  }
-
-  const result = [];
-  for (let i = 0; i < array.length; i++) {
-    result.push(await fn(array[i], i, array));
-  }
-  return result;
+this.global.define('isNaN', arg => {
+  return typeof arg !== 'number' || Number.isNaN(arg);
+});
+this.global.define('random', (min, max) => {
+  if (max === undefined) {
+    // Only one argument → random between 0 and min
+    return Math.floor(Math.random() * min);
+  }
+  min = Number(min);
+  max = Number(max);
+  if (isNaN(min) || isNaN(max)) return 0;
+  return Math.floor(Math.random() * (max - min)) + min;
 });
-this.global.define('filter', async (array, fn) => {
-  if (!Array.isArray(array)) {
-    throw new RuntimeError('filter() expects an array', null, this.source);
-  }
-  if (typeof fn !== 'function') {
-    throw new RuntimeError('filter() expects a function', null, this.source);
-  }
 
-  const result = [];
-  for (let i = 0; i < array.length; i++) {
-    if (await fn(array[i], i, array)) {
-      result.push(array[i]);
+   this.global.define('map', async (array, fn) => {
+    if (!Array.isArray(array)) {
+      throw new RuntimeError('map() expects an array', null, evaluator.source);
     }
-  }
-  return result;
-});
-this.global.define('reduce', async (array, fn, initial) => {
-  if (!Array.isArray(array)) {
-    throw new RuntimeError('reduce() expects an array', null, this.source);
-  }
-  if (typeof fn !== 'function') {
-    throw new RuntimeError('reduce() expects a function', null, this.source);
-  }
 
-  let acc;
-  let startIndex = 0;
+    const result = [];
+    for (let i = 0; i < array.length; i++) {
+      result.push(
+        await evaluator.callFunction(
+          fn,
+          [array[i], i, array],
+          evaluator.global
+        )
+      );
+    }
+    return result;
+  });
 
-  if (initial !== undefined) {
-    acc = initial;
-  } else {
-    if (array.length === 0) {
-      throw new RuntimeError('reduce() of empty array with no initial value', null, this.source);
+  this.global.define('filter', async (array, fn) => {
+    if (!Array.isArray(array)) {
+      throw new RuntimeError('filter() expects an array', null, evaluator.source);
     }
-    acc = array[0];
-    startIndex = 1;
-  }
 
-  for (let i = startIndex; i < array.length; i++) {
-    acc = await fn(acc, array[i], i, array);
-  }
+    const result = [];
+    for (let i = 0; i < array.length; i++) {
+      if (
+        await evaluator.callFunction(
+          fn,
+          [array[i], i, array],
+          evaluator.global
+        )
+      ) {
+        result.push(array[i]);
+      }
+    }
+    return result;
+  });
 
-  return acc;
-});
+  this.global.define('reduce', async (array, fn, initial) => {
+    if (!Array.isArray(array)) {
+      throw new RuntimeError('reduce() expects an array', null, evaluator.source);
+    }
+
+    let acc;
+    let i = 0;
+
+    if (initial !== undefined) {
+      acc = initial;
+    } else {
+      if (array.length === 0) {
+        throw new RuntimeError(
+          'reduce() of empty array with no initial value',
+          null,
+          evaluator.source
+        );
+      }
+      acc = array[0];
+      i = 1;
+    }
+
+    for (; i < array.length; i++) {
+      acc = await evaluator.callFunction(
+        fn,
+        [acc, array[i], i, array],
+        evaluator.global
+      );
+    }
+
+    return acc;
+  });
 
     this.global.define('keys', arg => arg && typeof arg === 'object' ? Object.keys(arg) : []);
     this.global.define('values', arg => arg && typeof arg === 'object' ? Object.values(arg) : []);
@@ -376,21 +438,30 @@ case 'RaceClause':
   const callee = await this.evaluate(node.callee, env);
 
   if (typeof callee === 'object' && callee.body) {
-    const evaluator = this; 
-    const Constructor = function(...args) {
+    const evaluator = this;
+
+    const Constructor = function (...args) {
       const newEnv = new Environment(callee.env);
       newEnv.define('this', this);
+
       for (let i = 0; i < callee.params.length; i++) {
-        newEnv.define(callee.params[i], args[i]);
+        const param = callee.params[i];
+        const paramName = typeof param === 'string' ? param : param.name;
+        newEnv.define(paramName, args[i]);
       }
-      return evaluator.evaluate(callee.body, newEnv);
+
+      return (async () => {
+        await evaluator.evaluate(callee.body, newEnv);
+        return this;
+      })();
     };
 
     const args = [];
     for (const a of node.arguments) args.push(await this.evaluate(a, env));
-    return new Constructor(...args);
+    return await new Constructor(...args);
   }
 
+  // native JS constructor fallback
   if (typeof callee !== 'function') {
     throw new RuntimeError('NewExpression callee is not a function', node, this.source);
   }
@@ -612,27 +683,31 @@ evalArrowFunction(node, env) {
   return async function (...args) {
     const localEnv = new Environment(env);
 
+    // Bind parameters safely
     node.params.forEach((p, i) => {
-      localEnv.define(p.name, args[i]);
+      const paramName = typeof p === 'string' ? p : p.name;
+      localEnv.define(paramName, args[i]);
     });
 
     try {
       if (node.isBlock) {
+        // Block body
         const result = await evaluator.evaluate(node.body, localEnv);
-        return result ?? null;
+        return result === undefined ? null : result;  // ensure null instead of undefined
       } else {
-        return await evaluator.evaluate(node.body, localEnv);
+        // Expression body
+        const result = await evaluator.evaluate(node.body, localEnv);
+        return result === undefined ? null : result;  // ensure null instead of undefined
       }
     } catch (err) {
-      if (err instanceof ReturnValue) {
-        return err.value; 
-      }
+      if (err instanceof ReturnValue) return err.value === undefined ? null : err.value;
       throw err;
     }
   };
 }
 
 
+
 async evalAssignment(node, env) {
   const rightVal = await this.evaluate(node.right, env);
   const left = node.left;
@@ -793,13 +868,10 @@ async evalUnary(node, env) {
 
   }
 }
-
 async evalIf(node, env) {
-  const test = await this.evaluate(node.test, env);
+  let test = await this.evaluate(node.test, env);
 
-  if (typeof test !== 'boolean') {
-    throw new RuntimeError('If condition must evaluate to a boolean', node.test, this.source);
-  }
+  test = !!test;
 
   if (test) {
     return await this.evaluate(node.consequent, env);
@@ -812,27 +884,26 @@ async evalIf(node, env) {
   return null;
 }
 
-
 async evalWhile(node, env) {
   while (true) {
-    const test = await this.evaluate(node.test, env);
+    let test = await this.evaluate(node.test, env);
 
-    if (typeof test !== 'boolean') {
-      throw new RuntimeError('While condition must evaluate to a boolean', node.test, this.source);
-    }
+    test = !!test;
 
     if (!test) break;
 
     try {
       await this.evaluate(node.body, env);
     } catch (e) {
-      if (e instanceof BreakSignal) break;
-      if (e instanceof ContinueSignal) continue;
-      throw e;
+      if (e instanceof BreakSignal) break;     
+      if (e instanceof ContinueSignal) continue; 
+      throw e;                                
     }
   }
+
   return null;
 }
+
 async evalFor(node, env) {
   if (node.type === 'ForInStatement') {
     const iterable = await this.evaluate(node.iterable, env);
@@ -973,24 +1044,40 @@ async evalIndex(node, env) {
 async evalObject(node, env) {
   const out = {};
   for (const p of node.props) {
-    if (!p.key || !p.value) {
-      throw new RuntimeError('Invalid object property', node, this.source);
+    if (!p.key) {
+      throw new RuntimeError('Object property must have a key', node, this.source);
     }
+
     const key = await this.evaluate(p.key, env);
-    const value = await this.evaluate(p.value, env);
-    out[key] = value; // dynamic property assignment
+    let value = null;
+
+    if (p.value) {
+      value = await this.evaluate(p.value, env);
+      if (value === undefined) value = null; // <- force null instead of undefined
+    }
+
+    out[key] = value;
   }
   return out;
 }
 
 
 
+
 async evalMember(node, env) {
   const obj = await this.evaluate(node.object, env);
 
-  if (obj == null) throw new RuntimeError('Member access of null or undefined', node, this.source);
+  if (obj == null) {
+    throw new RuntimeError('Member access of null or undefined', node, this.source);
+  }
+
+  const prop = obj[node.property];
+
+  if (typeof prop === 'function') {
+    return prop.bind(obj);
+  }
 
-  return obj[node.property];
+  return prop;
 }
 
 
@@ -1024,4 +1111,4 @@ async evalUpdate(node, env) {
 
 }
 
-module.exports = Evaluator;  
+module.exports = Evaluator;   

package/src/lexer.js

@@ -28,7 +28,7 @@ class Lexer {
       'break', 'continue', 'func', 'return',
       'true', 'false', 'null',
       'ask', 'define', 'import', 'from', 'as',
-      'async', 'await', 'new', 'in', 'do', 'track', 'start', 'race'
+      'async', 'await', 'new', 'in', 'do', 'track', 'start', 'race', 'not', 'and', 'or'
     ];
 }
 
@@ -111,6 +111,8 @@ class Lexer {
     }
 
 if (this.keywords.includes(result)) {
+  if (result === 'and') return { type: 'AND', value: 'and', line: startLine, column: startCol };
+  if (result === 'or')  return { type: 'OR', value: 'or', line: startLine, column: startCol };
   return { type: result.toUpperCase(), value: result, line: startLine, column: startCol };
 }
 

package/src/parser.js

@@ -256,14 +256,18 @@ ifStatement() {
     test = this.expression();
   }
 
-  const consequent = this.block();
+  const consequent = this.statementOrBlock();
 
   let alternate = null;
   if (this.current.type === 'ELSE') {
-    this.eat('ELSE');
-    if (this.current.type === 'IF') alternate = this.ifStatement();
-    else alternate = this.block();
+  this.eat('ELSE');
+  if (this.current.type === 'IF') {
+    alternate = this.ifStatement();
+  } else {
+    alternate = this.statementOrBlock();
   }
+}
+
 
   return { 
     type: 'IfStatement', 
@@ -274,18 +278,51 @@ ifStatement() {
     column: t.column 
   };
 }
+parseExpressionOnly() {
+  return this.expression();
+}
 
 whileStatement() {
   const t = this.current; 
   this.eat('WHILE');
 
   let test;
+
   if (this.current.type === 'LPAREN') {
     this.eat('LPAREN');
     test = this.expression();
     this.eat('RPAREN');
-  } else {
-    test = this.expression();
+  } 
+  else {
+    const startPos = this.pos;
+    const startToken = this.current;
+
+    const exprTokens = [];
+    let braceFound = false;
+    let depth = 0;
+
+    while (this.current.type !== 'EOF') {
+      if (this.current.type === 'LBRACE' && depth === 0) {
+        braceFound = true;
+        break;
+      }
+      if (this.current.type === 'LPAREN') depth++;
+      if (this.current.type === 'RPAREN') depth--;
+      exprTokens.push(this.current);
+      this.advance();
+    }
+
+    if (!braceFound) {
+      throw new ParseError(
+        "Expected '{' after while condition",
+        this.current,
+        this.source
+      );
+    }
+
+    const Parser = require('./parser'); 
+    const exprParser = new Parser(exprTokens, this.source);
+    test = exprParser.parseExpressionOnly(); 
   }
 
   const body = this.block();
@@ -298,6 +335,7 @@ whileStatement() {
   };
 }
 
+
 importStatement() {
   const t = this.current; 
   this.eat('IMPORT');
@@ -497,6 +535,12 @@ returnStatement() {
 
   return { type: 'ReturnStatement', argument, line: t.line, column: t.column };
 }
+statementOrBlock() {
+  if (this.current.type === 'LBRACE') {
+    return this.block();
+  }
+  return this.statement();
+}
 
 block() {
   const t = this.current; // LBRACE token
@@ -706,13 +750,7 @@ postfix() {
       continue;
     }
 
-    if (node.type === 'Identifier' && t.type === 'IDENTIFIER') {
-      const argNode = { type: 'Identifier', name: t.value, line: t.line, column: t.column };
-      this.eat('IDENTIFIER');
-      node = { type: 'CallExpression', callee: node, arguments: [argNode], line: node.line, column: node.column };
-      continue;
-    }
-
+   
     break;
   }
   return node;
@@ -866,21 +904,56 @@ arrowFunction(params) {
   }
 
   if (t.type === 'LBRACE') {
-    const startLine = t.line;
-    const startCol = t.column;
-    this.eat('LBRACE');
-    const props = [];
-    while (this.current.type !== 'RBRACE') {
-      const key = this.expression(); 
-      this.eat('COLON');
-      const value = this.expression();
-      props.push({ key, value });
-      if (this.current.type === 'COMMA') this.eat('COMMA');
+  const startLine = t.line;
+  const startCol = t.column;
+  this.eat('LBRACE');
+
+  const props = [];
+
+  while (this.current.type !== 'RBRACE') {
+    let key;
+
+    if (this.current.type === 'IDENTIFIER') {
+      const k = this.current;
+      this.eat('IDENTIFIER');
+      key = {
+        type: 'Literal',
+        value: k.value,
+        line: k.line,
+        column: k.column
+      };
     }
-    this.eat('RBRACE');
-    return { type: 'ObjectExpression', props, line: startLine, column: startCol };
+    else if (this.current.type === 'STRING') {
+      const k = this.current;
+      this.eat('STRING');
+      key = {
+        type: 'Literal',
+        value: k.value,
+        line: k.line,
+        column: k.column
+      };
+    }
+    else {
+      throw new ParseError(
+        'Invalid object key',
+        this.current,
+        this.source
+      );
+    }
+
+    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, line: startLine, column: startCol };
+}
+
+
   throw new ParseError(
     `Unexpected token '${t.type}'`,
     t,

package/src/starlight.js

@@ -12,7 +12,7 @@ const Lexer = require('./lexer');
 const Parser = require('./parser');
 const Evaluator = require('./evaluator');
 
-const VERSION = '1.1.9';
+const VERSION = '1.1.11';
 
 const COLOR = {
     reset: '\x1b[0m',