starlight-cli 1.1.17 → 1.1.18

package/dist/index.js

@@ -10466,6 +10466,8 @@ this.global.define('toStr', arg => String(arg));
 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
@@ -10568,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) : []);
@@ -11122,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(
@@ -11134,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);
+
+    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 arr.slice(s, e);
+    return result;
 
   } catch (err) {
     if (err instanceof RuntimeError) throw err;
@@ -11150,6 +11180,7 @@ async evalSlice(node, env) {
   }
 }
 
+
 async evalStartStatement(node, env) {
   try {
     const value = await this.evaluate(node.discriminant, env);
@@ -11674,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}`,
@@ -11688,7 +11756,6 @@ async evalUnary(node, env) {
           env
         );
     }
-
   } catch (e) {
     if (e instanceof RuntimeError) throw e;
     throw new RuntimeError(
@@ -11700,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
@@ -11978,7 +12090,8 @@ async evalIndex(node, env) {
       env
     );
   }
-}
+} 
+
 async evalObject(node, env) {
   try {
     const out = {};
@@ -13617,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);
         }
-      }
-
-      if (this.current.type !== 'RBRACKET') {
-        throw new ParseError(
-          "Expected ']' after slice",
-          this.current,
-          this.source
-        );
-      }
-
-      this.eat('RBRACKET');
+        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;
     }
 
@@ -13812,6 +13844,7 @@ postfix() {
   return node;
 }
 
+
 arrowFunction(params) {
   const t = this.current;
   this.eat('ARROW');
@@ -14162,8 +14195,8 @@ if (t.type === 'FUNC') {
 } 
 
 }
-
-module.exports = Parser;
+module.exports = Parser;
+
 
 /***/ }),
 
@@ -14343,7 +14376,7 @@ const Lexer = __nccwpck_require__(211);
 const Parser = __nccwpck_require__(222);
 const Evaluator = __nccwpck_require__(112);
 
-const VERSION = '1.1.17';
+const VERSION = '1.1.18';
 
 const COLOR = {
     reset: '\x1b[0m',
@@ -14503,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);
 }
 

package/package.json

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

package/src/evaluator.js

@@ -256,6 +256,8 @@ this.global.define('toStr', arg => String(arg));
 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
@@ -358,6 +360,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) : []);
@@ -912,8 +917,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(
@@ -924,10 +927,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);
+
+    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 arr.slice(s, e);
+    return result;
 
   } catch (err) {
     if (err instanceof RuntimeError) throw err;
@@ -940,6 +970,7 @@ async evalSlice(node, env) {
   }
 }
 
+
 async evalStartStatement(node, env) {
   try {
     const value = await this.evaluate(node.discriminant, env);
@@ -1464,12 +1495,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}`,
@@ -1478,7 +1546,6 @@ async evalUnary(node, env) {
           env
         );
     }
-
   } catch (e) {
     if (e instanceof RuntimeError) throw e;
     throw new RuntimeError(
@@ -1490,6 +1557,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
@@ -1768,7 +1880,8 @@ async evalIndex(node, env) {
       env
     );
   }
-}
+} 
+
 async evalObject(node, env) {
   try {
     const out = {};

package/src/parser.js

@@ -1286,192 +1286,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');
+
+        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');
 
-      if (this.current.type !== 'RBRACKET') {
-        throw new ParseError(
-          "Expected ']' after slice",
-          this.current,
-          this.source
-        );
+          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 };
+        }
       }
-
-      this.eat('RBRACKET');
-
-      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;
     }
 
@@ -1481,6 +1400,7 @@ postfix() {
   return node;
 }
 
+
 arrowFunction(params) {
   const t = this.current;
   this.eat('ARROW');
@@ -1831,5 +1751,4 @@ if (t.type === 'FUNC') {
 } 
 
 }
-
-module.exports = Parser;
+module.exports = Parser;

package/src/starlight.js

@@ -12,7 +12,7 @@ const Lexer = require('./lexer');
 const Parser = require('./parser');
 const Evaluator = require('./evaluator');
 
-const VERSION = '1.1.17';
+const VERSION = '1.1.18';
 
 const COLOR = {
     reset: '\x1b[0m',
@@ -172,7 +172,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);
 }