@mirascript/mirascript 0.1.21 → 0.1.23

package/src/vm/operations/compound.ts

@@ -0,0 +1,148 @@
+import { VmError } from '../../helpers/error.js';
+import { hasOwnEnumerable, isNaN, keys, create } from '../../helpers/utils.js';
+import { toString } from '../../helpers/convert/index.js';
+import { display } from '../../helpers/serialize.js';
+import { isVmPrimitive, isVmArray, isVmRecord, isVmFunction, isVmExtern, isVmWrapper } from '../../helpers/types.js';
+import type { VmAny, VmImmutable, VmRecord, VmValue, VmConst } from '../types/index.js';
+import { isSame } from './utils.js';
+import { $AssertInit } from './common.js';
+import { $ToNumber, $ToString } from './convert.js';
+
+const { trunc } = Math;
+const { at } = Array.prototype;
+
+export const $In = (value: VmAny, iterable: VmAny): boolean => {
+    $AssertInit(value);
+    $AssertInit(iterable);
+    if (iterable == null) return false;
+    if (typeof iterable != 'object') return false;
+    if (isVmArray(iterable)) {
+        if (value == null) {
+            // array may have empty slots
+            for (const item of iterable) if (item == null) return true;
+            return false;
+        }
+        // JS %SameValueZero is same with `isSame` in this context
+        if (isVmPrimitive(value)) return iterable.includes(value);
+        // value is not null here, so it's ok to skip empty slots, since `isSame(null, something)` is always false
+        return iterable.some((item = null) => isSame(item, value satisfies NonNullable<VmValue>));
+    }
+    // iterable is a record or an extern here, value should be a string
+    const key = toString(value, undefined);
+    if (isVmWrapper(iterable)) return iterable.has(key);
+    return hasOwnEnumerable(iterable satisfies VmRecord, key);
+};
+export const $Length = (value: VmAny): number => {
+    $AssertInit(value);
+    if (isVmArray(value)) return value.length;
+    if (isVmRecord(value)) return keys(value).length;
+    if (isVmWrapper(value)) return value.keys().length;
+
+    throw new VmError(`Value has no length: ${display(value)}`, 0);
+};
+export const $Omit = (value: VmAny, omitted: ReadonlyArray<number | string>): VmRecord => {
+    $AssertInit(value);
+    if (value == null || !isVmRecord(value)) return {};
+    const result: Record<string, VmConst> = {};
+    const valueKeys = keys(value);
+    const omittedSet = new Set(omitted.map($ToString));
+    for (const key of valueKeys) {
+        if (!omittedSet.has(key)) {
+            /* c8 ignore next */
+            result[key] = value[key] ?? null;
+        }
+    }
+    return result;
+};
+export const $Pick = (value: VmAny, picked: ReadonlyArray<number | string>): VmRecord => {
+    $AssertInit(value);
+    if (value == null || !isVmRecord(value)) return {};
+    const result: Record<string, VmConst> = {};
+    for (const key of picked) {
+        const k = $ToString(key);
+        if (hasOwnEnumerable(value, k)) {
+            result[k] = value[k] ?? null;
+        }
+    }
+    return result;
+};
+export const $Has = (obj: VmAny, key: VmAny): boolean => {
+    $AssertInit(obj);
+    const pk = $ToString(key);
+    if (obj == null || typeof obj != 'object') return false;
+    if (isVmWrapper(obj)) return obj.has(pk);
+    return hasOwnEnumerable(obj, pk);
+};
+export const $Get = (obj: VmAny, key: VmAny): VmValue => {
+    $AssertInit(obj);
+    if (isVmArray(obj)) {
+        const index = $ToNumber(key);
+        if (isNaN(index)) return null;
+        return (at.call(obj, trunc(index)) as VmConst | undefined) ?? null;
+    }
+    const pk = $ToString(key);
+    if (obj == null || typeof obj != 'object') return null;
+    if (isVmWrapper(obj)) return obj.get(pk) ?? null;
+    if (!hasOwnEnumerable(obj, pk)) return null;
+    return (obj as Record<string, VmImmutable>)[pk] ?? null;
+};
+export const $Set = (obj: VmAny, key: VmAny, value: VmAny): void => {
+    $AssertInit(obj);
+    $AssertInit(value);
+    const pk = $ToString(key);
+    if (obj == null) return;
+    if (!isVmExtern(obj)) throw new VmError(`Expected extern, got ${display(obj)}`, undefined);
+    obj.set(pk, value);
+};
+export const $Iterable = (value: VmAny): Iterable<VmValue | undefined> => {
+    $AssertInit(value);
+    if (isVmWrapper(value)) return value.keys();
+    if (isVmArray(value)) return value;
+    if (value != null && typeof value == 'object') return keys(value);
+    throw new VmError(`Value is not iterable: ${display(value)}`, isVmFunction(value) ? [] : [value]);
+};
+
+export const $RecordSpread = (record: VmAny): VmRecord | null => {
+    $AssertInit(record);
+    if (record == null || isVmRecord(record)) return record;
+    if (isVmArray(record)) {
+        const result: Record<string, VmConst> = {};
+        const len = record.length;
+        for (let i = 0; i < len; i++) {
+            const item = record[i];
+            result[i] = item ?? null;
+        }
+        return result;
+    }
+    if (isVmExtern(record)) {
+        const result: Record<string, VmConst> = create(null);
+        for (const key of record.keys()) {
+            const value = record.get(key) ?? null;
+            // 当前只有 Primitive 不会进行二次包装
+            if (isVmPrimitive(value)) {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    throw new VmError(`Expected record, array, extern or nil, got ${display(record)}`, null);
+};
+
+export const $ArraySpread = (array: VmAny): Iterable<VmConst | undefined> => {
+    $AssertInit(array);
+    if (array == null) return [];
+    if (isVmArray(array)) return array;
+    if (isVmExtern(array) && typeof (array.value as Iterable<unknown>)[Symbol.iterator] == 'function') {
+        const result: VmConst[] = [];
+        for (const item of array.value as Iterable<unknown>) {
+            // 当前只有 Primitive 不会进行二次包装
+            if (isVmPrimitive(item)) {
+                result.push(item);
+            } else {
+                result.push(null);
+            }
+        }
+        return result;
+    }
+    throw new VmError(`Expected array, iterable extern or nil, got ${display(array)}`, []);
+};

package/src/vm/operations/convert.ts

@@ -0,0 +1,24 @@
+import { toNumber, toString, toBoolean, toFormat } from '../../helpers/convert/index.js';
+import type { VmAny } from '../types/index.js';
+import { $AssertInit } from './common.js';
+
+export const $ToBoolean = (value: VmAny): boolean => {
+    if (typeof value == 'boolean') return value;
+    $AssertInit(value);
+    return toBoolean(value, undefined);
+};
+export const $ToString = (value: VmAny): string => {
+    if (typeof value == 'string') return value;
+    $AssertInit(value);
+    return toString(value, undefined);
+};
+export const $ToNumber = (value: VmAny): number => {
+    if (typeof value == 'number') return value;
+    $AssertInit(value);
+    return toNumber(value, undefined);
+};
+export const $Format = (value: VmAny, format: VmAny): string => {
+    $AssertInit(value);
+    const f = format == null ? '' : $ToString(format);
+    return toFormat(value, f);
+};

package/src/vm/operations/cp.ts

@@ -0,0 +1 @@
+export { Cp as $Cp, CpEnter as $CpEnter, CpExit as $CpExit } from '../checkpoint.js';

package/src/vm/{helpers.ts → operations/helpers.ts}

@@ -1,16 +1,15 @@
-import { create, defineProperty, isFinite } from '../helpers/utils.js';
-import { VM_ARRAY_MAX_LENGTH, VM_FUNCTION_ANONYMOUS_NAME } from '../helpers/constants.js';
-import { isVmConst } from '../helpers/types.js';
-import { $AssertInit, $ToNumber } from './operations.js';
-import type { VmFunctionLike } from './types/function.js';
-import { DefaultVmContext, type VmContext } from './types/context.js';
-import type { VmConst, VmAny, VmArray, VmValue } from './types/index.js';
-import { VmFunction } from './types/function.js';
-
-export { Cp, CpEnter, CpExit } from './checkpoint.js';
+import { create, defineProperty, isFinite } from '../../helpers/utils.js';
+import { VM_ARRAY_MAX_LENGTH, VM_FUNCTION_ANONYMOUS_NAME } from '../../helpers/constants.js';
+import { isVmConst } from '../../helpers/types.js';
+import type { VmFunctionLike } from '../types/function.js';
+import { DefaultVmContext, type VmContext } from '../types/context.js';
+import type { VmConst, VmAny, VmArray, VmValue } from '../types/index.js';
+import { VmFunction } from '../types/function.js';
+import { $AssertInit } from './common.js';
+import { $ToNumber } from './convert.js';
 
 /** 过滤剩余参数数组 */
-export const Vargs = (varags: VmAny[]): VmArray => {
+export const $VArgs = (varags: VmAny[]): VmArray => {
     for (let i = 0, l = varags.length; i < l; i++) {
         const el = varags[i];
         if (!isVmConst(el)) {
@@ -21,7 +20,7 @@ export const Vargs = (varags: VmAny[]): VmArray => {
 };
 
 /** 构造 record | array 元素 */
-export const Element = (value: VmAny): VmConst => {
+export const $El = (value: VmAny): VmConst => {
     $AssertInit(value);
     if (!isVmConst(value)) return null;
     return value;
@@ -29,20 +28,20 @@ export const Element = (value: VmAny): VmConst => {
 
 const EMPTY = create(null);
 /** 构造 record 可选元素 */
-export const ElementOpt = (key: string, value: VmAny): VmConst => {
+export const $ElOpt = (key: string, value: VmAny): VmConst => {
     $AssertInit(value);
     if (value == null || !isVmConst(value)) return EMPTY;
     return { __proto__: null, [key]: value };
 };
 
 /** 构造函数和函数表达式 */
-export const Function = (name: string | null | undefined, fn: VmFunctionLike): VmFunction => {
+export const $Fn = (name: string | null | undefined, fn: VmFunctionLike): VmFunction => {
     defineProperty(fn, 'name', { value: name || VM_FUNCTION_ANONYMOUS_NAME });
     return VmFunction(fn, { isLib: false, injectCp: false });
 };
 
 /** 读取闭包上值 */
-export const Upvalue = (value: VmAny): VmValue => {
+export const $Upvalue = (value: VmAny): VmValue => {
     $AssertInit(value);
     return value;
 };
@@ -55,7 +54,7 @@ const assertArrayLength = (start: number, end: number) => {
 const isEmptyRange = (start: number, end: number) => {
     return !isFinite(start) || !isFinite(end) || start > end;
 };
-export const ArrayRange = (start: VmAny, end: VmAny): VmArray => {
+export const $ArrayRange = (start: VmAny, end: VmAny): VmArray => {
     const s = $ToNumber(start);
     const e = $ToNumber(end);
     if (isEmptyRange(s, e)) return [];
@@ -66,7 +65,7 @@ export const ArrayRange = (start: VmAny, end: VmAny): VmArray => {
     }
     return arr;
 };
-export const ArrayRangeExclusive = (start: VmAny, end: VmAny): VmArray => {
+export const $ArrayRangeExclusive = (start: VmAny, end: VmAny): VmArray => {
     const s = $ToNumber(start);
     const e = $ToNumber(end);
     if (isEmptyRange(s, e)) return [];
@@ -79,6 +78,6 @@ export const ArrayRangeExclusive = (start: VmAny, end: VmAny): VmArray => {
 };
 
 /** 默认执行上下文 */
-export function GlobalFallback(): VmContext {
+export function $GlobalFallback(): VmContext {
     return DefaultVmContext;
 }

package/src/vm/operations/index.ts

@@ -0,0 +1,9 @@
+export * from './common.js';
+export * from './convert.js';
+export * from './type-check.js';
+export * from './operator.js';
+export * from './slice.js';
+export * from './helpers.js';
+export * from './compound.js';
+export * from './cp.js';
+export * from './call.js';

package/src/vm/operations/operator.ts

@@ -0,0 +1,131 @@
+import { toFormat } from '../../helpers/convert/index.js';
+import { isNaN } from '../../helpers/utils.js';
+import type { VmAny } from '../types/index.js';
+import { $AssertInit } from './common.js';
+import { $ToBoolean, $ToNumber, $ToString } from './convert.js';
+import { isSame, overloadNumberString } from './utils.js';
+
+// String operations
+export const $Concat = (...args: readonly string[]): string => {
+    return args.map((a) => toFormat(a, null)).join('');
+};
+
+// Unary operations
+export const $Pos = (a: VmAny): number => {
+    return $ToNumber(a);
+};
+export const $Neg = (a: VmAny): number => {
+    return -$ToNumber(a);
+};
+export const $Not = (a: VmAny): boolean => {
+    return !$ToBoolean(a);
+};
+
+// Math operations
+export const $Add = (a: VmAny, b: VmAny): number => {
+    return $ToNumber(a) + $ToNumber(b);
+};
+export const $Sub = (a: VmAny, b: VmAny): number => {
+    return $ToNumber(a) - $ToNumber(b);
+};
+export const $Mul = (a: VmAny, b: VmAny): number => {
+    return $ToNumber(a) * $ToNumber(b);
+};
+export const $Div = (a: VmAny, b: VmAny): number => {
+    return $ToNumber(a) / $ToNumber(b);
+};
+export const $Mod = (a: VmAny, b: VmAny): number => {
+    return $ToNumber(a) % $ToNumber(b);
+};
+export const $Pow = (a: VmAny, b: VmAny): number => {
+    return $ToNumber(a) ** $ToNumber(b);
+};
+
+// Logical operations without short-circuiting
+export const $And = (a: VmAny, b: VmAny): boolean => {
+    return $ToBoolean(a) && $ToBoolean(b);
+};
+export const $Or = (a: VmAny, b: VmAny): boolean => {
+    return $ToBoolean(a) || $ToBoolean(b);
+};
+
+// Comparison operations
+export const $Gt = (a: VmAny, b: VmAny): boolean => {
+    if (overloadNumberString(a, b)) {
+        return $ToNumber(a) > $ToNumber(b);
+    } else {
+        return $ToString(a) > $ToString(b);
+    }
+};
+export const $Gte = (a: VmAny, b: VmAny): boolean => {
+    if (overloadNumberString(a, b)) {
+        return $ToNumber(a) >= $ToNumber(b);
+    } else {
+        return $ToString(a) >= $ToString(b);
+    }
+};
+export const $Lt = (a: VmAny, b: VmAny): boolean => {
+    if (overloadNumberString(a, b)) {
+        return $ToNumber(a) < $ToNumber(b);
+    } else {
+        return $ToString(a) < $ToString(b);
+    }
+};
+export const $Lte = (a: VmAny, b: VmAny): boolean => {
+    if (overloadNumberString(a, b)) {
+        return $ToNumber(a) <= $ToNumber(b);
+    } else {
+        return $ToString(a) <= $ToString(b);
+    }
+};
+
+// Equality operations
+export const $Eq = (a: VmAny, b: VmAny): boolean => {
+    $AssertInit(a);
+    $AssertInit(b);
+    // Number comparison is a special case to handle NaN correctly
+    if (typeof a == 'number' && typeof b == 'number') return a === b;
+    return isSame(a, b);
+};
+export const $Neq = (a: VmAny, b: VmAny): boolean => {
+    return !$Eq(a, b);
+};
+
+const { abs, min } = Math;
+export const $Aeq = (a: VmAny, b: VmAny): boolean => {
+    if (overloadNumberString(a, b)) {
+        const an = $ToNumber(a);
+        const bn = $ToNumber(b);
+        const EPS = 1e-15;
+        if (isNaN(an) || isNaN(bn)) return false;
+        // Since Inf - Inf is NaN, we must check for equality first
+        if (an === bn) return true;
+        const absoluteDifference = abs(an - bn);
+        if (absoluteDifference < EPS) return true;
+        const base = min(abs(an), abs(bn));
+        return absoluteDifference < base * EPS;
+    } else {
+        // For strings, we use normalized case-insensitive comparison
+        const as = $ToString(a);
+        const bs = $ToString(b);
+        if (as === bs) return true;
+        const ai = as.toLowerCase();
+        const bi = bs.toLowerCase();
+        if (ai === bi) return true;
+        const an = ai.normalize('NFC');
+        const bn = bi.normalize('NFC');
+        return an === bn;
+    }
+};
+export const $Naeq = (a: VmAny, b: VmAny): boolean => {
+    return !$Aeq(a, b);
+};
+
+export const $Same = (a: VmAny, b: VmAny): boolean => {
+    $AssertInit(a);
+    $AssertInit(b);
+    return isSame(a, b);
+};
+export const $Nsame = (a: VmAny, b: VmAny): boolean => {
+    return !$Same(a, b);
+};

package/src/vm/operations/slice.ts

@@ -0,0 +1,41 @@
+import { VmError } from '../../helpers/error.js';
+import { display } from '../../helpers/serialize.js';
+import { isNaN, isSafeInteger } from '../../helpers/utils.js';
+import { isVmArray } from '../../helpers/types.js';
+import type { VmAny, VmArray } from '../types/index.js';
+import { $AssertInit } from './common.js';
+import { $ToNumber } from './convert.js';
+const { ceil } = Math;
+const { slice } = Array.prototype;
+
+const sliceCore = (value: VmArray, start: number, end: number, exclusive: boolean): VmArray => {
+    const { length } = value;
+
+    if (isNaN(start)) start = 0;
+    else if (start < 0) start = length + start;
+    if (isNaN(end)) end = exclusive ? length : length - 1;
+    else if (end < 0) end = length + end;
+
+    start = ceil(start);
+    if (exclusive || !isSafeInteger(end)) {
+        end = ceil(end);
+    } else {
+        end = end + 1;
+    }
+    return slice.call(value, start, end) satisfies unknown[] as VmArray;
+};
+
+export const $Slice = (value: VmAny, start: VmAny, end: VmAny): VmArray => {
+    $AssertInit(value);
+    if (!isVmArray(value)) throw new VmError(`Expected array, got ${display(value)}`, []);
+    const s = start != null ? $ToNumber(start) : 0;
+    const e = end != null ? $ToNumber(end) : value.length - 1;
+    return sliceCore(value, s, e, false);
+};
+export const $SliceExclusive = (value: VmAny, start: VmAny, end: VmAny): VmArray => {
+    $AssertInit(value);
+    if (!isVmArray(value)) throw new VmError(`Expected array, got ${display(value)}`, []);
+    const s = start != null ? $ToNumber(start) : 0;
+    const e = end != null ? $ToNumber(end) : value.length;
+    return sliceCore(value, s, e, true);
+};

package/src/vm/operations/type-check.ts

@@ -0,0 +1,38 @@
+import { VmError } from '../../helpers/error.js';
+import { isVmArray, isVmRecord, isVmWrapper } from '../../helpers/types.js';
+import type { TypeName, VmAny, VmArray, VmRecord, VmValue } from '../types/index.js';
+import { $AssertInit } from './common.js';
+
+export const $Type = (value: VmAny): TypeName => {
+    // 允许未初始化值通过
+    if (value == null) return 'nil';
+    if (isVmWrapper(value)) return value.type;
+    if (isVmArray(value)) return 'array';
+    if (typeof value == 'object') return 'record';
+    return typeof value as TypeName;
+};
+export const $IsBoolean = (value: VmAny): value is boolean => {
+    $AssertInit(value);
+    return typeof value == 'boolean';
+};
+export const $IsNumber = (value: VmAny): value is number => {
+    $AssertInit(value);
+    return typeof value == 'number';
+};
+export const $IsString = (value: VmAny): value is string => {
+    $AssertInit(value);
+    return typeof value == 'string';
+};
+export const $IsRecord = (value: VmAny): value is VmRecord => {
+    $AssertInit(value);
+    return isVmRecord(value);
+};
+export const $IsArray = (value: VmAny): value is VmArray => {
+    $AssertInit(value);
+    return isVmArray(value);
+};
+export const $AssertNonNil = (value: VmAny): asserts value is NonNullable<VmValue> => {
+    $AssertInit(value);
+    if (value !== null) return;
+    throw new VmError(`Expected non-nil value`, null);
+};

package/src/vm/operations/utils.ts

@@ -0,0 +1,66 @@
+import { hasOwnEnumerable, isNaN, keys } from '../../helpers/utils.js';
+import { isVmArray, isVmWrapper } from '../../helpers/types.js';
+import type { VmAny, VmValue } from '../types/index.js';
+
+/**
+ * 确定操作的重载
+ * @returns 如果应按数字处理则返回 true；如果应按字符串处理则返回 false
+ */
+export function overloadNumberString(a: VmAny, b: VmAny): boolean {
+    if (typeof a == 'number' || typeof b == 'number') return true;
+    if (typeof a == 'string' || typeof b == 'string') return false;
+    return true;
+}
+
+/**
+ * 检查两个 VmValue 是否相同
+ */
+export function isSame(a: VmValue, b: VmValue): boolean {
+    // Check for NaN
+    if (typeof a == 'number' && typeof b == 'number') {
+        return a === b || (isNaN(a) && isNaN(b));
+    }
+    // Check all primitive types, and fast path for reference equality
+    if (a === b) return true;
+    // Any primitives and functions arrive here are not equal
+    if (a == null || typeof a != 'object' || b == null || typeof b != 'object') return false;
+    // Handle wrapper values
+    if (isVmWrapper(a)) return a.same(b);
+    if (isVmWrapper(b)) return b.same(a);
+    // Handle array values
+    if (isVmArray(a) && isVmArray(b)) {
+        const len = a.length;
+        if (len !== b.length) {
+            return false;
+        }
+        // Compare array items
+        for (let i = 0; i < len; i++) {
+            if (!isSame(a[i] ?? null, b[i] ?? null)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Handle record values
+    if (!isVmArray(a) && !isVmArray(b)) {
+        // Compare record fields
+        const aKeys = keys(a);
+        const bKeys = keys(b);
+        if (aKeys.length !== bKeys.length) {
+            return false;
+        }
+        for (const key of aKeys) {
+            if (!hasOwnEnumerable(b, key)) {
+                return false;
+            }
+            /* c8 ignore next 2 */
+            const av = a[key] ?? null;
+            const bv = b[key] ?? null;
+            if (!isSame(av, bv)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}

package/src/vm/types/boundary.ts

@@ -4,7 +4,7 @@ import { kVmFunctionProxy } from '../../helpers/constants.js';
 import type { VmFunctionLike, VmFunction } from './function.js';
 import { VmExtern } from './extern.js';
 import type { VmAny, VmConst, VmModule, VmPrimitive, VmValue } from './index.js';
-import { $Call } from '../operations.js';
+import { $Call } from '../operations/call.js';
 
 /** 创建 Mirascript 函数在宿主语言运行的代理 */
 export function toVmFunctionProxy<T extends VmFunctionLike>(fn: VmFunction<T>): T {
@@ -15,7 +15,7 @@ export function toVmFunctionProxy<T extends VmFunctionLike>(fn: VmFunction<T>):
         const ret = $Call(
             fn,
             // 作为函数参数传入的值一定丢失了它的 this
-            args.map((v) => wrapToVmValue(v, null)),
+            args.map((v) => wrapToVmValue(v, null, null)),
         );
         return unwrapFromVmValue(ret);
     };
@@ -29,26 +29,26 @@ export function toVmFunctionProxy<T extends VmFunctionLike>(fn: VmFunction<T>):
 }
 
 /** 解开 Mirascript 函数在宿主语言运行的代理 */
-export function fromVmFunctionProxy<T extends VmFunctionLike>(fn: T): VmFunction<T> | undefined {
+export function fromVmFunctionProxy<T extends VmFunctionLike>(fn: T): VmFunction<T> | null {
     if (isVmFunction(fn)) return fn;
 
     const original = (fn as unknown as { [kVmFunctionProxy]?: VmFunction<T> })[kVmFunctionProxy];
     if (original && isVmFunction(original)) return original;
 
-    return undefined;
+    return null;
 }
 
 /** 将宿主语言的值包装为 Mirascript 类型 */
 export function wrapToVmValue(
     value: unknown,
-    thisArg: VmExtern | null = null,
-    assumeVmValue?: (obj: object) => obj is Exclude<VmConst, VmPrimitive>,
+    thisArg: unknown = null,
+    assumeVmValue: ((obj: object) => obj is Exclude<VmConst, VmPrimitive>) | null = null,
 ): VmValue {
     if (value == null) return null;
     switch (typeof value) {
         case 'function': {
             const unwrapped = fromVmFunctionProxy(value as VmFunctionLike);
-            if (unwrapped) return unwrapped;
+            if (unwrapped != null) return unwrapped;
             return new VmExtern(value as () => never, thisArg);
         }
         case 'object': {
@@ -71,6 +71,16 @@ export function wrapToVmValue(
     }
 }
 
+/** 创建绑定 */
+function bindThis<T extends (...args: unknown[]) => unknown>(fn: T, thisArg: unknown): T {
+    if (thisArg == null) return fn;
+    return new Proxy(fn, {
+        apply(target, _thisArg, args) {
+            return apply(target, thisArg, args);
+        },
+    });
+}
+
 /** 取消宿主语言的值的 Mirascript 包装  */
 export function unwrapFromVmValue(value: VmAny): unknown {
     if (isVmFunction(value)) {
@@ -83,10 +93,5 @@ export function unwrapFromVmValue(value: VmAny): unknown {
         return value.value;
     }
     const f = value as VmExtern<(...args: unknown[]) => unknown>;
-    const caller = f.thisArg!.value;
-    return new Proxy(f.value, {
-        apply(target, thisArg, args): unknown {
-            return apply(target, caller, args);
-        },
-    });
+    return bindThis(f.value, f.thisArg);
 }