starlight-cli 1.1.8 → 1.1.10

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://starlight-learn-lang.pages.dev/
+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,76 @@ 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);
-  }
+   this.global.define('map', async (array, fn) => {
+    if (!Array.isArray(array)) {
+      throw new RuntimeError('map() expects an array', null, evaluator.source);
+    }
 
-  const result = [];
-  for (let i = 0; i < array.length; i++) {
-    result.push(await fn(array[i], i, array));
-  }
-  return result;
-});
-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++) {
+      result.push(
+        await evaluator.callFunction(
+          fn,
+          [array[i], i, array],
+          evaluator.global
+        )
+      );
+    }
+    return result;
+  });
 
-  const result = [];
-  for (let i = 0; i < array.length; i++) {
-    if (await fn(array[i], i, array)) {
-      result.push(array[i]);
+  this.global.define('filter', async (array, fn) => {
+    if (!Array.isArray(array)) {
+      throw new RuntimeError('filter() 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++) {
+      if (
+        await evaluator.callFunction(
+          fn,
+          [array[i], i, array],
+          evaluator.global
+        )
+      ) {
+        result.push(array[i]);
+      }
+    }
+    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('reduce', async (array, fn, initial) => {
+    if (!Array.isArray(array)) {
+      throw new RuntimeError('reduce() 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);
-  }
+    let acc;
+    let i = 0;
 
-  return acc;
-});
+    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) : []);
@@ -10477,12 +10525,26 @@ this.global.define('range', (...args) => {
         return readlineSync.question(prompt + ' ');
     });
     this.global.define('num', arg => {
-    const n = Number(arg);
-    if (Number.isNaN(n)) {
-        throw new RuntimeError('Cannot convert value to number', null, this.source);
+    if (arg === null || arg === undefined) return 0;
+
+    const t = typeof arg;
+
+    if (t === 'number') return arg;       // already a number
+    if (t === 'boolean') return arg ? 1 : 0;
+    if (t === 'string') {
+        const n = Number(arg);
+        if (!Number.isNaN(n)) return n;  // numeric string
+        return 0;                        // non-numeric string becomes 0
     }
-    return n;
+    if (Array.isArray(arg)) return arg.length;   // array → length
+    if (t === 'object') return Object.keys(arg).length; // object → number of keys
+
+    // fallback for anything else
+    const n = Number(arg);
+    if (!Number.isNaN(n)) return n;
+    return 0;
 });
+
 this.global.define('fetch', async (url, options = {}) => {
   const res = await fetch(url, options);
   return {
@@ -10572,21 +10634,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);
   }
@@ -10808,27 +10879,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;
@@ -10924,7 +10999,30 @@ async evalBinary(node, env) {
   }
 
   switch (node.operator) {
-    case 'PLUS': return l + r;
+    case 'PLUS': {
+  if (Array.isArray(l) && Array.isArray(r)) {
+    return l.concat(r);
+  }
+
+  if (typeof l === 'string' || typeof r === 'string') {
+    return String(l) + String(r);
+  }
+
+  if (typeof l === 'number' && typeof r === 'number') {
+    return l + r;
+  }
+
+  if (typeof l === 'object' && typeof r === 'object') {
+    return { ...l, ...r };
+  }
+
+  throw new RuntimeError(
+    `Unsupported operands for +: ${typeof l} and ${typeof r}`,
+    node,
+    this.source
+  );
+}
+
     case 'MINUS': return l - r;
     case 'STAR': return l * r;
     case 'SLASH': return l / r;
@@ -11146,18 +11244,26 @@ 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);
 
@@ -11197,7 +11303,7 @@ async evalUpdate(node, env) {
 
 }
 
-module.exports = Evaluator;  
+module.exports = Evaluator;   
 
 /***/ }),
 
@@ -11692,14 +11798,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', 
@@ -11933,6 +12043,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
@@ -12142,13 +12258,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;
@@ -12302,21 +12412,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,
@@ -12507,7 +12652,7 @@ const Lexer = __nccwpck_require__(211);
 const Parser = __nccwpck_require__(222);
 const Evaluator = __nccwpck_require__(112);
 
-const VERSION = '1.1.8';
+const VERSION = '1.1.10';
 
 const COLOR = {
     reset: '\x1b[0m',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starlight-cli",
-  "version": "1.1.8",
+  "version": "1.1.10",
   "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,76 @@ 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);
-  }
+   this.global.define('map', async (array, fn) => {
+    if (!Array.isArray(array)) {
+      throw new RuntimeError('map() expects an array', null, evaluator.source);
+    }
 
-  const result = [];
-  for (let i = 0; i < array.length; i++) {
-    result.push(await fn(array[i], i, array));
-  }
-  return result;
-});
-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++) {
+      result.push(
+        await evaluator.callFunction(
+          fn,
+          [array[i], i, array],
+          evaluator.global
+        )
+      );
+    }
+    return result;
+  });
 
-  const result = [];
-  for (let i = 0; i < array.length; i++) {
-    if (await fn(array[i], i, array)) {
-      result.push(array[i]);
+  this.global.define('filter', async (array, fn) => {
+    if (!Array.isArray(array)) {
+      throw new RuntimeError('filter() 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++) {
+      if (
+        await evaluator.callFunction(
+          fn,
+          [array[i], i, array],
+          evaluator.global
+        )
+      ) {
+        result.push(array[i]);
+      }
+    }
+    return result;
+  });
+
+  this.global.define('reduce', async (array, fn, initial) => {
+    if (!Array.isArray(array)) {
+      throw new RuntimeError('reduce() expects an array', null, evaluator.source);
+    }
 
-  if (initial !== undefined) {
-    acc = initial;
-  } else {
-    if (array.length === 0) {
-      throw new RuntimeError('reduce() of empty array with no initial value', null, this.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;
     }
-    acc = array[0];
-    startIndex = 1;
-  }
 
-  for (let i = startIndex; i < array.length; i++) {
-    acc = await fn(acc, array[i], i, array);
-  }
+    for (; i < array.length; i++) {
+      acc = await evaluator.callFunction(
+        fn,
+        [acc, array[i], i, array],
+        evaluator.global
+      );
+    }
 
-  return acc;
-});
+    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) : []);
@@ -267,12 +315,26 @@ this.global.define('range', (...args) => {
         return readlineSync.question(prompt + ' ');
     });
     this.global.define('num', arg => {
-    const n = Number(arg);
-    if (Number.isNaN(n)) {
-        throw new RuntimeError('Cannot convert value to number', null, this.source);
+    if (arg === null || arg === undefined) return 0;
+
+    const t = typeof arg;
+
+    if (t === 'number') return arg;       // already a number
+    if (t === 'boolean') return arg ? 1 : 0;
+    if (t === 'string') {
+        const n = Number(arg);
+        if (!Number.isNaN(n)) return n;  // numeric string
+        return 0;                        // non-numeric string becomes 0
     }
-    return n;
+    if (Array.isArray(arg)) return arg.length;   // array → length
+    if (t === 'object') return Object.keys(arg).length; // object → number of keys
+
+    // fallback for anything else
+    const n = Number(arg);
+    if (!Number.isNaN(n)) return n;
+    return 0;
 });
+
 this.global.define('fetch', async (url, options = {}) => {
   const res = await fetch(url, options);
   return {
@@ -362,21 +424,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);
   }
@@ -598,27 +669,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;
@@ -714,7 +789,30 @@ async evalBinary(node, env) {
   }
 
   switch (node.operator) {
-    case 'PLUS': return l + r;
+    case 'PLUS': {
+  if (Array.isArray(l) && Array.isArray(r)) {
+    return l.concat(r);
+  }
+
+  if (typeof l === 'string' || typeof r === 'string') {
+    return String(l) + String(r);
+  }
+
+  if (typeof l === 'number' && typeof r === 'number') {
+    return l + r;
+  }
+
+  if (typeof l === 'object' && typeof r === 'object') {
+    return { ...l, ...r };
+  }
+
+  throw new RuntimeError(
+    `Unsupported operands for +: ${typeof l} and ${typeof r}`,
+    node,
+    this.source
+  );
+}
+
     case 'MINUS': return l - r;
     case 'STAR': return l * r;
     case 'SLASH': return l / r;
@@ -936,18 +1034,26 @@ 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);
 
@@ -987,4 +1093,4 @@ async evalUpdate(node, env) {
 
 }
 
-module.exports = Evaluator;  
+module.exports = Evaluator;   

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', 
@@ -497,6 +501,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 +716,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 +870,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.8';
+const VERSION = '1.1.10';
 
 const COLOR = {
     reset: '\x1b[0m',