starlight-cli 1.0.25 → 1.0.26

package/src/evaluator.js

@@ -4,390 +4,478 @@ const Lexer = require('./lexer');
 const Parser = require('./parser');
 const path = require('path');
 
-class ReturnValue { constructor(value) { this.value = value; } }
+class ReturnValue {
+  constructor(value) { this.value = value; }
+}
 class BreakSignal {}
 class ContinueSignal {}
 
 class Environment {
-    constructor(parent = null) {
-        this.store = Object.create(null);
-        this.parent = parent;
-    }
+  constructor(parent = null) {
+    this.store = Object.create(null);
+    this.parent = parent;
+  }
+
+  has(name) {
+    if (name in this.store) return true;
+    if (this.parent) return this.parent.has(name);
+    return false;
+  }
+
+  get(name) {
+    if (name in this.store) return this.store[name];
+    if (this.parent) return this.parent.get(name);
+    throw new Error(`Undefined variable: ${name}`);
+  }
+
+  set(name, value) {
+    if (name in this.store) { this.store[name] = value; return value; }
+    if (this.parent && this.parent.has(name)) { return this.parent.set(name, value); }
+    this.store[name] = value;
+    return value;
+  }
+
+  define(name, value) {
+    this.store[name] = value;
+    return value;
+  }
+}
 
-    has(name) {
-        if (name in this.store) return true;
-        if (this.parent) return this.parent.has(name);
-        return false;
-    }
+class Evaluator {
+  constructor() {
+    this.global = new Environment();
+    this.setupBuiltins();
+  }
+
+  setupBuiltins() {
+    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;
+        return 0;
+    });
+
+    this.global.define('print', arg => { console.log(arg); return null; });
+    this.global.define('type', arg => {
+        if (Array.isArray(arg)) return 'array';
+        return typeof arg;
+    });
+    this.global.define('keys', arg => arg && typeof arg === 'object' ? Object.keys(arg) : []);
+    this.global.define('values', arg => arg && typeof arg === 'object' ? Object.values(arg) : []);
+
+    this.global.define('ask', prompt => {
+        const readlineSync = require('readline-sync');
+        return readlineSync.question(prompt + ' ');
+    });
+    this.global.define('num', arg => {
+    const n = Number(arg);
+    if (Number.isNaN(n)) {
+        throw new Error('Cannot convert value to number');
+    }
+    return n;
+});
+this.global.define('fetch', async (url, options = {}) => {
+  const res = await fetch(url, options);
+  return {
+    status: res.status,
+    ok: res.ok,
+    text: async () => await res.text(),
+    json: async () => await res.json()
+  };
+});
+
+// GET request
+this.global.define('get', async (url) => {
+  const res = await fetch(url);
+  return await res.json();
+});
+
+this.global.define('post', async (url, data) => {
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(data)
+  });
+  return await res.json();
+});
+
+this.global.define('sleep', async (ms) => {
+  return new Promise(resolve => setTimeout(resolve, ms));
+});
+this.global.define('str', arg => {
+    return String(arg);
+});
 
-    get(name) {
-        if (name in this.store) return this.store[name];
-        if (this.parent) return this.parent.get(name);
-        throw new Error(`Undefined variable: ${name}`);
-    }
+}
 
