starlight-cli 1.0.17 → 1.0.19

package/dist/index.js

@@ -1347,9 +1347,7 @@ 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 {}
 
@@ -1392,37 +1390,27 @@ 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 => {
-        const readlineSync = __nccwpck_require__(552);
-        return readlineSync.question(prompt + ' ');
-    });
+    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 => {
-    return String(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));
+  }
 
   evaluate(node, env = this.global) {
     switch (node.type) {
@@ -1439,6 +1427,7 @@ this.global.define('str', arg => {
       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);
@@ -1464,72 +1453,65 @@ this.global.define('str', arg => {
 
   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;
 
-  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}`);
+ 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() : '';
     }
+  }
+  return result;
+}
 
-    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);
+  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');
 
-    lib = {};
-    for (const key of Object.keys(moduleEnv.store)) {
-      lib[key] = moduleEnv.store[key];
-    }
+      if (!fs.existsSync(fullPath)) throw new Error(`Import not found: ${spec}`);
 
-    lib.default = lib;
-  }
+      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);
 
-  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);
+      lib = {};
+      for (const key of Object.keys(moduleEnv.store)) lib[key] = moduleEnv.store[key];
+      lib.default = lib;
     }
-    if (imp.type === 'NamedImport') {
-      if (!(imp.imported in lib)) {
-        throw new Error(`Module '${spec}' has no export '${imp.imported}'`);
+
+    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]);
       }
-      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;
-        throw e;
-      }
+      try { result = this.evaluate(stmt, env); }
+      catch (e) { if (e instanceof ReturnValue || e instanceof BreakSignal || e instanceof ContinueSignal) throw e; else throw e; }
     }
     return result;
   }
@@ -1542,27 +1524,15 @@ evalImport(node, env) {
   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);
@@ -1580,9 +1550,7 @@ evalImport(node, env) {
     }
 
     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;
   }
 
@@ -1594,8 +1562,7 @@ evalImport(node, env) {
 
   evalAsk(node, env) {
     const prompt = this.evaluate(node.prompt, env);
-    const input = readlineSync.question(prompt + ' ');
-    return input;
+    return readlineSync.question(prompt + ' ');
   }
 
   evalDefine(node, env) {
@@ -1612,12 +1579,16 @@ evalImport(node, env) {
       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 '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}`);
     }
   }
@@ -1685,9 +1656,7 @@ evalImport(node, env) {
       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) => {
@@ -1727,15 +1696,8 @@ evalImport(node, env) {
     };
     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;
@@ -1744,7 +1706,8 @@ evalImport(node, env) {
   }
 }
 
-module.exports = Evaluator;  
+module.exports = Evaluator;
+
 
 /***/ }),
 
@@ -1763,8 +1726,8 @@ class Lexer {
     this.currentChar = this.pos < this.input.length ? this.input[this.pos] : null;
   }
 
