Add XOR (^) and XOR assignment (^=) support:

- Tokenizer: Added Token::BitXor and Token::BitXorAssign.
- Parser: Added parse_bitwise_xor and integrated it into precedence.
- AST: Added Expr::BitXor and Expr::BitXorAssign.
- Evaluator: Implemented BinaryOp::BitXor and evaluate_bitxor_assign.
- Tests: Added unit tests for XOR and XOR assignment.

Author: ssrlive

src/core.rs

@@ -139,6 +139,7 @@ pub enum Expr {
     MulAssign(Box<Expr>, Box<Expr>),        // target, value
     DivAssign(Box<Expr>, Box<Expr>),        // target, value
     ModAssign(Box<Expr>, Box<Expr>),        // target, value
+    BitXorAssign(Box<Expr>, Box<Expr>),     // target, value
     Increment(Box<Expr>),
     Decrement(Box<Expr>),
     PostIncrement(Box<Expr>),
@@ -172,6 +173,7 @@ pub enum Expr {
     /// Logical operators with short-circuit semantics
     LogicalAnd(Box<Expr>, Box<Expr>),
     LogicalOr(Box<Expr>, Box<Expr>),
+    BitXor(Box<Expr>, Box<Expr>),
     Value(Value), // literal value
 }
 
@@ -194,6 +196,7 @@ pub enum BinaryOp {
     In,
     NullishCoalescing,
     Pow,
+    BitXor,
 }
 
 #[derive(Debug, Clone)]

src/core/eval.rs

@@ -1698,6 +1698,7 @@ pub fn evaluate_expr(env: &JSObjectDataPtr, expr: &Expr) -> Result<Value, JSErro
         Expr::PowAssign(target, value) => evaluate_pow_assign(env, target, value),
         Expr::DivAssign(target, value) => evaluate_div_assign(env, target, value),
         Expr::ModAssign(target, value) => evaluate_mod_assign(env, target, value),
+        Expr::BitXorAssign(target, value) => evaluate_bitxor_assign(env, target, value),
         Expr::Increment(expr) => evaluate_increment(env, expr),
         Expr::Decrement(expr) => evaluate_decrement(env, expr),
         Expr::PostIncrement(expr) => evaluate_post_increment(env, expr),
@@ -1719,6 +1720,7 @@ pub fn evaluate_expr(env: &JSObjectDataPtr, expr: &Expr) -> Result<Value, JSErro
             let l = evaluate_expr(env, left)?;
             if is_truthy(&l) { Ok(l) } else { evaluate_expr(env, right) }
         }
+        Expr::BitXor(left, right) => evaluate_binary(env, left, &crate::core::BinaryOp::BitXor, right),
         Expr::Index(obj, idx) => evaluate_index(env, obj, idx),
         Expr::Property(obj, prop) => evaluate_property(env, obj, prop),
         Expr::Call(func_expr, args) => match evaluate_call(env, func_expr, args) {
@@ -2237,6 +2239,52 @@ fn evaluate_mod_assign(env: &JSObjectDataPtr, target: &Expr, value: &Expr) -> Re
     Ok(result)
 }
 