-    set(name, value) {
-        if (name in this.store) { this.store[name] = value; return value; }
-        if (this.parent && this.parent.has(name)) { return this.parent.set(name, value); }
-        this.store[name] = value;
-        return value;
-    }
+async evaluate(node, env = this.global) {
+  switch (node.type) {
+    case 'Program': return await this.evalProgram(node, env);
+    case 'BlockStatement': return await this.evalBlock(node, new Environment(env));
+    case 'VarDeclaration': return await this.evalVarDeclaration(node, env);
+    case 'AssignmentExpression': return await this.evalAssignment(node, env);
+    case 'CompoundAssignment': return await this.evalCompoundAssignment(node, env);
+    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 '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 'Literal': return node.value;
+    case 'Identifier': return env.get(node.name);
+    case 'IfStatement': return await this.evalIf(node, env);
+    case 'WhileStatement': return await this.evalWhile(node, env);
+    case 'ForStatement': return await this.evalFor(node, env);
+    case 'BreakStatement': throw new BreakSignal();
+    case 'ContinueStatement': throw new ContinueSignal();
+    case 'ImportStatement': return await this.evalImport(node, env);
+    case 'FunctionDeclaration': return this.evalFunctionDeclaration(node, env);
+    case 'CallExpression': return await this.evalCall(node, env);
+    case 'ArrowFunctionExpression': return this.evalArrowFunction(node, env);
+    case 'ReturnStatement': {
+      const val = node.argument ? await this.evaluate(node.argument, env) : null;
+      throw new ReturnValue(val);
+    }
+   
+    case 'ArrayExpression':
+      return await Promise.all(node.elements.map(el => this.evaluate(el, env)));
+    case 'IndexExpression': return await this.evalIndex(node, env);
+    case 'ObjectExpression': {
+      const out = {};
+      for (const p of node.props) {
+        out[p.key] = await this.evaluate(p.value, env);
+      }
+      return out;
+    }
+    case 'MemberExpression': return await this.evalMember(node, env);
+    case 'UpdateExpression': return await this.evalUpdate(node, env);
+    case 'AwaitExpression': {
+      const val = await this.evaluate(node.argument, env);
+      return val;
+    }
+    default:
+      throw new Error(`Unknown node type in evaluator: ${node.type}`);
+  }
+}
 
-    define(name, value) {
-        this.store[name] = value;
-        return value;
-    }
+async evalProgram(node, env) {
+  let result = null;
+  for (const stmt of node.body) {
+    result = await this.evaluate(stmt, env);
+  }
+  return result;
 }
 
-class Evaluator {
-    constructor() {
-        this.global = new Environment();
-        this.setupBuiltins();
-    }
+async evalImport(node, env) {
+  const spec = node.path;
+  let lib;
 
-    setupBuiltins() {
-        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;
-            return 0;
-        });
-
-        this.global.define('print', arg => { console.log(arg); return null; });
-        this.global.define('type', arg => Array.isArray(arg) ? 'array' : typeof arg);
-        this.global.define('keys', arg => arg && typeof arg === 'object' ? Object.keys(arg) : []);
-        this.global.define('values', arg => arg && typeof arg === 'object' ? Object.values(arg) : []);
-
-        this.global.define('ask', prompt => readlineSync.question(prompt + ' '));
-        this.global.define('num', arg => {
-            const n = Number(arg);
-            if (Number.isNaN(n)) throw new Error('Cannot convert value to number');
-            return n;
-        });
-        this.global.define('str', arg => String(arg));
-
-        // Async fetch built-in for API requests
-        this.global.define('fetch', async (url, options) => {
-            const fetch = require('node-fetch'); // Make sure node-fetch is installed
-            const res = await fetch(url, options);
-            return res;
-        });
-    }
+  try {
+    const resolved = require.resolve(spec, {
+      paths: [process.cwd()]
+    });
+    lib = require(resolved);
+  } catch (e) {
+    const fullPath = path.isAbsolute(spec)
+      ? spec
+      : path.join(process.cwd(), spec.endsWith('.sl') ? spec : spec + '.sl');
 
-    async evaluate(node, env = this.global) {
-        switch (node.type) {
-            case 'Program': return await this.evalProgram(node, env);
-            case 'BlockStatement': return await this.evalBlock(node, new Environment(env));
-            case 'VarDeclaration': return await this.evalVarDeclaration(node, env);
-            case 'AssignmentExpression': return await this.evalAssignment(node, env);
-            case 'CompoundAssignment': return await this.evalCompoundAssignment(node, env);
-            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 '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 'Literal': return node.value;
-            case 'Identifier': return env.get(node.name);
-            case 'IfStatement': return await this.evalIf(node, env);
-            case 'WhileStatement': return await this.evalWhile(node, env);
-            case 'ForStatement': return await this.evalFor(node, env);
-            case 'BreakStatement': throw new BreakSignal();
-            case 'ContinueStatement': throw new ContinueSignal();
-            case 'ImportStatement': return await this.evalImport(node, env);
-            case 'FunctionDeclaration': return await this.evalFunctionDeclaration(node, env);
-            case 'CallExpression': return await this.evalCall(node, env);
-            case 'ArrowFunctionExpression': return await this.evalArrowFunction(node, env);
-            case 'ReturnStatement': {
-                const val = node.argument ? await this.evaluate(node.argument, env) : null;
-                throw new ReturnValue(val);
-            }
-            case 'ArrayExpression': return await Promise.all(node.elements.map(el => this.evaluate(el, env)));
-            case 'IndexExpression': return await this.evalIndex(node, env);
-            case 'ObjectExpression': return await this.evalObject(node, env);
-            case 'MemberExpression': return await this.evalMember(node, env);
-            case 'UpdateExpression': return await this.evalUpdate(node, env);
-            default:
-                throw new Error(`Unknown node type in evaluator: ${node.type}`);
-        }
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`Import not found: ${spec}`);
     }
 
