perf: optimize tokenizer and parser performance

.github/workflows/ci.yml

@@ -34,8 +34,8 @@ jobs:
       - name: Run tests
         run: pnpm test
 
-      - name: Run benchmarks
-        run: pnpm run benchmark
-
       - name: Build package
         run: pnpm run build
+
+      - name: Run benchmarks
+        run: pnpm run benchmark

README.md

@@ -9,7 +9,7 @@ Now we have solved this problem for you. We have designed a simple and easy-to-u
 - 🔒 **Secure by default** - No access to global objects or prototype chain, does not use `eval` or `new Function`
 - 🚀 **High performance** - Supports pre-compilation of expressions for improved performance with repeated evaluations
 - 🛠️ **Extensible** - Register custom functions to easily extend functionality
-- 🪩 **Lightweight** - Zero dependencies, small footprint
+- 🪩 **Lightweight** - Zero dependencies, small footprint, only 7.8KB
 
 ## Installation
 
@@ -174,6 +174,17 @@ const result = evaluate('@formatCurrency(price * quantity)', {
 ```
 **Default Global Functions:** `['abs', 'ceil', 'floor', 'round', 'sqrt', 'pow', 'max', 'min']`
 
+## Benchmarks
+
+Performance comparison of different evaluation methods: (baseline: new Function)
+
+| Expression Type       | new Function vs evaluate after compile | new Function vs evaluate without compile | new Function vs [expr-eval](https://www.npmjs.com/package/expr-eval?activeTab=readme) Parser |
+|-----------------------|----------------------------------------|------------------------------------------|----------------------------------|
+| Simple Expressions    | 1.59x faster                          | 6.36x faster                             | 23.94x faster                    |
+| Medium Expressions    | 2.16x faster                          | 9.81x faster                            | 37.81x faster                    |
+| Complex Expressions   | 1.59x faster                          | 4.89x faster                             | 32.74x faster                    |
+
+
 ## Advanced Usage
 
 ### Timeout Handling

bench/expr.bench.ts

@@ -1,5 +1,6 @@
+import { Parser } from "expr-eval";
 import { bench, describe } from "vitest";
-import { compile, evaluate, register } from "../src";
+import { compile, evaluate, register } from "../dist/index.esm.js";
 
 const context = {
 	user: {
@@ -27,7 +28,6 @@ const context = {
 	},
 };
 
-// 测试表达式
 const simpleExpression = "user.age + 5";
 const mediumExpression = 'user.scores[2] > 80 ? "Good" : "Needs improvement"';
 const complexExpression =
@@ -38,12 +38,15 @@ const complexExpression2 =
 
 const simpleExpressionCompiler = compile(simpleExpression);
 const mediumExpressionCompiler = compile(mediumExpression);
-const complexExpression2Compiler = compile(complexExpression);
+const complexExpressionCompiler = compile(complexExpression);
 
 register("calculateTotal", context.calculateTotal);
 register("applyDiscount", context.applyDiscount);
 
-// 创建 Function 对象
+const parser = new Parser();
+parser.functions.calculateTotal = context.calculateTotal;
+parser.functions.applyDiscount = context.applyDiscount;
+
 const newFunctionSimple = new Function(
 	"context",
 	`with(context) { return ${simpleExpression}; }`,
@@ -58,43 +61,67 @@ const newFunctionComplex = new Function(
 );
 
 describe("Simple Expression Benchmarks", () => {
-	bench("evaluate after compile (baseline)", () => {
+	bench("evaluate after compile (baseline) only interpreter", () => {
 		simpleExpressionCompiler(context);
 	});
 
 	bench("new Function (vs evaluate)", () => {
 		newFunctionSimple(context);
 	});
 
-	bench("evaluate without compile (vs evaluate)", () => {
-		evaluate(simpleExpression, context);
+	bench(
+		"evaluate without compile (vs evaluate) tokenize + parse + interpreter",
+		() => {
+			evaluate(simpleExpression, context);
+		},
+	);
+
+	bench("expr-eval Parser (vs evaluate)", () => {
+		// @ts-ignore
+		Parser.evaluate(simpleExpression, context);
 	});
 });
 
 describe("Medium Expression Benchmarks", () => {
-	bench("evaluate after compile (baseline)", () => {
+	bench("evaluate after compile (baseline) only interpreter", () => {
 		mediumExpressionCompiler(context);
 	});
 
 	bench("new Function (vs evaluate)", () => {
 		newFunctionMedium(context);
 	});
 
-	bench("evaluate without compile (vs evaluate)", () => {
-		evaluate(mediumExpression, context);
+	bench(
+		"evaluate without compile (vs evaluate) tokenize + parse + interpreter",
+		() => {
+			evaluate(mediumExpression, context);
+		},
+	);
+
+	bench("expr-eval Parser (vs evaluate)", () => {
+		// @ts-ignore
+		Parser.evaluate(mediumExpression, context);
 	});
 });
 
 describe("Complex Expression Benchmarks", () => {
-	bench("evaluate after compile (baseline)", () => {
-		complexExpression2Compiler(context);
+	bench("evaluate after compile (baseline) only interpreter", () => {
+		complexExpressionCompiler(context);
 	});
 
 	bench("new Function (vs evaluate)", () => {
 		newFunctionComplex(context);
 	});
 
-	bench("evaluate without compile (vs evaluate)", () => {
-		evaluate(complexExpression2, context);
+	bench(
+		"evaluate without compile (vs evaluate) tokenize + parse + interpreter",
+		() => {
+			evaluate(complexExpression2, context);
+		},
+	);
+
+	bench("expr-eval Parser (vs evaluate)", () => {
+		// @ts-ignore
+		parser.evaluate(complexExpression2, context);
 	});
 });

package.json

@@ -19,6 +19,7 @@
 		"@rollup/plugin-terser": "^0.4.4",
 		"@rollup/plugin-typescript": "^12.1.2",
 		"@vitest/coverage-v8": "^3.0.8",
+		"expr-eval": "^2.0.2",
 		"rollup": "^4.34.6",
 		"tslib": "^2.8.1",
 		"vitest": "^3.0.8"

src/interpreter.ts

@@ -1,13 +1,14 @@
-import type {
-	BinaryExpression,
-	CallExpression,
-	ConditionalExpression,
-	Expression,
-	Identifier,
-	Literal,
-	MemberExpression,
-	Program,
-	UnaryExpression,
+import {
+	type BinaryExpression,
+	type CallExpression,
+	type ConditionalExpression,
+	type Expression,
+	type Identifier,
+	type Literal,
+	type MemberExpression,
+	NodeType,
+	type Program,
+	type UnaryExpression,
 } from "./parser";
 import { ExpressionError } from "./utils";
 
@@ -225,19 +226,19 @@ export const evaluateAst = (
 	const evaluateNode = (node: Expression): unknown => {
 		try {
 			switch (node.type) {
-				case "Literal":
+				case NodeType.Literal:
 					return evaluateLiteral(node);
-				case "Identifier":
+				case NodeType.Identifier:
 					return evaluateIdentifier(node);
-				case "MemberExpression":
+				case NodeType.MemberExpression:
 					return evaluateMemberExpression(node);
-				case "CallExpression":
+				case NodeType.CallExpression:
 					return evaluateCallExpression(node);
-				case "BinaryExpression":
+				case NodeType.BinaryExpression:
 					return evaluateBinaryExpression(node);
-				case "UnaryExpression":
+				case NodeType.UnaryExpression:
 					return evaluateUnaryExpression(node);
-				case "ConditionalExpression":
+				case NodeType.ConditionalExpression:
 					return evaluateConditionalExpression(node);
 				default:
 					throw new ExpressionError(