@codehz/json-expr 0.5.6 → 0.6.1

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

@@ -1,16 +1,28 @@
 //#region src/types.d.ts
+declare const ProxyExpression: unique symbol;
 /**
  * Proxy Expression 类型标记（用于类型推导）
  * 这是一个 phantom type，实际运行时是 Proxy 对象
  */
 type ProxyExpression<T = unknown> = {
-  readonly __proxyExpression: T;
+  readonly [ProxyExpression]: T;
 };
+/**
+ * 特殊全局类型 - 这些类型作为参数时允许直接传入原始值
+ * 不需要递归展开其属性
+ */
+type BuiltinObjects = Date | RegExp | Error | URL | URLSearchParams | ArrayBuffer | SharedArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+/**
+ * 将数组/元组类型的每个元素转换为 ProxifyArg
+ * 保留元组的结构信息
+ */
+type ProxifyArgTuple<T extends readonly unknown[]> = T extends readonly [infer Head, ...infer Tail] ? [ProxifyArg<Head>, ...ProxifyArgTuple<Tail>] : T extends readonly [] ? [] : T extends readonly (infer E)[] ? readonly ProxifyArg<E>[] : never;
+type ProxifyArg<T> = Proxify<T> | (T extends BuiltinObjects | string | number | boolean | bigint | undefined | null ? T : T extends readonly unknown[] ? ProxifyArgTuple<T> : T extends Map<infer K, infer V> ? Map<ProxifyArg<K>, ProxifyArg<V>> : T extends Set<infer E> ? Set<ProxifyArg<E>> : T extends WeakMap<infer K, infer V> ? WeakMap<ProxifyArg<K>, ProxifyArg<V>> : T extends WeakSet<infer E> ? WeakSet<ProxifyArg<E>> : T extends Promise<infer R> ? Promise<ProxifyArg<R>> : T extends ((...args: infer _A) => infer _R) ? never : { [K in keyof T]: ProxifyArg<T[K]> });
 /**
  * 处理函数参数的 Proxy 转换
  * 参数可以是原始值或对应的 Proxy
  */
-type ProxifyArgs<T extends unknown[]> = { [K in keyof T]: T[K] | Proxify<T[K]> };
+type ProxifyArgs<T extends unknown[]> = { [K in keyof T]: ProxifyArg<T[K]> };
 /**
  * 需要保留泛型参数的数组方法名
  * 这些方法需要显式定义以保留类型推导
@@ -123,9 +135,14 @@ type PhiNode = ["phi"];
  */
 type ControlFlowNode = BranchNode | JumpNode | PhiNode;
 /**
- * 表达式类型（可以是字符串或控制流节点）
+ * Lambda 函数节点
+ * ["fn", paramCount, ...stmts]
  */
-type CompiledExpression = string | ControlFlowNode;
+type FnNode = ["fn", paramCount: number, ...stmts: CompiledExpression[]];
+/**
+ * 表达式类型（可以是字符串、控制流节点或 Lambda 节点）
+ */
+type CompiledExpression = string | ControlFlowNode | FnNode;
 /**
  * 编译后的可序列化结构
  * 数组形式：[string[], ...expressions[]]
@@ -134,15 +151,6 @@ type CompiledExpression = string | ControlFlowNode;
  * - 表达式可以是字符串或控制流节点（br/jmp/phi）
  */
 type CompiledData = [variableNames: string[], ...expressions: CompiledExpression[]];
-/**
- * 递归地去除 Proxify 包装
- * 处理嵌套的对象和数组中的所有 Proxy 类型
- * - 如果是 Proxify<T>，提取并返回 UnproxyDeep<T>
- * - 如果是对象，递归处理每个属性
- * - 如果是数组，递归处理元素
- * - 其他情况返回原值
- */
-type UnproxyDeep<T> = T extends ProxyExpression<infer U> ? UnproxyDeep<U> : T extends readonly (infer E)[] ? UnproxyDeep<E>[] : T extends object ? { [K in keyof T]: UnproxyDeep<T[K]> } : T;
 /**
  * Lambda 参数代理类型
  * 与普通 Proxify<T> 相同，但标记为 lambda 参数
@@ -185,62 +193,7 @@ type InferLambdaArgs<L> = L extends Lambda<infer Args, unknown> ? Args : never;
  */
 type InferLambdaReturn<L> = L extends Lambda<unknown[], infer R> ? R : never;
 //#endregion