-    async evalProgram(node, env) {
-        let result = null;
-        for (const stmt of node.body) result = await this.evaluate(stmt, env);
-        return result;
-    }
+    const code = fs.readFileSync(fullPath, 'utf-8');
+    const tokens = new Lexer(code).getTokens();
+    const ast = new Parser(tokens).parse();
 
-    async evalBlock(node, env) {
-        let result = null;
-        for (const stmt of node.body) {
-            try { result = await this.evaluate(stmt, env); }
-            catch (e) {
-                if (e instanceof ReturnValue || e instanceof BreakSignal || e instanceof ContinueSignal) throw e;
-                throw e;
-            }
-        }
-        return result;
-    }
+    const moduleEnv = new Environment(env);
+    await this.evaluate(ast, moduleEnv);
 
-    async evalVarDeclaration(node, env) {
-        const val = await this.evaluate(node.expr, env);
-        return env.define(node.id, val);
+    lib = {};
+    for (const key of Object.keys(moduleEnv.store)) {
+      lib[key] = moduleEnv.store[key];
     }
 
-    async evalArrowFunction(node, env) {
-        return { params: node.params, body: node.body, env, arrow: true };
-    }
+    lib.default = lib;
+  }
 
-    async evalAssignment(node, env) {
-        const rightVal = await this.evaluate(node.right, env);
-        const left = node.left;
-
-        if (left.type === 'Identifier') return env.set(left.name, rightVal);
-        if (left.type === 'MemberExpression') {
-            const obj = await this.evalMemberObj(left, env);
-            obj[left.property] = rightVal;
-            return rightVal;
-        }
-        if (left.type === 'IndexExpression') {
-            const obj = await this.evalIndexObj(left, env);
-            const idx = await this.evaluate(left.indexer, env);
-            obj[idx] = rightVal;
-            return rightVal;
-        }
-        throw new Error('Invalid assignment target');
+  for (const imp of node.specifiers) {
+    if (imp.type === 'DefaultImport') {
+      env.define(imp.local, lib.default ?? lib);
     }
-
-    async evalCompoundAssignment(node, env) {
-        const left = node.left;
-        let current;
-        if (left.type === 'Identifier') current = env.get(left.name);
-        else if (left.type === 'MemberExpression') current = await this.evalMember(left, env);
-        else if (left.type === 'IndexExpression') current = await this.evalIndex(left, env);
-        else throw new Error('Invalid compound assignment target');
-
-        const rhs = await this.evaluate(node.right, env);
-        let computed;
-        switch (node.operator) {
-            case 'PLUSEQ': computed = current + rhs; break;
-            case 'MINUSEQ': computed = current - rhs; break;
-            case 'STAREQ': computed = current * rhs; break;
-            case 'SLASHEQ': computed = current / rhs; break;
-            case 'MODEQ': computed = current % rhs; break;
-            default: throw new Error('Unknown compound operator');
-        }
-
-        if (left.type === 'Identifier') env.set(left.name, computed);
-        else await this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
-
-        return computed;
+    if (imp.type === 'NamespaceImport') {
+      env.define(imp.local, lib);
     }
-
-    async evalSldeploy(node, env) {
-        const val = await this.evaluate(node.expr, env);
-        console.log(val);
-        return val;
+    if (imp.type === 'NamedImport') {
+      if (!(imp.imported in lib)) {
+        throw new Error(`Module '${spec}' has no export '${imp.imported}'`);
+      }
+      env.define(imp.local, lib[imp.imported]);
     }
+  }
 
-    async evalAsk(node, env) {
-        const prompt = await this.evaluate(node.prompt, env);
-        return readlineSync.question(prompt + ' ');
-    }
+  return null;
+}
 
-    async evalDefine(node, env) {
-        const val = node.expr ? await this.evaluate(node.expr, env) : null;
-        return this.global.define(node.id, val);
-    }
+async evalBlock(node, env) {
+  let result = null;
+  for (const stmt of node.body) {
+    try {
+      result = await this.evaluate(stmt, env);
+    } catch (e) {
+      if (e instanceof ReturnValue || e instanceof BreakSignal || e instanceof ContinueSignal) throw e;
+      throw e;
+    }
+  }
+  return result;
+}
 
-    async evalBinary(node, env) {
-        const l = await this.evaluate(node.left, env);
-        const r = await 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}`);
-        }
-    }
+async evalVarDeclaration(node, env) {
+  const val = await this.evaluate(node.expr, env);
+  return env.define(node.id, val);
+}
 
-    async evalLogical(node, env) {
-        const l = await this.evaluate(node.left, env);
-        if (node.operator === 'AND') return l && await this.evaluate(node.right, env);
-        if (node.operator === 'OR') return l || await this.evaluate(node.right, env);
-        throw new Error(`Unknown logical operator ${node.operator}`);
-    }
+evalArrowFunction(node, env) {
+  return {
+    params: node.params,
+    body: node.body,
+    env: env,
+    arrow: true,
+    async: node.async || false
+  };
+}
 
-    async evalUnary(node, env) {
-        const val = await this.evaluate(node.argument, env);
-        switch (node.operator) {
-            case 'NOT': return !val;
-            case 'MINUS': return -val;
-            case 'PLUS': return +val;
-            default: throw new Error(`Unknown unary operator ${node.operator}`);
-        }
-    }
+async evalAssignment(node, env) {
+  const rightVal = await this.evaluate(node.right, env);
+  const left = node.left;
+
+  if (left.type === 'Identifier') return env.set(left.name, rightVal);
+  if (left.type === 'MemberExpression') {
+    const obj = await this.evaluate(left.object, env);
+    obj[left.property] = rightVal;
+    return rightVal;
+  }
+  if (left.type === 'IndexExpression') {
+    const obj = await this.evaluate(left.object, env);
+    const idx = await this.evaluate(left.indexer, env);
+    obj[idx] = rightVal;
+    return rightVal;
+  }
+
+  throw new Error('Invalid assignment target');
+}
 
-    async evalIf(node, env) {
-        const test = await this.evaluate(node.test, env);
-        if (test) return await this.evaluate(node.consequent, env);
-        if (node.alternate) return await this.evaluate(node.alternate, env);
-        return null;
-    }
+async evalCompoundAssignment(node, env) {
+  const left = node.left;
+  let current;
+
+  if (left.type === 'Identifier') current = env.get(left.name);
+  else if (left.type === 'MemberExpression') current = await this.evalMember(left, env);
+  else if (left.type === 'IndexExpression') current = await this.evalIndex(left, env);
+  else throw new Error('Invalid compound assignment target');
+
+  const rhs = await this.evaluate(node.right, env);
+  let computed;
+  switch (node.operator) {
+    case 'PLUSEQ': computed = current + rhs; break;
+    case 'MINUSEQ': computed = current - rhs; break;
+    case 'STAREQ': computed = current * rhs; break;
+    case 'SLASHEQ': computed = current / rhs; break;
+    case 'MODEQ': computed = current % rhs; break;
+    default: throw new Error('Unknown compound operator');
+  }
+
+  if (left.type === 'Identifier') env.set(left.name, computed);
+  else if (left.type === 'MemberExpression') await this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
+  else await this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
+
+  return computed;
+}
 
-    async evalWhile(node, env) {
-        while (await this.evaluate(node.test, env)) {
-            try { await this.evaluate(node.body, env); }
-            catch (e) { if (e instanceof BreakSignal) break; if (e instanceof ContinueSignal) continue; throw e; }
-        }
-        return null;
-    }
+async evalSldeploy(node, env) {
+  const val = await this.evaluate(node.expr, env);
+  console.log(val);
+  return val;
+}
 
-    async evalFor(node, env) {
-        const local = new Environment(env);
-        if (node.init) await this.evaluate(node.init, local);
-        while (!node.test || await this.evaluate(node.test, local)) {
-            try { await this.evaluate(node.body, local); }
-            catch (e) {
-                if (e instanceof BreakSignal) break;
-                if (e instanceof ContinueSignal) { if (node.update) await this.evaluate(node.update, local); continue; }
-                throw e;
-            }
-            if (node.update) await this.evaluate(node.update, local);
-        }
-        return null;
-    }
+async evalAsk(node, env) {
+  const prompt = await this.evaluate(node.prompt, env);
+  const input = readlineSync.question(prompt + ' ');
+  return input;
+}
 
-    async evalFunctionDeclaration(node, env) {
-        const fn = { params: node.params, body: node.body, env };
-        env.define(node.name, fn);
-        return null;
-    }
+async evalDefine(node, env) {
+  const val = node.expr ? await this.evaluate(node.expr, env) : null;
+  return this.global.define(node.id, val);
+}
 
-    async evalCall(node, env) {
-        const calleeEvaluated = await this.evaluate(node.callee, env);
+async evalBinary(node, env) {
+  const l = await this.evaluate(node.left, env);
+  const r = await 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}`);
+  }
+}
 
