@cloudpss/expression 0.6.0-alpha.15 → 0.6.0-alpha.17

package/src/definitions/utils.ts

@@ -1,6 +1,6 @@
 import { klona } from 'klona';
-import { isVmArray, type VmPrimitive, type VmValue } from '@mirascript/mirascript';
-import { Expression, isExpression } from '../expression.js';
+import { isVmArray, isVmRecord, type VmPrimitive, type VmValue } from '@mirascript/mirascript';
+import { Expression, isExpression, type ExpressionOrValue } from '../expression.js';
 import type { ChoiceParameterType, Parameter, ParameterMap } from './parameter.js';
 import { TypeInfo } from '../type.js';
 import type { ArgumentMap, ArgumentValue } from './argument.js';
@@ -11,7 +11,9 @@ const { isArray } = Array;
 export function enumType(definition: Pick<ParameterMap[ChoiceParameterType], 'type' | 'choices'>): TypeInfo | null {
     const { choices } = definition;
     if (typeof choices == 'function' || isExpression(choices)) return null;
+    // 首先根据参数类型确定默认类型
     let defaultType: TypeInfo = definition.type === 'logical' ? 'boolean' : 'number';
+    // 然后根据默认值调整默认类型
     if ('value' in definition) {
         const { value } = definition;
         if (typeof value == 'boolean') defaultType = 'boolean';
@@ -23,6 +25,7 @@ export function enumType(definition: Pick<ParameterMap[ChoiceParameterType], 'ty
     let type: TypeInfo | null = null;
     for (const choice of choices) {
         const v = choice?.key;
+        // 选项值为空时，使用默认类型
         const t = v == null ? defaultType : typeof v;
         if (t === 'string') {
             if (type == null) type = 'string';
@@ -42,15 +45,18 @@ export function enumType(definition: Pick<ParameterMap[ChoiceParameterType], 'ty
 
 /**
  * 转换参数值的类型，不回退到 {@link Parameter.value} 提供的默认值
+ * 转换失败时返回 null
  */
-export function toArgumentValue<V extends ArgumentValue>(value: VmValue, definition: Parameter): V {
+export function toArgumentValue<V extends ArgumentValue>(
+    value: VmValue | null | undefined,
+    definition: Parameter,
+): V | null {
     // 避免无效的 VmValue 导致错误
     value ??= null;
-
     switch (definition.type) {
         case 'real':
         case 'integer':
-            return TypeInfo.toNumber(value) as V;
+            return TypeInfo.toNumber(value, null) as V;
         case 'text':
         case 'file':
         case 'code':
@@ -58,16 +64,16 @@ export function toArgumentValue<V extends ArgumentValue>(value: VmValue, definit
         case 'cssColor' as never:
         case 'cssBackground' as never:
         case 'resourceId' as never:
-            return TypeInfo.toString(value) as V;
+            return TypeInfo.toString(value, null) as V;
 
         case 'choice':
         case 'logical': {
             if (value == null && Array.isArray(definition.choices) && definition.choices.length > 0) {
-                value = definition.choices[0]?.key;
+                value = definition.choices[0]?.key as V;
             }
             const type = enumType(definition);
             if (!type) return value as V;
-            return TypeInfo.to(value, type) as V;
+            return TypeInfo.to(value, type, null) as V;
         }
 
         case 'multiSelect': {
@@ -75,7 +81,13 @@ export function toArgumentValue<V extends ArgumentValue>(value: VmValue, definit
             if (v.length === 0) return v as V;
             const type = enumType(definition);
             if (!type) return v as V;
-            return v.map((x) => TypeInfo.to(x, type)) as readonly VmPrimitive[] as V;
+            const to = TypeInfo.converter(type);
+            const ret: VmPrimitive[] = [];
+            for (const x of v) {
+                const r = to(x, null);
+                if (r != null) ret.push(r);
+            }
+            return ret as readonly VmPrimitive[] as V;
         }
 
         case 'table': {
@@ -84,7 +96,10 @@ export function toArgumentValue<V extends ArgumentValue>(value: VmValue, definit
         }
 
         case 'grouped':
-        case 'record':
+        case 'record': {
+            if (!isVmRecord(value)) return null;
+            return value as V;
+        }
         default:
             return value as V;
     }
@@ -127,7 +142,7 @@ export function fillArgumentMap<T extends Record<string, ArgumentValue>>(
     if (!checkParameterDefinitions(definition)) return args;
 
     /** 参数键的类型 */
-    type K = keyof T & string;
+    type K = keyof T;
     /** 参数值的类型 */
     type V = NonNullable<T[K]>;
     const keys = new Set(Object.keys(args) as K[]);
@@ -140,13 +155,13 @@ export function fillArgumentMap<T extends Record<string, ArgumentValue>>(
             const currentValue = keys.has(key) ? args[key] : undefined;
             if (currentValue == null) {
                 // 使用默认值填充
-                const defaultValue = param.value;
+                const defaultValue = param.value as ExpressionOrValue<V>;
                 if (isExpression(defaultValue)) {
                     args[key] = Expression<V>(defaultValue.source);
                 } else {
                     const value =
                         defaultValue != null && typeof defaultValue == 'object' ? klona(defaultValue) : defaultValue;
-                    args[key] = toArgumentValue<V>(value, param);
+                    args[key] = toArgumentValue<V>(value, param) ?? value;
                 }
             } else {
                 // 已存在的参数值
@@ -167,6 +182,7 @@ export function fillArgumentMap<T extends Record<string, ArgumentValue>>(
     // 删除多余的参数
     for (const key of keys) {
         // 保留特殊参数和私有字段
+        if (typeof key != 'string') continue;
         const k0 = key[0];
         if (k0 === '_' || k0 === '$' || k0 === '@' || k0 === 'ɵ') continue;
         delete args[key];

package/src/main.ts

@@ -1,11 +1,11 @@
 import { isVmFunction, isVmPrimitive, wrapToVmValue, type VmValue } from '@mirascript/mirascript';
-import { lib } from '@mirascript/mirascript/subtle';
+import { serialize } from '@mirascript/mirascript/subtle';
 import { defaultOptions, type Logger, type Options } from './interface.js';
 import { parse } from './parser.js';
 import { analyze, type AccessChain } from './analyze.js';
 import {
     type CompiledExpression,
-    Expression,
+    type Expression,
     type ExpressionFunction,
     type ExpressionOrValue,
     type ExpressionSource,
@@ -30,7 +30,6 @@ import {
 } from './definitions.js';
 const { isArray } = Array;
 const { defineProperty } = Object;
-const { to_string } = lib;
 
 /** 选项类型 */
 export type EvaluatedChoices<T extends ChoiceParameterType> = {
@@ -80,12 +79,17 @@ export class Evaluator {
         const value = parse(this, expression.source, throws, false);
         const tag = expression[ExpressionTag];
         const type = tag ? TypeInfo.parse(tag) : '';
-        const compiled: ExpressionFunction<T> = (scope, evaluator) => {
-            const ret = evaluate<T>(evaluator, value, scope);
-            if (ret == null) return null;
-            if (!type) return ret;
-            return TypeInfo.to(ret, type) as T;
-        };
+        let compiled: ExpressionFunction<T>;
+        if (!type) {
+            compiled = (scope, evaluator) => evaluate<T>(evaluator, value, scope);
+        } else {
+            const to = TypeInfo.converter(type);
+            compiled = (scope, evaluator) => {
+                const ret = evaluate<T>(evaluator, value, scope);
+                if (ret == null) return null;
+                return to(ret) as T;
+            };
+        }
         defineProperty(compiled, ExpressionTag, { value: type, enumerable: true });
         defineProperty(compiled, 'source', { value: value.source, enumerable: true });
         return compiled as CompiledExpression<T>;
@@ -98,7 +102,7 @@ export class Evaluator {
         const value = parse(this, template, throws, true);
         const result = evaluate<string>(this, value, scope ?? this.scope) ?? template;
         if (typeof result == 'string') return result;
-        return to_string(result);
+        return TypeInfo.toString(result);
     }
 
     /** 求值 */
@@ -190,14 +194,15 @@ export class Evaluator {
         scope: Scope | null | undefined,
         defaults = true,
     ): boolean {
-        if (typeof condition == 'boolean') return condition;
         if (condition == null) return defaults;
-        condition = to_string(condition).trim() as ConditionExpression & string;
+        if (typeof condition == 'boolean') return condition;
         if (condition === '') return defaults;
         if (condition === 'true') return true;
         if (condition === 'false') return false;
         try {
-            return this.evaluate(Expression(condition, 'boolean'), scope, defaults);
+            const result = this.evaluateSource(condition, scope, defaults);
+            if (typeof result == 'boolean') return result;
+            throw new Error(`Condition evaluates to \`${serialize(result)}\``);
         } catch (ex) {
             if (scope?.throws) {
                 throw ex;
@@ -269,8 +274,10 @@ export class Evaluator {
     ): V {
         // 默认值有可能为表达式，因此需要先填充再求值
         expression ??= definition.value as ExpressionOrValue<V>;
+        // 求值失败时返回默认值
         const result = this.evaluate<V>(expression, scope, definition.value as V);
-        return toArgumentValue<V>(result, definition);
+        // 转换失败时返回转换前的值
+        return toArgumentValue<V>(result, definition) ?? result;
     }
     /** 求参数表的所有参数值 */
     evaluateArgs<T extends Record<string, ArgumentValue>>(

package/src/migrator/call.ts

@@ -6,7 +6,6 @@ import {
     isObjectNode,
     type FunctionNode,
     type MathNode,
-    isOperatorNode,
 } from 'mathjs';
 import type { Options, Result } from './interface.js';
 import type { State } from './state.js';
@@ -14,6 +13,7 @@ import { constantValue, equalText, globalFnName, len, symbolName } from './utils
 import { migrateAtomic, migrateExpr, migrateNode } from './node.js';
 import { concat } from './concat.js';
 import { toNumber, toString } from './to-type.js';
+import { isVmArray, isVmPrimitive } from '@mirascript/mirascript';
 
 const EXACT_UNARY_FUNCTION = new Map<string, Result['type']>([
     // 只支持标量的 mathjs 函数
@@ -71,6 +71,11 @@ function migrateFunctionCall(
             type: EXACT_UNARY_FUNCTION.get(fnName)!,
             code: `${fnName}(${arg.code})`,
         };
+    } else if (fnName === 'random' && args.length === 0) {
+        return {
+            type: 'number',
+            code: `${globalFnName(state, 'random')}()`,
+        };
     } else if (fnName === 're' || fnName === 'im') {
         const m = migrateAtomic(state, args[0]!);
         state.err(`不支持复数`);
@@ -264,26 +269,43 @@ function migrateFunctionCall(
             type: 'string',
             code: `${g('to_string')}(${inner.code})`,
         };
-    } else if (
-        fnName === 'sum' &&
-        args.length === 1 &&
-        isArrayNode(args[0]) &&
-        args[0].items.length === 1 &&
-        isOperatorNode(args[0].items[0]) &&
-        ['>=', '>', '<=', '<', '==', '!='].includes(args[0].items[0].op) &&
-        typeof constantValue(args[0].items[0].args[1]!) === 'number'
-    ) {
-        // sum([a > v])
-        const a = migrateAtomic(state, args[0].items[0].args[0]!);
-        const v = migrateAtomic(state, args[0].items[0].args[1]!);
+    } else if (fnName === 'sum' || fnName === 'prod') {
+        const newFnName = fnName === 'sum' ? 'sum' : 'product';
+        if (args.length !== 1) {
+            return {
+                type: 'number',
+                code: `${g(newFnName)}(${args.map((a) => migrateAtomic(state, a).code).join(', ')})`,
+            };
+        }
+        const arg = migrateAtomic(state, args[0]!);
+        if (arg.literal) {
+            if (isVmPrimitive(arg.literal)) {
+                return {
+                    type: 'number',
+                    code: `${g(newFnName)}(${arg.code})`,
+                };
+            }
+            if (isVmArray(arg.literal) && arg.literal.every((v) => isVmPrimitive(v))) {
+                return {
+                    type: 'number',
+                    code: `${g(newFnName)}(${arg.code})`,
+                };
+            }
+        }
+        if (arg.type === 'array' || !arg.type) {
+            return {
+                type: 'number',
+                code: `${g(newFnName)}(${arg.code}::${g('flatten')}())`,
+            };
+        }
         return {
             type: 'number',
-            code: `${g('sum')}(${g('map')}(${a.code}, fn { it ${args[0].items[0].op} ${v.code} }))`,
+            code: `${g(newFnName)}(${arg.code})`,
         };
     }
 
     return call(state, node, (fn, args) => {
-        const fun = state.globals.get(fnName);
+        const fun = state.globals.has(fnName) ? state.globals.get(fnName) : undefined;
         if (typeof fun === 'function') {
             if (args.some((a) => a.type !== 'number' && a.type !== 'boolean' && a.type !== 'string')) {
                 state.warn(`函数行为可能不一致: ${fnName}`);

package/src/migrator/node.ts

@@ -17,7 +17,7 @@ import {
 import type { State } from './state.js';
 import type { Options, Result } from './interface.js';
 import type { VmConst } from '@mirascript/mirascript';
-import { unsupportedNode } from './utils.js';
+import { constantValue, unsupportedNode } from './utils.js';
 import { migrateAccess } from './access.js';
 import { migrateCall } from './call.js';
 import { migrateOperator } from './operator.js';
@@ -25,6 +25,7 @@ import { migrateSymbol } from './symbol.js';
 import { migrateCondition } from './condition.js';
 import { migrateFunctionAssignment } from './function.js';
 import { serialize } from './serialize.js';
+import { toNumber } from './to-type.js';
 
 /** 转换 AST */
 export function migrateAtomic(state: State, node: MathNode): Result {
@@ -113,6 +114,26 @@ export function migrateNode(state: State, node: MathNode, options: Options): Res
     }
     if (isRelationalNode(node)) {
         const { conditionals, params } = node;
+        // 优化范围判断 a <= b <= c
+        if (
+            conditionals.length === 2 &&
+            params.length === 3 &&
+            conditionals[0] === 'smallerEq' &&
+            conditionals[1] === 'smallerEq'
+        ) {
+            // 模式匹配只支持常量
+            const l = constantValue(params[0]!);
+            const r = constantValue(params[2]!);
+            if (typeof l == 'number' && typeof r == 'number' && l < r) {
+                const v = toNumber(state, migrateNode(state, params[1]!, options));
+                let code = `${v.code} is ${l}..${r}`;
+                if (options.format !== 'no-paren') code = `(${code})`;
+                return {
+                    type: 'boolean',
+                    code,
+                };
+            }
+        }
         const exprs = [];
         for (let i = 0; i < conditionals.length; i++) {
             const fn = conditionals[i]! as OperatorNodeFn;

package/src/migrator/operator.ts

@@ -8,6 +8,7 @@ import {
     isOperatorNode,
     isNode,
 } from 'mathjs';
+import { isVmArray, type TypeName, type VmAny } from '@mirascript/mirascript';
 import { operations } from '@mirascript/mirascript/subtle';
 import { symbolName, constantValue, equalText, scalar, globalFnName } from './utils.js';
 import type { State } from './state.js';
@@ -91,10 +92,12 @@ const BIT_OPS_TO_BOOL_OPS = {
 } as const;
 
 const COMPARE_OPERATORS = {
-    smaller: '<',
-    smallerEq: '<=',
-    larger: '>',
-    largerEq: '>=',
+    smaller: ['<'],
+    smallerEq: ['<='],
+    larger: ['>'],
+    largerEq: ['>='],
+    equal: ['=~', '=='],
+    unequal: ['!~', '!='],
 } as const;
 
 /** 转换为 boolean */
@@ -103,6 +106,21 @@ function b(op: string, state: State, node: MathNode): string {
     return toBoolean(state, scalar(op, state, re)).code;
 }
 
+/** 数组元素类型 */
+function elementType(lit: VmAny): TypeName | undefined {
+    if (!isVmArray(lit) || !lit.length) return undefined;
+    let type: TypeName | undefined = undefined;
+    for (const e of lit) {
+        const t = operations.$Type(e as VmAny);
+        if (!type) {
+            type = t;
+        } else if (type !== t) {
+            return undefined;
+        }
+    }
+    return type;
+}
+
 /** 二元操作 */
 function binary(
     state: State,
@@ -115,23 +133,27 @@ function binary(
         return op(state, l, r);
     }
     if (Array.isArray(l.literal) && l.literal.every((e) => !Array.isArray(e))) {
+        const it = { code: 'it', type: elementType(l.literal) };
         return {
             type: 'array',
-            code: `${l.code}::${globalFnName(state, 'map')}(fn { ${op(state, { code: 'it' }, r).code} })`,
+            code: `${l.code}::${globalFnName(state, 'map')}(fn { ${op(state, it, r).code} })`,
         };
     }
     if (Array.isArray(r.literal) && r.literal.every((e) => !Array.isArray(e))) {
+        const it = { code: 'it', type: elementType(r.literal) };
         return {
             type: 'array',
-            code: `${r.code}::${globalFnName(state, 'map')}(fn { ${op(state, l, { code: 'it' }).code} })`,
+            code: `${r.code}::${globalFnName(state, 'map')}(fn { ${op(state, l, it).code} })`,
         };
     }
     if (alt) {
         return alt(state, l, r);
     }
+    const a = { code: 'a', type: l.type === 'array' ? elementType(l.literal) : l.type };
+    const b = { code: 'b', type: r.type === 'array' ? elementType(r.literal) : r.type };
     return {
         type: l.type === 'array' || r.type === 'array' ? 'array' : undefined,
-        code: `${globalFnName(state, 'matrix')}.entrywise(${l.code}, ${r.code}, fn (a, b) { ${op(state, { code: 'a' }, { code: 'b' }).code} })`,
+        code: `${globalFnName(state, 'matrix')}.entrywise(${l.code}, ${r.code}, fn (a, b) { ${op(state, a, b).code} })`,
     };
 }
 
@@ -141,9 +163,10 @@ function unary(state: State, v: Result, op: (state: State, v: Result) => Result)
         return op(state, v);
     }
     if (Array.isArray(v.literal) && v.literal.every((e) => !Array.isArray(e))) {
+        const it = { code: 'it', type: elementType(v.literal) };
         return {
             type: 'array',
-            code: `${v.code}::${globalFnName(state, 'map')}(fn { ${op(state, { code: 'it' }).code} })`,
+            code: `${v.code}::${globalFnName(state, 'map')}(fn { ${op(state, it).code} })`,
         };
     }
     return {
@@ -288,17 +311,21 @@ export function migrateOperator(
         }
 
         case 'equal':
-        case 'unequal': {
-            const op = fn === 'equal' ? '==' : '!=';
+        case 'unequal':
+        case 'smaller':
+        case 'smallerEq':
+        case 'larger':
+        case 'largerEq': {
+            const [op, eqOp] = COMPARE_OPERATORS[fn];
             const c0 = constantValue(a0);
             const c1 = constantValue(a1);
-            if (c0 === null || c1 === null) {
-                state.loose();
-                const p0 = c0 === null ? { code: `nil` } : scalar(op, state, migrateExpr(state, a0));
-                const p1 = c1 === null ? { code: `nil` } : scalar(op, state, migrateExpr(state, a1));
+            if (eqOp && (c0 === null || c1 === null)) {
+                // Mathjs 只支持标量与 null 比较
+                const p0 = c0 === null ? { code: `nil` } : migrateExpr(state, a0);
+                const p1 = c1 === null ? { code: `nil` } : migrateExpr(state, a1);
                 return {
                     type: 'boolean',
-                    code: `${open}${p0.code} ${op} ${p1.code}${close}`,
+                    code: `${open}${p0.code} ${eqOp} ${p1.code}${close}`,
                 };
             }
             // PI, E 与常量比较时，不进行转换
@@ -317,7 +344,19 @@ export function migrateOperator(
             };
 
             return binary(state, a(a0), a(a1), (state, l, r) => {
-                if (l.type === 'boolean' && r.type === 'boolean') {
+                if (l.literal !== undefined) {
+                    return {
+                        type: 'boolean',
+                        code: `${toNumber(state, l).code} ${op} ${r.code}`,
+                    };
+                }
+                if (r.literal !== undefined) {
+                    return {
+                        type: 'boolean',
+                        code: `${l.code} ${op} ${toNumber(state, r).code}`,
+                    };
+                }
+                if (l.type === 'number' || r.type === 'number') {
                     return {
                         type: 'boolean',
                         code: `${l.code} ${op} ${r.code}`,
@@ -329,16 +368,6 @@ export function migrateOperator(
                 };
             });
         }
-        case 'smaller':
-        case 'smallerEq':
-        case 'larger':
-        case 'largerEq': {
-            const op = COMPARE_OPERATORS[fn];
-            return {
-                type: 'boolean',
-                code: `${open}${scalar(op, state, migrateExpr(state, a0)).code} ${op} ${scalar(op, state, migrateExpr(state, a1)).code}${close}`,
-            };
-        }
 
         default: {
             state.err(`不支持的运算符: ${fn}`);

package/src/migrator/symbol.ts

@@ -14,8 +14,8 @@ export function migrateSymbol(state: State, node: SymbolNode, migrateConst: bool
             code: migrateSymbolName(name, true),
         };
     }
-    const global = state.globals.get(name);
-    if (global != null) {
+    if (state.globals.has(name)) {
+        const global = state.globals.get(name);
         return {
             type: operations.$Type(global),
             code: migrateSymbolName(name, false),

package/src/migrator/to-type.ts

@@ -9,7 +9,7 @@ import { globalFnName } from './utils.js';
 export function toBoolean(state: State, node: MathNode | Result): Result {
     const helper = (): void => {
         state.helper(
-            "fn @@to_boolean { if it is nil { return nil; } it != '' && it != '0' && it != 0 && it is not nan && !!it }",
+            "fn @@to_boolean { if it is nil { nil } else { it != '' && it != '0' && it != 0 && it is not nan && !!it } }",
         );
     };
     if (!isNode(node)) {
@@ -85,7 +85,7 @@ export function toNumber(state: State, node: MathNode | Result): Result {
                 code: node.as_number,
             };
         }
-        if (node.type === 'string' && node.literal !== undefined) {
+        if ((node.type === 'string' || node.type === 'boolean') && node.literal !== undefined) {
             const lit = Number(node.literal);
             return {
                 type: 'number',

package/src/type.ts

@@ -1,6 +1,5 @@
 import type { TypeName, VmValue, VmValueMap } from '@mirascript/mirascript';
-import { lib } from '@mirascript/mirascript/subtle';
-const { to_string, to_number, to_boolean } = lib;
+import { convert } from '@mirascript/mirascript/subtle';
 
 /** 类型信息 */
 export type TypeInfo = 'string' | 'number' | 'boolean';
@@ -13,10 +12,11 @@ type TypeMap = VmValueMap & {
     s: string;
     f: number;
     b: boolean;
+    '': VmValue;
 };
 
 /** Ts 类型 */
-export type TsTypeOf<T extends TypeInfo | LegacyType> = TypeMap[T];
+export type TsTypeOf<T extends TypeInfo | LegacyType | '', I extends VmValue = VmValue> = T extends '' ? I : TypeMap[T];
 
 /** 兼容的旧类型 */
 export type LegacyType = 's' | 'f' | 'b';
@@ -49,39 +49,48 @@ export namespace TypeInfo {
     }
 
     /** 转换类型 */
-    export function to<T extends TypeInfo | LegacyType>(value: VmValue | undefined, type: T): TsTypeOf<T> {
-        /** 返回类型 */
-        type R = TsTypeOf<T>;
-        value ??= null;
-        if (!type) return value as R;
+    export function to<T extends TypeInfo | LegacyType | '', I extends VmValue = VmValue, F = undefined>(
+        value: I | undefined,
+        type: T,
+        fallback?: F,
+    ): TsTypeOf<T> | Exclude<F, undefined> {
+        const c = converter(type);
+        return (c as typeof convert.toNumber)(value, fallback) as TsTypeOf<T>;
+    }
+
+    /** 不转换 */
+    function identity<T extends VmValue>(value: T | undefined): T | null {
+        return value ?? null;
+    }
+
+    /** 获取转换器 */
+    type Converters = {
+        string: typeof convert.toString;
+        s: typeof convert.toString;
+        number: typeof convert.toNumber;
+        f: typeof convert.toNumber;
+        boolean: typeof convert.toBoolean;
+        b: typeof convert.toBoolean;
+        '': typeof identity;
+    };
+    /** 获取转换器 */
+    export function converter<T extends TypeInfo | LegacyType | ''>(type: T): Converters[T] {
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
         switch (type) {
             case 'b':
             case 'boolean':
-                return toBoolean(value) as R;
+                return toBoolean as Converters[T];
             case 'f':
             case 'number':
-                return toNumber(value) as R;
+                return toNumber as Converters[T];
             case 's':
             case 'string':
-                return toString(value) as R;
+                return toString as Converters[T];
             default:
-                (type) satisfies never;
-                return value as R;
+                (type) satisfies '';
+                return identity as Converters[T];
         }
     }
 
-    /** 转换为字符串 */
-    export function toString(value: VmValue | undefined): string {
-        return to_string(value ?? null);
-    }
-
-    /** 转换为数字 */
-    export function toNumber(value: VmValue | undefined): number {
-        return to_number(value ?? null);
-    }
-
-    /** 转换为布尔值 */
-    export function toBoolean(value: VmValue | undefined): boolean {
-        return to_boolean(value ?? null);
-    }
+    export const { toBoolean, toFormat, toNumber, toString } = convert;
 }

package/tests/condition.ts

@@ -27,20 +27,28 @@ describe('Evaluate conditions', () => {
         expect(e.evaluateCondition('true' as ExpressionSource<boolean>, s)).toBe(true);
         expect(e.evaluateCondition('false' as ExpressionSource<boolean>, s)).toBe(false);
     });
-    it('can convert to boolean', () => {
-        expect(e.evaluateCondition('""' as ExpressionSource<boolean>, s)).toBe(true);
-        expect(e.evaluateCondition('nil' as ExpressionSource<boolean>, s)).toBe(true);
-        expect(e.evaluateCondition('undefined' as ExpressionSource<boolean>, s)).toBe(true);
-        expect(e.evaluateCondition('0' as ExpressionSource<boolean>, s)).toBe(true);
-        expect(e.evaluateCondition('nan' as ExpressionSource<boolean>, s)).toBe(true);
+    it('can evaluate to boolean', () => {
         expect(e.evaluateCondition('(false)' as ExpressionSource<boolean>, s)).toBe(false);
-
-        expect(e.evaluateCondition('""' as ExpressionSource<boolean>, s, false)).toBe(true);
-        expect(e.evaluateCondition('nil' as ExpressionSource<boolean>, s, false)).toBe(false);
-        expect(e.evaluateCondition('undefined' as ExpressionSource<boolean>, s, false)).toBe(false);
-        expect(e.evaluateCondition('0' as ExpressionSource<boolean>, s, false)).toBe(true);
-        expect(e.evaluateCondition('nan' as ExpressionSource<boolean>, s, false)).toBe(true);
+        expect(e.evaluateCondition('(true)' as ExpressionSource<boolean>, s)).toBe(true);
         expect(e.evaluateCondition('(false)' as ExpressionSource<boolean>, s, false)).toBe(false);
+        expect(e.evaluateCondition('(true)' as ExpressionSource<boolean>, s, false)).toBe(true);
+    });
+    it('can evaluate to nil', () => {
+        expect(e.evaluateCondition('{}' as ExpressionSource<boolean>, s)).toBe(true);
+        expect(e.evaluateCondition('{}' as ExpressionSource<boolean>, s, false)).toBe(false);
+    });
+    it('do not convert to boolean', () => {
+        expect(en.evaluateCondition('""' as ExpressionSource<boolean>, s)).toBe(true);
+        expect(en.evaluateCondition('nil' as ExpressionSource<boolean>, s)).toBe(true);
+        expect(en.evaluateCondition('undefined' as ExpressionSource<boolean>, s)).toBe(true);
+        expect(en.evaluateCondition('0' as ExpressionSource<boolean>, s)).toBe(true);
+        expect(en.evaluateCondition('nan' as ExpressionSource<boolean>, s)).toBe(true);
+
+        expect(en.evaluateCondition('""' as ExpressionSource<boolean>, s, false)).toBe(false);
+        expect(en.evaluateCondition('nil' as ExpressionSource<boolean>, s, false)).toBe(false);
+        expect(en.evaluateCondition('undefined' as ExpressionSource<boolean>, s, false)).toBe(false);
+        expect(en.evaluateCondition('0' as ExpressionSource<boolean>, s, false)).toBe(false);
+        expect(en.evaluateCondition('nan' as ExpressionSource<boolean>, s, false)).toBe(false);
     });
     it('can evaluate complex', () => {
         expect(e.evaluateCondition('12>3' as ExpressionSource<boolean>, s)).toBe(true);