-//#region src/compile.d.ts
-/**
- * 编译选项
- */
-interface CompileOptions {
-  /**
-   * 是否启用短路求值
-   * 为 &&, ||, ??, 和三元表达式生成控制流节点
-   * @default true
-   */
-  shortCircuit?: boolean;
-}
-/**
- * 将 Proxy Expression 编译为可序列化的 JSON 结构
- *
- * @template TResult - 表达式结果类型
- * @param expression - Proxy Expression，或包含 Proxy 的对象/数组/原始值
- * @param variables - 所有使用的变量定义
- * @param options - 编译选项
- * @returns 编译后的数据结构 [变量名列表, 表达式1, 表达式2, ...]
- *
- * @throws 如果传入无效的表达式或未定义的变量引用
- *
- * @example
- * ```ts
- * const x = variable<number>()
- * const y = variable<number>()
- * 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"]
- * ```
- */
-declare function compile<TResult>(expression: ExprValue<TResult>, variables: Record<string, unknown>, options?: CompileOptions): CompiledData;
-//#endregion
-//#region src/evaluate.d.ts
-/**
- * 执行编译后的表达式
- *
- * @template TResult - 表达式结果类型
- * @param data - 编译后的数据结构 [变量名列表, 表达式1, 表达式2, ...]
- * @param values - 变量值映射，按变量名提供值
- * @returns 最后一个表达式的求值结果
- *
- * @throws 如果运行时类型验证失败或表达式执行出错
- *
- * @example
- * ```ts
- * const compiled = [["x", "y"], "$0+$1", "$1*2"]
- * const result = evaluate<number>(compiled, { x: 2, y: 3 })
- * // => 6  (3 * 2)
- * ```
- */
-declare function evaluate<TResult = unknown>(data: CompiledData, values: Record<string, unknown>): TResult;
-//#endregion
-//#region src/type-parser.d.ts
+//#region src/types/type-parser/utils.d.ts
 /** 去除字符串两端空白 */
 type TrimStart<S extends string> = S extends ` ${infer Rest}` | `\t${infer Rest}` | `\n${infer Rest}` ? TrimStart<Rest> : S;
 /** 是否是字母或下划线 */
@@ -249,18 +202,47 @@ type IsIdentifierStart<C extends string> = C extends "a" | "b" | "c" | "d" | "e"
 type IsIdentifierChar<C extends string> = IsIdentifierStart<C> extends true ? true : C extends "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ? true : false;
 /** 是否是数字 */
 type IsDigit<C extends string> = C extends "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ? true : false;
+/** 全局类型映射 */
+interface GlobalTypeMap {
+  Math: Math;
+  JSON: JSON;
+  Number: NumberConstructor;
+  String: StringConstructor;
+  Boolean: BooleanConstructor;
+  Array: ArrayConstructor;
+  Object: ObjectConstructor;
+  Date: DateConstructor;
+  RegExp: RegExpConstructor;
+  undefined: undefined;
+  NaN: number;
+  Infinity: number;
+  parseInt: typeof globalThis.parseInt;
+  parseFloat: typeof globalThis.parseFloat;
+  isNaN: typeof globalThis.isNaN;
+  isFinite: typeof globalThis.isFinite;
+}
 /** JS保留字和全局对象 */
 type ReservedWords = "true" | "false" | "null" | "undefined" | "if" | "else" | "for" | "while" | "do" | "switch" | "case" | "break" | "continue" | "return" | "function" | "var" | "let" | "const" | "class" | "new" | "this" | "typeof" | "instanceof" | keyof GlobalTypeMap;
+//#endregion
+//#region src/types/type-parser/context.d.ts
+/** 从 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]> };
+/** 找出未定义的标识符 */
+type FindUndefinedIdentifiers<Ids extends string, ContextKeys extends string> = Ids extends ContextKeys ? never : Ids;
+//#endregion
+//#region src/types/type-parser/identifiers.d.ts
 /** 解析一个标识符，返回 [标识符, 剩余字符串] */
 type ParseIdentifier<S extends string, Acc extends string = ""> = S extends `${infer C}${infer Rest}` ? IsIdentifierChar<C> extends true ? ParseIdentifier<Rest, `${Acc}${C}`> : [Acc, S] : [Acc, S];
 /** 跳过数字字面量 */
 type SkipNumber<S extends string> = S extends `${infer C}${infer Rest}` ? C extends "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "." ? SkipNumber<Rest> : S : S;
 /** 跳过字符串字面量（单引号） */
-type SkipSingleQuoteString<S extends string> = S extends `'${infer Rest}` ? SkipSingleQuoteStringContent<Rest> : S;
-type SkipSingleQuoteStringContent<S extends string> = S extends `\\'${infer Rest}` ? SkipSingleQuoteStringContent<Rest> : S extends `'${infer Rest}` ? Rest : S extends `${string}${infer Rest}` ? SkipSingleQuoteStringContent<Rest> : S;
+type SkipSingleQuoteString<S extends string> = S extends `'${infer Rest}` ? SkipSingleQuoteStringContent$1<Rest> : S;
+type SkipSingleQuoteStringContent$1<S extends string> = S extends `\\'${infer Rest}` ? SkipSingleQuoteStringContent$1<Rest> : S extends `'${infer Rest}` ? Rest : S extends `${string}${infer Rest}` ? SkipSingleQuoteStringContent$1<Rest> : S;
 /** 跳过字符串字面量（双引号） */
