starlight-cli 1.1.14 → 1.1.16

package/dist/index.js

@@ -10433,7 +10433,24 @@ this.global.define('random', (min, max) => {
   if (isNaN(min) || isNaN(max)) return 0;
   return Math.floor(Math.random() * (max - min)) + min;
 });
+this.global.define('JSONParse', arg => {
+        if (typeof arg !== 'string') {
+            throw new RuntimeError('JSONParse expects a string', null, evaluator.source);
+        }
+        try {
+            return JSON.parse(arg);
+        } catch (e) {
+            throw new RuntimeError('Invalid JSON string: ' + e.message, null, evaluator.source);
+        }
+    });
 
+    this.global.define('JSONStringify', arg => {
+        try {
+            return JSON.stringify(arg);
+        } catch (e) {
+            throw new RuntimeError('Cannot stringify value: ' + e.message, null, evaluator.source);
+        }
+    });
    this.global.define('map', async (array, fn) => {
     if (!Array.isArray(array)) {
       throw new RuntimeError('map() expects an array', null, evaluator.source);
@@ -10615,10 +10632,17 @@ async evaluate(node, env = this.global) {
     case 'SldeployStatement': return await this.evalSldeploy(node, env);
     case 'AskStatement': return await this.evalAsk(node, env);
     case 'DefineStatement': return await this.evalDefine(node, env);
+    case 'FunctionExpression':
+  return this.evalFunctionExpression(node, env);
+case 'SliceExpression':
+  return await this.evalSlice(node, env);
+
     case 'ExpressionStatement': return await this.evaluate(node.expression, env);
     case 'BinaryExpression': return await this.evalBinary(node, env);
     case 'LogicalExpression': return await this.evalLogical(node, env);
     case 'UnaryExpression': return await this.evalUnary(node, env);
+    case 'ConditionalExpression':
+  return await this.evalConditional(node, env);
     case 'Literal': return node.value;
     case 'Identifier': return env.get(node.name, node, this.source);
     case 'IfStatement': return await this.evalIf(node, env);
@@ -10721,6 +10745,36 @@ async evalProgram(node, env) {
   }
   return result;
 }
+async evalSlice(node, env) {
+  try {
+    const arr = await this.evaluate(node.object, env);
+    const start = node.start ? await this.evaluate(node.start, env) : 0;
+    const end = node.end ? await this.evaluate(node.end, env) : arr.length;
+
+    if (!Array.isArray(arr)) {
+      throw new RuntimeError(
+        'Slice target must be an array',
+        node,
+        this.source,
+        env
+      );
+    }
+
+    const s = start < 0 ? Math.max(arr.length + start, 0) : Math.min(start, arr.length);
+    const e = end < 0 ? Math.max(arr.length + end, 0) : Math.min(end, arr.length);
+
+    return arr.slice(s, e);
+
+  } catch (err) {
+    if (err instanceof RuntimeError) throw err;
+    throw new RuntimeError(
+      err.message || 'Error evaluating slice expression',
+      node,
+      this.source,
+      env
+    );
+  }
+}
 
 async evalStartStatement(node, env) {
   try {
@@ -10769,6 +10823,24 @@ async evalStartStatement(node, env) {
     );
   }
 }
+async evalConditional(node, env) {
+  try {
+    const test = await this.evaluate(node.test, env);
+    if (test) {
+      return await this.evaluate(node.consequent, env);
+    } else {
+      return await this.evaluate(node.alternate, env);
+    }
+  } catch (e) {
+    if (e instanceof RuntimeError) throw e;
+    throw new RuntimeError(
+      e.message || 'Error evaluating conditional expression',
+      node,
+      this.source,
+      env
+    );
+  }
+}
 
 async evalRaceClause(node, env) {
   try {
@@ -11379,6 +11451,41 @@ async evalFor(node, env) {
     );
   }
 }
+evalFunctionExpression(node, env) {
+  if (!node.body || !Array.isArray(node.params)) {
+    throw new RuntimeError(
+      'Invalid function expression',
+      node,
+      this.source,
+      env
+    );
+  }
+
+  const evaluator = this;
+
+  const fn = async function (...args) {
+    const localEnv = new Environment(env);
+
+    for (let i = 0; i < node.params.length; i++) {
+      const param = node.params[i];
+      const paramName = typeof param === 'string' ? param : param.name;
+      localEnv.define(paramName, args[i]);
+    }
+
+    try {
+      const result = await evaluator.evaluate(node.body, localEnv);
+      return result === undefined ? null : result;
+    } catch (e) {
+      if (e instanceof ReturnValue) return e.value === undefined ? null : e.value;
+      throw e;
+    }
+  };
+  fn.params = node.params;
+  fn.body = node.body;
+  fn.env = env;
+
+  return fn;
+}
 
 evalFunctionDeclaration(node, env) {
   try {
@@ -11466,7 +11573,6 @@ async evalCall(node, env) {
     );
   }
 }
-
 async evalIndex(node, env) {
   try {
     const obj = await this.evaluate(node.object, env);
@@ -11499,7 +11605,6 @@ async evalIndex(node, env) {
     );
   }
 }
-
 async evalObject(node, env) {
   try {
     const out = {};
@@ -13144,33 +13249,100 @@ postfix() {
   while (true) {
     const t = this.current;
 
-    if (t.type === 'LBRACKET') {
-      const startLine = t.line;
-      const startCol = t.column;
-      this.eat('LBRACKET');
+   if (t.type === 'LBRACKET') {
+  const startLine = t.line;
+  const startCol = t.column;
+  this.eat('LBRACKET');
+
+  let start = null;
+  let end = null;
+  let step = null;
 
-      const index = this.expression();
+  if (this.current.type === 'COLON') {
+    this.eat('COLON');
+
+    if (this.current.type !== 'RBRACKET' && this.current.type !== 'COLON') {
+      end = this.expression();
+    }
+
+    if (this.current.type === 'COLON') {
+      this.eat('COLON');
+      if (this.current.type !== 'RBRACKET') {
+        step = this.expression();
+      }
+    }
+
+    if (this.current.type !== 'RBRACKET') {
+      throw new ParseError(
+        "Expected ']' after slice",
+        this.current,
+        this.source
+      );
+    }
+
+    this.eat('RBRACKET');
+
+    node = {
+      type: 'SliceExpression',
+      object: node,
+      start,
+      end,
+      step,
+      line: startLine,
+      column: startCol
+    };
+
+  } else {
+    start = this.expression();
+
+    if (this.current.type === 'COLON') {
+      this.eat('COLON');
+
+      if (this.current.type !== 'RBRACKET' && this.current.type !== 'COLON') {
+        end = this.expression();
+      }
+
+      if (this.current.type === 'COLON') {
+        this.eat('COLON');
+        if (this.current.type !== 'RBRACKET') {
+          step = this.expression();
+        }
+      }
 
       if (this.current.type !== 'RBRACKET') {
         throw new ParseError(
-          "Expected ']' after index expression",
+          "Expected ']' after slice",
           this.current,
-          this.source,
-          "Index access must be closed, e.g. arr[0]"
+          this.source
         );
       }
 
       this.eat('RBRACKET');
 
+      node = {
+        type: 'SliceExpression',
+        object: node,
+        start,
+        end,
+        step,
+        line: startLine,
+        column: startCol
+      };
+
+    } else {
+      this.eat('RBRACKET');
       node = {
         type: 'IndexExpression',
         object: node,
-        indexer: index,
+        indexer: start,
         line: startLine,
         column: startCol
       };
-      continue;
     }
+  }
+}
+
+
 
     if (t.type === 'LPAREN') {
       const startLine = t.line;
@@ -13302,6 +13474,7 @@ arrowFunction(params) {
   };
 }
 
+
 primary() {
   const t = this.current;
 
@@ -13373,7 +13546,6 @@ primary() {
     return { type: 'NewExpression', callee, arguments: args, line: t.line, column: t.column };
   }
 
-  // ---- ask(...) function call ----
   if (t.type === 'ASK') {
     this.eat('ASK');
 
@@ -13414,6 +13586,69 @@ primary() {
       column: t.column
     };
   }
+if (t.type === 'FUNC') {
+    const funcToken = t;
+    this.eat('FUNC');
+
+    let params = [];
+    if (this.current.type === 'LPAREN') {
+      this.eat('LPAREN');
+
+      if (this.current.type !== 'RPAREN') {
+        if (this.current.type !== 'IDENTIFIER') {
+          throw new ParseError(
+            "Expected parameter name",
+            this.current,
+            this.source
+          );
+        }
+
+        params.push(this.current.value);
+        this.eat('IDENTIFIER');
+
+        while (this.current.type === 'COMMA') {
+          this.eat('COMMA');
+          if (this.current.type !== 'IDENTIFIER') {
+            throw new ParseError(
+              "Expected parameter name",
+              this.current,
+              this.source
+            );
+          }
+          params.push(this.current.value);
+          this.eat('IDENTIFIER');
+        }
+      }
+
+      if (this.current.type !== 'RPAREN') {
+        throw new ParseError(
+          "Expected ')' after function parameters",
+          this.current,
+          this.source
+        );
+      }
+
+      this.eat('RPAREN');
+    }
+
+    if (this.current.type !== 'LBRACE') {
+      throw new ParseError(
+        "Expected '{' to start function body",
+        this.current,
+        this.source
+      );
+    }
+
+    const body = this.block();
+
+    return {
+      type: 'FunctionExpression',
+      params,
+      body,
+      line: funcToken.line,
+      column: funcToken.column
+    };
+  }
 
   if (t.type === 'IDENTIFIER') {
     const name = t.value;
@@ -13550,7 +13785,7 @@ primary() {
     t,
     this.source
   );
-}
+} 
 
 }
 
@@ -13734,7 +13969,7 @@ const Lexer = __nccwpck_require__(211);
 const Parser = __nccwpck_require__(222);
 const Evaluator = __nccwpck_require__(112);
 
-const VERSION = '1.1.14';
+const VERSION = '1.1.16';
 
 const COLOR = {
     reset: '\x1b[0m',

package/package.json

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

package/src/evaluator.js

@@ -223,7 +223,24 @@ this.global.define('random', (min, max) => {
   if (isNaN(min) || isNaN(max)) return 0;
   return Math.floor(Math.random() * (max - min)) + min;
 });
+this.global.define('JSONParse', arg => {
+        if (typeof arg !== 'string') {
+            throw new RuntimeError('JSONParse expects a string', null, evaluator.source);
+        }
+        try {
+            return JSON.parse(arg);
+        } catch (e) {
+            throw new RuntimeError('Invalid JSON string: ' + e.message, null, evaluator.source);
+        }
+    });
 
+    this.global.define('JSONStringify', arg => {
+        try {
+            return JSON.stringify(arg);
+        } catch (e) {
+            throw new RuntimeError('Cannot stringify value: ' + e.message, null, evaluator.source);
+        }
+    });
    this.global.define('map', async (array, fn) => {
     if (!Array.isArray(array)) {
       throw new RuntimeError('map() expects an array', null, evaluator.source);
@@ -405,10 +422,17 @@ async evaluate(node, env = this.global) {
     case 'SldeployStatement': return await this.evalSldeploy(node, env);
     case 'AskStatement': return await this.evalAsk(node, env);
     case 'DefineStatement': return await this.evalDefine(node, env);
+    case 'FunctionExpression':
+  return this.evalFunctionExpression(node, env);
+case 'SliceExpression':
+  return await this.evalSlice(node, env);
+
     case 'ExpressionStatement': return await this.evaluate(node.expression, env);
     case 'BinaryExpression': return await this.evalBinary(node, env);
     case 'LogicalExpression': return await this.evalLogical(node, env);
     case 'UnaryExpression': return await this.evalUnary(node, env);
+    case 'ConditionalExpression':
+  return await this.evalConditional(node, env);
     case 'Literal': return node.value;
     case 'Identifier': return env.get(node.name, node, this.source);
     case 'IfStatement': return await this.evalIf(node, env);
@@ -511,6 +535,36 @@ async evalProgram(node, env) {
   }
   return result;
 }
+async evalSlice(node, env) {
+  try {
+    const arr = await this.evaluate(node.object, env);
+    const start = node.start ? await this.evaluate(node.start, env) : 0;
+    const end = node.end ? await this.evaluate(node.end, env) : arr.length;
+
+    if (!Array.isArray(arr)) {
+      throw new RuntimeError(
+        'Slice target must be an array',
+        node,
+        this.source,
+        env
+      );
+    }
+
+    const s = start < 0 ? Math.max(arr.length + start, 0) : Math.min(start, arr.length);
+    const e = end < 0 ? Math.max(arr.length + end, 0) : Math.min(end, arr.length);
+
+    return arr.slice(s, e);
+
+  } catch (err) {
+    if (err instanceof RuntimeError) throw err;
+    throw new RuntimeError(
+      err.message || 'Error evaluating slice expression',
+      node,
+      this.source,
+      env
+    );
+  }
+}
 
 async evalStartStatement(node, env) {
   try {
@@ -559,6 +613,24 @@ async evalStartStatement(node, env) {
     );
   }
 }
+async evalConditional(node, env) {
+  try {
+    const test = await this.evaluate(node.test, env);
+    if (test) {
+      return await this.evaluate(node.consequent, env);
+    } else {
+      return await this.evaluate(node.alternate, env);
+    }
+  } catch (e) {
+    if (e instanceof RuntimeError) throw e;
+    throw new RuntimeError(
+      e.message || 'Error evaluating conditional expression',
+      node,
+      this.source,
+      env
+    );
+  }
+}
 
 async evalRaceClause(node, env) {
   try {
@@ -1169,6 +1241,41 @@ async evalFor(node, env) {
     );
   }
 }
+evalFunctionExpression(node, env) {
+  if (!node.body || !Array.isArray(node.params)) {
+    throw new RuntimeError(
+      'Invalid function expression',
+      node,
+      this.source,
+      env
+    );
+  }
+
+  const evaluator = this;
+
+  const fn = async function (...args) {
+    const localEnv = new Environment(env);
+
+    for (let i = 0; i < node.params.length; i++) {
+      const param = node.params[i];
+      const paramName = typeof param === 'string' ? param : param.name;
+      localEnv.define(paramName, args[i]);
+    }
+
+    try {
+      const result = await evaluator.evaluate(node.body, localEnv);
+      return result === undefined ? null : result;
+    } catch (e) {
+      if (e instanceof ReturnValue) return e.value === undefined ? null : e.value;
+      throw e;
+    }
+  };
+  fn.params = node.params;
+  fn.body = node.body;
+  fn.env = env;
+
+  return fn;
+}
 
 evalFunctionDeclaration(node, env) {
   try {
@@ -1256,7 +1363,6 @@ async evalCall(node, env) {
     );
   }
 }
-
 async evalIndex(node, env) {
   try {
     const obj = await this.evaluate(node.object, env);
@@ -1289,7 +1395,6 @@ async evalIndex(node, env) {
     );
   }
 }
-
 async evalObject(node, env) {
   try {
     const out = {};

package/src/parser.js

@@ -1292,33 +1292,100 @@ postfix() {
   while (true) {
     const t = this.current;
 
-    if (t.type === 'LBRACKET') {
-      const startLine = t.line;
-      const startCol = t.column;
-      this.eat('LBRACKET');
+   if (t.type === 'LBRACKET') {
+  const startLine = t.line;
+  const startCol = t.column;
+  this.eat('LBRACKET');
+
+  let start = null;
+  let end = null;
+  let step = null;
 
-      const index = this.expression();
+  if (this.current.type === 'COLON') {
+    this.eat('COLON');
+
+    if (this.current.type !== 'RBRACKET' && this.current.type !== 'COLON') {
+      end = this.expression();
+    }
+
+    if (this.current.type === 'COLON') {
+      this.eat('COLON');
+      if (this.current.type !== 'RBRACKET') {
+        step = this.expression();
+      }
+    }
+
+    if (this.current.type !== 'RBRACKET') {
+      throw new ParseError(
+        "Expected ']' after slice",
+        this.current,
+        this.source
+      );
+    }
+
+    this.eat('RBRACKET');
+
+    node = {
+      type: 'SliceExpression',
+      object: node,
+      start,
+      end,
+      step,
+      line: startLine,
+      column: startCol
+    };
+
+  } else {
+    start = this.expression();
+
+    if (this.current.type === 'COLON') {
+      this.eat('COLON');
+
+      if (this.current.type !== 'RBRACKET' && this.current.type !== 'COLON') {
+        end = this.expression();
+      }
+
+      if (this.current.type === 'COLON') {
+        this.eat('COLON');
+        if (this.current.type !== 'RBRACKET') {
+          step = this.expression();
+        }
+      }
 
       if (this.current.type !== 'RBRACKET') {
         throw new ParseError(
-          "Expected ']' after index expression",
+          "Expected ']' after slice",
           this.current,
-          this.source,
-          "Index access must be closed, e.g. arr[0]"
+          this.source
         );
       }
 
       this.eat('RBRACKET');
 
+      node = {
+        type: 'SliceExpression',
+        object: node,
+        start,
+        end,
+        step,
+        line: startLine,
+        column: startCol
+      };
+
+    } else {
+      this.eat('RBRACKET');
       node = {
         type: 'IndexExpression',
         object: node,
-        indexer: index,
+        indexer: start,
         line: startLine,
         column: startCol
       };
-      continue;
     }
+  }
+}
+
+
 
     if (t.type === 'LPAREN') {
       const startLine = t.line;
@@ -1450,6 +1517,7 @@ arrowFunction(params) {
   };
 }
 
+
 primary() {
   const t = this.current;
 
@@ -1521,7 +1589,6 @@ primary() {
     return { type: 'NewExpression', callee, arguments: args, line: t.line, column: t.column };
   }
 
-  // ---- ask(...) function call ----
   if (t.type === 'ASK') {
     this.eat('ASK');
 
@@ -1562,6 +1629,69 @@ primary() {
       column: t.column
     };
   }
+if (t.type === 'FUNC') {
+    const funcToken = t;
+    this.eat('FUNC');
+
+    let params = [];
+    if (this.current.type === 'LPAREN') {
+      this.eat('LPAREN');
+
+      if (this.current.type !== 'RPAREN') {
+        if (this.current.type !== 'IDENTIFIER') {
+          throw new ParseError(
+            "Expected parameter name",
+            this.current,
+            this.source
+          );
+        }
+
+        params.push(this.current.value);
+        this.eat('IDENTIFIER');
+
+        while (this.current.type === 'COMMA') {
+          this.eat('COMMA');
+          if (this.current.type !== 'IDENTIFIER') {
+            throw new ParseError(
+              "Expected parameter name",
+              this.current,
+              this.source
+            );
+          }
+          params.push(this.current.value);
+          this.eat('IDENTIFIER');
+        }
+      }
+
+      if (this.current.type !== 'RPAREN') {
+        throw new ParseError(
+          "Expected ')' after function parameters",
+          this.current,
+          this.source
+        );
+      }
+
+      this.eat('RPAREN');
+    }
+
+    if (this.current.type !== 'LBRACE') {
+      throw new ParseError(
+        "Expected '{' to start function body",
+        this.current,
+        this.source
+      );
+    }
+
+    const body = this.block();
+
+    return {
+      type: 'FunctionExpression',
+      params,
+      body,
+      line: funcToken.line,
+      column: funcToken.column
+    };
+  }
 
   if (t.type === 'IDENTIFIER') {
     const name = t.value;
@@ -1698,7 +1828,7 @@ primary() {
     t,
     this.source
   );
-}
+} 
 
 }
 

package/src/starlight.js

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