littlewing 0.4.2 → 0.5.0

package/README.md

@@ -5,10 +5,10 @@ A minimal, high-performance arithmetic expression language with a complete lexer
 ## Features
 
 - 🚀 **Minimal & Fast** - O(n) algorithms throughout (lexer, parser, executor)
-- 📦 **Small Bundle** - 5.62 KB gzipped, zero dependencies
+- 📦 **Small Bundle** - 6.89 KB gzipped, zero dependencies
 - 🌐 **Browser Ready** - 100% ESM, no Node.js APIs
 - 🔒 **Type-Safe** - Strict TypeScript with full type coverage
-- ✅ **Thoroughly Tested** - 136 tests, 99.52% line coverage
+- ✅ **Thoroughly Tested** - 247 tests, 98.61% line coverage
 - 📐 **Pure Arithmetic** - Numbers-only, clean semantics
 - 🎯 **Clean API** - Intuitive dual API (class-based + functional)
 - 📝 **Well Documented** - Complete JSDoc and examples
@@ -126,7 +126,7 @@ z = x * y;
 
 ### Operators
 
-All standard arithmetic operators with proper precedence:
+#### Arithmetic Operators
 
 ```typescript
 2 + 3; // addition
@@ -134,23 +134,98 @@ All standard arithmetic operators with proper precedence:
 3 * 4; // multiplication
 10 / 2; // division
 10 % 3; // modulo
-2 ^
-	(3 - // exponentiation (power)
-		5); // unary minus
+2 ^ 3; // exponentiation (power)
+-5; // unary minus
+```
+
+#### Comparison Operators
+
+Returns `1` for true, `0` for false (following the numbers-only philosophy):
+
+```typescript
+5 == 5; // equality → 1
+5 != 3; // not equal → 1
+5 > 3; // greater than → 1
+5 < 3; // less than → 0
+5 >= 5; // greater than or equal → 1
+5 <= 3; // less than or equal → 0
+```
+
+#### Logical Operators
+
+Returns `1` for true, `0` for false. Treats `0` as false, any non-zero value as true:
+
+```typescript
+1 && 1; // logical AND → 1 (both truthy)
+1 && 0; // logical AND → 0 (right is falsy)
+0 || 1; // logical OR → 1 (right is truthy)
+0 || 0; // logical OR → 0 (both falsy)
+
+// Commonly used with comparisons
+5 > 3 && 10 > 8; // → 1 (both conditions true)
+5 < 3 || 10 > 8; // → 1 (second condition true)
+age >= 18 && age <= 65; // age range check
+isStudent || age >= 65; // student or senior discount
+```
+
+#### Ternary Operator
+
+Conditional expression with `? :` syntax:
+
+```typescript
+5 > 3 ? 100 : 50; // → 100 (condition is true)
+0 ? 100 : 50; // → 50 (0 is falsy)
+x = age >= 18 ? 1 : 0; // assign based on condition
+
+// Nested ternaries
+age < 18 ? 10 : age >= 65 ? 15 : 0; // age-based discount
+```
+
+#### Assignment Operators
+
+```typescript
+x = 5; // regular assignment
+price ??= 100; // nullish assignment - only assigns if variable doesn't exist
+```
+
+The `??=` operator is useful for providing default values to external variables:
+
+```typescript
+// Without ??=
+execute("price * 2", { variables: { price: 50 } }); // → 100
+execute("price * 2", {}); // Error: Undefined variable: price
+
+// With ??=
+execute("price ??= 100; price * 2", { variables: { price: 50 } }); // → 100 (uses existing)
+execute("price ??= 100; price * 2", {}); // → 200 (uses default)
+```
+
+Unlike `||`, the `??=` operator preserves `0` values:
+
+```typescript
+execute("x ??= 10; x", { variables: { x: 0 } }); // → 0 (preserves zero)
+execute("x ??= 10; x", {}); // → 10 (assigns default)
 ```
 
 ### Operator Precedence
 