-type SkipDoubleQuoteString<S extends string> = S extends `"${infer Rest}` ? SkipDoubleQuoteStringContent<Rest> : S;
-type SkipDoubleQuoteStringContent<S extends string> = S extends `\\"${infer Rest}` ? SkipDoubleQuoteStringContent<Rest> : S extends `"${infer Rest}` ? Rest : S extends `${string}${infer Rest}` ? SkipDoubleQuoteStringContent<Rest> : S;
+type SkipDoubleQuoteString<S extends string> = S extends `"${infer Rest}` ? SkipDoubleQuoteStringContent$1<Rest> : S;
+type SkipDoubleQuoteStringContent$1<S extends string> = S extends `\\"${infer Rest}` ? SkipDoubleQuoteStringContent$1<Rest> : S extends `"${infer Rest}` ? Rest : S extends `${string}${infer Rest}` ? SkipDoubleQuoteStringContent$1<Rest> : S;
 /** 跳过模板字符串 */
 type SkipTemplateString<S extends string> = S extends `\`${infer Rest}` ? SkipTemplateStringContent<Rest> : S;
 type SkipTemplateStringContent<S extends string> = S extends `\\\`${infer Rest}` ? SkipTemplateStringContent<Rest> : S extends `\`${infer Rest}` ? Rest : S extends `${string}${infer Rest}` ? SkipTemplateStringContent<Rest> : S;
@@ -269,12 +251,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 提取值类型 */
-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]> };
-/** 找出未定义的标识符 */
-type FindUndefinedIdentifiers<Ids extends string, ContextKeys extends string> = Ids extends ContextKeys ? never : Ids;
+//#endregion
+//#region src/types/type-parser/ast-types.d.ts
 interface ASTNumber {
   type: "number";
 }
@@ -335,7 +313,6 @@ interface ASTObject<Props extends Record<string, unknown> = Record<string, unkno
   type: "object";
   properties: Props;
 }