+fn evaluate_bitxor_assign(env: &JSObjectDataPtr, target: &Expr, value: &Expr) -> Result<Value, JSError> {
+    // a ^= b is equivalent to a = a ^ b
+    let left_val = evaluate_expr(env, target)?;
+    let right_val = evaluate_expr(env, value)?;
+    let result = match (left_val, right_val) {
+        (Value::Number(ln), Value::Number(rn)) => {
+            let to_int32 = |n: f64| -> i32 {
+                if !n.is_finite() || n == 0.0 {
+                    return 0;
+                }
+                let two32 = 4294967296f64;
+                let int = n.trunc();
+                let int32bit = ((int % two32) + two32) % two32;
+                if int32bit >= 2147483648f64 {
+                    (int32bit - two32) as i32
+                } else {
+                    int32bit as i32
+                }
+            };
+            Value::Number((to_int32(ln) ^ to_int32(rn)) as f64)
+        }
+        (Value::BigInt(la), Value::BigInt(rb)) => {
+            let a = BigInt::parse_bytes(la.as_bytes(), 10).ok_or(raise_eval_error!("invalid bigint"))?;
+            let b = BigInt::parse_bytes(rb.as_bytes(), 10).ok_or(raise_eval_error!("invalid bigint"))?;
+            use std::ops::BitXor;
+            Value::BigInt(a.bitxor(&b).to_string())
+        }
+        (Value::BigInt(_), Value::Number(_)) | (Value::Number(_), Value::BigInt(_)) => {
+            return Err(raise_type_error!("Cannot mix BigInt and other types"));
+        }
+        _ => {
+            return Err(raise_eval_error!("Invalid operands for ^="));
+        }
+    };
+    match &result {
+        Value::Number(n) => {
+            let _ = evaluate_assignment_expr(env, target, &Expr::Number(*n))?;
+        }
+        Value::BigInt(s) => {
+            let _ = evaluate_assignment_expr(env, target, &Expr::BigInt(s.clone()))?;
+        }
+        _ => unreachable!(),
+    }
+    Ok(result)
+}
+
 fn evaluate_assignment_expr(env: &JSObjectDataPtr, target: &Expr, value: &Expr) -> Result<Value, JSError> {
     let val = evaluate_expr(env, value)?;
     match target {
@@ -3274,6 +3322,38 @@ fn evaluate_binary(env: &JSObjectDataPtr, left: &Expr, op: &BinaryOp, right: &Ex
                 _ => Ok(Value::Boolean(false)),
             }
         }
+        BinaryOp::BitXor => match (l, r) {
+            (Value::Number(ln), Value::Number(rn)) => {
+                // ToInt32 semantics for Number inputs
+                let to_int32 = |n: f64| -> i32 {
+                    if !n.is_finite() || n == 0.0 {
+                        return 0;
+                    }
+                    let two32 = 4294967296f64;
+                    let int = n.trunc();
+                    // modulo 2^32
+                    let int32bit = ((int % two32) + two32) % two32;
+                    if int32bit >= 2147483648f64 {
+                        (int32bit - two32) as i32
+                    } else {
+                        int32bit as i32
+                    }
+                };
+                let a = to_int32(ln);
+                let b = to_int32(rn);
+                Ok(Value::Number((a ^ b) as f64))
+            }
+            (Value::BigInt(la), Value::BigInt(rb)) => {
+                let a = BigInt::parse_bytes(la.as_bytes(), 10).ok_or(raise_eval_error!("invalid bigint"))?;
+                let b = BigInt::parse_bytes(rb.as_bytes(), 10).ok_or(raise_eval_error!("invalid bigint"))?;
+                use std::ops::BitXor;
+                Ok(Value::BigInt((a.bitxor(&b)).to_string()))
+            }
+            (Value::BigInt(_), Value::Number(_)) | (Value::Number(_), Value::BigInt(_)) => {
+                Err(raise_type_error!("Cannot mix BigInt and other types"))
+            }
+            _ => Err(raise_eval_error!("Bitwise XOR only supported for numbers or BigInt")),
+        },
         BinaryOp::In => {
             // Check if property exists in object
             match (l, r) {

src/core/parser.rs

@@ -99,6 +99,7 @@ pub fn parse_assignment(tokens: &mut Vec<Token>) -> Result<Expr, JSError> {
             Token::Assign
             | Token::LogicalAndAssign
             | Token::LogicalOrAssign
+            | Token::BitXorAssign
             | Token::NullishAssign
             | Token::AddAssign
             | Token::SubAssign
@@ -165,10 +166,29 @@ pub fn parse_assignment(tokens: &mut Vec<Token>) -> Result<Expr, JSError> {
             let right = parse_assignment(tokens)?;
             Ok(Expr::ModAssign(Box::new(left), Box::new(right)))
         }
+        Token::BitXorAssign => {
+            tokens.remove(0);
+            let right = parse_assignment(tokens)?;
+            Ok(Expr::BitXorAssign(Box::new(left), Box::new(right)))
+        }
         _ => Ok(left),
     }
 }
 
+fn parse_bitwise_xor(tokens: &mut Vec<Token>) -> Result<Expr, JSError> {
+    let left = parse_additive(tokens)?;
+    if tokens.is_empty() {
+        return Ok(left);
+    }
+    if matches!(tokens[0], Token::BitXor) {
+        tokens.remove(0);
+        let right = parse_bitwise_xor(tokens)?;
+        Ok(Expr::BitXor(Box::new(left), Box::new(right)))
+    } else {
+        Ok(left)
+    }
+}
+
 fn parse_logical_and(tokens: &mut Vec<Token>) -> Result<Expr, JSError> {
     let left = parse_comparison(tokens)?;
     if tokens.is_empty() {
@@ -212,7 +232,7 @@ fn parse_nullish(tokens: &mut Vec<Token>) -> Result<Expr, JSError> {
 }
 
 fn parse_comparison(tokens: &mut Vec<Token>) -> Result<Expr, JSError> {
-    let left = parse_additive(tokens)?;
+    let left = parse_bitwise_xor(tokens)?;
     if tokens.is_empty() {
         return Ok(left);
     }

src/core/token.rs

@@ -76,8 +76,10 @@ pub enum Token {
     LogicalNot,
     LogicalAnd,
     LogicalOr,
+    BitXor,
     LogicalAndAssign,
     LogicalOrAssign,
+    BitXorAssign,
     NullishAssign,
     AddAssign,
     SubAssign,
@@ -433,6 +435,16 @@ pub fn tokenize(expr: &str) -> Result<Vec<Token>, JSError> {
                     return Err(raise_tokenize_error!());
                 }
             }
+            '^' => {
+                // Recognize '^=' (bitwise XOR assignment) and '^' (bitwise XOR)
+                if i + 1 < chars.len() && chars[i + 1] == '=' {
+                    tokens.push(Token::BitXorAssign);
+                    i += 2;
+                } else {
+                    tokens.push(Token::BitXor);
+                    i += 1;
+                }
+            }
             '0'..='9' => {
                 let start = i;
                 // integer part (allow underscores as numeric separators)

tests/number_tests.rs

@@ -465,4 +465,40 @@ mod number_tests {
             }
         }
     }
+
+    #[test]
+    fn test_bitwise_xor_numbers() {
+        let script = "5 ^ 3";
+        let result = evaluate_script(script);
+        match result {
+            Ok(Value::Number(n)) => {
+                assert_eq!(n, 6.0); // 5 ^ 3 = 6
+            }
+            _ => panic!("Expected 5 ^ 3 to evaluate to 6, got {:?}", result),
+        }
+    }
+
+    #[test]
+    fn test_bitwise_xor_negative_numbers() {
+        let script = "-5 ^ 3";
+        let result = evaluate_script(script);
+        match result {
+            Ok(Value::Number(n)) => {
+                assert_eq!(n, -8.0); // -5 ^ 3 = -8
+            }
+            _ => panic!("Expected -5 ^ 3 to evaluate to -8, got {:?}", result),
+        }
+    }
+
+    #[test]
+    fn test_bitwise_xor_assignment() {
+        let script = "let a = 5; a ^= 3; a";
+        let result = evaluate_script(script);
+        match result {
+            Ok(Value::Number(n)) => {
+                assert_eq!(n, 6.0); // a = 5; a ^= 3; a = 6
+            }
+            _ => panic!("Expected a ^= 3 to evaluate to 6, got {:?}", result),
+        }
+    }
 }