starlight-cli 1.0.23 → 1.0.25

package/dist/index.js

@@ -1347,421 +1347,394 @@ const Lexer = __nccwpck_require__(211);
 const Parser = __nccwpck_require__(222);
 const path = __nccwpck_require__(928);
 
-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;
-  }
+    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}`);
-  }
+    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;
-  }
+    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;
-  }
+    define(name, value) {
+        this.store[name] = value;
+        return value;
+    }
 }
 
 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) : []);
+    constructor() {
+        this.global = new Environment();
+        this.setupBuiltins();
+    }
 
-    this.global.define('ask', prompt => {
-        const readlineSync = __nccwpck_require__(552);
-        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');
+    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 = __nccwpck_require__(266); // Make sure node-fetch is installed
+            const res = await fetch(url, options);
+            return res;
+        });
     }
-    return n;
-});
 
-this.global.define('str', arg => {
-    return String(arg);
-});
+    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}`);
+        }
+    }
 
-}
+    async evalProgram(node, env) {
+        let result = null;
+        for (const stmt of node.body) result = await this.evaluate(stmt, env);
+        return result;
+    }
 
+    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;
+    }
 
-  evaluate(node, env = this.global) {
-    switch (node.type) {
-      case 'Program': return this.evalProgram(node, env);
-      case 'BlockStatement': return this.evalBlock(node, new Environment(env));
-      case 'VarDeclaration': return this.evalVarDeclaration(node, env);
-      case 'AssignmentExpression': return this.evalAssignment(node, env);
-      case 'CompoundAssignment': return this.evalCompoundAssignment(node, env);
-      case 'SldeployStatement': return this.evalSldeploy(node, env);
-      case 'AskStatement': return this.evalAsk(node, env);
-      case 'DefineStatement': return this.evalDefine(node, env);
-      case 'ExpressionStatement': return this.evaluate(node.expression, env);
-      case 'BinaryExpression': return this.evalBinary(node, env);
-      case 'LogicalExpression': return this.evalLogical(node, env);
-      case 'UnaryExpression': return this.evalUnary(node, env);
-      case 'Literal': return node.value;
-      case 'Identifier': return env.get(node.name);
-      case 'IfStatement': return this.evalIf(node, env);
-      case 'WhileStatement': return this.evalWhile(node, env);
-      case 'ForStatement': return this.evalFor(node, env);
-      case 'BreakStatement': throw new BreakSignal();
-      case 'ContinueStatement': throw new ContinueSignal();
-      case 'ImportStatement': return this.evalImport(node, env);
-      case 'FunctionDeclaration': return this.evalFunctionDeclaration(node, env);
-      case 'CallExpression': return this.evalCall(node, env);
-      case 'ReturnStatement': {
-        const val = node.argument ? this.evaluate(node.argument, env) : null;
-        throw new ReturnValue(val);
-      }
-      case 'ArrayExpression': return node.elements.map(el => this.evaluate(el, env));
-      case 'IndexExpression': return this.evalIndex(node, env);
-      case 'ObjectExpression': return this.evalObject(node, env);
-      case 'MemberExpression': return this.evalMember(node, env);
-      case 'UpdateExpression': return this.evalUpdate(node, env);
-      default:
-        throw new Error(`Unknown node type in evaluator: ${node.type}`);
+    async evalVarDeclaration(node, env) {
+        const val = await this.evaluate(node.expr, env);
+        return env.define(node.id, val);
     }
-  }
 
-  evalProgram(node, env) {
-    let result = null;
-    for (const stmt of node.body) {
-      result = this.evaluate(stmt, env);
+    async evalArrowFunction(node, env) {
+        return { params: node.params, body: node.body, env, arrow: true };
     }
-    return result;
-  }
-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');
+    async evalAssignment(node, env) {
+        const rightVal = await this.evaluate(node.right, env);
+        const left = node.left;
 
-    if (!fs.existsSync(fullPath)) {
-      throw new Error(`Import not found: ${spec}`);
+        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');
     }
 
-    const code = fs.readFileSync(fullPath, 'utf-8');
-    const tokens = new Lexer(code).getTokens();
-    const ast = new Parser(tokens).parse();
+    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');
+        }
 
-    const moduleEnv = new Environment(env);
-    this.evaluate(ast, moduleEnv);
+        if (left.type === 'Identifier') env.set(left.name, computed);
+        else await this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
 
-    lib = {};
-    for (const key of Object.keys(moduleEnv.store)) {
-      lib[key] = moduleEnv.store[key];
+        return computed;
     }
 
-    lib.default = lib;
-  }
-
-  for (const imp of node.specifiers) {
-    if (imp.type === 'DefaultImport') {
-      env.define(imp.local, lib.default ?? lib);
+    async evalSldeploy(node, env) {
+        const val = await this.evaluate(node.expr, env);
+        console.log(val);
+        return val;
     }
-    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;
-}
-
-
-  evalBlock(node, env) {
-    let result = null;
-    for (const stmt of node.body) {
-      try {
-        result = this.evaluate(stmt, env);
-      } catch (e) {
-        if (e instanceof ReturnValue || e instanceof BreakSignal || e instanceof ContinueSignal) throw e;
-        throw e;
-      }
+    async evalAsk(node, env) {
+        const prompt = await this.evaluate(node.prompt, env);
+        return readlineSync.question(prompt + ' ');
     }
-    return result;
-  }
 
-  evalVarDeclaration(node, env) {
-    const val = this.evaluate(node.expr, env);
-    return env.define(node.id, val);
-  }
+    async evalDefine(node, env) {
+        const val = node.expr ? await this.evaluate(node.expr, env) : null;
+        return this.global.define(node.id, val);
+    }
 
-  evalAssignment(node, env) {
-    const rightVal = this.evaluate(node.right, env);
-    const left = node.left;
+    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 (left.type === 'Identifier') return env.set(left.name, rightVal);
-    if (left.type === 'MemberExpression') {
-      const obj = this.evaluate(left.object, env);
-      obj[left.property] = rightVal;
-      return rightVal;
+    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 (left.type === 'IndexExpression') {
-      const obj = this.evaluate(left.object, env);
-      const idx = this.evaluate(left.indexer, env);
-      obj[idx] = rightVal;
-      return rightVal;
+
+    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}`);
+        }
     }
 
-    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;
+    }
 
-  evalCompoundAssignment(node, env) {
-    const left = node.left;
-    let current;
+    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;
+    }
 
-    if (left.type === 'Identifier') current = env.get(left.name);
-    else if (left.type === 'MemberExpression') current = this.evalMember(left, env);
-    else if (left.type === 'IndexExpression') current = this.evalIndex(left, env);
-    else throw new Error('Invalid compound assignment target');
+    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;
+    }
 
-    const rhs = 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');
+    async evalFunctionDeclaration(node, env) {
+        const fn = { params: node.params, body: node.body, env };
+        env.define(node.name, fn);
+        return null;
     }
 
-    if (left.type === 'Identifier') env.set(left.name, computed);
-    else if (left.type === 'MemberExpression') this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
-    else this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
+    async evalCall(node, env) {
+        const calleeEvaluated = await this.evaluate(node.callee, env);
 
-    return computed;
-  }
+        if (typeof calleeEvaluated === 'function') {
+            const args = [];
+            for (const a of node.arguments) args.push(await this.evaluate(a, env));
+            return await calleeEvaluated(...args);
+        }
 
-  evalSldeploy(node, env) {
-    const val = this.evaluate(node.expr, env);
-    console.log(val);
-    return val;
-  }
+        if (!calleeEvaluated || typeof calleeEvaluated !== 'object' || !calleeEvaluated.body) throw new Error('Call to non-function');
 
-  evalAsk(node, env) {
-    const prompt = this.evaluate(node.prompt, env);
-    const input = readlineSync.question(prompt + ' ');
-    return input;
-  }
+        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);
+        }
 
-  evalDefine(node, env) {
-    const val = node.expr ? this.evaluate(node.expr, env) : null;
-    return this.global.define(node.id, val);
-  }
+        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; }
+    }
 
-  evalBinary(node, env) {
-    const l = this.evaluate(node.left, env);
-    const r = this.evaluate(node.right, env);
+    async evalIndex(node, env) {
+        const obj = await this.evaluate(node.object, env);
+        const idx = await this.evaluate(node.indexer, env);
 
-    if (node.operator === 'SLASH' && r === 0) {
-        throw new Error('Division by zero');
+        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];
     }
 
-    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 evalObject(node, env) {
+        const out = {};
+        for (const p of node.props) out[p.key] = await this.evaluate(p.value, env);
+        return out;
     }
-}
-
 
-  evalLogical(node, env) {
-    const l = this.evaluate(node.left, env);
-    if (node.operator === 'AND') return l && this.evaluate(node.right, env);
-    if (node.operator === 'OR') return l || this.evaluate(node.right, env);
-    throw new Error(`Unknown logical operator ${node.operator}`);
-  }
-
-  evalUnary(node, env) {
-    const val = 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 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];
     }
-  }
-
-  evalIf(node, env) {
-    const test = this.evaluate(node.test, env);
-    if (test) return this.evaluate(node.consequent, env);
-    if (node.alternate) return this.evaluate(node.alternate, env);
-    return null;
-  }
 
-  evalWhile(node, env) {
-    while (this.evaluate(node.test, env)) {
-      try { this.evaluate(node.body, env); }
-      catch (e) {
-        if (e instanceof BreakSignal) break;
-        if (e instanceof ContinueSignal) continue;
-        throw e;
-      }
+    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;
     }
-    return null;
-  }
 
-  evalFor(node, env) {
-    const local = new Environment(env);
-    if (node.init) this.evaluate(node.init, local);
-    while (!node.test || this.evaluate(node.test, local)) {
-      try { this.evaluate(node.body, local); }
-      catch (e) {
-        if (e instanceof BreakSignal) break;
-        if (e instanceof ContinueSignal) { if (node.update) this.evaluate(node.update, local); continue; }
-        throw e;
-      }
-      if (node.update) this.evaluate(node.update, local);
+    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 null;
-  }
-
-  evalFunctionDeclaration(node, env) {
-    const fn = { params: node.params, body: node.body, env };
-    env.define(node.name, fn);
-    return null;
-  }
 
-  evalCall(node, env) {
-    const calleeEvaluated = this.evaluate(node.callee, env);
-    if (typeof calleeEvaluated === 'function') {
-      const args = node.arguments.map(a => this.evaluate(a, env));
-      return calleeEvaluated(...args);
-    }
-    if (!calleeEvaluated || typeof calleeEvaluated !== 'object' || !calleeEvaluated.body) {
-      throw new Error('Call to non-function');
+    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; }
     }
-    const fn = calleeEvaluated;
-    const callEnv = new Environment(fn.env);
-    fn.params.forEach((p, i) => {
-      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; }
-  }
 
-  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 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 evalImport(node, env) {
+        const spec = node.path;
+        let lib;
 
-    return obj[idx];
-}
+        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();
 
-  evalObject(node, env) {
-    const out = {};
-    for (const p of node.props) out[p.key] = this.evaluate(p.value, env);
-    return out;
-  }
+            const moduleEnv = new Environment(env);
+            await this.evaluate(ast, moduleEnv);
 
-  evalMember(node, env) {
-    const obj = 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];
-}
+            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]);
+            }
+        }
 
-  evalUpdate(node, env) {
-    const arg = node.argument;
-    const getCurrent = () => {
-      if (arg.type === 'Identifier') return env.get(arg.name);
-      if (arg.type === 'MemberExpression') return this.evalMember(arg, env);
-      if (arg.type === 'IndexExpression') return this.evalIndex(arg, env);
-      throw new Error('Invalid update target');
-    };
-    const setValue = (v) => {
-      if (arg.type === 'Identifier') env.set(arg.name, v);
-      else if (arg.type === 'MemberExpression') {
-        const obj = this.evaluate(arg.object, env);
-        obj[arg.property] = v;
-      }
-      else if (arg.type === 'IndexExpression') {
-        const obj = this.evaluate(arg.object, env);
-        const idx = this.evaluate(arg.indexer, env);
-        obj[idx] = v;
-      }
-    };
-    const current = getCurrent();
-    const newVal = (node.operator === 'PLUSPLUS') ? current + 1 : current - 1;
-    if (node.prefix) { setValue(newVal); return newVal; }
-    else { setValue(newVal); return current; }
-  }
+        return null;
+    }
 }
 
-module.exports = Evaluator; 
+module.exports = Evaluator;
+
 
 /***/ }),
 
@@ -1909,7 +1882,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; }
@@ -2317,6 +2302,15 @@ class Parser {
     }
     return node;
   }
+arrowFunction(params) {
+  this.eat('ARROW');
+  const body = this.expression();
+  return {
+    type: 'ArrowFunctionExpression',
+    params,
+    body
+  };
+}
 
   primary() {
     const t = this.current;
@@ -2343,17 +2337,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');
@@ -2392,6 +2416,14 @@ class Parser {
 
 module.exports = Parser;
 
+/***/ }),
+
+/***/ 266:
+/***/ ((module) => {
+
+module.exports = eval("require")("node-fetch");
+
+
 /***/ }),
 
 /***/ 317:
@@ -2492,7 +2524,7 @@ const Lexer = __nccwpck_require__(211);
 const Parser = __nccwpck_require__(222);
 const Evaluator = __nccwpck_require__(112);
 
-const VERSION = '1.0.23';
+const VERSION = '1.0.25';
 
 const COLOR = {
     reset: '\x1b[0m',