-/** 运算符优先级（从低到高） */
 /** 解析结果：[AST, 剩余字符串] */
 type ParseResult<T, Rest extends string> = {
   ast: T;
@@ -344,6 +321,82 @@ type ParseResult<T, Rest extends string> = {
 type ParseError = {
   error: true;
 };
+//#endregion
+//#region src/types/type-parser/expression-parser.d.ts
+/** 解析数字字面量，返回 [数字字符串, 剩余] */
+type ParseNumberLiteral<S extends string, Acc extends string = ""> = S extends `${infer C}${infer Rest}` ? C extends "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "." ? ParseNumberLiteral<Rest, `${Acc}${C}`> : [Acc, S] : [Acc, S];
+/** 解析字符串字面量 */
+type ParseStringLiteral<S extends string> = S extends `'${infer __}` ? {
+  rest: SkipSingleQuoteString<S>;
+} : S extends `"${infer __}` ? {
+  rest: SkipDoubleQuoteString<S>;
+} : S extends `\`${infer __}` ? {
+  rest: SkipTemplateString<S>;
+} : never;
+/** 解析数组字面量 */
+type ParseArrayLiteral<S extends string, Elements extends unknown[] = []> = TrimStart<S> extends `]${infer Rest}` ? ParseResult<ASTArray<Elements>, Rest> : ParseTernary<S> extends ParseResult<infer Element, infer Rest> ? TrimStart<Rest> extends `,${infer Rest2}` ? ParseArrayLiteral<Rest2, [...Elements, Element]> : TrimStart<Rest> extends `]${infer Rest2}` ? ParseResult<ASTArray<[...Elements, Element]>, Rest2> : ParseError : ParseError;
+/** 解析对象属性键 */
+type ParseObjectKey<S extends string> = TrimStart<S> extends `'${infer _}` ? SkipSingleQuoteStringContent<TrimStart<S> extends `'${infer Rest}` ? Rest : never> extends `${infer Rest}` ? TrimStart<S> extends `'${infer Key}'${infer _Rest}` ? {
+  key: Key;
+  rest: Rest;
+} : never : never : TrimStart<S> extends `"${infer _}` ? SkipDoubleQuoteStringContent<TrimStart<S> extends `"${infer Rest}` ? Rest : never> extends `${infer Rest}` ? TrimStart<S> extends `"${infer Key}"${infer _Rest}` ? {
+  key: Key;
+  rest: Rest;
+} : never : never : ParseIdentifier<TrimStart<S>> extends [infer Key extends string, infer Rest extends string] ? Key extends "" ? never : {
+  key: Key;
+  rest: Rest;
+} : never;
+type SkipSingleQuoteStringContent<S extends string> = S extends `\\'${infer Rest}` ? SkipSingleQuoteStringContent<Rest> : S extends `'${infer Rest}` ? Rest : S extends `${string}${infer Rest}` ? SkipSingleQuoteStringContent<Rest> : S;
+type SkipDoubleQuoteStringContent<S extends string> = S extends `\\"${infer Rest}` ? SkipDoubleQuoteStringContent<Rest> : S extends `"${infer Rest}` ? Rest : S extends `${string}${infer Rest}` ? SkipDoubleQuoteStringContent<Rest> : S;
+/** 解析对象字面量 */
+type ParseObjectLiteral<S extends string, Props extends Record<string, unknown> = {}> = TrimStart<S> extends `}${infer Rest}` ? ParseResult<ASTObject<Props>, Rest> : ParseObjectKey<S> extends {
+  key: infer Key extends string;
+  rest: infer Rest1 extends string;
+} ? TrimStart<Rest1> extends `:${infer Rest2}` ? ParseTernary<Rest2> extends ParseResult<infer Value, infer Rest3> ? TrimStart<Rest3> extends `,${infer Rest4}` ? ParseObjectLiteral<Rest4, Props & Record<Key, Value>> : TrimStart<Rest3> extends `}${infer Rest4}` ? ParseResult<ASTObject<Props & Record<Key, Value>>, Rest4> : ParseError : ParseError : ParseError : ParseError;
+/** 解析标识符主表达式 */
+type ParseIdentifierPrimary<S extends string> = ParseIdentifier<TrimStart<S>> extends [infer Name extends string, infer Rest extends string] ? Name extends "" ? ParseError : ParseResult<ASTIdentifier<Name>, Rest> : ParseError;
+/** 解析主表达式 */
+type ParsePrimary<S extends string> = TrimStart<S> extends `(${infer Rest}` ? ParseTernary<Rest> extends ParseResult<infer Inner, infer Rest2> ? TrimStart<Rest2> extends `)${infer Rest3}` ? ParseResult<ASTParen<Inner>, Rest3> : ParseError : ParseError : TrimStart<S> extends `[${infer Rest}` ? ParseArrayLiteral<Rest> : TrimStart<S> extends `{${infer Rest}` ? ParseObjectLiteral<Rest> : TrimStart<S> extends `true${infer Rest}` ? IsIdentifierChar<Rest extends `${infer C}${string}` ? C : ""> extends true ? ParseIdentifierPrimary<S> : ParseResult<ASTBoolean, Rest> : TrimStart<S> extends `false${infer Rest}` ? IsIdentifierChar<Rest extends `${infer C}${string}` ? C : ""> extends true ? ParseIdentifierPrimary<S> : ParseResult<ASTBoolean, Rest> : TrimStart<S> extends `${infer C}${infer __Rest}` ? IsDigit<C> extends true ? ParseNumberLiteral<TrimStart<S>> extends [infer __Num, infer Rest2 extends string] ? ParseResult<ASTNumber, Rest2> : ParseError : C extends "-" ? TrimStart<__Rest> extends `${infer C2}${string}` ? IsDigit<C2> extends true ? ParseNumberLiteral<TrimStart<__Rest>> extends [infer __Num, infer Rest2 extends string] ? ParseResult<ASTNumber, Rest2> : ParseError : ParseError : ParseError : C extends "'" | '"' | "`" ? ParseStringLiteral<TrimStart<S>> extends {
+  rest: infer Rest2 extends string;
+} ? ParseResult<ASTString, Rest2> : ParseError : IsIdentifierStart<C> extends true ? ParseIdentifierPrimary<S> : ParseError : ParseError;
+/** 解析后缀运算符入口 */
+type ParsePostfix<S extends string> = ParsePrimary<TrimStart<S>> extends ParseResult<infer Base, infer Rest> ? ParsePostfixTail<Base, Rest> : ParseError;
+/** 解析后缀运算符尾部 */
+type ParsePostfixTail<Base, S extends string> = TrimStart<S> extends `.${infer Rest}` ? ParseIdentifier<TrimStart<Rest>> extends [infer Prop extends string, infer Rest2 extends string] ? Prop extends "" ? ParseResult<Base, S> : ParsePostfixTail<ASTMemberAccess<Base, Prop>, Rest2> : ParseResult<Base, S> : TrimStart<S> extends `[${infer Rest}` ? ParseTernary<Rest> extends ParseResult<infer Index, infer Rest2> ? TrimStart<Rest2> extends `]${infer Rest3}` ? ParsePostfixTail<ASTComputedMember<Base, Index>, Rest3> : ParseResult<Base, S> : ParseResult<Base, S> : TrimStart<S> extends `(${infer Rest}` ? ParseCallArgs<Rest> extends {
+  args: infer Args extends unknown[];
+  rest: infer Rest2 extends string;
+} ? ParsePostfixTail<ASTCall<Base, Args>, Rest2> : ParseResult<Base, S> : ParseResult<Base, S>;
+/** 解析函数调用参数 */
+type ParseCallArgs<S extends string, Args extends unknown[] = []> = TrimStart<S> extends `)${infer Rest}` ? {
+  args: Args;
+  rest: Rest;
+} : ParseTernary<S> extends ParseResult<infer Arg, infer Rest> ? TrimStart<Rest> extends `,${infer Rest2}` ? ParseCallArgs<Rest2, [...Args, Arg]> : TrimStart<Rest> extends `)${infer Rest2}` ? {
+  args: [...Args, Arg];
+  rest: Rest2;
+} : {
+  args: Args;
+  rest: S;
+} : {
+  args: Args;
+  rest: S;
+};
+/** 运算符优先级（从低到高）:
+ * Level 1: ?: (三元)
+ * Level 2: ?? (空值合并)
+ * Level 3: || (逻辑或)
+ * Level 4: && (逻辑与)
+ * Level 5: | (位或)
+ * Level 6: ^ (位异或)
+ * Level 7: & (位与)
+ * Level 8: ==, !=, ===, !== (相等)
+ * Level 9: <, >, <=, >= (比较)
+ * Level 10: <<, >>, >>> (位移)
+ * Level 11: +, - (加减)
+ * Level 12: *, /, % (乘除)
+ * Level 13: ** (幂运算，右结合)
+ * Level 14: 一元运算符
+ * Level 15: 成员访问、函数调用
+ */
 /** 解析三元表达式（最低优先级）- 右结合 */
 type ParseTernary<S extends string> = ParseLogicalOr<TrimStart<S>> extends ParseResult<infer Left, infer Rest1> ? TrimStart<Rest1> extends `?${infer AfterQ}` ? ParseTernary<AfterQ> extends ParseResult<infer Then, infer Rest2> ? TrimStart<Rest2> extends `:${infer AfterColon}` ? ParseTernary<AfterColon> extends ParseResult<infer Else, infer Rest3> ? ParseResult<ASTTernary<Left, Then, Else>, Rest3> : ParseResult<Left, Rest1> : ParseResult<Left, Rest1> : ParseResult<Left, Rest1> : ParseResult<Left, Rest1> : ParseError;
 /** 解析逻辑或 || */
@@ -384,60 +437,10 @@ type ParseExponentiation<S extends string> = ParseUnary<TrimStart<S>> extends Pa
 type ParseExponentiationTail<Left, S extends string> = TrimStart<S> extends `**${infer Rest}` ? ParseExponentiation<Rest> extends ParseResult<infer Right, infer Rest2> ? ParseResult<ASTBinary<"**", Left, Right>, Rest2> : ParseResult<Left, S> : ParseResult<Left, S>;
 /** 解析一元运算符 */
 type ParseUnary<S extends string> = TrimStart<S> extends `!${infer Rest}` ? ParseUnary<Rest> extends ParseResult<infer Operand, infer Rest2> ? ParseResult<ASTUnary<"!", Operand>, Rest2> : ParseError : TrimStart<S> extends `~${infer Rest}` ? ParseUnary<Rest> extends ParseResult<infer Operand, infer Rest2> ? ParseResult<ASTUnary<"~", Operand>, Rest2> : ParseError : TrimStart<S> extends `typeof${infer Rest}` ? IsIdentifierChar<Rest extends `${infer C}${string}` ? C : ""> extends true ? ParseError : ParseUnary<Rest> extends ParseResult<infer Operand, infer Rest2> ? ParseResult<ASTUnary<"typeof", Operand>, Rest2> : ParseError : TrimStart<S> extends `void${infer Rest}` ? IsIdentifierChar<Rest extends `${infer C}${string}` ? C : ""> extends true ? ParseError : ParseUnary<Rest> extends ParseResult<infer Operand, infer Rest2> ? ParseResult<ASTUnary<"void", Operand>, Rest2> : ParseError : TrimStart<S> extends `-${infer Rest}` ? IsDigit<Rest extends `${infer C}${string}` ? C : ""> extends true ? ParsePostfix<S> : ParseUnary<Rest> extends ParseResult<infer Operand, infer Rest2> ? ParseResult<ASTUnary<"-", Operand>, Rest2> : ParseError : TrimStart<S> extends `+${infer Rest}` ? ParseUnary<Rest> extends ParseResult<infer Operand, infer Rest2> ? ParseResult<ASTUnary<"+", Operand>, Rest2> : ParseError : ParsePostfix<S>;
-/** 解析后缀运算符（成员访问、函数调用） */
-type ParsePostfix<S extends string> = ParsePrimary<TrimStart<S>> extends ParseResult<infer Base, infer Rest> ? ParsePostfixTail<Base, Rest> : ParseError;
-type ParsePostfixTail<Base, S extends string> = TrimStart<S> extends `.${infer Rest}` ? ParseIdentifier<TrimStart<Rest>> extends [infer Prop extends string, infer Rest2 extends string] ? Prop extends "" ? ParseResult<Base, S> : ParsePostfixTail<ASTMemberAccess<Base, Prop>, Rest2> : ParseResult<Base, S> : TrimStart<S> extends `[${infer Rest}` ? ParseTernary<Rest> extends ParseResult<infer Index, infer Rest2> ? TrimStart<Rest2> extends `]${infer Rest3}` ? ParsePostfixTail<ASTComputedMember<Base, Index>, Rest3> : ParseResult<Base, S> : ParseResult<Base, S> : TrimStart<S> extends `(${infer Rest}` ? ParseCallArgs<Rest> extends {
-  args: infer Args extends unknown[];
-  rest: infer Rest2 extends string;
-} ? ParsePostfixTail<ASTCall<Base, Args>, Rest2> : ParseResult<Base, S> : ParseResult<Base, S>;
-/** 解析函数调用参数 */
-type ParseCallArgs<S extends string, Args extends unknown[] = []> = TrimStart<S> extends `)${infer Rest}` ? {
-  args: Args;
-  rest: Rest;
-} : ParseTernary<S> extends ParseResult<infer Arg, infer Rest> ? TrimStart<Rest> extends `,${infer Rest2}` ? ParseCallArgs<Rest2, [...Args, Arg]> : TrimStart<Rest> extends `)${infer Rest2}` ? {
-  args: [...Args, Arg];
-  rest: Rest2;
-} : {
-  args: Args;
-  rest: S;
-} : {
-  args: Args;
-  rest: S;
-};
-/** 解析数字字面量，返回 [数字字符串, 剩余] */
-type ParseNumberLiteral<S extends string, Acc extends string = ""> = S extends `${infer C}${infer Rest}` ? C extends "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "." ? ParseNumberLiteral<Rest, `${Acc}${C}`> : [Acc, S] : [Acc, S];
-/** 解析数组字面量 */
-type ParseArrayLiteral<S extends string, Elements extends unknown[] = []> = TrimStart<S> extends `]${infer Rest}` ? ParseResult<ASTArray<Elements>, Rest> : ParseTernary<S> extends ParseResult<infer Element, infer Rest> ? TrimStart<Rest> extends `,${infer Rest2}` ? ParseArrayLiteral<Rest2, [...Elements, Element]> : TrimStart<Rest> extends `]${infer Rest2}` ? ParseResult<ASTArray<[...Elements, Element]>, Rest2> : ParseError : ParseError;
-/** 解析对象属性键 */
-type ParseObjectKey<S extends string> = TrimStart<S> extends `'${infer _}` ? SkipSingleQuoteStringContent<TrimStart<S> extends `'${infer Rest}` ? Rest : never> extends `${infer Rest}` ? TrimStart<S> extends `'${infer Key}'${infer _Rest}` ? {
-  key: Key;
-  rest: Rest;
-} : never : never : TrimStart<S> extends `"${infer _}` ? SkipDoubleQuoteStringContent<TrimStart<S> extends `"${infer Rest}` ? Rest : never> extends `${infer Rest}` ? TrimStart<S> extends `"${infer Key}"${infer _Rest}` ? {
-  key: Key;
-  rest: Rest;
-} : never : never : ParseIdentifier<TrimStart<S>> extends [infer Key extends string, infer Rest extends string] ? Key extends "" ? never : {
-  key: Key;
-  rest: Rest;
-} : never;
-/** 解析对象字面量 */
-type ParseObjectLiteral<S extends string, Props extends Record<string, unknown> = {}> = TrimStart<S> extends `}${infer Rest}` ? ParseResult<ASTObject<Props>, Rest> : ParseObjectKey<S> extends {
-  key: infer Key extends string;
-  rest: infer Rest1 extends string;
-} ? TrimStart<Rest1> extends `:${infer Rest2}` ? ParseTernary<Rest2> extends ParseResult<infer Value, infer Rest3> ? TrimStart<Rest3> extends `,${infer Rest4}` ? ParseObjectLiteral<Rest4, Props & Record<Key, Value>> : TrimStart<Rest3> extends `}${infer Rest4}` ? ParseResult<ASTObject<Props & Record<Key, Value>>, Rest4> : ParseError : ParseError : ParseError : ParseError;
-/** 解析主表达式 */
-type ParsePrimary<S extends string> = TrimStart<S> extends `(${infer Rest}` ? ParseTernary<Rest> extends ParseResult<infer Inner, infer Rest2> ? TrimStart<Rest2> extends `)${infer Rest3}` ? ParseResult<ASTParen<Inner>, Rest3> : ParseError : ParseError : TrimStart<S> extends `[${infer Rest}` ? ParseArrayLiteral<Rest> : TrimStart<S> extends `{${infer Rest}` ? ParseObjectLiteral<Rest> : TrimStart<S> extends `true${infer Rest}` ? IsIdentifierChar<Rest extends `${infer C}${string}` ? C : ""> extends true ? ParseIdentifierPrimary<S> : ParseResult<ASTBoolean, Rest> : TrimStart<S> extends `false${infer Rest}` ? IsIdentifierChar<Rest extends `${infer C}${string}` ? C : ""> extends true ? ParseIdentifierPrimary<S> : ParseResult<ASTBoolean, Rest> : TrimStart<S> extends `${infer C}${infer __Rest}` ? IsDigit<C> extends true ? ParseNumberLiteral<TrimStart<S>> extends [infer __Num, infer Rest2 extends string] ? ParseResult<ASTNumber, Rest2> : ParseError : C extends "-" ? TrimStart<__Rest> extends `${infer C2}${string}` ? IsDigit<C2> extends true ? ParseNumberLiteral<TrimStart<__Rest>> extends [infer __Num, infer Rest2 extends string] ? ParseResult<ASTNumber, Rest2> : ParseError : ParseError : ParseError : C extends "'" | '"' | "`" ? ParseStringLiteral<TrimStart<S>> extends {
-  rest: infer Rest2 extends string;
-} ? ParseResult<ASTString, Rest2> : ParseError : IsIdentifierStart<C> extends true ? ParseIdentifierPrimary<S> : ParseError : ParseError;
-type ParseIdentifierPrimary<S extends string> = ParseIdentifier<TrimStart<S>> extends [infer Name extends string, infer Rest extends string] ? Name extends "" ? ParseError : ParseResult<ASTIdentifier<Name>, Rest> : ParseError;
-type ParseStringLiteral<S extends string> = S extends `'${infer __}` ? {
-  rest: SkipSingleQuoteString<S>;
-} : S extends `"${infer __}` ? {
-  rest: SkipDoubleQuoteString<S>;
-} : S extends `\`${infer __}` ? {
-  rest: SkipTemplateString<S>;
-} : never;
 /** 解析表达式入口 */
 type ParseExpression<S extends string> = ParseTernary<S> extends ParseResult<infer AST, infer Rest> ? TrimStart<Rest> extends "" ? AST : ASTUnknown : ASTUnknown;
+//#endregion
+//#region src/types/type-parser/type-inference.d.ts
 /** 推导数组元素类型 */
 type InferArrayElements<Elements extends unknown[], TypeMap, Result extends unknown[] = []> = Elements extends [infer First, ...infer Rest] ? InferArrayElements<Rest, TypeMap, [...Result, InferTypeFromAST<First, TypeMap>]> : Result;
 /** 推导对象属性类型 */
@@ -456,25 +459,8 @@ type InferComputedMemberType<Obj> = Obj extends readonly (infer T)[] ? T : Obj e
 } ? T : Obj extends Record<string, infer V> ? V : unknown;
 /** 函数调用类型推导 */
 type InferCallType<Callee> = Callee extends ((...args: any[]) => infer R) ? R : unknown;
-/** 全局类型映射 */
-interface GlobalTypeMap {
-  Math: Math;
-  JSON: JSON;
-  Number: NumberConstructor;
-  String: StringConstructor;
-  Boolean: BooleanConstructor;
-  Array: ArrayConstructor;
-  Object: ObjectConstructor;
-  Date: DateConstructor;
-  RegExp: RegExpConstructor;
-  undefined: undefined;
-  NaN: number;
-  Infinity: number;
-  parseInt: typeof globalThis.parseInt;
-  parseFloat: typeof globalThis.parseFloat;
-  isNaN: typeof globalThis.isNaN;
-  isFinite: typeof globalThis.isFinite;
-}
+//#endregion
+//#region src/types/type-parser/index.d.ts
 /** 表达式验证结果 */
 type ValidateExpression<Source extends string, TContext> = ExtractIdentifiers<Source> extends infer Ids extends string ? keyof TContext extends infer Keys extends string ? FindUndefinedIdentifiers<Ids, Keys> extends never ? true : {
   error: "undefined_identifiers";
@@ -487,7 +473,7 @@ type ValidateExpression<Source extends string, TContext> = ExtractIdentifiers<So
 /** 从表达式推导返回类型 */
 type InferExpressionResult<Source extends string, TContext> = InferTypeFromAST<ParseExpression<Source>, ContextTypeMap<TContext>>;
 //#endregion
-//#region src/expr.d.ts
+//#region src/api/expr.d.ts
 /**
  * 创建表达式
  * 返回 Proxy Expression，可以继续链式调用
@@ -517,7 +503,7 @@ type InferExpressionResult<Source extends string, TContext> = InferTypeFromAST<P
  */
 declare function expr<TContext extends Record<string, unknown>>(context: TContext): <TSource extends string>(source: ValidateExpression<TSource, TContext> extends never ? never : TSource) => Proxify<InferExpressionResult<TSource, TContext>>;
 //#endregion
-//#region src/lambda.d.ts
+//#region src/api/lambda.d.ts
 /**
  * 创建类型安全的 lambda 表达式
  *
@@ -538,7 +524,7 @@ 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/template.d.ts
+//#region src/api/template.d.ts
 /**
  * Tagged template 函数，用于创建包含变量的字符串表达式
  *
@@ -556,36 +542,7 @@ declare function lambda<Args extends unknown[], R>(builder: LambdaBuilder<Args,
  */
 declare function t(strings: TemplateStringsArray, ...values: unknown[]): Proxify<string>;
 //#endregion
-//#region src/test-helper.d.ts
-/**
- * 从变量映射推导值类型
- * 例如: { x: Variable<number> } -> { x: number }
- */
-type InferVariableValues<T extends Record<string, Variable<unknown>>> = { [K in keyof T]: T[K] extends Variable<infer U> ? U : never };
-/**
- * 编译并求值表达式
- * 自动推导变量类型和返回类型
- *
- * @template TResult - 表达式求值结果类型
- * @template TVars - 变量映射类型
- * @param expr - 要编译的表达式
- * @param variables - 变量定义映射
- * @param values - 变量值映射
- * @returns 表达式求值结果
- *
- * @example
- * ```ts
- * const callback = variable<(f: (x: number) => number) => number>();
- * const result = compileAndEvaluate(
- *   myExpr,
- *   { callback },
- *   { callback: (fn) => fn(5) }
- * );
- * ```
- */
-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
+//#region src/api/variable.d.ts
 /**
  * 创建一个类型化变量
  * 返回 Proxy 对象，支持链式属性访问和方法调用
@@ -599,7 +556,7 @@ declare function compileAndEvaluate<TResult = unknown, TVars extends Record<stri
  */
 declare function variable<T>(): Variable<T>;
 //#endregion
-//#region src/wrap.d.ts
+//#region src/api/wrap.d.ts
 /**
  * 将静态值包装为 Proxy Expression
  * 返回的 Proxy 可以像 Variable 一样调用方法和访问属性
@@ -626,5 +583,53 @@ declare function variable<T>(): Variable<T>;
  */
 declare function wrap<T>(value: T): Proxify<T>;
 //#endregion
-export { type CompileOptions, type CompiledData, type CompiledExpression, type ExprValue, type InferLambdaArgs, type InferLambdaReturn, type Lambda, type LambdaBuilder, type Proxify, type ProxyExpression, type Variable, compile, compileAndEvaluate, evaluate, expr, lambda, t, variable, wrap };
+//#region src/core/compile.d.ts
+/**
+ * 编译选项
+ */
+interface CompileOptions {}
+/**
+ * 将 Proxy Expression 编译为可序列化的 JSON 结构
+ *
+ * @template TResult - 表达式结果类型
+ * @param expression - Proxy Expression，或包含 Proxy 的对象/数组/原始值
+ * @param variables - 所有使用的变量定义
+ * @param options - 编译选项
+ * @returns 编译后的数据结构 [变量名列表, 表达式1, 表达式2, ...]
+ *
+ * @throws 如果传入无效的表达式或未定义的变量引用
+ *
+ * @example
+ * ```ts
+ * const x = variable<number>()
+ * const y = variable<number>()
+ * 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]"]
+ * ```
+ */
+declare function compile<TResult>(expression: ExprValue<TResult>, variables: Record<string, unknown>, _options?: CompileOptions): CompiledData;
+//#endregion
+//#region src/core/evaluate.d.ts
+/**
+ * 执行编译后的表达式
+ *
+ * @template TResult - 表达式结果类型
+ * @param data - 编译后的数据结构 [变量名列表, 表达式1, 表达式2, ...]
+ * @param values - 变量值映射，按变量名提供值
+ * @returns 最后一个表达式的求值结果
+ *
+ * @throws 如果运行时类型验证失败或表达式执行出错
+ *
+ * @example
+ * ```ts
+ * const compiled = [["x", "y"], "$[0]+$[1]", "$[1]*2"]
+ * const result = evaluate<number>(compiled, { x: 2, y: 3 })
+ * // => 6  (3 * 2)
+ * ```
+ */
+declare function evaluate<TResult = unknown>(data: CompiledData, values: Record<string, unknown>): TResult;
+//#endregion
+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, evaluate, expr, lambda, t, variable, wrap };
 //# sourceMappingURL=index.d.mts.map