starlight-cli 1.1.16 → 1.1.18

package/dist/index.js

@@ -10213,7 +10213,6 @@ const fs = __nccwpck_require__(896);
 const Lexer = __nccwpck_require__(211);
 const Parser = __nccwpck_require__(222);
 const path = __nccwpck_require__(928);
-
 class ReturnValue {
   constructor(value) { this.value = value; }
 }
@@ -10414,7 +10413,51 @@ formatValue(value, seen = new Set()) {
         if (arg && typeof arg === 'object') return Object.keys(arg).length;
         return 0;
     });
+this.global.define('lower', arg => {
+    if (typeof arg !== 'string') return String(arg).toLowerCase();
+    return arg.toLowerCase();
+  });
+this.global.define('toStr', arg => String(arg));
 
+  this.global.define('upper', arg => {
+    if (typeof arg !== 'string') return String(arg).toUpperCase();
+    return arg.toUpperCase();
+  });
+
+  this.global.define('trim', arg => {
+    if (typeof arg !== 'string') return String(arg).trim();
+    return arg.trim();
+  });
+
+  this.global.define('startsWith', (str, prefix) => {
+    if (typeof str !== 'string') str = String(str);
+    if (typeof prefix !== 'string') prefix = String(prefix);
+    return str.startsWith(prefix);
+  });
+
+  this.global.define('endsWith', (str, suffix) => {
+    if (typeof str !== 'string') str = String(str);
+    if (typeof suffix !== 'string') suffix = String(suffix);
+    return str.endsWith(suffix);
+  });
+
+  this.global.define('includes', (str, substr) => {
+    if (typeof str !== 'string') str = String(str);
+    if (typeof substr !== 'string') substr = String(substr);
+    return str.includes(substr);
+  });
+
+  this.global.define('repeat', (str, times) => {
+    if (typeof str !== 'string') str = String(str);
+    return str.repeat(Number(times) || 0);
+  });
+
+  this.global.define('replace', (str, search, replacement) => {
+    if (typeof str !== 'string') str = String(str);
+    if (typeof search !== 'string') search = String(search);
+    if (typeof replacement !== 'string') replacement = String(replacement);
+    return str.split(search).join(replacement);
+  });
     this.global.define('print', arg => { console.log(arg); return null; });
     this.global.define('type', arg => {
         if (Array.isArray(arg)) return 'array';
@@ -10423,6 +10466,8 @@ formatValue(value, seen = new Set()) {
 this.global.define('isNaN', arg => {
   return typeof arg !== 'number' || Number.isNaN(arg);
 });
+
+
 this.global.define('random', (min, max) => {
   if (max === undefined) {
     // Only one argument → random between 0 and min
@@ -10525,6 +10570,9 @@ this.global.define('encodeURLComponent', arg => {
 
     return acc;
   });
+this.global.define('hasOwn', (obj, prop) => {
+  return Object.prototype.hasOwnProperty.call(obj, prop)
+});
 
     this.global.define('keys', arg => arg && typeof arg === 'object' ? Object.keys(arg) : []);
     this.global.define('values', arg => arg && typeof arg === 'object' ? Object.values(arg) : []);
@@ -10563,6 +10611,72 @@ this.global.define('range', (...args) => {
 
   return result;
 });
+this.global.define('floor', arg => Math.floor(Number(arg)));
+this.global.define('ceil', arg => Math.ceil(Number(arg)));
+this.global.define('round', arg => Math.round(Number(arg)));
+this.global.define('abs', arg => Math.abs(Number(arg)));
+this.global.define('pow', (base, exp) => Math.pow(Number(base), Number(exp)));
+this.global.define('sqrt', arg => Math.sqrt(Number(arg)));
+this.global.define('min', (...args) => Math.min(...args.map(Number)));
+this.global.define('max', (...args) => Math.max(...args.map(Number)));
+this.global.define('randomFloat', (min, max) => {
+    min = Number(min); max = Number(max);
+    if (isNaN(min) || isNaN(max)) return 0;
+    return Math.random() * (max - min) + min;
+});
+
+this.global.define('push', (arr, val) => {
+    if (!Array.isArray(arr)) throw new RuntimeError('push() expects an array', null, this.source);
+    arr.push(val); return arr.length;
+});
+this.global.define('pop', arr => {
+    if (!Array.isArray(arr)) throw new RuntimeError('pop() expects an array', null, this.source);
+    return arr.pop();
+});
+this.global.define('shift', arr => {
+    if (!Array.isArray(arr)) throw new RuntimeError('shift() expects an array', null, this.source);
+    return arr.shift();
+});
+this.global.define('unshift', (arr, val) => {
+    if (!Array.isArray(arr)) throw new RuntimeError('unshift() expects an array', null, this.source);
+    arr.unshift(val); return arr.length;
+});
+this.global.define('sort', (arr, fn) => {
+    if (!Array.isArray(arr)) throw new RuntimeError('sort() expects an array', null, this.source);
+    if (fn && typeof fn === 'function') return arr.sort(fn);
+    return arr.sort();
+});
+this.global.define('reverse', arr => {
+    if (!Array.isArray(arr)) throw new RuntimeError('reverse() expects an array', null, this.source);
+    return arr.reverse();
+});
+
+this.global.define('has', (obj, key) => obj && typeof obj === 'object' ? obj.hasOwnProperty(key) : false);
+this.global.define('merge', (obj1, obj2) => {
+    if (!obj1 || typeof obj1 !== 'object') obj1 = {};
+    if (!obj2 || typeof obj2 !== 'object') obj2 = {};
+    return { ...obj1, ...obj2 };
+});
+
+this.global.define('uuid', () => {
+    // simple random UUID v4
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+        const r = Math.random() * 16 | 0;
+        const v = c === 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+});
+this.global.define('timestamp', () => Date.now());
+this.global.define('clone', arg => {
+    if (Array.isArray(arg)) return [...arg];
+    if (arg && typeof arg === 'object') return { ...arg };
+    return arg; // primitive types
+});
+this.global.define('typeOf', arg => {
+    if (arg === null) return 'null';
+    if (Array.isArray(arg)) return 'array';
+    return typeof arg;
+});
 
     this.global.define('ask', prompt => {
         const readlineSync = __nccwpck_require__(552);
@@ -10619,6 +10733,271 @@ this.global.define('sleep', async (ms) => {
 this.global.define('str', arg => {
     return String(arg);
 });
+this.global.define('now', () => Date.now()); 
+this.global.define('formatDate', (timestamp, locale = 'en-US', options = {}) => {
+  if (timestamp === null || timestamp === undefined) timestamp = Date.now();
+  const t = typeof timestamp === 'number' ? timestamp : Number(timestamp);
+  if (isNaN(t)) t = Date.now();
+  return new Date(t).toLocaleString(locale, options);
+});
+
+this.global.define('readFile', path => {
+  if (typeof path !== 'string') path = String(path);
+  try {
+    return fs.readFileSync(path, 'utf-8');
+  } catch (e) {
+    throw new RuntimeError('readFile error: ' + e.message, null, this.source);
+  }
+});
+this.global.define('writeFile', (path, content) => {
+  if (typeof path !== 'string') path = String(path);
+  if (typeof content !== 'string') content = String(content);
+  try {
+    fs.writeFileSync(path, content, 'utf-8');
+    return true;
+  } catch (e) {
+    throw new RuntimeError('writeFile error: ' + e.message, null, this.source);
+  }
+});
+
+this.global.define('split', (str, separator) => {
+  if (typeof str !== 'string') str = String(str);
+  if (separator === undefined) separator = '';
+  return str.split(separator);
+});
+
+this.global.define('join', (arr, separator = '') => {
+  if (!Array.isArray(arr)) throw new RuntimeError('join() expects an array', null, this.source);
+  return arr.join(separator);
+});
+
+this.global.define('substring', (str, start, end) => {
+  if (typeof str !== 'string') str = String(str);
+  start = Number(start) || 0;
+  end = end !== undefined ? Number(end) : undefined;
+  return str.substring(start, end);
+});
+
+this.global.define('padStart', (str, targetLength, padString = ' ') => {
+  if (typeof str !== 'string') str = String(str);
+  targetLength = Number(targetLength) || 0;
+  return str.padStart(targetLength, padString);
+});
+
+this.global.define('padEnd', (str, targetLength, padString = ' ') => {
+  if (typeof str !== 'string') str = String(str);
+  targetLength = Number(targetLength) || 0;
+  return str.padEnd(targetLength, padString);
+});
+this.global.define('unique', arr => {
+    if (!Array.isArray(arr)) throw new RuntimeError('unique() expects an array', null, this.source);
+    return [...new Set(arr)];
+});
+
+this.global.define('indexOf', (arr, val) => {
+    if (!Array.isArray(arr)) throw new RuntimeError('indexOf() expects an array', null, this.source);
+    return arr.indexOf(val);
+});
+
+this.global.define('includesArr', (arr, val) => {
+    if (!Array.isArray(arr)) throw new RuntimeError('includesArr() expects an array', null, this.source);
+    return arr.includes(val);
+});
+
+this.global.define('flatten', arr => {
+    if (!Array.isArray(arr)) throw new RuntimeError('flatten() expects an array', null, this.source);
+    return arr.flat(Infinity);
+});
+
+this.global.define('randomChoice', arr => {
+    if (!Array.isArray(arr)) throw new RuntimeError('randomChoice() expects an array', null, this.source);
+    return arr[Math.floor(Math.random() * arr.length)];
+});
+
+this.global.define('entries', obj => {
+    if (!obj || typeof obj !== 'object') throw new RuntimeError('entries() expects an object', null, this.source);
+    return Object.entries(obj);
+});
+
+this.global.define('invert', obj => {
+    if (!obj || typeof obj !== 'object') throw new RuntimeError('invert() expects an object', null, this.source);
+    const result = {};
+    for (const key in obj) result[obj[key]] = key;
+    return result;
+});
+
+this.global.define('isEmpty', arg => {
+    if (arg == null) return true;
+    if (Array.isArray(arg) || typeof arg === 'string') return arg.length === 0;
+    if (typeof arg === 'object') return Object.keys(arg).length === 0;
+    return false;
+});
+
+this.global.define('deepClone', arg => {
+    return JSON.parse(JSON.stringify(arg));
+});
+
+this.global.define('capitalize', str => {
+    if (typeof str !== 'string') str = String(str);
+    if (str.length === 0) return '';
+    return str[0].toUpperCase() + str.slice(1);
+});
+
+this.global.define('reverseStr', str => {
+    if (typeof str !== 'string') str = String(str);
+    return str.split('').reverse().join('');
+});
+
+this.global.define('trimStart', str => {
+    if (typeof str !== 'string') str = String(str);
+    return str.trimStart();
+});
+
+this.global.define('trimEnd', str => {
+    if (typeof str !== 'string') str = String(str);
+    return str.trimEnd();
+});
+
+this.global.define('clamp', (value, min, max) => {
+    value = Number(value); min = Number(min); max = Number(max);
+    return Math.min(Math.max(value, min), max);
+});
+
+this.global.define('sign', value => {
+    value = Number(value);
+    return Math.sign(value);
+});
+
+this.global.define('appendFile', (path, content) => {
+    if (typeof path !== 'string') path = String(path);
+    if (typeof content !== 'string') content = String(content);
+    try {
+        fs.appendFileSync(path, content, 'utf-8');
+        return true;
+    } catch (e) {
+        throw new RuntimeError('appendFile error: ' + e.message, null, this.source);
+    }
+});
+
+this.global.define('exists', path => {
+    if (typeof path !== 'string') path = String(path);
+    return fs.existsSync(path);
+});
+
+this.global.define('mkdir', path => {
+    if (typeof path !== 'string') path = String(path);
+    if (!fs.existsSync(path)) fs.mkdirSync(path, { recursive: true });
+    return true;
+});
+this.global.define('count', (arr, value) => {
+    if (!Array.isArray(arr)) throw new RuntimeError('count() expects an array', null, this.source);
+    return arr.filter(x => x === value).length;
+});
+
+this.global.define('uniqueBy', (arr, fn) => {
+    if (!Array.isArray(arr)) throw new RuntimeError('uniqueBy() expects an array', null, this.source);
+    const seen = new Set();
+    const result = [];
+    for (const item of arr) {
+        const key = fn ? fn(item) : item;
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(item);
+        }
+    }
+    return result;
+});
+this.global.define('getProp', (obj, key, defaultValue = null) => {
+    if (!obj || typeof obj !== 'object') return defaultValue;
+    const keys = key.split('.');
+    let current = obj;
+    for (const k of keys) {
+        if (current[k] === undefined) return defaultValue;
+        current = current[k];
+    }
+    return current;
+});
+
+this.global.define('setProp', (obj, key, value) => {
+    if (!obj || typeof obj !== 'object') throw new RuntimeError('setProp() expects an object', null, this.source);
+    const keys = key.split('.');
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        if (!current[keys[i]] || typeof current[keys[i]] !== 'object') current[keys[i]] = {};
+        current = current[keys[i]];
+    }
+    current[keys[keys.length - 1]] = value;
+    return obj;
+});
+
+this.global.define('mergeDeep', (obj1, obj2) => {
+    const isObject = val => val && typeof val === 'object';
+    const result = {...obj1};
+    for (const key in obj2) {
+        if (isObject(obj2[key]) && isObject(result[key])) {
+            result[key] = this.global.get('mergeDeep')(result[key], obj2[key]);
+        } else {
+            result[key] = obj2[key];
+        }
+    }
+    return result;
+});
+this.global.define('camelCase', str => {
+    if (typeof str !== 'string') str = String(str);
+    return str
+        .replace(/[-_ ]+./g, s => s.charAt(s.length - 1).toUpperCase())
+        .replace(/^[A-Z]/, s => s.toLowerCase());
+});
+
+this.global.define('kebabCase', str => {
+    if (typeof str !== 'string') str = String(str);
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/\s+/g, '-')
+        .replace(/_+/g, '-')
+        .toLowerCase();
+});
+
+this.global.define('repeatStr', (str, times) => {
+    if (typeof str !== 'string') str = String(str);
+    return str.repeat(Number(times) || 0);
+});
+this.global.define('randomInt', (min, max) => {
+    min = Number(min); max = Number(max);
+    if (isNaN(min) || isNaN(max)) return 0;
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+});
+
+this.global.define('lerp', (a, b, t) => {
+    a = Number(a); b = Number(b); t = Number(t);
+    return a + (b - a) * t;
+});
+
+this.global.define('degToRad', deg => Number(deg) * (Math.PI / 180));
+this.global.define('radToDeg', rad => Number(rad) * (180 / Math.PI));
+this.global.define('readJSON', path => {
+    const content = this.global.get('readFile')(path);
+    return JSON.parse(content);
+});
+
+this.global.define('writeJSON', (path, obj) => {
+    const content = JSON.stringify(obj, null, 2);
+    return this.global.get('writeFile')(path, content);
+});
+
+this.global.define('deleteFile', path => {
+    if (typeof path !== 'string') path = String(path);
+    if (!fs.existsSync(path)) return false;
+    fs.unlinkSync(path);
+    return true;
+});
+
+this.global.define('rmdir', path => {
+    if (typeof path !== 'string') path = String(path);
+    if (!fs.existsSync(path)) return false;
+    fs.rmSync(path, { recursive: true, force: true });
+    return true;
+});
 
 }
 
@@ -10748,8 +11127,6 @@ async evalProgram(node, env) {
 async evalSlice(node, env) {
   try {
     const arr = await this.evaluate(node.object, env);
-    const start = node.start ? await this.evaluate(node.start, env) : 0;
-    const end = node.end ? await this.evaluate(node.end, env) : arr.length;
 
     if (!Array.isArray(arr)) {
       throw new RuntimeError(
@@ -10760,10 +11137,37 @@ async evalSlice(node, env) {
       );
     }
 
-    const s = start < 0 ? Math.max(arr.length + start, 0) : Math.min(start, arr.length);
-    const e = end < 0 ? Math.max(arr.length + end, 0) : Math.min(end, arr.length);
+    let start = node.start ? await this.evaluate(node.start, env) : 0;
+    let end = node.end ? await this.evaluate(node.end, env) : arr.length;
+    let step = node.step ? await this.evaluate(node.step, env) : 1;
+
+    if (step === 0) {
+      throw new RuntimeError(
+        'Slice step cannot be zero',
+        node,
+        this.source,
+        env
+      );
+    }
+    start = start < 0 ? arr.length + start : start;
+    end = end < 0 ? arr.length + end : end;
+
+    start = Math.min(Math.max(start, 0), arr.length);
+    end = Math.min(Math.max(end, 0), arr.length);
 
-    return arr.slice(s, e);
+    const result = [];
+
+    if (step > 0) {
+      for (let i = start; i < end; i += step) {
+        result.push(arr[i]);
+      }
+    } else {
+      for (let i = start; i > end; i += step) {
+        result.push(arr[i]);
+      }
+    }
+
+    return result;
 
   } catch (err) {
     if (err instanceof RuntimeError) throw err;
@@ -10776,6 +11180,7 @@ async evalSlice(node, env) {
   }
 }
 
+
 async evalStartStatement(node, env) {
   try {
     const value = await this.evaluate(node.discriminant, env);
@@ -11300,12 +11705,49 @@ async evalLogical(node, env) {
 
 async evalUnary(node, env) {
   try {
+    // Handle prefix update operators
+    if (node.type === 'UpdateExpression' && node.prefix) {
+      if (node.argument.type !== 'Identifier') {
+        throw new RuntimeError(
+          `Invalid operand for update operator: ${node.operator}`,
+          node,
+          this.source,
+          env
+        );
+      }
+
+      const varName = node.argument.name;
+      let currentVal = await env.get(varName); // assuming env.get returns the variable value
+
+      switch (node.operator) {
+        case 'PLUSPLUS':
+          currentVal++;
+          await env.set(varName, currentVal);
+          return currentVal;
+        case 'MINUSMINUS':
+          currentVal--;
+          await env.set(varName, currentVal);
+          return currentVal;
+        default:
+          throw new RuntimeError(
+            `Unknown update operator: ${node.operator}`,
+            node,
+            this.source,
+            env
+          );
+      }
+    }
+
+    // Evaluate the argument first
     const val = await this.evaluate(node.argument, env);
 
     switch (node.operator) {
-      case 'NOT': return !val;
-      case 'MINUS': return -val;
-      case 'PLUS': return +val;
+      case 'NOT':
+        return !val;
+      case 'MINUS':
+        return -val;
+      case 'PLUS':
+        return +val;
       default:
         throw new RuntimeError(
           `Unknown unary operator: ${node.operator}`,
@@ -11314,7 +11756,6 @@ async evalUnary(node, env) {
           env
         );
     }
-
   } catch (e) {
     if (e instanceof RuntimeError) throw e;
     throw new RuntimeError(
@@ -11326,6 +11767,51 @@ async evalUnary(node, env) {
   }
 }
 
+// Handle postfix updates (x++ or x--)
+async evalPostfixUpdate(node, env) {
+  if (node.type !== 'UpdateExpression' || node.prefix) {
+    throw new RuntimeError(
+      `Invalid postfix update node`,
+      node,
+      this.source,
+      env
+    );
+  }
+
+  if (node.argument.type !== 'Identifier') {
+    throw new RuntimeError(
+      `Invalid operand for postfix update operator: ${node.operator}`,
+      node,
+      this.source,
+      env
+    );
+  }
+
+  const varName = node.argument.name;
+  let currentVal = await env.get(varName);
+
+  let returnVal = currentVal;
+
+  switch (node.operator) {
+    case 'PLUSPLUS':
+      currentVal++;
+      await env.set(varName, currentVal);
+      return returnVal; // return original value
+    case 'MINUSMINUS':
+      currentVal--;
+      await env.set(varName, currentVal);
+      return returnVal; // return original value
+    default:
+      throw new RuntimeError(
+        `Unknown postfix operator: ${node.operator}`,
+        node,
+        this.source,
+        env
+      );
+  }
+}
+
+
 async evalIf(node, env) {
   let test = await this.evaluate(node.test, env);
   test = !!test; // coerce to boolean
@@ -11604,7 +12090,8 @@ async evalIndex(node, env) {
       env
     );
   }
-}
+} 
+
 async evalObject(node, env) {
   try {
     const out = {};
@@ -13243,192 +13730,111 @@ unary() {
 
   return this.postfix();
 }
+
 postfix() {
   let node = this.primary();
 
   while (true) {
     const t = this.current;
 
-   if (t.type === 'LBRACKET') {
-  const startLine = t.line;
-  const startCol = t.column;
-  this.eat('LBRACKET');
-
-  let start = null;
-  let end = null;
-  let step = null;
-
-  if (this.current.type === 'COLON') {
-    this.eat('COLON');
-
-    if (this.current.type !== 'RBRACKET' && this.current.type !== 'COLON') {
-      end = this.expression();
-    }
-
-    if (this.current.type === 'COLON') {
-      this.eat('COLON');
-      if (this.current.type !== 'RBRACKET') {
-        step = this.expression();
-      }
-    }
-
-    if (this.current.type !== 'RBRACKET') {
-      throw new ParseError(
-        "Expected ']' after slice",
-        this.current,
-        this.source
-      );
-    }
-
-    this.eat('RBRACKET');
-
-    node = {
-      type: 'SliceExpression',
-      object: node,
-      start,
-      end,
-      step,
-      line: startLine,
-      column: startCol
-    };
-
-  } else {
-    start = this.expression();
-
-    if (this.current.type === 'COLON') {
-      this.eat('COLON');
+    // Handle indexing / slicing
+    if (t.type === 'LBRACKET') {
+      const startLine = t.line;
+      const startCol = t.column;
+      this.eat('LBRACKET');
 
-      if (this.current.type !== 'RBRACKET' && this.current.type !== 'COLON') {
-        end = this.expression();
-      }
+      let start = null;
+      let end = null;
+      let step = null;
 
+      // Slice: [:end:step] or [start:end:step]
       if (this.current.type === 'COLON') {
         this.eat('COLON');
+        if (this.current.type !== 'RBRACKET' && this.current.type !== 'COLON') {
+          end = this.expression();
+        }
+        if (this.current.type === 'COLON') {
+          this.eat('COLON');
+          if (this.current.type !== 'RBRACKET') {
+            step = this.expression();
+          }
+        }
         if (this.current.type !== 'RBRACKET') {
-          step = this.expression();
+          throw new ParseError("Expected ']' after slice", this.current, this.source);
         }
-      }
+        this.eat('RBRACKET');
 
-      if (this.current.type !== 'RBRACKET') {
-        throw new ParseError(
-          "Expected ']' after slice",
-          this.current,
-          this.source
-        );
-      }
-
-      this.eat('RBRACKET');
-
-      node = {
-        type: 'SliceExpression',
-        object: node,
-        start,
-        end,
-        step,
-        line: startLine,
-        column: startCol
-      };
+        node = { type: 'SliceExpression', object: node, start, end, step, line: startLine, column: startCol };
+      } else {
+        // Normal index or slice starting with an expression
+        start = this.expression();
+        if (this.current.type === 'COLON') {
+          this.eat('COLON');
+          if (this.current.type !== 'RBRACKET' && this.current.type !== 'COLON') {
+            end = this.expression();
+          }
+          if (this.current.type === 'COLON') {
+            this.eat('COLON');
+            if (this.current.type !== 'RBRACKET') {
+              step = this.expression();
+            }
+          }
+          if (this.current.type !== 'RBRACKET') {
+            throw new ParseError("Expected ']' after slice", this.current, this.source);
+          }
+          this.eat('RBRACKET');
 
-    } else {
-      this.eat('RBRACKET');
-      node = {
-        type: 'IndexExpression',
-        object: node,
-        indexer: start,
-        line: startLine,
-        column: startCol
-      };
+          node = { type: 'SliceExpression', object: node, start, end, step, line: startLine, column: startCol };
+        } else {
+          this.eat('RBRACKET');
+          node = { type: 'IndexExpression', object: node, indexer: start, line: startLine, column: startCol };
+        }
+      }
+      continue; // continue to allow . or () after []
     }
-  }
-}
-
-
 
+    // Handle function call
     if (t.type === 'LPAREN') {
       const startLine = t.line;
       const startCol = t.column;
       this.eat('LPAREN');
 
       const args = [];
-
       while (this.current.type !== 'RPAREN') {
         if (this.current.type === 'EOF') {
-          throw new ParseError(
-            "Unterminated function call",
-            this.current,
-            this.source,
-            "Did you forget to close ')'?"
-          );
+          throw new ParseError("Unterminated function call", this.current, this.source, "Did you forget to close ')'?");
         }
-
         args.push(this.expression());
-
-        if (this.current.type === 'COMMA') {
-          this.eat('COMMA');
-        } else {
-          break;
-        }
-      }
-
-      if (this.current.type !== 'RPAREN') {
-        throw new ParseError(
-          "Expected ')' after function arguments",
-          this.current,
-          this.source,
-          "Function calls must be closed with ')'"
-        );
+        if (this.current.type === 'COMMA') this.eat('COMMA');
       }
 
       this.eat('RPAREN');
 
-      node = {
-        type: 'CallExpression',
-        callee: node,
-        arguments: args,
-        line: startLine,
-        column: startCol
-      };
+      node = { type: 'CallExpression', callee: node, arguments: args, line: startLine, column: startCol };
       continue;
     }
 
+    // Handle member access
     if (t.type === 'DOT') {
       const startLine = t.line;
       const startCol = t.column;
       this.eat('DOT');
 
       if (this.current.type !== 'IDENTIFIER') {
-        throw new ParseError(
-          "Expected property name after '.'",
-          this.current,
-          this.source,
-          "Member access requires a property name, e.g. obj.value"
-        );
+        throw new ParseError("Expected property name after '.'", this.current, this.source, "Member access requires a property name, e.g. obj.value");
       }
 
       const property = this.current.value;
       this.eat('IDENTIFIER');
 
-      node = {
-        type: 'MemberExpression',
-        object: node,
-        property,
-        line: startLine,
-        column: startCol
-      };
+      node = { type: 'MemberExpression', object: node, property, line: startLine, column: startCol };
       continue;
     }
 
+    // Handle postfix update operators
     if (t.type === 'PLUSPLUS' || t.type === 'MINUSMINUS') {
       this.eat(t.type);
-
-      node = {
-        type: 'UpdateExpression',
-        operator: t.type,
-        argument: node,
-        prefix: false,
-        line: t.line,
-        column: t.column
-      };
+      node = { type: 'UpdateExpression', operator: t.type, argument: node, prefix: false, line: t.line, column: t.column };
       continue;
     }
 
@@ -13438,6 +13844,7 @@ postfix() {
   return node;
 }
 
+
 arrowFunction(params) {
   const t = this.current;
   this.eat('ARROW');
@@ -13788,8 +14195,8 @@ if (t.type === 'FUNC') {
 } 
 
 }
-
-module.exports = Parser;
+module.exports = Parser;
+
 
 /***/ }),
 
@@ -13969,7 +14376,7 @@ const Lexer = __nccwpck_require__(211);
 const Parser = __nccwpck_require__(222);
 const Evaluator = __nccwpck_require__(112);
 
-const VERSION = '1.1.16';
+const VERSION = '1.1.18';
 
 const COLOR = {
     reset: '\x1b[0m',
@@ -14129,7 +14536,7 @@ Usage:
 
 if (args[0] === '-v' || args[0] === '--version') {
     console.log(`${COLOR.bold}Starlight CLI v${VERSION}${COLOR.reset}`);
-    console.log(`${COLOR.magenta}Developed by Macedon${COLOR.reset}`);
+    console.log(`${COLOR.magenta}Developed by Dominex Macedon${COLOR.reset}`);
     process.exit(0);
 }