starlight-cli 1.0.22 → 1.0.24

package/dist/index.js

@@ -1448,6 +1448,9 @@ this.global.define('str', arg => {
       case 'ImportStatement': return this.evalImport(node, env);
       case 'FunctionDeclaration': return this.evalFunctionDeclaration(node, env);
       case 'CallExpression': return this.evalCall(node, env);
+      case 'ArrowFunctionExpression':
+  return this.evalArrowFunction(node, env);
+
       case 'ReturnStatement': {
         const val = node.argument ? this.evaluate(node.argument, env) : null;
         throw new ReturnValue(val);
@@ -1538,6 +1541,14 @@ evalImport(node, env) {
     const val = this.evaluate(node.expr, env);
     return env.define(node.id, val);
   }
+evalArrowFunction(node, env) {
+  return {
+    params: node.params,
+    body: node.body,
+    env: env,
+    arrow: true
+  };
+}
 
   evalAssignment(node, env) {
     const rightVal = this.evaluate(node.right, env);
@@ -1606,21 +1617,27 @@ evalImport(node, env) {
   evalBinary(node, env) {
     const l = this.evaluate(node.left, env);
     const r = this.evaluate(node.right, env);
+
+    if (node.operator === 'SLASH' && r === 0) {
+        throw new Error('Division by zero');
+    }
+
     switch (node.operator) {
-      case 'PLUS': return l + r;
-      case 'MINUS': return l - r;
-      case 'STAR': return l * r;
-      case 'SLASH': return l / r;
-      case 'MOD': return l % r;
-      case 'EQEQ': return l === r;
-      case 'NOTEQ': return l !== r;
-      case 'LT': return l < r;
-      case 'LTE': return l <= r;
-      case 'GT': return l > r;
-      case 'GTE': return l >= r;
-      default: throw new Error(`Unknown binary operator ${node.operator}`);
+        case 'PLUS': return l + r;
+        case 'MINUS': return l - r;
+        case 'STAR': return l * r;
+        case 'SLASH': return l / r;
+        case 'MOD': return l % r;
+        case 'EQEQ': return l === r;
+        case 'NOTEQ': return l !== r;
+        case 'LT': return l < r;
+        case 'LTE': return l <= r;
+        case 'GT': return l > r;
+        case 'GTE': return l >= r;
+        default: throw new Error(`Unknown binary operator ${node.operator}`);
     }
-  }
+}
+
 
   evalLogical(node, env) {
     const l = this.evaluate(node.left, env);
@@ -1694,16 +1711,31 @@ evalImport(node, env) {
       const argVal = node.arguments[i] ? this.evaluate(node.arguments[i], env) : null;
       callEnv.define(p, argVal);
     });
-    try { return this.evaluate(fn.body, callEnv); }
-    catch (e) { if (e instanceof ReturnValue) return e.value; throw e; }
+    try {
+  const result = this.evaluate(fn.body, callEnv);
+  return fn.arrow ? result : result;
+} catch (e) {
+  if (e instanceof ReturnValue) return e.value;
+  throw e;
+}
+
   }
 
   evalIndex(node, env) {
     const obj = this.evaluate(node.object, env);
     const idx = this.evaluate(node.indexer, env);
-    if (obj == null) throw new Error('Indexing null/undefined');
+
+    if (obj == null) throw new Error('Indexing null or undefined');
+    if (Array.isArray(obj) && (idx < 0 || idx >= obj.length)) {
+        throw new Error('Array index out of bounds');
+    }
+    if (typeof obj === 'object' && !(idx in obj)) {
+        throw new Error(`Property '${idx}' does not exist`);
+    }
+
     return obj[idx];
-  }
+}
+
 
   evalObject(node, env) {
     const out = {};
@@ -1713,9 +1745,11 @@ evalImport(node, env) {
 
   evalMember(node, env) {
     const obj = this.evaluate(node.object, env);
-    if (obj == null) throw new Error('Member access of null/undefined');
+    if (obj == null) throw new Error('Member access of null or undefined');
+    if (!(node.property in obj)) throw new Error(`Property '${node.property}' does not exist`);
     return obj[node.property];
-  }
+}
+
 
   evalUpdate(node, env) {
     const arg = node.argument;
@@ -1892,7 +1926,19 @@ class Lexer {
       const startCol = this.column;
 
       if (char === '=' && next === '=') { tokens.push({ type: 'EQEQ', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
-      if (char === '=' && next === '>') { tokens.push({ type: 'ARROW', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
+    
+if (char === '=' && next === '>') {
+  tokens.push({ type: 'ARROW', line: startLine, column: startCol });
+  this.advance(); this.advance();
+  continue;
+}
+
+if (char === '-' && next === '>') {
+  tokens.push({ type: 'ARROW', line: startLine, column: startCol });
+  this.advance(); this.advance();
+  continue;
+}
+
       if (char === '!' && next === '=') { tokens.push({ type: 'NOTEQ', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
       if (char === '<' && next === '=') { tokens.push({ type: 'LTE', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
       if (char === '>' && next === '=') { tokens.push({ type: 'GTE', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
@@ -2300,6 +2346,15 @@ class Parser {
     }
     return node;
   }
+arrowFunction(params) {
+  this.eat('ARROW');
+  const body = this.expression();
+  return {
+    type: 'ArrowFunctionExpression',
+    params,
+    body
+  };
+}
 
   primary() {
     const t = this.current;
@@ -2326,17 +2381,47 @@ class Parser {
     }
 
     if (t.type === 'IDENTIFIER') {
-      const name = t.value;
+  const name = t.value;
+  this.eat('IDENTIFIER');
+
+  if (this.current.type === 'ARROW') {
+    return this.arrowFunction([name]);
+  }
+
+  return { type: 'Identifier', name };
+}
+
+
+   if (t.type === 'LPAREN') {
+  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');
+      params.push(this.current.value);
       this.eat('IDENTIFIER');
-      return { type: 'Identifier', name };
     }
+  }
+
+  this.eat('RPAREN');
+
+  if (this.current.type === 'ARROW') {
+    return this.arrowFunction(params);
+  }
+
+  if (params.length === 1) {
+    return { type: 'Identifier', name: params[0] };
+  }
+
+  throw new Error(
+    `Invalid grouped expression at line ${this.current.line}, column ${this.current.column}`
+  );
+}
 
-    if (t.type === 'LPAREN') {
-      this.eat('LPAREN');
-      const expr = this.expression();
-      this.eat('RPAREN');
-      return expr;
-    }
 
     if (t.type === 'LBRACKET') {
       this.eat('LBRACKET');
@@ -2475,7 +2560,7 @@ const Lexer = __nccwpck_require__(211);
 const Parser = __nccwpck_require__(222);
 const Evaluator = __nccwpck_require__(112);
 
-const VERSION = '1.0.22';
+const VERSION = '1.0.24';
 
 const COLOR = {
     reset: '\x1b[0m',

package/package.json

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

package/src/evaluator.js

@@ -105,6 +105,9 @@ this.global.define('str', arg => {
       case 'ImportStatement': return this.evalImport(node, env);
       case 'FunctionDeclaration': return this.evalFunctionDeclaration(node, env);
       case 'CallExpression': return this.evalCall(node, env);
+      case 'ArrowFunctionExpression':
+  return this.evalArrowFunction(node, env);
+
       case 'ReturnStatement': {
         const val = node.argument ? this.evaluate(node.argument, env) : null;
         throw new ReturnValue(val);
@@ -195,6 +198,14 @@ evalImport(node, env) {
     const val = this.evaluate(node.expr, env);
     return env.define(node.id, val);
   }
+evalArrowFunction(node, env) {
+  return {
+    params: node.params,
+    body: node.body,
+    env: env,
+    arrow: true
+  };
+}
 
   evalAssignment(node, env) {
     const rightVal = this.evaluate(node.right, env);
@@ -263,21 +274,27 @@ evalImport(node, env) {
   evalBinary(node, env) {
     const l = this.evaluate(node.left, env);
     const r = this.evaluate(node.right, env);
+
+    if (node.operator === 'SLASH' && r === 0) {
+        throw new Error('Division by zero');
+    }
+
     switch (node.operator) {
-      case 'PLUS': return l + r;
-      case 'MINUS': return l - r;
-      case 'STAR': return l * r;
-      case 'SLASH': return l / r;
-      case 'MOD': return l % r;
-      case 'EQEQ': return l === r;
-      case 'NOTEQ': return l !== r;
-      case 'LT': return l < r;
-      case 'LTE': return l <= r;
-      case 'GT': return l > r;
-      case 'GTE': return l >= r;
-      default: throw new Error(`Unknown binary operator ${node.operator}`);
+        case 'PLUS': return l + r;
+        case 'MINUS': return l - r;
+        case 'STAR': return l * r;
+        case 'SLASH': return l / r;
+        case 'MOD': return l % r;
+        case 'EQEQ': return l === r;
+        case 'NOTEQ': return l !== r;
+        case 'LT': return l < r;
+        case 'LTE': return l <= r;
+        case 'GT': return l > r;
+        case 'GTE': return l >= r;
+        default: throw new Error(`Unknown binary operator ${node.operator}`);
     }
-  }
+}
+
 
   evalLogical(node, env) {
     const l = this.evaluate(node.left, env);
@@ -351,16 +368,31 @@ evalImport(node, env) {
       const argVal = node.arguments[i] ? this.evaluate(node.arguments[i], env) : null;
       callEnv.define(p, argVal);
     });
-    try { return this.evaluate(fn.body, callEnv); }
-    catch (e) { if (e instanceof ReturnValue) return e.value; throw e; }
+    try {
+  const result = this.evaluate(fn.body, callEnv);
+  return fn.arrow ? result : result;
+} catch (e) {
+  if (e instanceof ReturnValue) return e.value;
+  throw e;
+}
+
   }
 
   evalIndex(node, env) {
     const obj = this.evaluate(node.object, env);
     const idx = this.evaluate(node.indexer, env);
-    if (obj == null) throw new Error('Indexing null/undefined');
+
+    if (obj == null) throw new Error('Indexing null or undefined');
+    if (Array.isArray(obj) && (idx < 0 || idx >= obj.length)) {
+        throw new Error('Array index out of bounds');
+    }
+    if (typeof obj === 'object' && !(idx in obj)) {
+        throw new Error(`Property '${idx}' does not exist`);
+    }
+
     return obj[idx];
-  }
+}
+
 
   evalObject(node, env) {
     const out = {};
@@ -370,9 +402,11 @@ evalImport(node, env) {
 
   evalMember(node, env) {
     const obj = this.evaluate(node.object, env);
-    if (obj == null) throw new Error('Member access of null/undefined');
+    if (obj == null) throw new Error('Member access of null or undefined');
+    if (!(node.property in obj)) throw new Error(`Property '${node.property}' does not exist`);
     return obj[node.property];
-  }
+}
+
 
   evalUpdate(node, env) {
     const arg = node.argument;

package/src/lexer.js

@@ -139,7 +139,19 @@ class Lexer {
       const startCol = this.column;
 
       if (char === '=' && next === '=') { tokens.push({ type: 'EQEQ', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
-      if (char === '=' && next === '>') { tokens.push({ type: 'ARROW', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
+    
+if (char === '=' && next === '>') {
+  tokens.push({ type: 'ARROW', line: startLine, column: startCol });
+  this.advance(); this.advance();
+  continue;
+}
+
+if (char === '-' && next === '>') {
+  tokens.push({ type: 'ARROW', line: startLine, column: startCol });
+  this.advance(); this.advance();
+  continue;
+}
+
       if (char === '!' && next === '=') { tokens.push({ type: 'NOTEQ', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
       if (char === '<' && next === '=') { tokens.push({ type: 'LTE', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
       if (char === '>' && next === '=') { tokens.push({ type: 'GTE', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }

package/src/parser.js

@@ -368,6 +368,15 @@ class Parser {
     }
     return node;
   }
+arrowFunction(params) {
+  this.eat('ARROW');
+  const body = this.expression();
+  return {
+    type: 'ArrowFunctionExpression',
+    params,
+    body
+  };
+}
 
   primary() {
     const t = this.current;
@@ -394,17 +403,47 @@ class Parser {
     }
 
     if (t.type === 'IDENTIFIER') {
-      const name = t.value;
+  const name = t.value;
+  this.eat('IDENTIFIER');
+
+  if (this.current.type === 'ARROW') {
+    return this.arrowFunction([name]);
+  }
+
+  return { type: 'Identifier', name };
+}
+
+
+   if (t.type === 'LPAREN') {
+  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');
+      params.push(this.current.value);
       this.eat('IDENTIFIER');
-      return { type: 'Identifier', name };
     }
+  }
+
+  this.eat('RPAREN');
+
+  if (this.current.type === 'ARROW') {
+    return this.arrowFunction(params);
+  }
+
+  if (params.length === 1) {
+    return { type: 'Identifier', name: params[0] };
+  }
+
+  throw new Error(
+    `Invalid grouped expression at line ${this.current.line}, column ${this.current.column}`
+  );
+}
 
-    if (t.type === 'LPAREN') {
-      this.eat('LPAREN');
-      const expr = this.expression();
-      this.eat('RPAREN');
-      return expr;
-    }
 
     if (t.type === 'LBRACKET') {
       this.eat('LBRACKET');

package/src/starlight.js

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