-1. Unary minus (`-`) - Highest
-2. Exponentiation (`^`)
-3. Multiplication, division, modulo (`*`, `/`, `%`)
-4. Addition, subtraction (`+`, `-`)
-5. Assignment (`=`) - Lowest
+From lowest to highest:
+
+1. Assignment (`=`, `??=`) - Lowest
+2. Ternary conditional (`? :`)
+3. Logical OR (`||`)
+4. Logical AND (`&&`)
+5. Comparison (`==`, `!=`, `<`, `>`, `<=`, `>=`)
+6. Addition, subtraction (`+`, `-`)
+7. Multiplication, division, modulo (`*`, `/`, `%`)
+8. Exponentiation (`^`)
+9. Unary minus (`-`) - Highest
 
 Parentheses override precedence:
 
 ```typescript
 (2 + 3) * 4; // → 20 (not 14)
+5 > 3 && 10 > 8; // → 1 (explicit grouping, though not necessary)
 ```
 
 ### Functions
@@ -292,8 +367,11 @@ The `ast` namespace provides convenient functions for building AST nodes:
 ```typescript
 import { ast } from "littlewing";
 
+// Literals and identifiers
 ast.number(42);
 ast.identifier("x");
+
+// Arithmetic operators
 ast.add(left, right);
 ast.subtract(left, right);
 ast.multiply(left, right);
@@ -301,7 +379,27 @@ ast.divide(left, right);
 ast.modulo(left, right);
 ast.exponentiate(left, right);
 ast.negate(argument);
-ast.assign("x", value);
+
+// Comparison operators
+ast.equals(left, right); // ==
+ast.notEquals(left, right); // !=
+ast.lessThan(left, right); // <
+ast.greaterThan(left, right); // >
+ast.lessEqual(left, right); // <=
+ast.greaterEqual(left, right); // >=
+
+// Logical operators
+ast.logicalAnd(left, right); // &&
+ast.logicalOr(left, right); // ||
+
+// Control flow
+ast.conditional(condition, consequent, alternate); // ? :
+
+// Assignment
+ast.assign("x", value); // =
+ast.nullishAssign("x", value); // ??=
+
+// Functions
 ast.functionCall("abs", [ast.number(-5)]);
 ```
 
@@ -509,6 +607,101 @@ execute("fahrenheit(roomTemp)", context); // → 68
 execute("kilometers(5)", context); // → 8.0467
 ```
 
+### Conditional Logic & Validation
+
+```typescript
+import { execute } from "littlewing";
+
+// Age-based discount system
+const discountScript = `
+  age ??= 30;
+  isStudent ??= 0;
+  isPremium ??= 0;
+
+  discount = isPremium ? 0.2 :
+             age < 18 ? 0.15 :
+             age >= 65 ? 0.15 :
+             isStudent ? 0.1 : 0;
+
+  discount
+`;
+
+execute(discountScript); // → 0 (default 30-year-old)
+execute(discountScript, { variables: { age: 16 } }); // → 0.15 (under 18)
+execute(discountScript, { variables: { isPremium: 1 } }); // → 0.2 (premium)
+execute(discountScript, { variables: { isStudent: 1 } }); // → 0.1 (student)
+
+// Range validation
+const validateAge = "age >= 18 && age <= 120";
+execute(validateAge, { variables: { age: 25 } }); // → 1 (valid)
+execute(validateAge, { variables: { age: 15 } }); // → 0 (too young)
+execute(validateAge, { variables: { age: 150 } }); // → 0 (invalid)
+
+// Complex business logic
+const eligibilityScript = `
+  age ??= 0;
+  income ??= 0;
+  creditScore ??= 0;
+
+  hasGoodCredit = creditScore >= 700;
+  hasStableIncome = income >= 30000;
+  isAdult = age >= 18;
+
+  eligible = isAdult && hasGoodCredit && hasStableIncome;
+  eligible
+`;
+
+execute(eligibilityScript, {
+	variables: { age: 25, income: 45000, creditScore: 750 },
+}); // → 1 (eligible)
+```
+
+### Dynamic Pricing
+
+```typescript
+import { execute } from "littlewing";
+
+const pricingFormula = `
+  // Defaults
+  basePrice ??= 100;
+  isPeakHour ??= 0;
+  isWeekend ??= 0;
+  quantity ??= 1;
+  isMember ??= 0;
+
+  // Surge pricing
+  surgeMultiplier = isPeakHour ? 1.5 : isWeekend ? 1.2 : 1.0;
+
+  // Volume discount
+  volumeDiscount = quantity >= 10 ? 0.15 :
+                   quantity >= 5 ? 0.1 :
+                   quantity >= 3 ? 0.05 : 0;
+
+  // Member discount (stacks with volume)
+  memberDiscount = isMember ? 0.1 : 0;
+
+  // Calculate final price
+  adjustedPrice = basePrice * surgeMultiplier;
+  afterVolumeDiscount = adjustedPrice * (1 - volumeDiscount);
+  finalPrice = afterVolumeDiscount * (1 - memberDiscount);
+
+  finalPrice * quantity
+`;
+
+// Regular customer, 1 item
+execute(pricingFormula); // → 100
+
+// Peak hour, 5 items, member
+execute(pricingFormula, {
+	variables: { isPeakHour: 1, quantity: 5, isMember: 1 },
+}); // → 607.5
+
+// Weekend, bulk order (10 items)
+execute(pricingFormula, {
+	variables: { isWeekend: 1, quantity: 10 },
+}); // → 1020
+```
+
 ### Scheduling System
 
 ```typescript
