@cloudpss/expression 0.6.0-alpha.14 → 0.6.0-alpha.16

package/src/migrator/node.ts

@@ -1,4 +1,4 @@
-import { serializePropName } from '@mirascript/mirascript/subtle';
+import { serializeRecordKey } from '@mirascript/mirascript/subtle';
 import {
     type MathNode,
     isAccessorNode,
@@ -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 {
@@ -82,7 +83,7 @@ export function migrateNode(state: State, node: MathNode, options: Options): Res
             } else {
                 literals[key] = item.literal;
             }
-            code.push(`${serializePropName(key)}: ${item.code}`);
+            code.push(`${serializeRecordKey(key)}: ${item.code}`);
         }
         return {
             type: 'record',
@@ -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/state.ts

@@ -4,6 +4,7 @@ import {
     type AssignmentNode,
     isAssignmentNode,
     isBlockNode,
+    isConstantNode,
     isFunctionAssignmentNode,
     isSymbolNode,
     type MathNode,
@@ -109,7 +110,7 @@ export class BaseState {
         const r = isFunc ? migrateFunctionAssignment(this, node) : migrator(this, node);
         let { code } = r;
         if (stmt && !isFunc && !code.endsWith(';')) code += ';';
-        if (node.comment) code += ' //' + node.comment;
+        if (node.comment) code += ' //' + node.comment.slice(1);
         this.ret.push(code);
     }
     /** 转换 */
@@ -142,6 +143,8 @@ export class BaseState {
                     }
                 }
                 return;
+            } else if (isConstantNode(ast) && ast.value === undefined && ast.comment) {
+                this.ret.push(`//${ast.comment.slice(1)}`);
             } else {
                 this.migrateStmt(migrateLast, false, ast);
                 return;
@@ -160,21 +163,33 @@ export class BaseState {
         // 写入原始 math.js 作为注释
         const lines = this.expr.split('\n').map((line) => `// ${line}`);
         lines.unshift(`// # 原始 math.js 表达式`);
+        const addComment = (prefix: string, item: string) => {
+            if (!item.includes('\n')) {
+                lines.unshift(`// ${prefix}: ${item}`);
+                return;
+            }
+            const l = item.split('\n');
+            const indent = ' '.repeat(prefix.length + 2);
+            for (let i = l.length - 1; i >= 1; i--) {
+                lines.unshift(`// ${indent}${l[i]}`);
+            }
+            lines.unshift(`// ${prefix}: ${l[0]}`);
+        };
         if (this.errors.size || this.warnings.size || this.critical.size) {
             const warnings = [...this.warnings];
             for (let i = warnings.length - 1; i >= 0; i--) {
                 const warn = warnings[i]!;
-                lines.unshift(`// - W: ${warn}`);
+                addComment('- W', warn);
             }
             const errors = [...this.errors];
             for (let i = errors.length - 1; i >= 0; i--) {
                 const err = errors[i]!;
-                lines.unshift(`// - E: ${err}`);
+                addComment('- E', err);
             }
             const critical = [...this.critical];
             for (let i = critical.length - 1; i >= 0; i--) {
                 const crit = critical[i]!;
-                lines.unshift(`// - C: ${crit}`);
+                addComment('- C', crit);
             }
             lines.unshift(`// # 转换日志`);
         }

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/re-exports.ts

@@ -9,13 +9,22 @@ export {
     isVmModule,
     isVmPrimitive,
     isVmRecord,
+    isVmArrayLikeRecord,
+    isVmArrayLikeRecordByEntires,
+    isVmArrayLikeRecordByKeys,
+    isVmCallable,
+    isVmScript,
+    isVmWrapper,
     isVmValue,
     VmExtern,
     VmFunction,
     VmModule,
+    VmError,
+    defineVmContextValue,
 } from '@mirascript/mirascript';
-export { serialize, serializePropName, serializeString, lib, operations } from '@mirascript/mirascript/subtle';
 export type {
+    VmScript,
+    VmValueMap,
     VmAny,
     VmArray,
     VmConst,
@@ -26,3 +35,13 @@ export type {
     VmUninitialized,
     VmValue,
 } from '@mirascript/mirascript';
+export {
+    serialize,
+    serializeRecordKey,
+    serializeString,
+    type SerializeOptions,
+    constants,
+    DefaultVmContext,
+    lib,
+    operations,
+} from '@mirascript/mirascript/subtle';

package/src/scope.ts

@@ -80,10 +80,10 @@ class ScopeProxyHandler implements ProxyHandler<object> {
     }
 }
 
+/** 最大求值计数 */
+const MAX_RECURSION = 500;
 /** 函数的执行环境 */
 export class Scope {
-    /** 最大求值计数 */
-    static readonly MAX_RECURSION = 500;
     constructor(
         /** 生成环境的工厂函数 */
         readonly scope:
@@ -193,7 +193,7 @@ export class Scope {
 
     /** 表达式递归求值 */
     eval(expression: Expression | CompiledExpression, path: readonly PropertyKey[]): VmValue {
-        if (this.evalCounter >= Scope.MAX_RECURSION) {
+        if (this.evalCounter >= MAX_RECURSION) {
             this.evalCounter = 0;
             throw new Error(`Execution recursion exceeds limit`);
         }

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);

package/tests/definition.ts

@@ -85,8 +85,10 @@ describe('definitions', () => {
             null,
         );
         // @ts-expect-error 测试 undefined 输入
-        expect(def.toArgumentValue(undefined, { type: 'real', key: '', name: '', description: '', value: 1 })).toBe(0);
-        expect(def.toArgumentValue(null, { type: 'real', key: '', name: '', description: '', value: 1 })).toBe(0);
+        expect(def.toArgumentValue(undefined, { type: 'real', key: '', name: '', description: '', value: 1 })).toBe(
+            null,
+        );
+        expect(def.toArgumentValue(null, { type: 'real', key: '', name: '', description: '', value: 1 })).toBe(null);
         expect(def.toArgumentValue('12', { type: 'real', key: '', name: '', description: '', value: 1 })).toBe(12);
         expect(def.toArgumentValue(null, { type: 'text', key: '', name: '', description: '', value: '1' })).toBe('');
         expect(def.toArgumentValue(12, { type: 'text', key: '', name: '', description: '', value: '1' })).toBe('12');
@@ -96,7 +98,7 @@ describe('definitions', () => {
 
         expect(
             def.toArgumentValue(null, { type: 'choice', key: '', name: '', description: '', value: 1, choices: [] }),
-        ).toBe(0);
+        ).toBe(null);
         expect(
             def.toArgumentValue(null, {
                 type: 'choice',
@@ -120,7 +122,7 @@ describe('definitions', () => {
                 ],
             }),
         ).toBe('0');
-        expect(def.toArgumentValue(null, { type: 'logical', key: '', name: '', description: '', value: 1 })).toBe(0);
+        expect(def.toArgumentValue(null, { type: 'logical', key: '', name: '', description: '', value: 1 })).toBe(null);
         expect(
             def.toArgumentValue(null, {
                 type: 'logical',
@@ -142,7 +144,7 @@ describe('definitions', () => {
                 description: '',
                 value: true,
             }),
-        ).toBe(false);
+        ).toBe(null);
         expect(
             def.toArgumentValue(null, {
                 type: 'logical',
@@ -194,7 +196,7 @@ describe('definitions', () => {
                 value: [1],
                 choices: [],
             }),
-        ).toStrictEqual([0]);
+        ).toStrictEqual([]);
         expect(
             def.toArgumentValue('', {
                 type: 'multiSelect',
@@ -206,7 +208,7 @@ describe('definitions', () => {
             }),
         ).toStrictEqual(['']);
         expect(
-            def.toArgumentValue(['', '1'], {
+            def.toArgumentValue(['', '1', '  2 '], {
                 type: 'multiSelect',
                 key: '',
                 name: '',
@@ -214,9 +216,9 @@ describe('definitions', () => {
                 value: [1],
                 choices: [],
             }),
-        ).toStrictEqual([0, 1]);
+        ).toStrictEqual([1, 2]);
         expect(
-            def.toArgumentValue(['', '1'], {
+            def.toArgumentValue(['', '1', '  2 '], {
                 type: 'multiSelect',
                 key: '',
                 name: '',
@@ -224,6 +226,6 @@ describe('definitions', () => {
                 value: [1],
                 choices: Expression(''),
             }),
-        ).toStrictEqual(['', '1']);
+        ).toStrictEqual(['', '1', '  2 ']);
     });
 });

package/tests/import.ts

@@ -1,6 +1,6 @@
 import { VmFunction } from '@mirascript/mirascript';
 import { Evaluator, Expression, Scope } from '../dist/index.js';
-import { lib } from '@mirascript/mirascript/subtle';
+import { convert, lib } from '@mirascript/mirascript/subtle';
 
 const e = new Evaluator({
     logger: {
@@ -26,7 +26,7 @@ describe('Import should work correctly', () => {
         expect(e.evaluate(Expression('add(1,2)'), s)).toBe(3);
         expect(e.evaluate(Expression('add::type()'), s)).toBe('extern');
         expect(e2.evaluate(Expression('add(1,2)'), s)).toBe(null);
-        expect(e2.evaluate(Expression('add::type()'), s)).toBe('nil');
+        expect(e2.evaluate(Expression('add::type()'), s)).toBe(null);
     });
 
     it('can remove modules', () => {
@@ -39,7 +39,7 @@ describe('Import should work correctly', () => {
     it('can replace modules', () => {
         e.import({ add: (x: number, y: number) => x + y });
         expect(e.evaluate(Expression('add::type()'), s)).toBe('extern');
-        e.import({ add: VmFunction((x, y) => lib.to_number(x) + lib.to_number(y)) });
+        e.import({ add: VmFunction((x, y) => convert.toNumber(x, 0) + convert.toNumber(y, 0)) });
         expect(e.evaluate(Expression('add::type()'), s)).toBe('function');
     });
 });