starlight-cli 1.0.20 → 1.0.22

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) {
@@ -1579,16 +1612,12 @@ class Evaluator {
       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 '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;
-      case 'LSHIFT': return l << r;
-      case 'RSHIFT': return l >> r;
       default: throw new Error(`Unknown binary operator ${node.operator}`);
     }
   }
@@ -1656,7 +1685,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) => {
@@ -1696,8 +1727,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 +1744,7 @@ class Evaluator {
   }
 }
 
-module.exports = Evaluator;
-
+module.exports = Evaluator; 
 
 /***/ }),
 
@@ -1719,19 +1756,27 @@ class Lexer {
     this.input = input;
     this.pos = 0;
     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;
   }
 
-  peek(n = 1) {
-    return this.pos + n < this.input.length ? this.input[this.pos + n] : null;
+  peek() {
+    return this.pos + 1 < this.input.length ? this.input[this.pos + 1] : null;
   }
 
   error(msg) {
-    throw new Error(`LEXER ERROR: ${msg} at position ${this.pos}`);
+    throw new Error(`${msg} at line ${this.line}, column ${this.column}`);
   }
 
   skipWhitespace() {
@@ -1741,7 +1786,7 @@ class Lexer {
   skipComment() {
     if (this.currentChar === '#') {
       if (this.peek() === '*') {
-        this.advance(); this.advance(); // #*
+        this.advance(); this.advance(); // skip #*
         while (this.currentChar !== null) {
           if (this.currentChar === '*' && this.peek() === '#') {
             this.advance(); this.advance();
@@ -1749,7 +1794,7 @@ class Lexer {
           }
           this.advance();
         }
-        this.error('Unterminated multi-line comment (#* ... *#)');
+        this.error("Unterminated multi-line comment (#* ... *#)");
       } else {
         while (this.currentChar && this.currentChar !== '\n') this.advance();
       }
@@ -1757,6 +1802,8 @@ class Lexer {
   }
 
   number() {
+    const startLine = this.line;
+    const startCol = this.column;
     let result = '';
     while (this.currentChar && /[0-9]/.test(this.currentChar)) {
       result += this.currentChar;
@@ -1764,32 +1811,20 @@ class Lexer {
     }
 
     if (this.currentChar === '.' && /[0-9]/.test(this.peek())) {
-      result += '.';
-      this.advance();
+      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 };
     }
 
-    if (this.currentChar && /[eE]/.test(this.currentChar)) {
-      result += this.currentChar;
-      this.advance();
-      if (this.currentChar === '+' || this.currentChar === '-') {
-        result += this.currentChar;
-        this.advance();
-      }
-      if (!/[0-9]/.test(this.currentChar)) this.error('Invalid exponent in number');
-      while (this.currentChar && /[0-9]/.test(this.currentChar)) {
-        result += this.currentChar;
-        this.advance();
-      }
-    }
-
-    return { type: 'NUMBER', value: parseFloat(result) };
+    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)) {
       result += this.currentChar;
@@ -1798,19 +1833,20 @@ class Lexer {
 
     const keywords = [
       'let', 'sldeploy', 'if', 'else', 'while', 'for',
-      'break', 'continue', 'func', 'return',
-      'true', 'false', 'null', 'undefined',
+      'break', 'continue', 'func', 'return', 'true', 'false', 'null',
       'ask', 'define', 'import', 'from', 'as'
     ];
 
     if (keywords.includes(result)) {
-      return { type: result.toUpperCase(), value: result };
+      return { type: result.toUpperCase(), value: result, line: startLine, column: startCol };
     }
 
-    return { type: 'IDENTIFIER', value: result };
+    return { type: 'IDENTIFIER', value: result, line: startLine, column: startCol };
   }
 
   string() {
+    const startLine = this.line;
+    const startCol = this.column;
     const quote = this.currentChar;
     this.advance();
     let result = '';
@@ -1818,58 +1854,26 @@ class Lexer {
     while (this.currentChar && this.currentChar !== quote) {
       if (this.currentChar === '\\') {
         this.advance();
-        const map = { n: '\n', t: '\t', '"': '"', "'": "'", '\\': '\\' };
-        result += map[this.currentChar] ?? this.currentChar;
+        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();
     }
 
-    if (this.currentChar !== quote) this.error('Unterminated string literal');
-
-    this.advance();
-    return { type: 'STRING', value: result };
-  }
-
-
-  templateString(tokens) {
-    this.advance(); // skip opening `
-
-    let buffer = '';
-
-    while (this.currentChar !== null) {
-      if (this.currentChar === '`') {
-        if (buffer.length > 0) {
-          tokens.push({ type: 'TEMPLATE_STRING', value: buffer });
-        }
-        this.advance();
-        return;
-      }
-
-      if (this.currentChar === '$' && this.peek() === '{') {
-        if (buffer.length > 0) {
-          tokens.push({ type: 'TEMPLATE_STRING', value: buffer });
-          buffer = '';
-        }
-        this.advance(); // $
-        this.advance(); // {
-        tokens.push({ type: 'DOLLAR_LBRACE' });
-        return;
-      }
-
-      if (this.currentChar === '\\') {
-        this.advance();
-        buffer += this.currentChar;
-        this.advance();
-        continue;
-      }
-
-      buffer += this.currentChar;
-      this.advance();
+    if (this.currentChar !== quote) {
+      this.error('Unterminated string literal');
     }
 
-    this.error('Unterminated template string');
+    this.advance();
+    return { type: 'STRING', value: result, line: startLine, column: startCol };
   }
 
   getTokens() {
@@ -1882,56 +1886,38 @@ class Lexer {
       if (/[A-Za-z_]/.test(this.currentChar)) { tokens.push(this.identifier()); continue; }
       if (this.currentChar === '"' || this.currentChar === "'") { tokens.push(this.string()); continue; }
 
-      if (this.currentChar === '`') {
-        this.templateString(tokens);
-        continue;
-      }
-
       const char = this.currentChar;
       const next = this.peek();
-      const next2 = this.peek(2);
-
-      if (char === '=' && next === '=' && next2 === '=') { tokens.push({ type: 'STRICT_EQ' }); this.advance(); this.advance(); this.advance(); continue; }
-      if (char === '!' && next === '=' && next2 === '=') { tokens.push({ type: 'STRICT_NOTEQ' }); this.advance(); this.advance(); this.advance(); continue; }
-      if (char === '=' && next === '=') { tokens.push({ type: 'EQEQ' }); this.advance(); this.advance(); continue; }
-      if (char === '=' && next === '>') { tokens.push({ type: 'ARROW' }); this.advance(); this.advance(); continue; }
-      if (char === '!' && next === '=') { tokens.push({ type: 'NOTEQ' }); this.advance(); this.advance(); continue; }
-      if (char === '<' && next === '=') { tokens.push({ type: 'LTE' }); this.advance(); this.advance(); continue; }
-      if (char === '>' && next === '=') { tokens.push({ type: 'GTE' }); this.advance(); this.advance(); continue; }
-      if (char === '<' && next === '<') { tokens.push({ type: 'LSHIFT' }); this.advance(); this.advance(); continue; }
-      if (char === '>' && next === '>') { tokens.push({ type: 'RSHIFT' }); this.advance(); this.advance(); continue; }
-      if (char === '&' && next === '&') { tokens.push({ type: 'AND' }); this.advance(); this.advance(); continue; }
-      if (char === '|' && next === '|') { tokens.push({ type: 'OR' }); this.advance(); this.advance(); continue; }
-      if (char === '+' && next === '+') { tokens.push({ type: 'PLUSPLUS' }); this.advance(); this.advance(); continue; }
-      if (char === '-' && next === '-') { tokens.push({ type: 'MINUSMINUS' }); this.advance(); this.advance(); continue; }
-
-      const compound = { '+': 'PLUSEQ', '-': 'MINUSEQ', '*': 'STAREQ', '/': 'SLASHEQ', '%': 'MODEQ' };
-      if (next === '=' && compound[char]) {
-        tokens.push({ type: compound[char] });
-        this.advance(); this.advance();
-        continue;
-      }
+      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',
-        '[': 'LBRACKET', ']': 'RBRACKET',
-        ';': 'SEMICOLON', ',': 'COMMA',
+        '(': 'LPAREN', ')': 'RPAREN', '{': 'LBRACE', '}': 'RBRACE',
+        ';': 'SEMICOLON', ',': 'COMMA', '[': 'LBRACKET', ']': 'RBRACKET',
         ':': 'COLON', '.': 'DOT'
       };
 
-      if (singles[char]) {
-        tokens.push({ type: singles[char] });
-        this.advance();
-        continue;
-      }
+      if (singles[char]) { tokens.push({ type: singles[char], line: startLine, column: startCol }); this.advance(); continue; }
 
-      this.error(`Unexpected character: ${char}`);
+      this.error("Unexpected character: " + char);
     }
 
-    tokens.push({ type: 'EOF' });
+    tokens.push({ type: 'EOF', line: this.line, column: this.column });
     return tokens;
   }
 }
@@ -1958,7 +1944,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) {
@@ -2045,52 +2034,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');
@@ -2170,23 +2159,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();
@@ -2233,7 +2205,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() };
@@ -2243,7 +2215,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() };
@@ -2312,7 +2284,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 };
@@ -2334,15 +2306,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');
@@ -2393,7 +2359,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 });
@@ -2403,12 +2369,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;
 
 /***/ }),
 
@@ -2510,7 +2475,7 @@ const Lexer = __nccwpck_require__(211);
 const Parser = __nccwpck_require__(222);
 const Evaluator = __nccwpck_require__(112);
 
-const VERSION = '1.0.20';
+const VERSION = '1.0.22';
 
 const COLOR = {
     reset: '\x1b[0m',