@codehz/json-expr 0.5.5 → 0.6.0

package/README.md

@@ -41,7 +41,7 @@ const result = expr({ sum, product })("sum + product");
 
 // 编译表达式（可序列化为 JSON）
 const compiled = compile(result, { x, y });
-// => [["x", "y"], "$0+$1", "$0*$1", "$2+$3"]
+// => [["x", "y"], "$[0]+$[1]", "$[0]*$[1]", "$[2]+$[3]"]
 
 // 执行编译后的表达式
 const value = evaluate(compiled, { x: 2, y: 3 });
@@ -102,7 +102,7 @@ const array = expr({ x, y })("[x, y].filter(v => v > 0)");
 // 其中 $N 用于引用之前的变量或表达式
 
 const compiled = compile(result, { x, y });
-// [["x", "y"], "$0+$1", "$0*$1", "$2+$3"]
+// [["x", "y"], "$[0]+$[1]", "$[0]*$[1]", "$[2]+$[3]"]
 ```
 
 ## API 参考
@@ -156,7 +156,6 @@ const result = expr({ sum, x })("sum * x");
 - `variables` - 表达式中使用的所有变量映射或数组
 - `options` - 编译选项（可选）
   - `inline?: boolean` - 是否启用内联优化，将只被引用一次的子表达式内联到使用位置（默认：true）
-  - `shortCircuit?: boolean` - 是否启用短路求值，为 &&, ||, ??, 和三元表达式生成控制流节点（默认：true）
 
 **返回值：** CompiledData 数组
 
@@ -170,15 +169,11 @@ const product = expr({ x, y })("x * y");
 const result = expr({ sum, product })("sum + product");
 
 const compiled = compile(result, { x, y });
-// [["x", "y"], "$0+$1", "$0*$1", "$2+$3"]
+// [["x", "y"], "$[0]+$[1]", "$[0]*$[1]", "$[2]+$[3]"]
 
 // 禁用内联优化
 const noInline = compile(result, { x, y }, { inline: false });
-// [["x", "y"], "$0+$1", "$0*$1", "$2+$3"]
-
-// 禁用短路求值
-const noShortCircuit = compile(result, { x, y }, { shortCircuit: false });
-// 生成的表达式将使用直接的运算符而非控制流节点
+// [["x", "y"], "$[0]+$[1]", "$[0]*$[1]", "$[2]+$[3]"]
 ```
 
 ### `evaluate<TResult>(data: CompiledData, values: Record<string, unknown>): TResult`
@@ -601,11 +596,11 @@ const b = variable<boolean>();
 
 // 逻辑或短路
 const orExpr = expr({ a, b })("a || b");
-const compiled = compile(orExpr, { a, b }, { shortCircuit: true });
+const compiled = compile(orExpr, { a, b });
 
 // 当 a 为 true 时，b 不会被求值
 // 编译数据包含控制流节点：
-// [["a", "b"], ["br", "$0", 1], "$1", ["phi"]]
+// [["a", "b"], ["br", "$[0]", 1], "$[1]", ["phi"]]
 
 // 空值合并
 const x = variable<number | null>();
@@ -632,8 +627,8 @@ const product = expr({ x, y })("x * y");
 const result = expr({ sum, product })("sum + product");
 
 // 自动内联后，编译结果为：
-// [["x", "y"], "($0+$1)+($0*$1)"]
-// 而不是 [["x", "y"], "$0+$1", "$0*$1", "$2+$3"]
+// [["x", "y"], "($[0]+$[1])+($[0]*$[1])"]
+// 而不是 [["x", "y"], "$[0]+$[1]", "$[0]*$[1]", "$[2]+$[3]"]
 
 const compiled = compile(result, { x, y });
 const value = evaluate(compiled, { x: 2, y: 3 });
@@ -670,7 +665,7 @@ const compiled = compile(result, { x, y });
 
 // 序列化
 const json = JSON.stringify(compiled);
-// "[["x","y"],"$0+$1","$0*$1","$2+$3"]"
+// "[["x","y"],"$[0]+$[1]","$[0]*$[1]","$[2]+$[3]"]"
 
 // 存储或传输...
 
@@ -693,8 +688,8 @@ const sum = expr({ x, y })("x + y");
 const compiled = compile(sum, { x, y });
 
 // 输出
