starlight-cli 1.0.21 → 1.0.23

package/dist/index.js

@@ -1347,7 +1347,9 @@ 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 {}
 
@@ -1390,27 +1392,37 @@ class Evaluator {
 
   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;
+        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;
+        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 => 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('ask', prompt => {
+        const readlineSync = __nccwpck_require__(552);
+        return readlineSync.question(prompt + ' ');
     });
-    this.global.define('str', arg => String(arg));
-  }
+    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 => {
+    return String(arg);
+});
+
+}
+
 
   evaluate(node, env = this.global) {
     switch (node.type) {
@@ -1427,7 +1439,6 @@ class Evaluator {
       case 'LogicalExpression': return this.evalLogical(node, env);
       case 'UnaryExpression': return this.evalUnary(node, env);
       case 'Literal': return node.value;
-      case 'TemplateLiteral': return this.evalTemplateLiteral(node, env);
       case 'Identifier': return env.get(node.name);
       case 'IfStatement': return this.evalIf(node, env);
       case 'WhileStatement': return this.evalWhile(node, env);
@@ -1453,65 +1464,72 @@ class Evaluator {
 
   evalProgram(node, env) {
     let result = null;
-    for (const stmt of node.body) result = this.evaluate(stmt, env);
+    for (const stmt of node.body) {
+      result = this.evaluate(stmt, env);
+    }
     return result;
   }
+evalImport(node, env) {
+  const spec = node.path;
+  let lib;
 
- evalTemplateLiteral(node, env) {
-  // node.parts is an array from parser: Literal or expression nodes
-  let result = '';
-  for (const part of node.parts) {
-    if (part.type === 'Literal') {
-      result += part.value;
-    } else {
-      const val = this.evaluate(part, env);
-      result += val != null ? val.toString() : '';
+  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}`);
     }
-  }
-  return result;
-}
 
+    const code = fs.readFileSync(fullPath, 'utf-8');
+    const tokens = new Lexer(code).getTokens();
+    const ast = new Parser(tokens).parse();
 
-  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');
+    const moduleEnv = new Environment(env);
+    this.evaluate(ast, moduleEnv);
 
-      if (!fs.existsSync(fullPath)) throw new Error(`Import not found: ${spec}`);
+    lib = {};
+    for (const key of Object.keys(moduleEnv.store)) {
+      lib[key] = moduleEnv.store[key];
+    }
 
-      const code = fs.readFileSync(fullPath, 'utf-8');
-      const tokens = new Lexer(code).getTokens();
-      const ast = new Parser(tokens).parse();
-      const moduleEnv = new Environment(env);
-      this.evaluate(ast, moduleEnv);
+    lib.default = lib;
+  }
 
-      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);
     }
-
-    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]);
+    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;
   }
 
+  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; else throw e; }
+      try {
+        result = this.evaluate(stmt, env);
+      } catch (e) {
+        if (e instanceof ReturnValue || e instanceof BreakSignal || e instanceof ContinueSignal) throw e;
+        throw e;
+      }
     }
     return result;
   }
@@ -1524,15 +1542,27 @@ class Evaluator {
   evalAssignment(node, env) {
     const rightVal = 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 = this.evaluate(left.object, env); obj[left.property] = rightVal; return rightVal; }
-    if (left.type === 'IndexExpression') { const obj = this.evaluate(left.object, env); const idx = this.evaluate(left.indexer, env); obj[idx] = rightVal; return rightVal; }
+    if (left.type === 'MemberExpression') {
+      const obj = this.evaluate(left.object, env);
+      obj[left.property] = rightVal;
+      return rightVal;
+    }
+    if (left.type === 'IndexExpression') {
+      const obj = this.evaluate(left.object, env);
+      const idx = this.evaluate(left.indexer, env);
+      obj[idx] = rightVal;
+      return rightVal;
+    }
+
     throw new Error('Invalid assignment target');
   }
 
   evalCompoundAssignment(node, env) {
     const left = node.left;
     let current;
+
     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);
@@ -1550,7 +1580,9 @@ class Evaluator {
     }
 
     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);
+
     return computed;
   }
 
@@ -1562,7 +1594,8 @@ class Evaluator {
 
   evalAsk(node, env) {
     const prompt = this.evaluate(node.prompt, env);
-    return readlineSync.question(prompt + ' ');
+    const input = readlineSync.question(prompt + ' ');
+    return input;
   }
 
   evalDefine(node, env) {
@@ -1573,25 +1606,27 @@ class Evaluator {
   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 'STRICT_EQ': return l === r;
-      case 'STRICT_NOTEQ': return l !== r;
-      case 'LT': return l < r;
-      case 'LTE': return l <= r;
-      case 'GT': return l > r;
-      case 'GTE': return l >= r;
-      case 'LSHIFT': return l << r;
-      case 'RSHIFT': 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);
@@ -1656,7 +1691,9 @@ class Evaluator {
       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');
+    if (!calleeEvaluated || typeof calleeEvaluated !== 'object' || !calleeEvaluated.body) {
+      throw new Error('Call to non-function');
+    }
     const fn = calleeEvaluated;
     const callEnv = new Environment(fn.env);
     fn.params.forEach((p, i) => {
@@ -1670,9 +1707,18 @@ class Evaluator {
   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 = {};
@@ -1682,9 +1728,11 @@ class Evaluator {
 
   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;
@@ -1696,8 +1744,15 @@ class Evaluator {
     };
     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; }
+      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;
@@ -1706,8 +1761,7 @@ class Evaluator {
   }
 }
 
-module.exports = Evaluator;
-
+module.exports = Evaluator; 
 
 /***/ }),
 
@@ -1718,10 +1772,18 @@ class Lexer {
   constructor(input) {
     this.input = input;
     this.pos = 0;
-    this.currentChar = input[this.pos];
+    this.currentChar = input[0] || null;
+    this.line = 1;     // current line
+    this.column = 1;   // current column
   }
 
   advance() {
+    if (this.currentChar === '\n') {
+      this.line++;
+      this.column = 0;
+    } else {
+      this.column++;
+    }
     this.pos++;
     this.currentChar = this.pos < this.input.length ? this.input[this.pos] : null;
   }
@@ -1730,152 +1792,149 @@ class Lexer {
     return this.pos + 1 < this.input.length ? this.input[this.pos + 1] : null;
   }
 
+  error(msg) {
+    throw new Error(`${msg} at line ${this.line}, column ${this.column}`);
+  }
+
   skipWhitespace() {
     while (this.currentChar && /\s/.test(this.currentChar)) this.advance();
   }
 
-  matchKeyword(id) {
-    const keywords = {
-      'let': 'LET',
-      'define': 'DEFINE',
-      'if': 'IF',
-      'else': 'ELSE',
-      'while': 'WHILE',
-      'for': 'FOR',
-      'break': 'BREAK',
-      'continue': 'CONTINUE',
-      'func': 'FUNC',
-      'return': 'RETURN',
-      'import': 'IMPORT',
-      'from': 'FROM',
-      'as': 'AS',
-      'true': 'TRUE',
-      'false': 'FALSE',
-      'null': 'NULL',
-      'undefined': 'UNDEFINED',
-      'ask': 'ASK',
-      'sldeploy': 'SLDEPLOY'
-    };
-    return keywords[id] || null;
+  skipComment() {
+    if (this.currentChar === '#') {
+      if (this.peek() === '*') {
+        this.advance(); this.advance(); // skip #*
+        while (this.currentChar !== null) {
+          if (this.currentChar === '*' && this.peek() === '#') {
+            this.advance(); this.advance();
+            return;
+          }
+          this.advance();
+        }
+        this.error("Unterminated multi-line comment (#* ... *#)");
+      } else {
+        while (this.currentChar && this.currentChar !== '\n') this.advance();
+      }
+    }
   }
 
   number() {
+    const startLine = this.line;
+    const startCol = this.column;
     let result = '';
-    while (this.currentChar && /[0-9.]/.test(this.currentChar)) {
+    while (this.currentChar && /[0-9]/.test(this.currentChar)) {
       result += this.currentChar;
       this.advance();
     }
-    return { type: 'NUMBER', value: parseFloat(result) };
+
+    if (this.currentChar === '.' && /[0-9]/.test(this.peek())) {
+      result += '.'; this.advance();
+      while (this.currentChar && /[0-9]/.test(this.currentChar)) {
+        result += this.currentChar;
+        this.advance();
+      }
+      return { type: 'NUMBER', value: parseFloat(result), line: startLine, column: startCol };
+    }
+
+    return { type: 'NUMBER', value: parseInt(result), line: startLine, column: startCol };
   }
 
   identifier() {
+    const startLine = this.line;
+    const startCol = this.column;
     let result = '';
-    while (this.currentChar && /[a-zA-Z0-9_]/.test(this.currentChar)) {
+    while (this.currentChar && /[A-Za-z0-9_]/.test(this.currentChar)) {
       result += this.currentChar;
       this.advance();
     }
-    const type = this.matchKeyword(result) || 'IDENTIFIER';
-    return { type, value: result };
+
+    const keywords = [
+      'let', 'sldeploy', 'if', 'else', 'while', 'for',
+      'break', 'continue', 'func', 'return', 'true', 'false', 'null',
+      'ask', 'define', 'import', 'from', 'as'
+    ];
+
+    if (keywords.includes(result)) {
+      return { type: result.toUpperCase(), value: result, line: startLine, column: startCol };
+    }
+
+    return { type: 'IDENTIFIER', value: result, line: startLine, column: startCol };
   }
 
-  string(quoteType) {
-    this.advance(); // skip opening quote
+  string() {
+    const startLine = this.line;
+    const startCol = this.column;
+    const quote = this.currentChar;
+    this.advance();
     let result = '';
-    while (this.currentChar && this.currentChar !== quoteType) {
+
+    while (this.currentChar && this.currentChar !== quote) {
       if (this.currentChar === '\\') {
         this.advance();
-        if (this.currentChar) {
-          const escapeChars = { n: '\n', r: '\r', t: '\t', '\\': '\\', '"': '"', "'": "'" };
-          result += escapeChars[this.currentChar] || this.currentChar;
-          this.advance();
+        switch (this.currentChar) {
+          case 'n': result += '\n'; break;
+          case 't': result += '\t'; break;
+          case '"': result += '"'; break;
+          case "'": result += "'"; break;
+          case '\\': result += '\\'; break;
+          default: result += this.currentChar;
         }
       } else {
         result += this.currentChar;
-        this.advance();
       }
+      this.advance();
     }
-    this.advance(); // skip closing quote
-    return { type: 'STRING', value: result };
-  }
 
-  templateLiteral() {
-    let result = '';
-    const tokens = [];
-    this.advance(); // skip initial backtick
-    while (this.currentChar !== null) {
-      if (this.currentChar === '$' && this.peek() === '{') {
-        if (result) tokens.push({ type: 'TEMPLATE_STRING', value: result });
-        result = '';
-        tokens.push({ type: 'DOLLAR_LBRACE' });
-        this.advance();
-        this.advance(); // skip "${"
-      } else if (this.currentChar === '`') {
-        if (result) tokens.push({ type: 'TEMPLATE_STRING', value: result });
-        this.advance();
-        break;
-      } else {
-        result += this.currentChar;
-        this.advance();
-      }
+    if (this.currentChar !== quote) {
+      this.error('Unterminated string literal');
     }
-    return tokens;
+
+    this.advance();
+    return { type: 'STRING', value: result, line: startLine, column: startCol };
   }
 
   getTokens() {
     const tokens = [];
-    while (this.currentChar !== null) {
-      this.skipWhitespace();
-
-      if (!this.currentChar) break;
 
-      if (/[0-9]/.test(this.currentChar)) tokens.push(this.number());
-      else if (/[a-zA-Z_]/.test(this.currentChar)) tokens.push(this.identifier());
-      else if (this.currentChar === '"' || this.currentChar === "'") tokens.push(this.string(this.currentChar));
-      else if (this.currentChar === '`') {
-        const parts = this.templateLiteral();
-        tokens.push(...parts);
-      }
-      else {
-        const char = this.currentChar;
-        switch (char) {
-          case '+': 
-            if (this.peek() === '+') { tokens.push({ type: 'PLUSPLUS' }); this.advance(); }
-            else if (this.peek() === '=') { tokens.push({ type: 'PLUSEQ' }); this.advance(); }
-            else tokens.push({ type: 'PLUS' });
-            break;
-          case '-':
-            if (this.peek() === '-') { tokens.push({ type: 'MINUSMINUS' }); this.advance(); }
-            else if (this.peek() === '=') { tokens.push({ type: 'MINUSEQ' }); this.advance(); }
-            else tokens.push({ type: 'MINUS' });
-            break;
-          case '*': tokens.push(this.peek() === '=' ? (this.advance(), { type: 'STAREQ' }) : { type: 'STAR' }); break;
-          case '/': tokens.push(this.peek() === '=' ? (this.advance(), { type: 'SLASHEQ' }) : { type: 'SLASH' }); break;
-          case '%': tokens.push(this.peek() === '=' ? (this.advance(), { type: 'MODEQ' }) : { type: 'MOD' }); break;
-          case '=': tokens.push(this.peek() === '=' ? (this.advance(), this.peek() === '=' ? (this.advance(), { type: 'STRICT_EQ' }) : { type: 'EQEQ' }) : { type: 'EQUAL' }); break;
-          case '!': tokens.push(this.peek() === '=' ? (this.advance(), this.peek() === '=' ? (this.advance(), { type: 'STRICT_NOTEQ' }) : { type: 'NOTEQ' }) : { type: 'NOT' }); break;
-          case '<': tokens.push(this.peek() === '<' ? (this.advance(), { type: 'LSHIFT' }) : this.peek() === '=' ? (this.advance(), { type: 'LTE' }) : { type: 'LT' }); break;
-          case '>': tokens.push(this.peek() === '>' ? (this.advance(), { type: 'RSHIFT' }) : this.peek() === '=' ? (this.advance(), { type: 'GTE' }) : { type: 'GT' }); break;
-          case '&': tokens.push(this.peek() === '&' ? (this.advance(), { type: 'AND' }) : { type: 'AMP' }); break;
-          case '|': tokens.push(this.peek() === '|' ? (this.advance(), { type: 'OR' }) : { type: 'PIPE' }); break;
-          case '(': tokens.push({ type: 'LPAREN' }); break;
-          case ')': tokens.push({ type: 'RPAREN' }); break;
-          case '{': tokens.push({ type: 'LBRACE' }); break;
-          case '}': tokens.push({ type: 'RBRACE' }); break;
-          case '[': tokens.push({ type: 'LBRACKET' }); break;
-          case ']': tokens.push({ type: 'RBRACKET' }); break;
-          case ',': tokens.push({ type: 'COMMA' }); break;
-          case ';': tokens.push({ type: 'SEMICOLON' }); break;
-          case '.': tokens.push({ type: 'DOT' }); break;
-          case ':': tokens.push({ type: 'COLON' }); break;
-          case '*': tokens.push({ type: 'STAR' }); break;
-          case '$': tokens.push({ type: 'DOLLAR' }); break;
-          case '?': tokens.push({ type: 'QUESTION' }); break;
-          default: throw new Error(`Unexpected character: ${char} at position ${this.pos}`);
-        }
-        this.advance();
-      }
+    while (this.currentChar !== null) {
+      if (/\s/.test(this.currentChar)) { this.skipWhitespace(); continue; }
+      if (this.currentChar === '#') { this.skipComment(); continue; }
+      if (/[0-9]/.test(this.currentChar)) { tokens.push(this.number()); continue; }
+      if (/[A-Za-z_]/.test(this.currentChar)) { tokens.push(this.identifier()); continue; }
+      if (this.currentChar === '"' || this.currentChar === "'") { tokens.push(this.string()); continue; }
+
+      const char = this.currentChar;
+      const next = this.peek();
+      const startLine = this.line;
+      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: '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; }
+      if (char === '&' && next === '&') { tokens.push({ type: 'AND', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
+      if (char === '|' && next === '|') { tokens.push({ type: 'OR', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
+      if (char === '+' && next === '+') { tokens.push({ type: 'PLUSPLUS', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
+      if (char === '-' && next === '-') { tokens.push({ type: 'MINUSMINUS', line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
+
+      const map = { '+': 'PLUSEQ', '-': 'MINUSEQ', '*': 'STAREQ', '/': 'SLASHEQ', '%': 'MODEQ' };
+      if (next === '=' && map[char]) { tokens.push({ type: map[char], line: startLine, column: startCol }); this.advance(); this.advance(); continue; }
+
+      const singles = {
+        '+': 'PLUS', '-': 'MINUS', '*': 'STAR', '/': 'SLASH', '%': 'MOD',
+        '=': 'EQUAL', '<': 'LT', '>': 'GT', '!': 'NOT',
+        '(': 'LPAREN', ')': 'RPAREN', '{': 'LBRACE', '}': 'RBRACE',
+        ';': 'SEMICOLON', ',': 'COMMA', '[': 'LBRACKET', ']': 'RBRACKET',
+        ':': 'COLON', '.': 'DOT'
+      };
+
+      if (singles[char]) { tokens.push({ type: singles[char], line: startLine, column: startCol }); this.advance(); continue; }
+
+      this.error("Unexpected character: " + char);
     }
-    tokens.push({ type: 'EOF' });
+
+    tokens.push({ type: 'EOF', line: this.line, column: this.column });
     return tokens;
   }
 }
@@ -1902,7 +1961,10 @@ class Parser {
 
   eat(type) {
     if (this.current.type === type) this.advance();
-    else throw new Error(`Expected ${type}, got ${this.current.type}`);
+    else throw new Error(
+  `Expected ${type}, got ${this.current.type} at line ${this.current.line}, column ${this.current.column}`
+);
+
   }
 
   peekType(offset = 1) {
@@ -1989,52 +2051,52 @@ class Parser {
     const body = this.block();
     return { type: 'WhileStatement', test, body };
   }
-
   importStatement() {
     this.eat('IMPORT');
 
     let specifiers = [];
 
     if (this.current.type === 'STAR') {
-      this.eat('STAR');
-      this.eat('AS');
-      const name = this.current.value;
-      this.eat('IDENTIFIER');
-      specifiers.push({ type: 'NamespaceImport', local: name });
+        this.eat('STAR');
+        this.eat('AS');
+        const name = this.current.value;
+        this.eat('IDENTIFIER');
+        specifiers.push({ type: 'NamespaceImport', local: name });
     }
     else if (this.current.type === 'LBRACE') {
-      this.eat('LBRACE');
-      while (this.current.type !== 'RBRACE') {
-        const importedName = this.current.value;
-        this.eat('IDENTIFIER');
-        let localName = importedName;
-        if (this.current.type === 'AS') {
-          this.eat('AS');
-          localName = this.current.value;
-          this.eat('IDENTIFIER');
+        this.eat('LBRACE');
+        while (this.current.type !== 'RBRACE') {
+            const importedName = this.current.value;
+            this.eat('IDENTIFIER');
+            let localName = importedName;
+            if (this.current.type === 'AS') {
+                this.eat('AS');
+                localName = this.current.value;
+                this.eat('IDENTIFIER');
+            }
+            specifiers.push({ type: 'NamedImport', imported: importedName, local: localName });
+            if (this.current.type === 'COMMA') this.eat('COMMA');
         }
-        specifiers.push({ type: 'NamedImport', imported: importedName, local: localName });
-        if (this.current.type === 'COMMA') this.eat('COMMA');
-      }
-      this.eat('RBRACE');
+        this.eat('RBRACE');
     }
     else if (this.current.type === 'IDENTIFIER') {
-      const localName = this.current.value;
-      this.eat('IDENTIFIER');
-      specifiers.push({ type: 'DefaultImport', local: localName });
+        const localName = this.current.value;
+        this.eat('IDENTIFIER');
+        specifiers.push({ type: 'DefaultImport', local: localName });
     } else {
-      throw new Error('Unexpected token in import statement');
+        throw new Error(`Unexpected token in import statement at line ${this.current.line}, column ${this.current.column}`);
     }
 
     this.eat('FROM');
     const pathToken = this.current;
-    if (pathToken.type !== 'STRING') throw new Error('Expected string literal after from in import');
+    if (pathToken.type !== 'STRING') throw new Error(`Expected string literal after from in import at line ${this.current.line}, column ${this.current.column}`);
     this.eat('STRING');
 
     if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
 
     return { type: 'ImportStatement', path: pathToken.value, specifiers };
-  }
+}
+
 
   forStatement() {
     this.eat('FOR');
@@ -2114,23 +2176,6 @@ class Parser {
     if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
     return { type: 'ExpressionStatement', expression: expr };
   }
-  parseTemplateLiteral() {
-  const parts = [];
-  while (true) {
-    if (this.current.type === 'TEMPLATE_STRING') {
-      parts.push({ type: 'Literal', value: this.current.value });
-      this.eat('TEMPLATE_STRING');
-    } else if (this.current.type === 'DOLLAR_LBRACE') {
-      this.eat('DOLLAR_LBRACE');
-      const expr = this.expression();
-      parts.push(expr);
-      this.eat('RBRACE');
-    } else {
-      break;
-    }
-  }
-  return { type: 'TemplateLiteral', parts };
-}
 
   expression() {
     return this.assignment();
@@ -2177,7 +2222,7 @@ class Parser {
 
   equality() {
     let node = this.comparison();
-    while (['EQEQ', 'NOTEQ', 'STRICT_EQ', 'STRICT_NOTEQ'].includes(this.current.type)) {
+    while (['EQEQ', 'NOTEQ'].includes(this.current.type)) {
       const op = this.current.type;
       this.eat(op);
       node = { type: 'BinaryExpression', operator: op, left: node, right: this.comparison() };
@@ -2187,7 +2232,7 @@ class Parser {
 
   comparison() {
     let node = this.term();
-    while (['LT', 'LTE', 'GT', 'GTE', 'LSHIFT', 'RSHIFT'].includes(this.current.type)) {
+    while (['LT', 'LTE', 'GT', 'GTE'].includes(this.current.type)) {
       const op = this.current.type;
       this.eat(op);
       node = { type: 'BinaryExpression', operator: op, left: node, right: this.term() };
@@ -2256,7 +2301,7 @@ class Parser {
       }
       if (this.current.type === 'DOT') {
         this.eat('DOT');
-        if (this.current.type !== 'IDENTIFIER') throw new Error('Expected property name after dot');
+        if (this.current.type !== 'IDENTIFIER') throw new Error(`Expected property name after dot at line ${this.current.line}, column ${this.current.column}`);
         const property = this.current.value;
         this.eat('IDENTIFIER');
         node = { type: 'MemberExpression', object: node, property };
@@ -2278,15 +2323,9 @@ class Parser {
 
     if (t.type === 'NUMBER') { this.eat('NUMBER'); return { type: 'Literal', value: t.value }; }
     if (t.type === 'STRING') { this.eat('STRING'); return { type: 'Literal', value: t.value }; }
-   if (t.type === 'TEMPLATE_STRING') {
-  return this.parseTemplateLiteral();
-}
-
-
     if (t.type === 'TRUE') { this.eat('TRUE'); return { type: 'Literal', value: true }; }
     if (t.type === 'FALSE') { this.eat('FALSE'); return { type: 'Literal', value: false }; }
     if (t.type === 'NULL') { this.eat('NULL'); return { type: 'Literal', value: null }; }
-    if (t.type === 'UNDEFINED') { this.eat('UNDEFINED'); return { type: 'Literal', value: undefined }; }
 
     if (t.type === 'ASK') {
       this.eat('ASK');
@@ -2337,7 +2376,7 @@ class Parser {
         let key;
         if (this.current.type === 'STRING') { key = this.current.value; this.eat('STRING'); }
         else if (this.current.type === 'IDENTIFIER') { key = this.current.value; this.eat('IDENTIFIER'); }
-        else throw new Error('Invalid object key');
+        else throw new Error(`Invalid object key at line ${this.current.line}, column ${this.current.column}`);
         this.eat('COLON');
         const value = this.expression();
         props.push({ key, value });
@@ -2347,12 +2386,11 @@ class Parser {
       return { type: 'ObjectExpression', props };
     }
 
-    throw new Error(`Unexpected token in primary: ${t.type}`);
+    throw new Error(`Unexpected token in primary: ${t.type} at line ${this.current.line}, column ${this.current.column}`);
   }
 }
 
-module.exports = Parser;
-
+module.exports = Parser;
 
 /***/ }),
 
@@ -2454,7 +2492,7 @@ const Lexer = __nccwpck_require__(211);
 const Parser = __nccwpck_require__(222);
 const Evaluator = __nccwpck_require__(112);
 
-const VERSION = '1.0.21';
+const VERSION = '1.0.23';
 
 const COLOR = {
     reset: '\x1b[0m',