-  peek() {
-    return this.pos + 1 < this.input.length ? this.input[this.pos + 1] : null;
+  peek(n = 1) {
+    return this.pos + n < this.input.length ? this.input[this.pos + n] : null;
   }
 
   error(msg) {
@@ -1806,10 +1769,21 @@ class Lexer {
         result += this.currentChar;
         this.advance();
       }
-      return { type: 'NUMBER', value: parseFloat(result) };
     }
 
-    return { type: 'NUMBER', value: parseInt(result) };
+    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) };
   }
 
   identifier() {
@@ -1822,7 +1796,7 @@ class Lexer {
     const keywords = [
       'let', 'sldeploy', 'if', 'else', 'while', 'for',
       'break', 'continue', 'func', 'return', 'true', 'false', 'null',
-      'ask', 'define', 'import', 'from', 'as'
+      'ask', 'define', 'import', 'from', 'as', 'undefined'
     ];
 
     if (keywords.includes(result)) {
@@ -1830,8 +1804,7 @@ class Lexer {
     }
 
     return { type: 'IDENTIFIER', value: result };
-}
-
+  }
 
   string() {
     const quote = this.currentChar;
@@ -1863,6 +1836,46 @@ class Lexer {
     return { type: 'STRING', value: result };
   }
 
+  templateString() {
+  this.advance(); // skip initial backtick `
+  let buffer = '';
+  const tokens = [];
+
+  while (this.currentChar && this.currentChar !== '`') {
+    if (this.currentChar === '$' && this.peek() === '{') {
+      if (buffer.length > 0) {
+        tokens.push({ type: 'TEMPLATE_STRING', value: buffer });
+        buffer = '';
+      }
+      tokens.push({ type: 'DOLLAR_LBRACE' }); // ${
+      this.advance(); this.advance();
+      continue;
+    }
+
+    if (this.currentChar === '\\') {
+      this.advance();
+      switch (this.currentChar) {
+        case 'n': buffer += '\n'; break;
+        case 't': buffer += '\t'; break;
+        case '`': buffer += '`'; break;
+        case '\\': buffer += '\\'; break;
+        default: buffer += this.currentChar;
+      }
+    } else {
+      buffer += this.currentChar;
+    }
+    this.advance();
+  }
+
+  if (buffer.length > 0) tokens.push({ type: 'TEMPLATE_STRING', value: buffer });
+
+  if (this.currentChar !== '`') this.error('Unterminated template string');
+  this.advance(); // skip closing backtick
+
+  return tokens; // return array of tokens
+}
+
+
   getTokens() {
     const tokens = [];
 
@@ -1872,15 +1885,26 @@ class Lexer {
       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; }
+      if (this.currentChar === '`') {
+  const tTokens = this.templateString();
+  tokens.push(...tTokens); // push all tokens returned from templateString
+  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; }
@@ -1907,7 +1931,8 @@ class Lexer {
   }
 }
 
-module.exports = Lexer; 
+module.exports = Lexer;
+
 
 /***/ }),
 
@@ -2015,40 +2040,41 @@ 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');
-            }
-            specifiers.push({ type: 'NamedImport', imported: importedName, local: localName });
-            if (this.current.type === 'COMMA') this.eat('COMMA');
+      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('RBRACE');
+        specifiers.push({ type: 'NamedImport', imported: importedName, local: localName });
+        if (this.current.type === 'COMMA') this.eat('COMMA');
+      }
+      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');
     }
 
     this.eat('FROM');