-// [["x", "y"], "$0+$1"]
-//  $0 引用 x，$1 引用 y
+// [["x", "y"], "$[0]+$[1]"]
+//  $[0] 引用 x，$[1] 引用 y
 ```
 
 ### V2 格式（控制流节点）
@@ -704,13 +699,13 @@ const compiled = compile(sum, { x, y });
 ```typescript
 // 输入
 const result = expr({ a, b })("a || b");
-const compiled = compile(result, { a, b }, { shortCircuit: true });
+const compiled = compile(result, { a, b });
 
 // 输出
 // [
 //   ["a", "b"],
-//   ["br", "$0", 1],  // 如果 $0 为 truthy，跳过 1 条指令
-//   "$1",             // 否则求值 $1
+//   ["br", "$[0]", 1],  // 如果 $[0] 为 truthy，跳过 1 条指令
+//   "$[1]",             // 否则求值 $[1]
 //   ["phi"]           // 取最近求值结果
 // ]
 ```
@@ -741,7 +736,7 @@ const xy = variable<number>();
 const conflict = expr({ xy, x })("xy + x");
 // 正确处理：编译器能区分 xy 和 x
 const compiled = compile(conflict, { xy, x });
-// => [["xy", "x"], "$0+$1"]
+// => [["xy", "x"], "$[0]+$[1]"]
 ```
 
 ### 运行时错误
