diff --git a/CHANGELOG.md b/CHANGELOG.md
index 57f8ad30..0d03e048 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 
+### Changed
+
+- Normalized WASM interface to match Python API ([#120](https://github.com/developmentseed/cql2-rs/pull/120))
+  - Renamed `CQL2` to `Expr` for consistency with Python
+  - Changed `Expr.matches()` and `Expr.reduce()` to accept JS objects instead of strings
+  - Changed `Expr.to_json()` to return JS objects instead of strings
+
 ## [0.4.2] - 2025-11-12
 
 ### Changed
diff --git a/Cargo.lock b/Cargo.lock
index 84c8b6ac..e610e36a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -632,6 +632,8 @@ version = "0.4.2"
 dependencies = [
  "cql2",
  "getrandom 0.3.4",
+ "js-sys",
+ "serde-wasm-bindgen",
  "serde_json",
  "wasm-bindgen",
  "wasm-bindgen-test",
@@ -2306,6 +2308,17 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "serde-wasm-bindgen"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8302e169f0eddcc139c70f139d19d6467353af16f9fce27e8c30158036a1e16b"
+dependencies = [
+ "js-sys",
+ "serde",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "serde_core"
 version = "1.0.228"
diff --git a/cli/src/lib.rs b/cli/src/lib.rs
index decbb7b4..513044f9 100644
--- a/cli/src/lib.rs
+++ b/cli/src/lib.rs
@@ -92,8 +92,10 @@ impl Cli {
 
     pub fn run_inner(self) -> Result<()> {
         if let Some(filter_path) = self.filter.as_ref() {
-            use std::fs::File;
-            use std::io::{BufRead, BufReader};
+            use std::{
+                fs::File,
+                io::{BufRead, BufReader},
+            };
             // Use self.input as the CQL2 expression
             let expr_str = self.input.as_ref().ok_or_else(|| {
                 anyhow!("CQL2 expression required as positional argument when using --filter")
diff --git a/docs/index.md b/docs/index.md
index 67e3ede3..e5af8499 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -11,6 +11,15 @@
 {'op': '=', 'args': [{'property': 'landsat:scene_id'}, 'LC82030282019133LGN00']}
 ```
 
+## Javascript
+
+```js
+> import { Expr } from 'cql2-wasm';
+> const expr = new Expr("landsat:scene_id = 'LC82030282019133LGN00'");
+> expr.to_json()
+{'op': '=', 'args': [{'property': 'landsat:scene_id'}, 'LC82030282019133LGN00']}
+```
+
 ## CLI
 
 ```shell
diff --git a/docs/playground.md b/docs/playground.md
index 59744322..db7c9415 100644
--- a/docs/playground.md
+++ b/docs/playground.md
@@ -69,7 +69,7 @@
 </style>
 
 <script type="module">
-  import init, { CQL2 } from '../pkg/cql2_wasm.js';
+  import init, { Expr as CQL2 } from '../pkg/cql2_wasm.js';
 
   await init();
   window.CQL2 = CQL2;
diff --git a/src/duckdb.rs b/src/duckdb.rs
index 4496c913..bb73a1f9 100644
--- a/src/duckdb.rs
+++ b/src/duckdb.rs
@@ -1,9 +1,5 @@
-use crate::sql::func;
-use crate::Error;
-use crate::Expr;
-use crate::ToSqlAst;
-use sqlparser::ast::visit_expressions_mut;
-use sqlparser::ast::Expr as SqlExpr;
+use crate::{sql::func, Error, Expr, ToSqlAst};
+use sqlparser::ast::{visit_expressions_mut, Expr as SqlExpr};
 use std::ops::ControlFlow;
 
 /// Traits for generating SQL for DuckDB with Spatial Extension
diff --git a/src/expr.rs b/src/expr.rs
index a9e06f85..5b80a8ec 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -1,15 +1,16 @@
 use crate::{geometry::spatial_op, temporal::temporal_op, Error, Geometry, Validator};
-use geo_types::Geometry as GGeom;
-use geo_types::{coord, Rect};
+use geo_types::{coord, Geometry as GGeom, Rect};
 use json_dotpath::DotPaths;
 use like::Like;
 use pg_escape::{quote_identifier, quote_literal};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use std::collections::HashSet;
-use std::fmt::Debug;
-use std::ops::{Add, Deref};
-use std::str::FromStr;
+use std::{
+    collections::HashSet,
+    fmt::Debug,
+    ops::{Add, Deref},
+    str::FromStr,
+};
 use unaccent::unaccent;
 use wkt::TryFromWkt;
 
diff --git a/src/sql.rs b/src/sql.rs
index 8a3e9cc7..f79326ad 100644
--- a/src/sql.rs
+++ b/src/sql.rs
@@ -1,13 +1,11 @@
-use crate::Error;
-use crate::Expr;
-use crate::Geometry;
+use crate::{Error, Expr, Geometry};
 use pg_escape::quote_identifier;
-use sqlparser::ast::DataType::{Date, Timestamp};
-use sqlparser::ast::Expr::Value as ValExpr;
-use sqlparser::ast::Expr::{Cast, Nested};
 use sqlparser::ast::{
-    Array as SqlArray, BinaryOperator, CastKind, Expr as SqlExpr, FunctionArgumentList,
-    FunctionArguments, Ident, TimezoneInfo, Value,
+    Array as SqlArray, BinaryOperator, CastKind,
+    DataType::{Date, Timestamp},
+    Expr as SqlExpr,
+    Expr::{Cast, Nested, Value as ValExpr},
+    FunctionArgumentList, FunctionArguments, Ident, TimezoneInfo, Value,
 };
 use std::vec;
 
diff --git a/wasm/Cargo.toml b/wasm/Cargo.toml
index ad6db9ea..7b702c26 100644
--- a/wasm/Cargo.toml
+++ b/wasm/Cargo.toml
@@ -19,6 +19,7 @@ cql2 = { path = ".." }
 wasm-bindgen = "0.2"
 getrandom = { version = "0.3.3", features = ["wasm_js"] }
 serde_json = "1.0"
+serde-wasm-bindgen = "0.6"
 
 [dependencies.web-sys]
 version = "0.3.82"
@@ -26,3 +27,4 @@ features = ['Document', 'Element', 'HtmlElement', 'Node', 'Window']
 
 [dev-dependencies]
 wasm-bindgen-test = "0.3.34"
+js-sys = "0.3"
diff --git a/wasm/src/lib.rs b/wasm/src/lib.rs
index c77a502f..cb96db79 100644
--- a/wasm/src/lib.rs
+++ b/wasm/src/lib.rs
@@ -15,10 +15,10 @@ pub fn parse_json(s: &str) -> Result<CQL2Expression, JsError> {
     Ok(CQL2Expression(expr))
 }
 
-#[wasm_bindgen(js_name = CQL2)]
+#[wasm_bindgen(js_name = Expr)]
 pub struct CQL2Expression(cql2::Expr);
 
-#[wasm_bindgen(js_class = CQL2)]
+#[wasm_bindgen(js_class = Expr)]
 impl CQL2Expression {
     #[wasm_bindgen(constructor)]
     pub fn new(v: String) -> Result<CQL2Expression, JsError> {
@@ -42,12 +42,12 @@ impl CQL2Expression {
     /// Check if the expression matches the given item
     ///
     /// # Arguments
-    /// * `item` - JSON string representing the item to match against
-    pub fn matches(&self, item: Option<String>) -> Result<bool, JsError> {
-        let value = if let Some(item_str) = item {
-            Some(serde_json::from_str(&item_str)?)
-        } else {
+    /// * `item` - JavaScript object representing the item to match against
+    pub fn matches(&self, item: JsValue) -> Result<bool, JsError> {
+        let value = if item.is_null() || item.is_undefined() {
             None
+        } else {
+            Some(serde_wasm_bindgen::from_value(item)?)
         };
         Ok(self.0.clone().matches(value.as_ref())?)
     }
@@ -55,20 +55,21 @@ impl CQL2Expression {
     /// Reduce the expression, optionally with an item context
     ///
     /// # Arguments
-    /// * `item` - Optional JSON string representing the item context for reduction
-    pub fn reduce(&self, item: Option<String>) -> Result<CQL2Expression, JsError> {
-        let value = if let Some(item_str) = item {
-            Some(serde_json::from_str(&item_str)?)
-        } else {
+    /// * `item` - JavaScript object representing the item context for reduction
+    pub fn reduce(&self, item: JsValue) -> Result<CQL2Expression, JsError> {
+        let value = if item.is_null() || item.is_undefined() {
             None
+        } else {
+            Some(serde_wasm_bindgen::from_value(item)?)
         };
         let r = self.0.clone().reduce(value.as_ref())?;
         Ok(CQL2Expression(r))
     }
 
-    pub fn to_json(&self) -> Result<String, JsError> {
+    pub fn to_json(&self) -> Result<JsValue, JsError> {
         let r = self.0.to_json()?;
-        Ok(r)
+        let js_value = serde_wasm_bindgen::to_value(&r)?;
+        Ok(js_value)
     }
 
     pub fn to_json_pretty(&self) -> Result<String, JsError> {
diff --git a/wasm/tests/common/mod.rs b/wasm/tests/common/mod.rs
index cdf99ca1..e8fa23d5 100644
--- a/wasm/tests/common/mod.rs
+++ b/wasm/tests/common/mod.rs
@@ -6,6 +6,8 @@
 #![cfg(target_arch = "wasm32")]
 
 use cql2_wasm::{parse_json, parse_text, CQL2Expression};
+use js_sys;
+use wasm_bindgen::JsValue;
 use wasm_bindgen_test::*;
 
 #[wasm_bindgen_test]
@@ -40,8 +42,11 @@ fn test_to_json() {
     let expr =
         CQL2Expression::new("landsat:scene_id = 'LC82030282019133LGN00'".to_string()).unwrap();
     let json = expr.to_json().unwrap();
-    assert!(json.contains("landsat:scene_id"));
-    assert!(json.contains("LC82030282019133LGN00"));
+    // Convert JsValue to JSON string for validation
+    let json_str = js_sys::JSON::stringify(&json).unwrap();
+    let json_str = json_str.as_string().unwrap();
+    assert!(json_str.contains("landsat:scene_id"));
+    assert!(json_str.contains("LC82030282019133LGN00"));
 }
 
 #[wasm_bindgen_test]
@@ -75,7 +80,9 @@ fn test_to_sql() {
 fn test_matches_with_matching_item() {
     let expr = CQL2Expression::new("id = 1".to_string()).unwrap();
     let item = r#"{"id": 1, "name": "test"}"#;
-    let result = expr.matches(Some(item.to_string())).unwrap();
+    let value: serde_json::Value = serde_json::from_str(item).unwrap();
+    let js_value: JsValue = serde_wasm_bindgen::to_value(&value).unwrap();
+    let result = expr.matches(js_value).unwrap();
     assert!(result);
 }
 
@@ -83,21 +90,23 @@ fn test_matches_with_matching_item() {
 fn test_matches_with_non_matching_item() {
     let expr = CQL2Expression::new("id = 1".to_string()).unwrap();
     let item = r#"{"id": 2, "name": "test"}"#;
-    let result = expr.matches(Some(item.to_string())).unwrap();
+    let value: serde_json::Value = serde_json::from_str(item).unwrap();
+    let js_value: JsValue = serde_wasm_bindgen::to_value(&value).unwrap();
+    let result = expr.matches(js_value).unwrap();
     assert!(!result);
 }
 
 #[wasm_bindgen_test]
 fn test_matches_without_item() {
     let expr = CQL2Expression::new("true".to_string()).unwrap();
-    let result = expr.matches(None).unwrap();
+    let result = expr.matches(JsValue::NULL).unwrap();
     assert!(result);
 }
 
 #[wasm_bindgen_test]
 fn test_reduce_without_item() {
     let expr = CQL2Expression::new("1 + 2".to_string()).unwrap();
-    let reduced = expr.reduce(None).unwrap();
+    let reduced = expr.reduce(JsValue::NULL).unwrap();
     let text = reduced.to_text().unwrap();
     assert_eq!(text, "3");
 }
@@ -106,7 +115,9 @@ fn test_reduce_without_item() {
 fn test_reduce_with_item() {
     let expr = CQL2Expression::new("id + 10".to_string()).unwrap();
     let item = r#"{"id": 5}"#;
-    let reduced = expr.reduce(Some(item.to_string())).unwrap();
+    let value: serde_json::Value = serde_json::from_str(item).unwrap();
+    let js_value: JsValue = serde_wasm_bindgen::to_value(&value).unwrap();
+    let reduced = expr.reduce(js_value).unwrap();
     let text = reduced.to_text().unwrap();
     assert_eq!(text, "15");
 }
diff --git a/wasm/tests/integration.mjs b/wasm/tests/integration.mjs
index f41bb5a1..48f9e928 100644
--- a/wasm/tests/integration.mjs
+++ b/wasm/tests/integration.mjs
@@ -11,7 +11,7 @@ import { strict as assert } from 'assert';
 import { readFile } from 'fs/promises';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
-import initModule, { CQL2, parseText, parseJson } from '../pkg/cql2_wasm.js';
+import initModule, { Expr, parseText, parseJson } from "../pkg/cql2_wasm.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -56,28 +56,29 @@ await (async () => {
   });
 
   await test('CQL2 is a constructor', () => {
-    assert.equal(typeof CQL2, 'function');
+    assert.equal(typeof Expr, "function");
   });
 
   // Test parseText function
-  await test('parseText() parses CQL2 text format', () => {
+  await test("parseText() parses CQL2 text format", () => {
     const expr = parseText("landsat:scene_id = 'LC82030282019133LGN00'");
     assert.ok(expr);
-    assert.ok(expr instanceof CQL2);
+    assert.ok(expr instanceof Expr);
   });
 
-  await test('parseText() handles complex syntax', () => {
+  await test("parseText() handles complex syntax", () => {
     // The parser is quite lenient, so we test it handles various inputs
     const expr = parseText("id = 1 AND name = 'test'");
     assert.ok(expr);
   });
 
   // Test parseJson function
-  await test('parseJson() parses CQL2 JSON format', () => {
-    const json = '{"op":"=","args":[{"property":"landsat:scene_id"},"LC82030282019133LGN00"]}';
+  await test("parseJson() parses CQL2 JSON format", () => {
+    const json =
+      '{"op":"=","args":[{"property":"landsat:scene_id"},"LC82030282019133LGN00"]}';
     const expr = parseJson(json);
     assert.ok(expr);
-    assert.ok(expr instanceof CQL2);
+    assert.ok(expr instanceof Expr);
   });
 
   await test('parseJson() throws on invalid JSON', () => {
@@ -87,120 +88,117 @@ await (async () => {
   });
 
   // Test CQL2 constructor
-  await test('new CQL2() creates expression from text', () => {
-    const expr = new CQL2("id = 1");
+  await test("new CQL2() creates expression from text", () => {
+    const expr = new Expr("id = 1");
     assert.ok(expr);
-    assert.ok(expr instanceof CQL2);
+    assert.ok(expr instanceof Expr);
   });
 
-  await test('new CQL2() handles various operators', () => {
-    const expr = new CQL2("value > 100");
+  await test("new CQL2() handles various operators", () => {
+    const expr = new Expr("value > 100");
     assert.ok(expr);
-    assert.ok(expr instanceof CQL2);
+    assert.ok(expr instanceof Expr);
   });
 
   // Test validate() method
-  await test('validate() method exists and works', () => {
-    const expr = new CQL2("id = 1");
-    assert.equal(typeof expr.validate, 'function');
+  await test("validate() method exists and works", () => {
+    const expr = new Expr("id = 1");
+    assert.equal(typeof expr.validate, "function");
     expr.validate(); // Should not throw
   });
 
-  await test('validate() validates against JSON schema', () => {
-    const expr = new CQL2("landsat:scene_id = 'LC82030282019133LGN00'");
+  await test("validate() validates against JSON schema", () => {
+    const expr = new Expr("landsat:scene_id = 'LC82030282019133LGN00'");
     expr.validate(); // Should not throw
   });
 
   // Test is_valid() method
-  await test('is_valid() method exists and returns boolean', () => {
-    const expr = new CQL2("id = 1");
-    assert.equal(typeof expr.is_valid, 'function');
-    assert.equal(typeof expr.is_valid(), 'boolean');
+  await test("is_valid() method exists and returns boolean", () => {
+    const expr = new Expr("id = 1");
+    assert.equal(typeof expr.is_valid, "function");
+    assert.equal(typeof expr.is_valid(), "boolean");
   });
 
-  await test('is_valid() returns true for valid expression', () => {
-    const expr = new CQL2("id = 1");
+  await test("is_valid() returns true for valid expression", () => {
+    const expr = new Expr("id = 1");
     assert.equal(expr.is_valid(), true);
   });
 
   // Test matches() method
-  await test('matches() method exists', () => {
-    const expr = new CQL2("id = 1");
-    assert.equal(typeof expr.matches, 'function');
+  await test("matches() method exists", () => {
+    const expr = new Expr("id = 1");
+    assert.equal(typeof expr.matches, "function");
   });
 
-  await test('matches() returns true for matching item', () => {
-    const expr = new CQL2("id = 1");
-    const item = JSON.stringify({ id: 1, name: "test" });
-    const result = expr.matches(item);
+  await test("matches() returns true for matching item", () => {
+    const expr = new Expr("id = 1");
+    const result = expr.matches({ id: 1, name: "test" });
     assert.equal(result, true);
   });
 
-  await test('matches() returns false for non-matching item', () => {
-    const expr = new CQL2("id = 1");
-    const item = JSON.stringify({ id: 2, name: "test" });
-    const result = expr.matches(item);
+  await test("matches() returns false for non-matching item", () => {
+    const expr = new Expr("id = 1");
+    const result = expr.matches({ id: 2, name: "test" });
     assert.equal(result, false);
   });
 
-  await test('matches() works without item (null/undefined)', () => {
-    const expr = new CQL2("true");
+  await test("matches() works without item (null/undefined)", () => {
+    const expr = new Expr("true");
     const result = expr.matches(null);
     assert.equal(result, true);
   });
 
   // Test reduce() method
-  await test('reduce() method exists', () => {
-    const expr = new CQL2("1 + 2");
-    assert.equal(typeof expr.reduce, 'function');
+  await test("reduce() method exists", () => {
+    const expr = new Expr("1 + 2");
+    assert.equal(typeof expr.reduce, "function");
   });
 
-  await test('reduce() simplifies expressions without item', () => {
-    const expr = new CQL2("1 + 2");
+  await test("reduce() simplifies expressions without item", () => {
+    const expr = new Expr("1 + 2");
     const reduced = expr.reduce(null);
-    assert.ok(reduced instanceof CQL2);
+    assert.ok(reduced instanceof Expr);
     const text = reduced.to_text();
     assert.equal(text, "3");
   });
 
-  await test('reduce() simplifies expressions with item context', () => {
-    const expr = new CQL2("id + 10");
-    const item = JSON.stringify({ id: 5 });
-    const reduced = expr.reduce(item);
+  await test("reduce() simplifies expressions with item context", () => {
+    const expr = new Expr("id + 10");
+    const reduced = expr.reduce({ id: 5 });
     const text = reduced.to_text();
     assert.equal(text, "15");
   });
 
   // Test to_json() method
-  await test('to_json() method exists and returns string', () => {
-    const expr = new CQL2("id = 1");
-    assert.equal(typeof expr.to_json, 'function');
+  await test("to_json() method exists and returns string", () => {
+    const expr = new Expr("id = 1");
+    assert.equal(typeof expr.to_json, "function");
     const json = expr.to_json();
-    assert.equal(typeof json, 'string');
+    assert.equal(typeof json, "string");
   });
 
-  await test('to_json() returns valid JSON', () => {
-    const expr = new CQL2("landsat:scene_id = 'LC82030282019133LGN00'");
+  await test("to_json() returns valid JSON", () => {
+    const expr = new Expr("landsat:scene_id = 'LC82030282019133LGN00'");
     const json = expr.to_json();
     const parsed = JSON.parse(json); // Should not throw
     assert.ok(parsed.args);
   });
 
   // Test to_json_pretty() method
-  await test('to_json_pretty() method exists and returns formatted JSON', () => {
-    const expr = new CQL2("id = 1");
-    assert.equal(typeof expr.to_json_pretty, 'function');
+  await test("to_json_pretty() method exists and returns formatted JSON", () => {
+    const expr = new Expr("id = 1");
+    assert.equal(typeof expr.to_json_pretty, "function");
     const json = expr.to_json_pretty();
-    assert.equal(typeof json, 'string');
-    assert.ok(json.includes('\n')); // Should have newlines
+    assert.equal(typeof json, "string");
+    assert.ok(json.includes("\n")); // Should have newlines
   });
 
   // Test to_text() method
-  await test('to_text() method exists and returns string', () => {
-    const expr = new CQL2("id = 1");
-    assert.equal(typeof expr.to_text, 'function');
+  await test("to_text() method exists and returns string", () => {
+    const expr = new Expr("id = 1");
+    assert.equal(typeof expr.to_text, "function");
     const text = expr.to_text();
-    assert.equal(typeof text, 'string');
+    assert.equal(typeof text, "string");
   });
 
   await test('to_text() converts JSON to text format', () => {
@@ -212,31 +210,33 @@ await (async () => {
   });
 
   // Test to_sql() method
-  await test('to_sql() method exists and returns string', () => {
-    const expr = new CQL2("id = 1");
-    assert.equal(typeof expr.to_sql, 'function');
+  await test("to_sql() method exists and returns string", () => {
+    const expr = new Expr("id = 1");
+    assert.equal(typeof expr.to_sql, "function");
     const sql = expr.to_sql();
-    assert.equal(typeof sql, 'string');
+    assert.equal(typeof sql, "string");
   });
 
-  await test('to_sql() converts expression to SQL', () => {
-    const expr = new CQL2("landsat:scene_id = 'LC82030282019133LGN00'");
+  await test("to_sql() converts expression to SQL", () => {
+    const expr = new Expr("landsat:scene_id = 'LC82030282019133LGN00'");
     const sql = expr.to_sql();
-    assert.ok(sql.includes("landsat:scene_id") || sql.includes("landsat_scene_id"));
+    assert.ok(
+      sql.includes("landsat:scene_id") || sql.includes("landsat_scene_id")
+    );
     assert.ok(sql.includes("LC82030282019133LGN00"));
   });
 
   // Test add() method
-  await test('add() method exists', () => {
-    const expr1 = new CQL2("id = 1");
-    assert.equal(typeof expr1.add, 'function');
+  await test("add() method exists", () => {
+    const expr1 = new Expr("id = 1");
+    assert.equal(typeof expr1.add, "function");
   });
 
-  await test('add() combines two expressions with AND', () => {
-    const expr1 = new CQL2("id = 1");
-    const expr2 = new CQL2("name = 'test'");
+  await test("add() combines two expressions with AND", () => {
+    const expr1 = new Expr("id = 1");
+    const expr2 = new Expr("name = 'test'");
     const combined = expr1.add(expr2);
-    assert.ok(combined instanceof CQL2);
+    assert.ok(combined instanceof Expr);
     const text = combined.to_text();
     assert.ok(text.includes("id"));
     assert.ok(text.includes("name"));
@@ -244,22 +244,22 @@ await (async () => {
   });
 
   // Test equals() method
-  await test('equals() method exists and returns boolean', () => {
-    const expr1 = new CQL2("id = 1");
-    const expr2 = new CQL2("id = 1");
-    assert.equal(typeof expr1.equals, 'function');
-    assert.equal(typeof expr1.equals(expr2), 'boolean');
+  await test("equals() method exists and returns boolean", () => {
+    const expr1 = new Expr("id = 1");
+    const expr2 = new Expr("id = 1");
+    assert.equal(typeof expr1.equals, "function");
+    assert.equal(typeof expr1.equals(expr2), "boolean");
   });
 
-  await test('equals() returns true for identical expressions', () => {
-    const expr1 = new CQL2("id = 1");
-    const expr2 = new CQL2("id = 1");
+  await test("equals() returns true for identical expressions", () => {
+    const expr1 = new Expr("id = 1");
+    const expr2 = new Expr("id = 1");
     assert.equal(expr1.equals(expr2), true);
   });
 
-  await test('equals() returns false for different expressions', () => {
-    const expr1 = new CQL2("id = 1");
-    const expr2 = new CQL2("id = 2");
+  await test("equals() returns false for different expressions", () => {
+    const expr1 = new Expr("id = 1");
+    const expr2 = new Expr("id = 2");
     assert.equal(expr1.equals(expr2), false);
   });