-        if (typeof calleeEvaluated === 'function') {
-            const args = [];
-            for (const a of node.arguments) args.push(await this.evaluate(a, env));
-            return await calleeEvaluated(...args);
-        }
+async evalLogical(node, env) {
+  const l = await this.evaluate(node.left, env);
+  if (node.operator === 'AND') return l && await this.evaluate(node.right, env);
+  if (node.operator === 'OR') return l || await this.evaluate(node.right, env);
+  throw new Error(`Unknown logical operator ${node.operator}`);
+}
 
-        if (!calleeEvaluated || typeof calleeEvaluated !== 'object' || !calleeEvaluated.body) throw new Error('Call to non-function');
+async evalUnary(node, env) {
+  const val = await this.evaluate(node.argument, env);
+  switch (node.operator) {
+    case 'NOT': return !val;
+    case 'MINUS': return -val;
+    case 'PLUS': return +val;
+    default: throw new Error(`Unknown unary operator ${node.operator}`);
+  }
+}
 
-        const fn = calleeEvaluated;
-        const callEnv = new Environment(fn.env);
-        for (let i = 0; i < fn.params.length; i++) {
-            const argVal = node.arguments[i] ? await this.evaluate(node.arguments[i], env) : null;
-            callEnv.define(fn.params[i], argVal);
-        }
+async evalIf(node, env) {
+  const test = await this.evaluate(node.test, env);
+  if (test) return await this.evaluate(node.consequent, env);
+  if (node.alternate) return await this.evaluate(node.alternate, env);
+  return null;
+}
 