@@ -895,11 +890,7 @@ const discount = evaluate(rule, {
    evaluate(compiled, values2);
    ```
 
-2. **合理使用短路求值**：对于条件表达式，启用短路求值可以避免不必要的计算
-
-   ```typescript
-   compile(expression, variables, { shortCircuit: true });
-   ```
+2. **利用短路求值**：短路求值已默认启用，对于条件表达式可以避免不必要的计算
 
 3. **利用自动内联**：编译器会自动内联只引用一次的子表达式，无需手动优化
 

package/dist/index.d.mts

@@ -12,9 +12,37 @@ type ProxyExpression<T = unknown> = {
  */
 type ProxifyArgs<T extends unknown[]> = { [K in keyof T]: T[K] | Proxify<T[K]> };
 /**
- * 需要特殊处理的数组方法名（有泛型参数，需要显式定义以保留类型推导）
+ * 需要保留泛型参数的数组方法名
+ * 这些方法需要显式定义以保留类型推导
+ */
+type GenericMethodNames = keyof GenericArrayMethods<unknown>;
+/**
+ * 泛型数组方法 - 需要手动定义以保留类型参数
+ */
+type GenericArrayMethods<E> = {
+  map<U>(fn: Proxify<(value: E, index: number, array: E[]) => U>): Proxify<U[]>;
+  flatMap<U>(fn: Proxify<(value: E, index: number, array: E[]) => U | readonly U[]>): Proxify<U[]>;
+  filter<S extends E>(predicate: Proxify<(value: E, index: number, array: E[]) => value is S>): Proxify<S[]>;
+  filter(predicate: Proxify<(value: E, index: number, array: E[]) => unknown>): Proxify<E[]>;
+  find(predicate: Proxify<(value: E, index: number, obj: E[]) => unknown>): Proxify<E | undefined>;
+  findLast(predicate: Proxify<(value: E, index: number, obj: E[]) => unknown>): Proxify<E | undefined>;
+  findIndex(predicate: Proxify<(value: E, index: number, obj: E[]) => unknown>): Proxify<number>;
+  findLastIndex(predicate: Proxify<(value: E, index: number, obj: E[]) => unknown>): Proxify<number>;
+  reduce<U>(fn: Proxify<(acc: U, val: E, idx: number, arr: E[]) => U>, init: U | Proxify<U>): Proxify<U>;
+  reduce(fn: Proxify<(acc: E, val: E, idx: number, arr: E[]) => E>): Proxify<E>;
+  reduceRight<U>(fn: Proxify<(acc: U, val: E, idx: number, arr: E[]) => U>, init: U | Proxify<U>): Proxify<U>;
+  reduceRight(fn: Proxify<(acc: E, val: E, idx: number, arr: E[]) => E>): Proxify<E>;
+  every(predicate: Proxify<(value: E, index: number, array: E[]) => unknown>): Proxify<boolean>;
+  some(predicate: Proxify<(value: E, index: number, array: E[]) => unknown>): Proxify<boolean>;
+  forEach(fn: Proxify<(value: E, index: number, array: E[]) => void>): Proxify<void>;
+  toSorted(compareFn?: Proxify<(a: E, b: E) => number>): Proxify<E[]>;
+  sort(compareFn?: Proxify<(a: E, b: E) => number>): Proxify<E[]>;
+};
+/**
+ * 通用方法/属性转换
+ * 将对象 T 的所有方法返回值和属性包装为 Proxify
  */
-type ProxifiedArrayMethods = "map" | "flatMap" | "filter" | "reduce" | "reduceRight" | "find" | "findIndex" | "findLast" | "findLastIndex" | "every" | "some" | "forEach" | "toSorted" | "sort";
+type ProxifyMethods<T> = { readonly [K in keyof T]: T[K] extends ((...args: infer A) => infer R) ? (...args: ProxifyArgs<A>) => Proxify<R> : Proxify<T[K]> };
 /**
  * 字符串类型的 Proxify 版本
  * 将所有字符串方法返回值包装为 Proxify
@@ -55,59 +83,26 @@ type ProxifiedString = {
   [key: string]: unknown;
 };
 /**
- * 数组类型的 Proxify 版本
- * 特殊处理泛型方法（map, filter 等），确保返回值类型正确
- */
-type ProxifiedArray<T> = {
-  map<U>(callbackfn: Proxify<(value: T, index: number, array: T[]) => U>): Proxify<U[]>;
-  flatMap<U>(callbackfn: Proxify<(value: T, index: number, array: T[]) => U | readonly U[]>): Proxify<U[]>;
-  filter<S extends T>(predicate: Proxify<(value: T, index: number, array: T[]) => value is S>): Proxify<S[]>;
-  filter(predicate: Proxify<(value: T, index: number, array: T[]) => unknown>): Proxify<T[]>;
-  reduce<U>(callbackfn: Proxify<(previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U>, initialValue: U | Proxify<U>): Proxify<U>;
-  reduce(callbackfn: Proxify<(previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T>): Proxify<T>;
-  reduceRight<U>(callbackfn: Proxify<(previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U>, initialValue: U | Proxify<U>): Proxify<U>;
-  reduceRight(callbackfn: Proxify<(previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T>): Proxify<T>;
-  find<S extends T>(predicate: Proxify<(value: T, index: number, obj: T[]) => value is S>): Proxify<S | undefined>;
-  find(predicate: Proxify<(value: T, index: number, obj: T[]) => unknown>): Proxify<T | undefined>;
-  findIndex(predicate: Proxify<(value: T, index: number, obj: T[]) => unknown>): Proxify<number>;
-  findLast<S extends T>(predicate: Proxify<(value: T, index: number, array: T[]) => value is S>): Proxify<S | undefined>;
-  findLast(predicate: Proxify<(value: T, index: number, array: T[]) => unknown>): Proxify<T | undefined>;
-  findLastIndex(predicate: Proxify<(value: T, index: number, array: T[]) => unknown>): Proxify<number>;
-  every<S extends T>(predicate: Proxify<(value: T, index: number, array: T[]) => value is S>): Proxify<boolean>;
-  every(predicate: Proxify<(value: T, index: number, array: T[]) => unknown>): Proxify<boolean>;
-  some(predicate: Proxify<(value: T, index: number, array: T[]) => unknown>): Proxify<boolean>;
-  forEach(callbackfn: Proxify<(value: T, index: number, array: T[]) => void>): Proxify<void>;
-  toSorted(compareFn?: Proxify<(a: T, b: T) => number>): Proxify<T[]>;
-  sort(compareFn?: Proxify<(a: T, b: T) => number>): Proxify<T[]>;
-} & { [K in Exclude<keyof T[], ProxifiedArrayMethods>]: Proxify<T[][K]> };
+ * 数组类型的 Proxify 版本 - 使用交叉类型
+ * 泛型方法单独定义 + 其他方法自动映射
+ */
+type ProxifiedArray<E> = GenericArrayMethods<E> & { [K in Exclude<keyof E[], GenericMethodNames>]: E[][K] extends ((...args: infer A) => infer R) ? (...args: ProxifyArgs<A>) => Proxify<R> : Proxify<E[][K]> };
 /**
  * 将类型 T 转换为 Proxy 包装类型
  * - 始终包含 ProxyExpression<T> 标记，用于 compile 函数类型检查
- * - 函数类型：保持函数签名，但参数允许 Proxy 或原始值，返回值递归应用 Proxify
  * - 字符串类型：使用 ProxifiedString 特殊处理字符串方法
  * - 数组类型：使用 ProxifiedArray 特殊处理泛型方法
- * - 对象类型：映射所有属性为 Proxify
+ * - 函数类型：保持函数签名，但参数允许 Proxy 或原始值，返回值递归应用 Proxify
+ * - 对象类型：使用 ProxifyMethods 映射所有属性
  * - 原始类型：保持不变（返回 ProxyExpression 包装）
  */
-type Proxify<T> = ProxyExpression<T> & (T extends string ? ProxifiedString : T extends ((...args: infer Args) => infer R) ? (...args: ProxifyArgs<Args>) => Proxify<R> : T extends readonly (infer E)[] ? ProxifiedArray<E> : T extends object ? { [K in keyof T]: Proxify<T[K]> } : unknown);
+type Proxify<T> = ProxyExpression<T> & (T extends string ? ProxifiedString : T extends readonly (infer E)[] ? ProxifiedArray<E> : T extends ((...args: infer Args) => infer R) ? (...args: ProxifyArgs<Args>) => Proxify<R> : T extends object ? ProxifyMethods<T> : unknown);
 /**
  * Variable 类型定义
  * 总是返回 Proxy 包装后的类型
  * @template T - 变量的值类型
  */
 type Variable<T = unknown> = Proxify<T>;
-/**
- * 表示一个表达式
- * @template TContext - 表达式上下文类型
- * @template TResult - 表达式结果类型
- * @deprecated 请使用新的 Proxy 类型系统
- */
-type Expression<TContext = Record<string, unknown>, TResult = unknown> = {
-  _tag: "expression";
-  context: TContext;
-  source: string;
-  _type: TResult;
-};
 /**
  * 条件跳转节点
  * 如果条件为 truthy，跳过 offset 条指令
@@ -128,9 +123,14 @@ type PhiNode = ["phi"];
  */
 type ControlFlowNode = BranchNode | JumpNode | PhiNode;
 /**
- * 表达式类型（可以是字符串或控制流节点）
+ * Lambda 函数节点
+ * ["fn", paramCount, ...stmts]
+ */
+type FnNode = ["fn", paramCount: number, ...stmts: CompiledExpression[]];
+/**
+ * 表达式类型（可以是字符串、控制流节点或 Lambda 节点）
  */
-type CompiledExpression = string | ControlFlowNode;
+type CompiledExpression = string | ControlFlowNode | FnNode;
 /**
  * 编译后的可序列化结构
  * 数组形式：[string[], ...expressions[]]
@@ -139,38 +139,6 @@ type CompiledExpression = string | ControlFlowNode;
  * - 表达式可以是字符串或控制流节点（br/jmp/phi）
  */
 type CompiledData = [variableNames: string[], ...expressions: CompiledExpression[]];
-/**
- * 内部表达式节点接口（供编译器使用）
- */
-interface ExprNode {
-  id: symbol;
-  tag: "variable" | "expression";
-  context?: Record<string, ExprNode>;
-  source?: string;
-}
-/**
- * 编译上下文接口（供编译器使用）
- */
-interface CompileContext {
-  variableOrder: string[];
-  nodeToIndex: Map<symbol, number>;
-  expressions: CompiledExpression[];
-}
-/**
- * 从 Variable 推导值类型
- * @template V - Variable 类型
- */
-type InferVariableType<V> = V extends Variable<infer T> ? T : never;
-/**
- * 从上下文对象推导各项的类型
- * @template C - 上下文对象类型
- */
-type InferContextType<C> = { [K in keyof C]: C[K] extends Variable<infer T> ? T : C[K] extends Expression<unknown, infer R> ? R : never };
-/**
- * 从 Expression 推导结果类型
- * @template E - Expression 类型
- */
-type InferExpressionType<E> = E extends Expression<unknown, infer R> ? R : never;
 /**
  * 递归地去除 Proxify 包装
  * 处理嵌套的对象和数组中的所有 Proxy 类型
@@ -195,19 +163,19 @@ type Primitive = string | number | boolean | null | undefined | symbol | bigint;
  */
 type DeepPartialProxy<T> = T extends Primitive ? T : T extends readonly (infer E)[] ? readonly (Proxify<E> | DeepPartialProxy<E>)[] : T extends object ? { [K in keyof T]: Proxify<T[K]> | DeepPartialProxy<T[K]> } : T;
 /**
- * Lambda 函数体返回值类型
- * 支持返回：
- * - Proxify<R>: 完整的代理表达式
+ * 表达式值类型
+ * 支持：
+ * - Proxify<T>: 完整的代理表达式
  * - 原始值: 字符串、数字等
  * - 对象/数组: 可以混合 Proxy 值和原始值
  */
-type LambdaBodyResult<T> = Proxify<T> | DeepPartialProxy<T>;
+type ExprValue<T> = Proxify<T> | DeepPartialProxy<T>;
 /**
  * Lambda 构建函数签名
  * @template Args - 参数类型元组
  * @template R - 返回值类型
  */
-type LambdaBuilder<Args extends unknown[], R> = (...params: { [K in keyof Args]: LambdaParam<Args[K]> }) => LambdaBodyResult<R>;
+type LambdaBuilder<Args extends unknown[], R> = (...params: { [K in keyof Args]: LambdaParam<Args[K]> }) => ExprValue<R>;
 /**
  * Lambda 表达式类型
  * 表示一个可序列化的函数
@@ -221,27 +189,12 @@ type InferLambdaArgs<L> = L extends Lambda<infer Args, unknown> ? Args : never;
  * 从 Lambda 类型提取返回类型
  */
 type InferLambdaReturn<L> = L extends Lambda<unknown[], infer R> ? R : never;
-/**
- * 常用 Lambda 类型别名
- */
-type MapCallback<T, R> = Lambda<[T, number, T[]], R>;
-type FilterCallback<T> = Lambda<[T, number, T[]], boolean>;
-type ReduceCallback<T, R> = Lambda<[R, T, number, T[]], R>;
-type FindCallback<T> = Lambda<[T, number, T[]], boolean>;
-type SortCallback<T> = Lambda<[T, T], number>;
 //#endregion
 //#region src/compile.d.ts
 /**
  * 编译选项
  */
-interface CompileOptions {
-  /**
-   * 是否启用短路求值
-   * 为 &&, ||, ??, 和三元表达式生成控制流节点
-   * @default true
-   */
-  shortCircuit?: boolean;
-}
+interface CompileOptions {}
 /**
  * 将 Proxy Expression 编译为可序列化的 JSON 结构
  *
@@ -260,10 +213,10 @@ interface CompileOptions {
  * const sum = expr({ x, y })("x + y")
  * const result = expr({ sum, x })("sum * x")
  * const compiled = compile(result, { x, y })
- * // => [["x", "y"], "($0+$1)*$0"]
+ * // => [["x", "y"], "($[0]+$[1])*$[0]"]
  * ```
  */
-declare function compile<TResult>(expression: LambdaBodyResult<TResult>, variables: Record<string, unknown>, options?: CompileOptions): CompiledData;
+declare function compile<TResult>(expression: ExprValue<TResult>, variables: Record<string, unknown>, _options?: CompileOptions): CompiledData;
 //#endregion
 //#region src/evaluate.d.ts
 /**
@@ -278,7 +231,7 @@ declare function compile<TResult>(expression: LambdaBodyResult<TResult>, variabl
  *
  * @example
  * ```ts
- * const compiled = [["x", "y"], "$0+$1", "$1*2"]
+ * const compiled = [["x", "y"], "$[0]+$[1]", "$[1]*2"]
  * const result = evaluate<number>(compiled, { x: 2, y: 3 })
  * // => 6  (3 * 2)
  * ```
@@ -314,8 +267,8 @@ type SkipTemplateStringContent<S extends string> = S extends `\\\`${infer Rest}`
  * 返回标识符的联合类型
  */
 type ExtractIdentifiers<S extends string, Collected extends string = never> = S extends "" ? Collected : TrimStart<S> extends `${infer Trimmed}` ? Trimmed extends "" ? Collected : Trimmed extends `'${string}` ? ExtractIdentifiers<SkipSingleQuoteString<Trimmed>, Collected> : Trimmed extends `"${string}` ? ExtractIdentifiers<SkipDoubleQuoteString<Trimmed>, Collected> : Trimmed extends `\`${string}` ? ExtractIdentifiers<SkipTemplateString<Trimmed>, Collected> : Trimmed extends `${infer First}${infer Rest}` ? IsIdentifierStart<First> extends true ? ParseIdentifier<Trimmed> extends [infer Id extends string, infer Remaining extends string] ? Id extends ReservedWords ? ExtractIdentifiers<Remaining, Collected> : ExtractIdentifiers<Remaining, Collected | Id> : Collected : IsDigit<First> extends true ? ExtractIdentifiers<SkipNumber<Trimmed>, Collected> : ExtractIdentifiers<Rest, Collected> : Collected : Collected;
-/** 从 Variable 或 Expression 提取值类型 */
-type ExtractType<T> = T extends ProxyExpression<infer V> ? V : T extends Variable<infer V> ? V : T extends Expression<unknown, infer R> ? R : never;
+/** 从 Variable 提取值类型 */
+type ExtractType<T> = T extends ProxyExpression<infer V> ? V : T extends Variable<infer V> ? V : never;
 /** 从上下文对象构建类型映射 */
 type ContextTypeMap<TContext> = { [K in keyof TContext]: ExtractType<TContext[K]> };
 /** 找出未定义的标识符 */
@@ -531,8 +484,6 @@ type ValidateExpression<Source extends string, TContext> = ExtractIdentifiers<So
 };
 /** 从表达式推导返回类型 */
 type InferExpressionResult<Source extends string, TContext> = InferTypeFromAST<ParseExpression<Source>, ContextTypeMap<TContext>>;
-/** 验证并推导表达式类型 */
-type ExpressionType<Source extends string, TContext> = ValidateExpression<Source, TContext> extends true ? InferExpressionResult<Source, TContext> : ValidateExpression<Source, TContext>;
 //#endregion
 //#region src/expr.d.ts
 /**
@@ -585,20 +536,6 @@ declare function expr<TContext extends Record<string, unknown>>(context: TContex
  */
 declare function lambda<Args extends unknown[], R>(builder: LambdaBuilder<Args, R>): Lambda<Args, R>;
 //#endregion
-//#region src/proxy-metadata.d.ts
-/**
- * 检查对象是否是 Proxy variable
- */
-declare function isProxyVariable(obj: unknown): obj is object;
-/**
- * 检查对象是否是 Proxy expression
- */
-declare function isProxyExpression(obj: unknown): obj is object;
-/**
- * 检查对象是否是任意 Proxy (variable 或 expression)
- */
-declare function isProxy(obj: unknown): obj is object;
-//#endregion
 //#region src/template.d.ts
 /**
  * Tagged template 函数，用于创建包含变量的字符串表达式
@@ -644,7 +581,7 @@ type InferVariableValues<T extends Record<string, Variable<unknown>>> = { [K in
  * );
  * ```
  */
-declare function compileAndEvaluate<TResult = unknown, TVars extends Record<string, Variable<unknown>> = Record<string, Variable<unknown>>>(expr: LambdaBodyResult<TResult>, variables: TVars, values: InferVariableValues<TVars>, options?: CompileOptions): UnproxyDeep<TResult>;
+declare function compileAndEvaluate<TResult = unknown, TVars extends Record<string, Variable<unknown>> = Record<string, Variable<unknown>>>(expr: ExprValue<TResult>, variables: TVars, values: InferVariableValues<TVars>, options?: CompileOptions): UnproxyDeep<TResult>;
 //#endregion
 //#region src/variable.d.ts
 /**
@@ -659,10 +596,6 @@ declare function compileAndEvaluate<TResult = unknown, TVars extends Record<stri
  * ```
  */
 declare function variable<T>(): Variable<T>;
-/**
- * 获取 variable 的唯一 Symbol ID
- */
-declare function getVariableId(variable: unknown): symbol | undefined;
 //#endregion
 //#region src/wrap.d.ts
 /**
@@ -691,5 +624,5 @@ declare function getVariableId(variable: unknown): symbol | undefined;
  */
 declare function wrap<T>(value: T): Proxify<T>;
 //#endregion
-export { type BranchNode, type CompileContext, type CompileOptions, type CompiledData, type CompiledExpression, type ContextTypeMap, type ControlFlowNode, type ExprNode, type Expression, type ExpressionType, type ExtractType, type FilterCallback, type FindCallback, type InferContextType, type InferExpressionResult, type InferExpressionType, type InferLambdaArgs, type InferLambdaReturn, type InferVariableType, type JumpNode, type Lambda, type LambdaBuilder, type LambdaParam, type MapCallback, type ParseExpression, type PhiNode, type Proxify, type ProxyExpression, type ReduceCallback, type SortCallback, type ValidateExpression, type Variable, compile, compileAndEvaluate, evaluate, expr, getVariableId, isProxy, isProxyExpression, isProxyVariable, lambda, t, variable, wrap };
+export { type CompileOptions, type CompiledData, type CompiledExpression, type ExprValue, type FnNode, type InferLambdaArgs, type InferLambdaReturn, type Lambda, type LambdaBuilder, type Proxify, type ProxyExpression, type Variable, compile, compileAndEvaluate, evaluate, expr, lambda, t, variable, wrap };
 //# sourceMappingURL=index.d.mts.map