@@ -538,15 +731,17 @@ const dueTimes = tasks.map((task) => ({
 
 ### Bundle Size
 
-- **5.62 KB gzipped** (28.22 KB raw)
+- **6.89 KB gzipped** (37.66 KB raw)
 - Zero dependencies
 - Includes production-grade O(n) optimizer
+- Full feature set: arithmetic, comparisons, logical operators, ternary, assignments
 - Fully tree-shakeable
 
 ### Test Coverage
 
-- **136 tests** with **99.52% line coverage**
-- **99.26% function coverage**
+- **247 tests** with **98.61% line coverage**
+- **98.21% function coverage**
+- Comprehensive coverage of all operators and features
 - All edge cases handled
 - Type-safe execution guaranteed
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 declare namespace exports_ast {
-	export { unaryOp, subtract, number, negate, multiply, modulo, identifier, functionCall, exponentiate, divide, binaryOp, assign, add };
+	export { unaryOp, subtract, number, nullishAssign, notEquals, negate, multiply, modulo, logicalOr, logicalAnd, lessThan, lessEqual, identifier, greaterThan, greaterEqual, functionCall, exponentiate, equals, divide, conditional, binaryOp, assign, add };
 }
 /**
 * Runtime value type - only numbers
@@ -8,14 +8,14 @@ type RuntimeValue = number;
 /**
 * Binary operator types
 */
-type Operator = "+" | "-" | "*" | "/" | "%" | "^";
+type Operator = "+" | "-" | "*" | "/" | "%" | "^" | "==" | "!=" | "<" | ">" | "<=" | ">=" | "&&" | "||";
 /**
 * Execution context providing global functions and variables
-* Functions must accept any arguments and return a number
+* Functions must accept zero or more number arguments and return a number
 * Variables must be numbers
 */
 interface ExecutionContext {
-	functions?: Record<string, (...args: any[]) => number>;
+	functions?: Record<string, (...args: number[]) => number>;
 	variables?: Record<string, number>;
 }
 /**
@@ -30,10 +30,21 @@ declare enum TokenType {
 	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",
 	LPAREN = "LPAREN",
 	RPAREN = "RPAREN",
 	EQUALS = "EQUALS",
 	COMMA = "COMMA",
+	QUESTION = "QUESTION",
+	COLON = "COLON",
+	NULLISH_ASSIGN = "NULLISH_ASSIGN",
 	EOF = "EOF"
 }
 /**
@@ -47,7 +58,7 @@ interface Token {
 /**
 * AST Node - base type
 */
-type ASTNode = Program | NumberLiteral | Identifier | BinaryOp | UnaryOp | FunctionCall | Assignment;
+type ASTNode = Program | NumberLiteral | Identifier | BinaryOp | UnaryOp | FunctionCall | Assignment | ConditionalExpression | NullishAssignment;
 /**
 * Program node (multiple statements)
 */
@@ -103,6 +114,26 @@ interface Assignment {
 	value: ASTNode;
 }
 /**
+* Conditional expression (ternary operator: condition ? consequent : alternate)
+* Returns consequent if condition !== 0, otherwise returns alternate
+*/
+interface ConditionalExpression {
+	type: "ConditionalExpression";
+	condition: ASTNode;
+	consequent: ASTNode;
+	alternate: ASTNode;
+}
+/**
+* Nullish assignment (x ??= 5)
+* Assigns value only if variable is undefined (not provided in context)
+* Used for providing defaults for external variables
+*/
+interface NullishAssignment {
+	type: "NullishAssignment";
+	name: string;
+	value: ASTNode;
+}
+/**
 * Type guard functions for discriminated union narrowing
 */
 declare function isNumberLiteral(node: ASTNode): node is NumberLiteral;
@@ -112,6 +143,8 @@ declare function isUnaryOp(node: ASTNode): node is UnaryOp;
 declare function isFunctionCall(node: ASTNode): node is FunctionCall;
 declare function isAssignment(node: ASTNode): node is Assignment;
 declare function isProgram(node: ASTNode): node is Program;
+declare function isConditionalExpression(node: ASTNode): node is ConditionalExpression;
+declare function isNullishAssignment(node: ASTNode): node is NullishAssignment;
 /**
 * Builder functions for creating AST nodes manually
 */
@@ -140,6 +173,15 @@ declare function functionCall(name: string, args?: ASTNode[]): FunctionCall;
 */
 declare function assign(name: string, value: ASTNode): Assignment;
 /**
+* Create a nullish assignment node (x ??= 5)
+* Assigns only if variable is undefined
+*/
+declare function nullishAssign(name: string, value: ASTNode): NullishAssignment;
+/**
+* Create a conditional expression node (ternary operator)
+*/
+declare function conditional(condition: ASTNode, consequent: ASTNode, alternate: ASTNode): ConditionalExpression;
+/**
 * Convenience functions for common operations
 */
 /**
@@ -171,6 +213,44 @@ declare function exponentiate(left: ASTNode, right: ASTNode): BinaryOp;
 */
 declare function negate(argument: ASTNode): UnaryOp;
 /**
+* Comparison operator convenience functions
+*/
+/**
+* Create an equality comparison (==)
+*/
+declare function equals(left: ASTNode, right: ASTNode): BinaryOp;
+/**
+* Create a not-equals comparison (!=)
+*/
+declare function notEquals(left: ASTNode, right: ASTNode): BinaryOp;
+/**
+* Create a less-than comparison (<)
+*/
+declare function lessThan(left: ASTNode, right: ASTNode): BinaryOp;
+/**
+* Create a greater-than comparison (>)
+*/
+declare function greaterThan(left: ASTNode, right: ASTNode): BinaryOp;
+/**
+* Create a less-than-or-equal comparison (<=)
+*/
+declare function lessEqual(left: ASTNode, right: ASTNode): BinaryOp;
+/**
+* Create a greater-than-or-equal comparison (>=)
+*/
+declare function greaterEqual(left: ASTNode, right: ASTNode): BinaryOp;
+/**
+* Logical operator convenience functions
+*/
+/**
+* Create a logical AND operation (&&)
+*/
+declare function logicalAnd(left: ASTNode, right: ASTNode): BinaryOp;
+/**
+* Create a logical OR operation (||)
+*/
+declare function logicalOr(left: ASTNode, right: ASTNode): BinaryOp;
+/**
 * CodeGenerator - converts AST nodes back to source code
 */
 declare class CodeGenerator {
@@ -207,6 +287,14 @@ declare class CodeGenerator {
 	*/
 	private generateAssignment;
 	/**
+	* Generate code for a nullish assignment
+	*/
+	private generateNullishAssignment;
+	/**
+	* Generate code for a conditional expression (ternary operator)
+	*/
+	private generateConditionalExpression;
+	/**
 	* Check if left operand needs parentheses based on operator precedence
 	* - For left-associative operators: parens only if strictly lower precedence
 	* - For right-associative operators (^): parens if lower or equal precedence
@@ -220,6 +308,7 @@ declare class CodeGenerator {
 	private needsParensRight;
 	/**
 	* Get precedence of an operator (higher number = higher precedence)
+	* Must match the precedence in parser.ts
 	*/
 	private getPrecedence;
 }
@@ -290,6 +379,17 @@ declare class Executor {
 	* Execute a variable assignment
 	*/
 	private executeAssignment;
+	/**
+	* Execute a nullish assignment (??=)
+	* Only assigns if the variable is undefined (not in variables map)
+	* Returns the existing value if defined, otherwise evaluates and assigns the value
+	*/
+	private executeNullishAssignment;
+	/**
+	* Execute a conditional expression (ternary operator)
+	* Returns consequent if condition !== 0, otherwise returns alternate
+	*/
+	private executeConditionalExpression;
 }
 /**
 * Execute source code with given context
@@ -332,6 +432,10 @@ declare class Lexer {
 	*/
 	private peek;
 	/**
+	* Peek ahead n positions without consuming
+	*/
+	private peekAhead;
+	/**
 	* Check if character is a digit
 	*/
 	private isDigit;
@@ -395,6 +499,16 @@ 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;
 	/**
@@ -421,4 +535,4 @@ declare class Parser {
 * @returns Parsed AST
 */
 declare function parseSource(source: string): ASTNode;
-export { parseSource, optimize, isUnaryOp, isProgram, isNumberLiteral, isIdentifier, isFunctionCall, isBinaryOp, isAssignment, generate, execute, defaultContext, exports_ast as ast, TokenType, Token, RuntimeValue, Parser, Lexer, Executor, ExecutionContext, CodeGenerator, ASTNode };
+export { parseSource, optimize, isUnaryOp, isProgram, isNumberLiteral, isNullishAssignment, isIdentifier, isFunctionCall, isConditionalExpression, isBinaryOp, isAssignment, generate, execute, defaultContext, exports_ast as ast, TokenType, Token, RuntimeValue, Parser, Lexer, Executor, ExecutionContext, CodeGenerator, ASTNode };

package/dist/index.js

@@ -16,13 +16,23 @@ __export(exports_ast, {
   unaryOp: () => unaryOp,
   subtract: () => subtract,
   number: () => number,
+  nullishAssign: () => nullishAssign,
+  notEquals: () => notEquals,
   negate: () => negate,
   multiply: () => multiply,
   modulo: () => modulo,
+  logicalOr: () => logicalOr,
+  logicalAnd: () => logicalAnd,
+  lessThan: () => lessThan,
+  lessEqual: () => lessEqual,
   identifier: () => identifier,
+  greaterThan: () => greaterThan,
+  greaterEqual: () => greaterEqual,
   functionCall: () => functionCall,
   exponentiate: () => exponentiate,
+  equals: () => equals,
   divide: () => divide,
+  conditional: () => conditional,
   binaryOp: () => binaryOp,
   assign: () => assign,
   add: () => add
@@ -68,6 +78,21 @@ function assign(name, value) {
     value
   };
 }
+function nullishAssign(name, value) {
+  return {
+    type: "NullishAssignment",
+    name,
+    value
+  };
+}
+function conditional(condition, consequent, alternate) {
+  return {
+    type: "ConditionalExpression",
+    condition,
+    consequent,
+    alternate
+  };
+}
 function add(left, right) {
   return binaryOp(left, "+", right);
 }
@@ -89,6 +114,30 @@ function exponentiate(left, right) {
 function negate(argument) {
   return unaryOp(argument);
 }
+function equals(left, right) {
+  return binaryOp(left, "==", right);
+}
+function notEquals(left, right) {
+  return binaryOp(left, "!=", right);
+}
+function lessThan(left, right) {
+  return binaryOp(left, "<", right);
+}
+function greaterThan(left, right) {
+  return binaryOp(left, ">", right);
+}
+function lessEqual(left, right) {
+  return binaryOp(left, "<=", right);
+}
+function greaterEqual(left, right) {
+  return binaryOp(left, ">=", right);
+}
+function logicalAnd(left, right) {
+  return binaryOp(left, "&&", right);
+}
+function logicalOr(left, right) {
+  return binaryOp(left, "||", right);
+}
 // src/types.ts
 var TokenType;
 ((TokenType2) => {
@@ -100,10 +149,21 @@ var TokenType;
   TokenType2["SLASH"] = "SLASH";
   TokenType2["PERCENT"] = "PERCENT";
   TokenType2["CARET"] = "CARET";
+  TokenType2["DOUBLE_EQUALS"] = "DOUBLE_EQUALS";
+  TokenType2["NOT_EQUALS"] = "NOT_EQUALS";
+  TokenType2["LESS_THAN"] = "LESS_THAN";
+  TokenType2["GREATER_THAN"] = "GREATER_THAN";
+  TokenType2["LESS_EQUAL"] = "LESS_EQUAL";
+  TokenType2["GREATER_EQUAL"] = "GREATER_EQUAL";
+  TokenType2["LOGICAL_AND"] = "LOGICAL_AND";
+  TokenType2["LOGICAL_OR"] = "LOGICAL_OR";
   TokenType2["LPAREN"] = "LPAREN";
   TokenType2["RPAREN"] = "RPAREN";
   TokenType2["EQUALS"] = "EQUALS";
   TokenType2["COMMA"] = "COMMA";
+  TokenType2["QUESTION"] = "QUESTION";
+  TokenType2["COLON"] = "COLON";
+  TokenType2["NULLISH_ASSIGN"] = "NULLISH_ASSIGN";
   TokenType2["EOF"] = "EOF";
 })(TokenType ||= {});
 function isNumberLiteral(node) {
@@ -127,6 +187,12 @@ function isAssignment(node) {
 function isProgram(node) {
   return node.type === "Program";
 }
+function isConditionalExpression(node) {
+  return node.type === "ConditionalExpression";
+}
+function isNullishAssignment(node) {
+  return node.type === "NullishAssignment";
+}
 
 // src/codegen.ts
 class CodeGenerator {
@@ -145,6 +211,10 @@ class CodeGenerator {
       return this.generateFunctionCall(node);
     if (isAssignment(node))
       return this.generateAssignment(node);
+    if (isNullishAssignment(node))
+      return this.generateNullishAssignment(node);
+    if (isConditionalExpression(node))
+      return this.generateConditionalExpression(node);
     throw new Error(`Unknown node type`);
   }
   generateProgram(node) {
@@ -179,6 +249,18 @@ class CodeGenerator {
     const value = this.generate(node.value);
     return `${node.name} = ${value}`;
   }
+  generateNullishAssignment(node) {
+    const value = this.generate(node.value);
+    return `${node.name} ??= ${value}`;
+  }
+  generateConditionalExpression(node) {
+    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 conditionCode = conditionNeedsParens ? `(${condition})` : condition;
+    return `${conditionCode} ? ${consequent} : ${alternate}`;
+  }
   needsParensLeft(node, operator) {
     if (!isBinaryOp(node))
       return false;
@@ -202,14 +284,25 @@ class CodeGenerator {
   getPrecedence(operator) {
     switch (operator) {
       case "^":
-        return 4;
+        return 8;
       case "*":
       case "/":
       case "%":
-        return 3;
+        return 7;
       case "+":
       case "-":
-        return 2;
+        return 6;
+      case "==":
+      case "!=":
+      case "<":
+      case ">":
+      case "<=":
+      case ">=":
+        return 5;
+      case "&&":
+        return 4;
+      case "||":
+        return 3;
       default:
         return 0;
     }
@@ -309,14 +402,64 @@ class Lexer {
         this.position++;
         return { type: "RPAREN" /* RPAREN */, value: ")", position: start };
       case "=":
+        if (this.peek() === "=") {
+          this.position += 2;
+          return { type: "DOUBLE_EQUALS" /* DOUBLE_EQUALS */, value: "==", position: start };
+        }
         this.position++;
         return { type: "EQUALS" /* EQUALS */, value: "=", position: start };
+      case "!":
+        if (this.peek() === "=") {
+          this.position += 2;
+          return { type: "NOT_EQUALS" /* NOT_EQUALS */, value: "!=", position: start };
+        }
+        throw new Error(`Unexpected character '${char}' at position ${start}`);
+      case "<":
+        if (this.peek() === "=") {
+          this.position += 2;
+          return { type: "LESS_EQUAL" /* LESS_EQUAL */, value: "<=", position: start };
+        }
+        this.position++;
+        return { type: "LESS_THAN" /* LESS_THAN */, value: "<", position: start };
+      case ">":
+        if (this.peek() === "=") {
+          this.position += 2;
+          return { type: "GREATER_EQUAL" /* GREATER_EQUAL */, value: ">=", position: start };
+        }
+        this.position++;
+        return { type: "GREATER_THAN" /* GREATER_THAN */, value: ">", position: start };
+      case "?":
+        if (this.peek() === "?" && this.peekAhead(2) === "=") {
+          this.position += 3;
+          return {
+            type: "NULLISH_ASSIGN" /* NULLISH_ASSIGN */,
+            value: "??=",
+            position: start
+          };
+        }
+        this.position++;
+        return { type: "QUESTION" /* QUESTION */, value: "?", position: start };
+      case ":":
+        this.position++;
+        return { type: "COLON" /* COLON */, value: ":", position: start };
       case ",":
         this.position++;
         return { type: "COMMA" /* COMMA */, value: ",", position: start };
       case ";":
         this.position++;
         return this.nextToken();
+      case "&":
+        if (this.peek() === "&") {
+          this.position += 2;
+          return { type: "LOGICAL_AND" /* LOGICAL_AND */, value: "&&", position: start };
+        }
+        throw new Error(`Unexpected character '${char}' at position ${start}`);
+      case "|":
+        if (this.peek() === "|") {
+          this.position += 2;
+          return { type: "LOGICAL_OR" /* LOGICAL_OR */, value: "||", position: start };
+        }
+        throw new Error(`Unexpected character '${char}' at position ${start}`);
       default:
         throw new Error(`Unexpected character '${char}' at position ${start}`);
     }
@@ -389,6 +532,9 @@ class Lexer {
   peek() {
     return this.getCharAt(this.position + 1);
   }
+  peekAhead(n) {
+    return this.getCharAt(this.position + n);
+  }
   isDigit(char) {
     return char >= "0" && char <= "9";
   }
@@ -442,12 +588,38 @@ class Parser {
         }
         const identName = left.name;
         this.advance();
-        const value = this.parseExpression(precedence + 1);
+        const value = this.parseExpression(precedence);
         left = {
           type: "Assignment",
           name: identName,
           value
         };
+      } else if (token.type === "NULLISH_ASSIGN" /* NULLISH_ASSIGN */) {
+        if (left.type !== "Identifier") {
+          throw new Error("Invalid assignment target");
+        }
+        const identName = left.name;
+        this.advance();
+        const value = this.parseExpression(precedence);
+        left = {
+          type: "NullishAssignment",
+          name: identName,
+          value
+        };
+      } else if (token.type === "QUESTION" /* QUESTION */) {
+        this.advance();
+        const consequent = this.parseExpression(0);
+        if (this.peek().type !== "COLON" /* COLON */) {
+          throw new Error("Expected : in ternary expression");
+        }
+        this.advance();
+        const alternate = this.parseExpression(precedence);
+        left = {
+          type: "ConditionalExpression",
+          condition: left,
+          consequent,
+          alternate
+        };
       } else if (this.isBinaryOperator(token.type)) {
         const operator = token.value;
         this.advance();
@@ -529,25 +701,39 @@ class Parser {
   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 2;
+        return 6;
       case "STAR" /* STAR */:
       case "SLASH" /* SLASH */:
       case "PERCENT" /* PERCENT */:
-        return 3;
+        return 7;
       case "CARET" /* CARET */:
-        return 4;
+        return 8;
       default:
         return 0;
     }
   }
   getUnaryPrecedence() {
-    return 5;
+    return 6;
   }
   isBinaryOperator(type) {
-    return type === "PLUS" /* PLUS */ || type === "MINUS" /* MINUS */ || type === "STAR" /* STAR */ || type === "SLASH" /* SLASH */ || type === "PERCENT" /* PERCENT */ || type === "CARET" /* CARET */;
+    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 */;
   }
   peek() {
     if (this.current >= this.tokens.length) {
@@ -593,6 +779,10 @@ class Executor {
       return this.executeFunctionCall(node);
     if (isAssignment(node))
       return this.executeAssignment(node);
+    if (isNullishAssignment(node))
+      return this.executeNullishAssignment(node);
+    if (isConditionalExpression(node))
+      return this.executeConditionalExpression(node);
     throw new Error(`Unknown node type`);
   }
   executeProgram(node) {
@@ -634,6 +824,22 @@ class Executor {
         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}`);
     }
@@ -661,6 +867,18 @@ class Executor {
     this.variables.set(node.name, value);
     return value;
   }
+  executeNullishAssignment(node) {
+    if (this.variables.has(node.name)) {
+      return this.variables.get(node.name);
+    }
+    const value = this.execute(node.value);
+    this.variables.set(node.name, value);
+    return value;
+  }
+  executeConditionalExpression(node) {
+    const condition = this.execute(node.condition);
+    return condition !== 0 ? this.execute(node.consequent) : this.execute(node.alternate);
+  }
 }
 function execute(source, context) {
   const ast = parseSource(source);
@@ -697,7 +915,7 @@ function analyzeProgram(node) {
     const stmt = node.statements[i];
     if (!stmt)
       continue;
-    if (isAssignment(stmt)) {
+    if (isAssignment(stmt) || isNullishAssignment(stmt)) {
       const varName = stmt.name;
       const count = assignmentCounts.get(varName) || 0;
       assignmentCounts.set(varName, count + 1);
@@ -784,7 +1002,7 @@ function collectDependencies(node, deps) {
   if (isNumberLiteral(node)) {
     return false;
   }
-  if (isAssignment(node)) {
+  if (isAssignment(node) || isNullishAssignment(node)) {
     return collectDependencies(node.value, deps);
   }
   if (isBinaryOp(node)) {
@@ -801,6 +1019,12 @@ function collectDependencies(node, deps) {
     }
     return true;
   }
+  if (isConditionalExpression(node)) {
+    const condHasCall = collectDependencies(node.condition, deps);
+    const consHasCall = collectDependencies(node.consequent, deps);
+    const altHasCall = collectDependencies(node.alternate, deps);
+    return condHasCall || consHasCall || altHasCall;
+  }
   if (isProgram(node)) {
     let hasCall = false;
     for (const stmt of node.statements) {
@@ -920,12 +1144,32 @@ function evaluateWithConstants(node, constants) {
       arguments: node.arguments.map((arg) => evaluateWithConstants(arg, constants))
     };
   }
+  if (isConditionalExpression(node)) {
+    const condition = evaluateWithConstants(node.condition, constants);
+    const consequent = evaluateWithConstants(node.consequent, constants);
+    const alternate = evaluateWithConstants(node.alternate, constants);
+    if (isNumberLiteral(condition)) {
+      return condition.value !== 0 ? consequent : alternate;
+    }
+    return {
+      ...node,
+      condition,
+      consequent,
+      alternate
+    };
+  }
   if (isAssignment(node)) {
     return {
       ...node,
       value: evaluateWithConstants(node.value, constants)
     };
   }
+  if (isNullishAssignment(node)) {
+    return {
+      ...node,
+      value: evaluateWithConstants(node.value, constants)
+    };
+  }
   return node;
 }
 function replaceWithConstants(node, constants) {
@@ -954,7 +1198,7 @@ function eliminateDeadCodeOptimal(node, analysis, allConstants) {
       filteredStatements.push(stmt);
       continue;
     }
-    if (isAssignment(stmt)) {
+    if (isAssignment(stmt) || isNullishAssignment(stmt)) {
       if (variablesInUse.has(stmt.name)) {
         filteredStatements.push(stmt);
       }
@@ -999,6 +1243,12 @@ function basicOptimize(node) {
       value: basicOptimize(node.value)
     };
   }
+  if (isNullishAssignment(node)) {
+    return {
+      ...node,
+      value: basicOptimize(node.value)
+    };
+  }
   if (isBinaryOp(node)) {
     const left = basicOptimize(node.left);
     const right = basicOptimize(node.right);
@@ -1028,6 +1278,20 @@ function basicOptimize(node) {
       arguments: node.arguments.map((arg) => basicOptimize(arg))
     };
   }
+  if (isConditionalExpression(node)) {
+    const condition = basicOptimize(node.condition);
+    const consequent = basicOptimize(node.consequent);
+    const alternate = basicOptimize(node.alternate);
+    if (isNumberLiteral(condition)) {
+      return condition.value !== 0 ? consequent : alternate;
+    }
+    return {
+      ...node,
+      condition,
+      consequent,
+      alternate
+    };
+  }
   if (isProgram(node)) {
     return {
       ...node,
@@ -1056,6 +1320,22 @@ function evaluateBinaryOp(operator, left, right) {
       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}`);
   }
@@ -1066,8 +1346,10 @@ export {
   isUnaryOp,
   isProgram,
   isNumberLiteral,
+  isNullishAssignment,
   isIdentifier,
   isFunctionCall,
+  isConditionalExpression,
   isBinaryOp,
   isAssignment,
   generate,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "littlewing",
-	"version": "0.4.2",
+	"version": "0.5.0",
 	"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",