-        try {
-            const result = await this.evaluate(fn.body, callEnv);
-            return fn.arrow ? result : result;
-        } catch (e) { if (e instanceof ReturnValue) return e.value; throw e; }
+async evalWhile(node, env) {
+  while (await this.evaluate(node.test, env)) {
+    try { await this.evaluate(node.body, env); }
+    catch (e) {
+      if (e instanceof BreakSignal) break;
+      if (e instanceof ContinueSignal) continue;
+      throw e;
     }
+  }
+  return null;
+}
 
-    async evalIndex(node, env) {
-        const obj = await this.evaluate(node.object, env);
-        const idx = await this.evaluate(node.indexer, env);
+async evalFor(node, env) {
+  const local = new Environment(env);
+  if (node.init) await this.evaluate(node.init, local);
+  while (!node.test || await this.evaluate(node.test, local)) {
+    try { await this.evaluate(node.body, local); }
+    catch (e) {
+      if (e instanceof BreakSignal) break;
+      if (e instanceof ContinueSignal) {
+        if (node.update) await this.evaluate(node.update, local);
+        continue;
+      }
+      throw e;
+    }
+    if (node.update) await this.evaluate(node.update, local);
+  }
+  return null;
+}
 
-        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];
-    }
+evalFunctionDeclaration(node, env) {
+  const fn = { params: node.params, body: node.body, env, async: node.async || false };
+  env.define(node.name, fn);
+  return null;
+}
 