@@ -2059,8 +2085,7 @@ class Parser {
     if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
 
     return { type: 'ImportStatement', path: pathToken.value, specifiers };
-}
-
+  }
 
   forStatement() {
     this.eat('FOR');
@@ -2140,6 +2165,23 @@ 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();
@@ -2186,7 +2228,7 @@ class Parser {
 
   equality() {
     let node = this.comparison();
-    while (['EQEQ', 'NOTEQ'].includes(this.current.type)) {
+    while (['EQEQ', 'NOTEQ', 'STRICT_EQ', 'STRICT_NOTEQ'].includes(this.current.type)) {
       const op = this.current.type;
       this.eat(op);
       node = { type: 'BinaryExpression', operator: op, left: node, right: this.comparison() };
@@ -2196,7 +2238,7 @@ class Parser {
 
   comparison() {
     let node = this.term();
-    while (['LT', 'LTE', 'GT', 'GTE'].includes(this.current.type)) {
+    while (['LT', 'LTE', 'GT', 'GTE', 'LSHIFT', 'RSHIFT'].includes(this.current.type)) {
       const op = this.current.type;
       this.eat(op);
       node = { type: 'BinaryExpression', operator: op, left: node, right: this.term() };
@@ -2287,9 +2329,14 @@ 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' || t.type === 'DOLLAR_LBRACE') {
+  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');
@@ -2354,7 +2401,8 @@ class Parser {
   }
 }
 
-module.exports = Parser; 
+module.exports = Parser;
+
 
 /***/ }),
 
@@ -2456,7 +2504,7 @@ const Lexer = __nccwpck_require__(211);
 const Parser = __nccwpck_require__(222);
 const Evaluator = __nccwpck_require__(112);
 
-const VERSION = '1.0.17';
+const VERSION = '1.0.19';
 
 const COLOR = {
     reset: '\x1b[0m',

package/package.json

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

package/src/evaluator.js

@@ -4,9 +4,7 @@ const Lexer = require('./lexer');
 const Parser = require('./parser');
 const path = require('path');
 
-class ReturnValue {
-  constructor(value) { this.value = value; }
-}
+class ReturnValue { constructor(value) { this.value = value; } }
 class BreakSignal {}
 class ContinueSignal {}
 
@@ -49,37 +47,27 @@ 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 => {
-        const readlineSync = require('readline-sync');
-        return readlineSync.question(prompt + ' ');
-    });
+    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 => {
-    return String(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));
+  }
 
   evaluate(node, env = this.global) {
     switch (node.type) {
@@ -96,6 +84,7 @@ this.global.define('str', arg => {
       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);
@@ -121,72 +110,65 @@ this.global.define('str', arg => {
 
   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;
 
-  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}`);
+ 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() : '';
     }
+  }
+  return result;
+}
 
-    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 = {};
-    for (const key of Object.keys(moduleEnv.store)) {
-      lib[key] = moduleEnv.store[key];
+  evalImport(node, env) {
+    const spec = node.path;
+    let lib;
+    try {
+      const resolved = require.resolve(spec, { paths: [process.cwd()] });
+      lib = require(resolved);
+    } catch (e) {
+      const fullPath = path.isAbsolute(spec)
+        ? spec
+        : path.join(process.cwd(), spec.endsWith('.sl') ? spec : spec + '.sl');
+
+      if (!fs.existsSync(fullPath)) throw new Error(`Import not found: ${spec}`);
+
+      const code = fs.readFileSync(fullPath, 'utf-8');
+      const tokens = new Lexer(code).getTokens();
+      const ast = new Parser(tokens).parse();
+      const moduleEnv = new Environment(env);
+      this.evaluate(ast, moduleEnv);
+
+      lib = {};
+      for (const key of Object.keys(moduleEnv.store)) lib[key] = moduleEnv.store[key];
+      lib.default = lib;
     }
 
-    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}'`);
+    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]);
       }
-      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;
-        throw e;
-      }
+      try { result = this.evaluate(stmt, env); }
+      catch (e) { if (e instanceof ReturnValue || e instanceof BreakSignal || e instanceof ContinueSignal) throw e; else throw e; }
     }
     return result;
   }
@@ -199,27 +181,15 @@ evalImport(node, env) {
   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);
@@ -237,9 +207,7 @@ evalImport(node, env) {
     }
 
     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;
   }
 
@@ -251,8 +219,7 @@ evalImport(node, env) {
 
   evalAsk(node, env) {
     const prompt = this.evaluate(node.prompt, env);
-    const input = readlineSync.question(prompt + ' ');
-    return input;
+    return readlineSync.question(prompt + ' ');
   }
 
   evalDefine(node, env) {
@@ -269,12 +236,16 @@ evalImport(node, env) {
       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 '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}`);
     }
   }
@@ -342,9 +313,7 @@ evalImport(node, env) {
       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) => {
@@ -384,15 +353,8 @@ evalImport(node, env) {
     };
     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;
@@ -401,4 +363,4 @@ evalImport(node, env) {
   }
 }
 
-module.exports = Evaluator;  
+module.exports = Evaluator;

package/src/lexer.js

@@ -10,8 +10,8 @@ class Lexer {
     this.currentChar = this.pos < this.input.length ? this.input[this.pos] : null;
   }
 
-  peek() {
-    return this.pos + 1 < this.input.length ? this.input[this.pos + 1] : null;
+  peek(n = 1) {
+    return this.pos + n < this.input.length ? this.input[this.pos + n] : null;
   }
 
   error(msg) {
@@ -53,10 +53,21 @@ class Lexer {
         result += this.currentChar;
         this.advance();
       }
-      return { type: 'NUMBER', value: parseFloat(result) };
     }
 
-    return { type: 'NUMBER', value: parseInt(result) };
+    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) };
   }
 
   identifier() {
@@ -69,7 +80,7 @@ class Lexer {
     const keywords = [
       'let', 'sldeploy', 'if', 'else', 'while', 'for',
       'break', 'continue', 'func', 'return', 'true', 'false', 'null',
-      'ask', 'define', 'import', 'from', 'as'
+      'ask', 'define', 'import', 'from', 'as', 'undefined'
     ];
 
     if (keywords.includes(result)) {
@@ -77,8 +88,7 @@ class Lexer {
     }
 
     return { type: 'IDENTIFIER', value: result };
-}
-
+  }
 
   string() {
     const quote = this.currentChar;
@@ -110,6 +120,46 @@ class Lexer {
     return { type: 'STRING', value: result };
   }
 
+  templateString() {
+  this.advance(); // skip initial backtick `
+  let buffer = '';
+  const tokens = [];
+
+  while (this.currentChar && this.currentChar !== '`') {
+    if (this.currentChar === '$' && this.peek() === '{') {
+      if (buffer.length > 0) {
+        tokens.push({ type: 'TEMPLATE_STRING', value: buffer });
+        buffer = '';
+      }
+      tokens.push({ type: 'DOLLAR_LBRACE' }); // ${
+      this.advance(); this.advance();
+      continue;
+    }
+
+    if (this.currentChar === '\\') {
+      this.advance();
+      switch (this.currentChar) {
+        case 'n': buffer += '\n'; break;
+        case 't': buffer += '\t'; break;
+        case '`': buffer += '`'; break;
+        case '\\': buffer += '\\'; break;
+        default: buffer += this.currentChar;
+      }
+    } else {
+      buffer += this.currentChar;
+    }
+    this.advance();
+  }
+
+  if (buffer.length > 0) tokens.push({ type: 'TEMPLATE_STRING', value: buffer });
+
+  if (this.currentChar !== '`') this.error('Unterminated template string');
+  this.advance(); // skip closing backtick
+
+  return tokens; // return array of tokens
+}
+
+
   getTokens() {
     const tokens = [];
 
@@ -119,15 +169,26 @@ class Lexer {
       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; }
+      if (this.currentChar === '`') {
+  const tTokens = this.templateString();
+  tokens.push(...tTokens); // push all tokens returned from templateString
+  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; }
@@ -154,4 +215,4 @@ class Lexer {
   }
 }
 
-module.exports = Lexer; 
+module.exports = Lexer;

package/src/parser.js

@@ -99,40 +99,41 @@ 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');
-            }
-            specifiers.push({ type: 'NamedImport', imported: importedName, local: localName });
-            if (this.current.type === 'COMMA') this.eat('COMMA');
+      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('RBRACE');
+        specifiers.push({ type: 'NamedImport', imported: importedName, local: localName });
+        if (this.current.type === 'COMMA') this.eat('COMMA');
+      }
+      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');
     }
 
     this.eat('FROM');
