littlewing 0.5.0 → 0.5.2

package/dist/index.d.ts

@@ -306,11 +306,6 @@ declare class CodeGenerator {
 	* - For left-associative operators: parens if lower or equal precedence
 	*/
 	private needsParensRight;
-	/**
-	* Get precedence of an operator (higher number = higher precedence)
-	* Must match the precedence in parser.ts
-	*/
-	private getPrecedence;
 }
 /**
 * Generate source code from an AST node
@@ -498,21 +493,10 @@ declare class Parser {
 	*/
 	private parseFunctionArguments;
 	/**
-	* Get operator precedence
-	* Precedence hierarchy:
-	* 0: None
-	* 1: Assignment (=, ??=)
-	* 2: Ternary conditional (? :)
-	* 3: Logical OR (||)
-	* 4: Logical AND (&&)
-	* 5: Comparison (==, !=, <, >, <=, >=)
-	* 6: Addition/Subtraction (+, -)
-	* 7: Multiplication/Division/Modulo (*, /, %)
-	* 8: Exponentiation (^)
-	*/
-	private getPrecedence;
-	/**
 	* Get unary operator precedence
+	* Returns 6 which is higher than add/sub (6) but lower than exponentiation (8)
+	* This means: -2^2 parses as -(2^2) = -4, not (-2)^2 = 4
+	* This matches the behavior of Python, Ruby, and most languages
 	*/
 	private getUnaryPrecedence;
 	/**

package/dist/index.js

@@ -194,6 +194,105 @@ function isNullishAssignment(node) {
   return node.type === "NullishAssignment";
 }
 
+// src/utils.ts
+function evaluateBinaryOperation(operator, left, right) {
+  switch (operator) {
+    case "+":
+      return left + right;
+    case "-":
+      return left - right;
+    case "*":
+      return left * right;
+    case "/":
+      if (right === 0) {
+        throw new Error("Division by zero");
+      }
+      return left / right;
+    case "%":
+      if (right === 0) {
+        throw new Error("Modulo by zero");
+      }
+      return left % right;
+    case "^":
+      return left ** right;
+    case "==":
+      return left === right ? 1 : 0;
+    case "!=":
+      return left !== right ? 1 : 0;
+    case "<":
+      return left < right ? 1 : 0;
+    case ">":
+      return left > right ? 1 : 0;
+    case "<=":
+      return left <= right ? 1 : 0;
+    case ">=":
+      return left >= right ? 1 : 0;
+    case "&&":
+      return left !== 0 && right !== 0 ? 1 : 0;
+    case "||":
+      return left !== 0 || right !== 0 ? 1 : 0;
+    default:
+      throw new Error(`Unknown operator: ${operator}`);
+  }
+}
+function getOperatorPrecedence(operator) {
+  switch (operator) {
+    case "^":
+      return 8;
+    case "*":
+    case "/":
+    case "%":
+      return 7;
+    case "+":
+    case "-":
+      return 6;
+    case "==":
+    case "!=":
+    case "<":
+    case ">":
+    case "<=":
+    case ">=":
+      return 5;
+    case "&&":
+      return 4;
+    case "||":
+      return 3;
+    default:
+      return 0;
+  }
+}
+function getTokenPrecedence(type) {
+  switch (type) {
+    case "EQUALS" /* EQUALS */:
+    case "NULLISH_ASSIGN" /* NULLISH_ASSIGN */:
+      return 1;
+    case "QUESTION" /* QUESTION */:
+      return 2;
+    case "LOGICAL_OR" /* LOGICAL_OR */:
+      return 3;
+    case "LOGICAL_AND" /* LOGICAL_AND */:
+      return 4;
+    case "DOUBLE_EQUALS" /* DOUBLE_EQUALS */:
+    case "NOT_EQUALS" /* NOT_EQUALS */:
+    case "LESS_THAN" /* LESS_THAN */:
+    case "GREATER_THAN" /* GREATER_THAN */:
+    case "LESS_EQUAL" /* LESS_EQUAL */:
+    case "GREATER_EQUAL" /* GREATER_EQUAL */:
+      return 5;
+    case "PLUS" /* PLUS */:
+    case "MINUS" /* MINUS */:
+      return 6;
+    case "STAR" /* STAR */:
+    case "SLASH" /* SLASH */:
+    case "PERCENT" /* PERCENT */:
+      return 7;
+    case "CARET" /* CARET */:
+      return 8;
+    default:
+      return 0;
+  }
+}
+
 // src/codegen.ts
 class CodeGenerator {
   generate(node) {
@@ -257,15 +356,15 @@ class CodeGenerator {
     const condition = this.generate(node.condition);
     const consequent = this.generate(node.consequent);
     const alternate = this.generate(node.alternate);
-    const conditionNeedsParens = isAssignment(node.condition) || isBinaryOp(node.condition) && this.getPrecedence(node.condition.operator) <= 2;
+    const conditionNeedsParens = isAssignment(node.condition) || isBinaryOp(node.condition) && getOperatorPrecedence(node.condition.operator) <= 2;
     const conditionCode = conditionNeedsParens ? `(${condition})` : condition;
     return `${conditionCode} ? ${consequent} : ${alternate}`;
   }
   needsParensLeft(node, operator) {
     if (!isBinaryOp(node))
       return false;
-    const nodePrecedence = this.getPrecedence(node.operator);
-    const operatorPrecedence = this.getPrecedence(operator);
+    const nodePrecedence = getOperatorPrecedence(node.operator);
+    const operatorPrecedence = getOperatorPrecedence(operator);
     if (operator === "^") {
       return nodePrecedence <= operatorPrecedence;
     }
@@ -274,39 +373,13 @@ class CodeGenerator {
   needsParensRight(node, operator) {
     if (!isBinaryOp(node))
       return false;
-    const nodePrecedence = this.getPrecedence(node.operator);
-    const operatorPrecedence = this.getPrecedence(operator);
+    const nodePrecedence = getOperatorPrecedence(node.operator);
+    const operatorPrecedence = getOperatorPrecedence(operator);
     if (operator === "^") {
       return nodePrecedence < operatorPrecedence;
     }
     return nodePrecedence <= operatorPrecedence;
   }
-  getPrecedence(operator) {
-    switch (operator) {
-      case "^":
-        return 8;
-      case "*":
-      case "/":
-      case "%":
-        return 7;
-      case "+":
-      case "-":
-        return 6;
-      case "==":
-      case "!=":
-      case "<":
-      case ">":
-      case "<=":
-      case ">=":
-        return 5;
-      case "&&":
-        return 4;
-      case "||":
-        return 3;
-      default:
-        return 0;
-    }
-  }
 }
 function generate(node) {
   const generator = new CodeGenerator;
@@ -548,6 +621,23 @@ class Lexer {
 }
 
 // src/parser.ts
+var BINARY_OPERATOR_TOKENS = new Set([
+  "PLUS" /* PLUS */,
+  "MINUS" /* MINUS */,
+  "STAR" /* STAR */,
+  "SLASH" /* SLASH */,
+  "PERCENT" /* PERCENT */,
+  "CARET" /* CARET */,
+  "DOUBLE_EQUALS" /* DOUBLE_EQUALS */,
+  "NOT_EQUALS" /* NOT_EQUALS */,
+  "LESS_THAN" /* LESS_THAN */,
+  "GREATER_THAN" /* GREATER_THAN */,
+  "LESS_EQUAL" /* LESS_EQUAL */,
+  "GREATER_EQUAL" /* GREATER_EQUAL */,
+  "LOGICAL_AND" /* LOGICAL_AND */,
+  "LOGICAL_OR" /* LOGICAL_OR */
+]);
+
 class Parser {
   tokens;
   current = 0;
@@ -578,7 +668,7 @@ class Parser {
     let left = this.parsePrefix();
     while (true) {
       const token = this.peek();
-      const precedence = this.getPrecedence(token.type);
+      const precedence = getTokenPrecedence(token.type);
       if (precedence < minPrecedence) {
         break;
       }
@@ -698,42 +788,11 @@ class Parser {
     }
     return args;
   }
-  getPrecedence(type) {
-    switch (type) {
-      case "EQUALS" /* EQUALS */:
-      case "NULLISH_ASSIGN" /* NULLISH_ASSIGN */:
-        return 1;
-      case "QUESTION" /* QUESTION */:
-        return 2;
-      case "LOGICAL_OR" /* LOGICAL_OR */:
-        return 3;
-      case "LOGICAL_AND" /* LOGICAL_AND */:
-        return 4;
-      case "DOUBLE_EQUALS" /* DOUBLE_EQUALS */:
-      case "NOT_EQUALS" /* NOT_EQUALS */:
-      case "LESS_THAN" /* LESS_THAN */:
-      case "GREATER_THAN" /* GREATER_THAN */:
-      case "LESS_EQUAL" /* LESS_EQUAL */:
-      case "GREATER_EQUAL" /* GREATER_EQUAL */:
-        return 5;
-      case "PLUS" /* PLUS */:
-      case "MINUS" /* MINUS */:
-        return 6;
-      case "STAR" /* STAR */:
-      case "SLASH" /* SLASH */:
-      case "PERCENT" /* PERCENT */:
-        return 7;
-      case "CARET" /* CARET */:
-        return 8;
-      default:
-        return 0;
-    }
-  }
   getUnaryPrecedence() {
     return 6;
   }
   isBinaryOperator(type) {
-    return type === "PLUS" /* PLUS */ || type === "MINUS" /* MINUS */ || type === "STAR" /* STAR */ || type === "SLASH" /* SLASH */ || type === "PERCENT" /* PERCENT */ || type === "CARET" /* CARET */ || type === "DOUBLE_EQUALS" /* DOUBLE_EQUALS */ || type === "NOT_EQUALS" /* NOT_EQUALS */ || type === "LESS_THAN" /* LESS_THAN */ || type === "GREATER_THAN" /* GREATER_THAN */ || type === "LESS_EQUAL" /* LESS_EQUAL */ || type === "GREATER_EQUAL" /* GREATER_EQUAL */ || type === "LOGICAL_AND" /* LOGICAL_AND */ || type === "LOGICAL_OR" /* LOGICAL_OR */;
+    return BINARY_OPERATOR_TOKENS.has(type);
   }
   peek() {
     if (this.current >= this.tokens.length) {
@@ -805,44 +864,7 @@ class Executor {
   executeBinaryOp(node) {
     const left = this.execute(node.left);
     const right = this.execute(node.right);
-    switch (node.operator) {
-      case "+":
-        return left + right;
-      case "-":
-        return left - right;
-      case "*":
-        return left * right;
-      case "/":
-        if (right === 0) {
-          throw new Error("Division by zero");
-        }
-        return left / right;
-      case "%":
-        if (right === 0) {
-          throw new Error("Modulo by zero");
-        }
-        return left % right;
-      case "^":
-        return left ** right;
-      case "==":
-        return left === right ? 1 : 0;
-      case "!=":
-        return left !== right ? 1 : 0;
-      case "<":
-        return left < right ? 1 : 0;
-      case ">":
-        return left > right ? 1 : 0;
-      case "<=":
-        return left <= right ? 1 : 0;
-      case ">=":
-        return left >= right ? 1 : 0;
-      case "&&":
-        return left !== 0 && right !== 0 ? 1 : 0;
-      case "||":
-        return left !== 0 || right !== 0 ? 1 : 0;
-      default:
-        throw new Error(`Unknown operator: ${node.operator}`);
-    }
+    return evaluateBinaryOperation(node.operator, left, right);
   }
   executeUnaryOp(node) {
     const arg = this.execute(node.argument);
@@ -923,11 +945,15 @@ function analyzeProgram(node) {
       const deps = new Set;
       const hasFunctionCall = collectDependencies(stmt.value, deps);
       dependencies.set(varName, deps);
-      if (count === 0 && isNumberLiteral(stmt.value)) {
-        constants.set(varName, stmt.value.value);
-      }
-      if (hasFunctionCall) {
+      if (isNullishAssignment(stmt)) {
         tainted.add(varName);
+      } else {
+        if (count === 0 && isNumberLiteral(stmt.value)) {
+          constants.set(varName, stmt.value.value);
+        }
+        if (hasFunctionCall) {
+          tainted.add(varName);
+        }
       }
     }
   }
@@ -1119,7 +1145,7 @@ function evaluateWithConstants(node, constants) {
     const left = evaluateWithConstants(node.left, constants);
     const right = evaluateWithConstants(node.right, constants);
     if (isNumberLiteral(left) && isNumberLiteral(right)) {
-      const result = evaluateBinaryOp(node.operator, left.value, right.value);
+      const result = evaluateBinaryOperation(node.operator, left.value, right.value);
       return number(result);
     }
     return {
@@ -1253,7 +1279,7 @@ function basicOptimize(node) {
     const left = basicOptimize(node.left);
     const right = basicOptimize(node.right);
     if (isNumberLiteral(left) && isNumberLiteral(right)) {
-      const result = evaluateBinaryOp(node.operator, left.value, right.value);
+      const result = evaluateBinaryOperation(node.operator, left.value, right.value);
       return number(result);
     }
     return {
@@ -1300,46 +1326,6 @@ function basicOptimize(node) {
   }
   return node;
 }
-function evaluateBinaryOp(operator, left, right) {
-  switch (operator) {
-    case "+":
-      return left + right;
-    case "-":
-      return left - right;
-    case "*":
-      return left * right;
-    case "/":
-      if (right === 0) {
-        throw new Error("Division by zero in constant folding");
-      }
-      return left / right;
-    case "%":
-      if (right === 0) {
-        throw new Error("Modulo by zero in constant folding");
-      }
-      return left % right;
-    case "^":
-      return left ** right;
-    case "==":
-      return left === right ? 1 : 0;
-    case "!=":
-      return left !== right ? 1 : 0;
-    case "<":
-      return left < right ? 1 : 0;
-    case ">":
-      return left > right ? 1 : 0;
-    case "<=":
-      return left <= right ? 1 : 0;
-    case ">=":
-      return left >= right ? 1 : 0;
-    case "&&":
-      return left !== 0 && right !== 0 ? 1 : 0;
-    case "||":
-      return left !== 0 || right !== 0 ? 1 : 0;
-    default:
-      throw new Error(`Unknown operator: ${operator}`);
-  }
-}
 export {
   parseSource,
   optimize,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "littlewing",
-	"version": "0.5.0",
+	"version": "0.5.2",
 	"description": "A minimal, high-performance arithmetic expression language with lexer, parser, and executor. Optimized for browsers with zero dependencies and type-safe execution.",
 	"keywords": [
 		"arithmetic",