-    async evalObject(node, env) {
-        const out = {};
-        for (const p of node.props) out[p.key] = await this.evaluate(p.value, env);
-        return out;
-    }
+async evalCall(node, env) {
+  const calleeEvaluated = await this.evaluate(node.callee, env);
+  if (typeof calleeEvaluated === 'function') {
+    const args = [];
+    for (const a of node.arguments) args.push(await this.evaluate(a, env));
+    return calleeEvaluated(...args);
+  }
+  if (!calleeEvaluated || typeof calleeEvaluated !== 'object' || !calleeEvaluated.body) {
+    throw new Error('Call to non-function');
+  }
+
+  const fn = calleeEvaluated;
+  const callEnv = new Environment(fn.env);
+
+  for (let i = 0; i < fn.params.length; i++) {
+    const argVal = node.arguments[i] ? await this.evaluate(node.arguments[i], env) : null;
+    callEnv.define(fn.params[i], argVal);
+  }
+
+  try {
+    const result = await this.evaluate(fn.body, callEnv);
+    return fn.arrow ? result : result;
+  } catch (e) {
+    if (e instanceof ReturnValue) return e.value;
+    throw e;
+  }
+}
 
-    async evalMember(node, env) {
-        const obj = await this.evaluate(node.object, env);
-        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];
-    }
+async evalIndex(node, env) {
+  const obj = await this.evaluate(node.object, env);
+  const idx = await this.evaluate(node.indexer, env);
 
-    async evalMemberObj(node, env) {
-        const obj = await this.evaluate(node.object, env);
-        if (obj == null) throw new Error('Member access of null or undefined');
-        return obj;
-    }
+  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`);
+  }
 
-    async evalIndexObj(node, env) {
-        const obj = await this.evaluate(node.object, env);
-        if (obj == null) throw new Error('Indexing null or undefined');
-        return obj;
-    }
+  return obj[idx];
+}
 
-    async evalUpdate(node, env) {
-        const arg = node.argument;
-        const getCurrent = async () => {
-            if (arg.type === 'Identifier') return env.get(arg.name);
-            if (arg.type === 'MemberExpression') return await this.evalMember(arg, env);
-            if (arg.type === 'IndexExpression') return await this.evalIndex(arg, env);
-            throw new Error('Invalid update target');
-        };
-        const setValue = async (v) => {
-            if (arg.type === 'Identifier') env.set(arg.name, v);
-            else if (arg.type === 'MemberExpression') { const obj = await this.evalMemberObj(arg, env); obj[arg.property] = v; }
-            else if (arg.type === 'IndexExpression') { const obj = await this.evalIndexObj(arg, env); const idx = await this.evaluate(arg.indexer, env); obj[idx] = v; }
-        };
-
-        const current = await getCurrent();
-        const newVal = (node.operator === 'PLUSPLUS') ? current + 1 : current - 1;
-
-        if (node.prefix) { await setValue(newVal); return newVal; }
-        else { await setValue(newVal); return current; }
-    }
+async evalObject(node, env) {
+  const out = {};
+  for (const p of node.props) out[p.key] = await this.evaluate(p.value, env);
+  return out;
+}
+
+async evalMember(node, env) {
+  const obj = await this.evaluate(node.object, env);
+  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];
+}
+
+async evalUpdate(node, env) {
+  const arg = node.argument;
+  const getCurrent = async () => {
+    if (arg.type === 'Identifier') return env.get(arg.name);
+    if (arg.type === 'MemberExpression') return await this.evalMember(arg, env);
+    if (arg.type === 'IndexExpression') return await this.evalIndex(arg, env);
+    throw new Error('Invalid update target');
+  };
+  const setValue = async (v) => {
+    if (arg.type === 'Identifier') env.set(arg.name, v);
+    else if (arg.type === 'MemberExpression') {
+      const obj = await this.evaluate(arg.object, env);
+      obj[arg.property] = v;
+    } else if (arg.type === 'IndexExpression') {
+      const obj = await this.evaluate(arg.object, env);
+      const idx = await this.evaluate(arg.indexer, env);
+      obj[idx] = v;
+    }
+  };
+
+  const current = await getCurrent();
+  const newVal = (node.operator === 'PLUSPLUS') ? current + 1 : current - 1;
+
+  if (node.prefix) { await setValue(newVal); return newVal; }
+  else { await setValue(newVal); return current; }
+}
 
-    async evalImport(node, env) {
-        const spec = node.path;
-        let lib;
-
-        try {
-            const resolved = require.resolve(spec, { paths: [process.cwd()] });
-            lib = require(resolved);
-        } catch (e) {
-            const fullPath = path.isAbsolute(spec) ? spec : path.join(process.cwd(), spec.endsWith('.sl') ? spec : spec + '.sl');
-            if (!fs.existsSync(fullPath)) throw new Error(`Import not found: ${spec}`);
-
-            const code = fs.readFileSync(fullPath, 'utf-8');
-            const tokens = new Lexer(code).getTokens();
-            const ast = new Parser(tokens).parse();
-
-            const moduleEnv = new Environment(env);
-            await this.evaluate(ast, moduleEnv);
-
-            lib = {};
-            for (const key of Object.keys(moduleEnv.store)) lib[key] = moduleEnv.store[key];
-            lib.default = lib;
-        }
-
-        for (const imp of node.specifiers) {
-            if (imp.type === 'DefaultImport') env.define(imp.local, lib.default ?? lib);
-            if (imp.type === 'NamespaceImport') env.define(imp.local, lib);
-            if (imp.type === 'NamedImport') {
-                if (!(imp.imported in lib)) throw new Error(`Module '${spec}' has no export '${imp.imported}'`);
-                env.define(imp.local, lib[imp.imported]);
-            }
-        }
-
-        return null;
-    }
 }
 
-module.exports = Evaluator;
+module.exports = Evaluator;