@@ -143,8 +144,7 @@ class Parser {
     if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
 
     return { type: 'ImportStatement', path: pathToken.value, specifiers };
-}
-
+  }
 
   forStatement() {
     this.eat('FOR');
@@ -224,6 +224,23 @@ 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();
@@ -270,7 +287,7 @@ class Parser {
 
   equality() {
     let node = this.comparison();
-    while (['EQEQ', 'NOTEQ'].includes(this.current.type)) {
+    while (['EQEQ', 'NOTEQ', 'STRICT_EQ', 'STRICT_NOTEQ'].includes(this.current.type)) {
       const op = this.current.type;
       this.eat(op);
       node = { type: 'BinaryExpression', operator: op, left: node, right: this.comparison() };
@@ -280,7 +297,7 @@ class Parser {
 
   comparison() {
     let node = this.term();
-    while (['LT', 'LTE', 'GT', 'GTE'].includes(this.current.type)) {
+    while (['LT', 'LTE', 'GT', 'GTE', 'LSHIFT', 'RSHIFT'].includes(this.current.type)) {
       const op = this.current.type;
       this.eat(op);
       node = { type: 'BinaryExpression', operator: op, left: node, right: this.term() };
@@ -371,9 +388,14 @@ 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' || t.type === 'DOLLAR_LBRACE') {
+  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');
@@ -438,4 +460,4 @@ class Parser {
   }
 }
 
-module.exports = Parser; 
+module.exports = Parser;

package/src/starlight.js

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