@mirascript/mirascript 0.1.62-alpha.9 → 0.1.63

package/src/vm/operations/helpers.ts

@@ -1,86 +1,52 @@
-import { create, defineProperty, entries, isFinite } from '../../helpers/utils.js';
-import { VM_ARRAY_MAX_LENGTH, VM_FUNCTION_ANONYMOUS_NAME } from '../../helpers/constants.js';
+import { create, defineProperty, entries } from '../../helpers/utils.js';
+import { 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, VmImmutable } from '../types/index.js';
+import type { VmConst, VmAny, VmValue, VmImmutable } from '../types/index.js';
 import { VmModule } from '../types/module.js';
 import { VmFunction } from '../types/function.js';
 import { $AssertInit } from './common.js';
-import { $ToNumber } from './convert.js';
 
 /** 构造 module */
-export function $Module<T extends Record<string, () => VmImmutable>>(
+export const $Module = <T extends Record<string, () => VmImmutable>>(
     name: string,
     body: T,
-): VmModule<{ [K in keyof T]: ReturnType<T[K]> }> {
+): VmModule<{ [K in keyof T]: ReturnType<T[K]> }> => {
     const mod = create(null) as { [K in keyof T]: ReturnType<T[K]> };
     for (const [key, get] of entries(body)) {
-        defineProperty(mod, key, { __proto__: null, get, enumerable: true });
+        defineProperty(mod, key, { __proto__: null, get, enumerable: true, configurable: true });
     }
     return new VmModule(name, mod);
-}
+};
 
 /** 构造 record | array 元素 */
-export function $El(value: VmAny): VmConst {
+export const $El = (value: VmAny): VmConst => {
     $AssertInit(value);
     if (!isVmConst(value)) return null;
     return value;
-}
+};
 
 const EMPTY = create(null);
 /** 构造 record 可选元素 */
-export function $ElOpt(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 function $Fn<T extends VmFunctionLike>(name: string | null | undefined, fn: T): VmFunction<T> {
-    return VmFunction(fn, { isLib: false, injectCp: false, name: name || VM_FUNCTION_ANONYMOUS_NAME });
-}
+export const $Fn = <T extends VmFunctionLike>(name: string | null | undefined, fn: T): VmFunction<T> => {
+    return VmFunction(fn, { isLib: false, name: name || VM_FUNCTION_ANONYMOUS_NAME });
+};
 
 /** 读取闭包上值 */
-export function $Upvalue<T extends VmValue>(value: T | undefined): T {
+export const $Upvalue = <T extends VmValue>(value: T | undefined): T => {
     $AssertInit(value);
     return value;
-}
-
-const assertArrayLength = (len: number) => {
-    if (len > VM_ARRAY_MAX_LENGTH) {
-        throw new RangeError(`Array length exceeds maximum limit of ${VM_ARRAY_MAX_LENGTH}`);
-    }
-};
-const isEmptyRange = (start: number, end: number) => {
-    return !isFinite(start) || !isFinite(end) || start > end;
 };
-/** 构造范围数组 */
-export function $ArrayRange(start: VmAny, end: VmAny): VmArray {
-    const s = $ToNumber(start);
-    const e = $ToNumber(end);
-    if (isEmptyRange(s, e)) return [];
-    assertArrayLength(e - s + 1);
-    const arr = [];
-    for (let i = s; i <= e; i++) {
-        arr.push(i);
-    }
-    return arr;
-}
-/** 构造范围数组（不包含结束值） */
-export function $ArrayRangeExclusive(start: VmAny, end: VmAny): VmArray {
-    const s = $ToNumber(start);
-    const e = $ToNumber(end);
-    if (isEmptyRange(s, e)) return [];
-    assertArrayLength(e - s);
-    const arr = [];
-    for (let i = s; i < e; i++) {
-        arr.push(i);
-    }
-    return arr;
-}
 
 /** 默认执行上下文 */
-export function $GlobalFallback(): VmContext {
+export const $GlobalFallback = (): VmContext => {
     return DefaultVmContext;
-}
+};

package/src/vm/operations/index.ts

@@ -7,3 +7,4 @@ export * from './helpers.js';
 export * from './compound.js';
 export * from './cp.js';
 export * from './call.js';
+export * from './array-range.js';

package/src/vm/operations/operator.ts

@@ -7,111 +7,121 @@ import { isSame, overloadNumberString } from './utils.js';
 
 // String operations
 /** 字符串连接 */
-export function $Concat(...args: readonly string[]): string {
+export function $Concat(...args: readonly VmAny[]): string {
     return args.map((a) => toFormat(a, null)).join('');
 }
 
 // Unary operations
 /** 正号 */
-export function $Pos(a: VmAny): number {
-    return $ToNumber(a);
-}
+export const $Pos = $ToNumber;
 /** 负号 */
-export function $Neg(a: VmAny): number {
-    return -$ToNumber(a);
-}
+export const $Neg = (a: VmAny): number => -$ToNumber(a);
 /** 非 */
-export function $Not(a: VmAny): boolean {
-    return !$ToBoolean(a);
-}
+export const $Not = (a: VmAny): boolean => !$ToBoolean(a);
 
 // Math operations
+const add = (a: VmAny, b: VmAny): number => $ToNumber(a) + $ToNumber(b);
 /** 加法 */
-export function $Add(a: VmAny, b: VmAny): number {
-    return $ToNumber(a) + $ToNumber(b);
-}
+export const $Add = (a: VmAny, b: VmAny): number => {
+    if (typeof a == 'number' && typeof b == 'number') return a + b;
+    return add(a, b);
+};
+const sub = (a: VmAny, b: VmAny): number => $ToNumber(a) - $ToNumber(b);
 /** 减法 */
-export function $Sub(a: VmAny, b: VmAny): number {
-    return $ToNumber(a) - $ToNumber(b);
-}
+export const $Sub = (a: VmAny, b: VmAny): number => {
+    if (typeof a == 'number' && typeof b == 'number') return a - b;
+    return sub(a, b);
+};
+const mul = (a: VmAny, b: VmAny): number => $ToNumber(a) * $ToNumber(b);
 /** 乘法 */
-export function $Mul(a: VmAny, b: VmAny): number {
-    return $ToNumber(a) * $ToNumber(b);
-}
+export const $Mul = (a: VmAny, b: VmAny): number => {
+    if (typeof a == 'number' && typeof b == 'number') return a * b;
+    return mul(a, b);
+};
+const div = (a: VmAny, b: VmAny): number => $ToNumber(a) / $ToNumber(b);
 /** 除法 */
-export function $Div(a: VmAny, b: VmAny): number {
-    return $ToNumber(a) / $ToNumber(b);
-}
+export const $Div = (a: VmAny, b: VmAny): number => {
+    if (typeof a == 'number' && typeof b == 'number') return a / b;
+    return div(a, b);
+};
+const mod = (a: VmAny, b: VmAny): number => $ToNumber(a) % $ToNumber(b);
 /** 取模 */
-export function $Mod(a: VmAny, b: VmAny): number {
-    return $ToNumber(a) % $ToNumber(b);
-}
+export const $Mod = (a: VmAny, b: VmAny): number => {
+    if (typeof a == 'number' && typeof b == 'number') return a % b;
+    return mod(a, b);
+};
+const pow = (a: VmAny, b: VmAny): number => $ToNumber(a) ** $ToNumber(b);
 /** 乘方 */
-export function $Pow(a: VmAny, b: VmAny): number {
-    return $ToNumber(a) ** $ToNumber(b);
-}
+export const $Pow = (a: VmAny, b: VmAny): number => {
+    if (typeof a == 'number' && typeof b == 'number') return a ** b;
+    return pow(a, b);
+};
 
 // Logical operations without short-circuiting
+const and = (a: VmAny, b: VmAny): boolean => $ToBoolean(a) && $ToBoolean(b);
 /** 与 */
-export function $And(a: VmAny, b: VmAny): boolean {
-    return $ToBoolean(a) && $ToBoolean(b);
-}
+export const $And = (a: VmAny, b: VmAny): boolean => {
+    if (typeof a == 'boolean' && typeof b == 'boolean') return a && b;
+    return and(a, b);
+};
+const or = (a: VmAny, b: VmAny): boolean => $ToBoolean(a) || $ToBoolean(b);
 /** 或 */
-export function $Or(a: VmAny, b: VmAny): boolean {
-    return $ToBoolean(a) || $ToBoolean(b);
-}
+export const $Or = (a: VmAny, b: VmAny): boolean => {
+    if (typeof a == 'boolean' && typeof b == 'boolean') return a || b;
+    return or(a, b);
+};
 
 // Comparison operations
 /** 大于 */
-export function $Gt(a: VmAny, b: VmAny): boolean {
+export const $Gt = (a: VmAny, b: VmAny): boolean => {
     if (overloadNumberString(a, b)) {
         return $ToNumber(a) > $ToNumber(b);
     } else {
         return $ToString(a) > $ToString(b);
     }
-}
+};
 /** 大于等于 */
-export function $Gte(a: VmAny, b: VmAny): boolean {
+export const $Gte = (a: VmAny, b: VmAny): boolean => {
     if (overloadNumberString(a, b)) {
         return $ToNumber(a) >= $ToNumber(b);
     } else {
         return $ToString(a) >= $ToString(b);
     }
-}
+};
 /** 小于 */
-export function $Lt(a: VmAny, b: VmAny): boolean {
+export const $Lt = (a: VmAny, b: VmAny): boolean => {
     if (overloadNumberString(a, b)) {
         return $ToNumber(a) < $ToNumber(b);
     } else {
         return $ToString(a) < $ToString(b);
     }
-}
+};
 /** 小于等于 */
-export function $Lte(a: VmAny, b: VmAny): boolean {
+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 function $Eq(a: VmAny, b: VmAny): boolean {
+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 function $Neq(a: VmAny, b: VmAny): boolean {
+export const $Neq = (a: VmAny, b: VmAny): boolean => {
     return !$Eq(a, b);
-}
+};
 
 const { abs, min } = Math;
 /** 近似等于 */
-export function $Aeq(a: VmAny, b: VmAny): boolean {
+export const $Aeq = (a: VmAny, b: VmAny): boolean => {
     if (overloadNumberString(a, b)) {
         const an = $ToNumber(a);
         const bn = $ToNumber(b);
@@ -135,19 +145,19 @@ export function $Aeq(a: VmAny, b: VmAny): boolean {
         const bn = bi.normalize('NFC');
         return an === bn;
     }
-}
+};
 /** 不近似等于 */
-export function $Naeq(a: VmAny, b: VmAny): boolean {
+export const $Naeq = (a: VmAny, b: VmAny): boolean => {
     return !$Aeq(a, b);
-}
+};
 
 /** 全等于 */
-export function $Same(a: VmAny, b: VmAny): boolean {
+export const $Same = (a: VmAny, b: VmAny): boolean => {
     $AssertInit(a);
     $AssertInit(b);
     return isSame(a, b);
-}
+};
 /** 不全等于 */
-export function $Nsame(a: VmAny, b: VmAny): boolean {
+export const $Nsame = (a: VmAny, b: VmAny): boolean => {
     return !$Same(a, b);
-}
+};

package/src/vm/operations/slice.ts

@@ -13,6 +13,7 @@ const sliceCore = (value: VmArray, start: number, end: number, exclusive: boolea
 
     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;
 
@@ -26,18 +27,18 @@ const sliceCore = (value: VmArray, start: number, end: number, exclusive: boolea
 };
 
 /** 获取数组切片 */
-export function $Slice(value: VmAny, start: VmAny, end: VmAny): 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 function $SliceExclusive(value: VmAny, start: VmAny, end: VmAny): VmArray {
+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

@@ -1,45 +1,42 @@
 import { VmError } from '../../helpers/error.js';
-import { isVmArray, isVmRecord, isVmWrapper } from '../../helpers/types.js';
+import { getVmType, isVmArray, isVmRecord } from '../../helpers/types.js';
 import type { VmTypeName, VmAny, VmArray, VmRecord, VmValue } from '../types/index.js';
 import { $AssertInit } from './common.js';
 
 /** 获取值的类型名称 */
-export function $Type(value: VmAny): VmTypeName {
+export const $Type = (value: VmAny): VmTypeName => {
     // 允许未初始化值通过
     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 VmTypeName;
-}
+    return getVmType(value);
+};
 /** 判断值是否为布尔值 */
-export function $IsBoolean(value: VmAny): value is boolean {
+export const $IsBoolean: (value: VmAny) => value is boolean = (value) => {
     $AssertInit(value);
     return typeof value == 'boolean';
-}
+};
 /** 判断值是否为数字 */
-export function $IsNumber(value: VmAny): value is number {
+export const $IsNumber: (value: VmAny) => value is number = (value) => {
     $AssertInit(value);
     return typeof value == 'number';
-}
+};
 /** 判断值是否为字符串 */
-export function $IsString(value: VmAny): value is string {
+export const $IsString: (value: VmAny) => value is string = (value) => {
     $AssertInit(value);
     return typeof value == 'string';
-}
+};
 /** 判断值是否为记录 */
-export function $IsRecord(value: VmAny): value is VmRecord {
+export const $IsRecord: (value: VmAny) => value is VmRecord = (value) => {
     $AssertInit(value);
     return isVmRecord(value);
-}
+};
 /** 判断值是否为数组 */
-export function $IsArray(value: VmAny): value is VmArray {
+export const $IsArray: (value: VmAny) => value is VmArray = (value) => {
     $AssertInit(value);
     return isVmArray(value);
-}
+};
 /** 断言值非 nil */
-export function $AssertNonNil<T extends VmValue>(value: T | undefined): asserts value is NonNullable<T> {
+export const $AssertNonNil: <T extends VmValue>(value: T | undefined) => asserts value is NonNullable<T> = (value) => {
     $AssertInit(value);
     if (value !== null) return;
     throw new VmError(`Expected non-nil value`, null);
-}
+};

package/src/vm/operations/utils.ts

@@ -6,16 +6,16 @@ import type { VmAny, VmValue } from '../types/index.js';
  * 确定操作的重载
  * @returns 如果应按数字处理则返回 true；如果应按字符串处理则返回 false
  */
-export function overloadNumberString(a: VmAny, b: VmAny): boolean {
+export const 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 {
+export const isSame = (a: VmValue, b: VmValue): boolean => {
     // Check for NaN
     if (typeof a == 'number' && typeof b == 'number') {
         return a === b || (isNaN(a) && isNaN(b));
@@ -63,4 +63,4 @@ export function isSame(a: VmValue, b: VmValue): boolean {
         return true;
     }
     return false;
-}
+};

package/src/vm/types/boundary.ts

@@ -1,10 +1,10 @@
 import { defineProperty, apply } from '../../helpers/utils.js';
 import { isVmExtern, isVmFunction, isVmWrapper } from '../../helpers/types.js';
 import { kVmFunctionProxy } from '../../helpers/constants.js';
+import { $Call } from '../operations/call.js';
+import type { VmAny, VmConst, VmModule, VmPrimitive, VmValue } from './index.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/call.js';
 
 /** 创建 Mirascript 函数在宿主语言运行的代理 */
 export function toVmFunctionProxy<T extends VmFunctionLike>(fn: VmFunction<T>): T {

package/src/vm/types/context.ts

@@ -1,10 +1,9 @@
-import { create, defineProperty, hasOwn, keys } from '../../helpers/utils.js';
+import { create, defineProperty, hasOwn, keys, freeze } from '../../helpers/utils.js';
 import { VmError } from '../../helpers/error.js';
 import { kVmContext } from '../../helpers/constants.js';
 import type { VmAny, VmImmutable, VmValue } from './index.js';
 import { wrapToVmValue } from './boundary.js';
 import { VmFunction } from './function.js';
-const { freeze } = Object;
 
 /** MiraScript 执行上下文 */
 export interface VmContext {

package/src/vm/types/function.ts

@@ -1,11 +1,10 @@
 import type { Writable } from 'type-fest';
 import type { DiagnosticCode } from '@mirascript/constants';
-import { defineProperty } from '../../helpers/utils.js';
+import { defineProperty, freeze } from '../../helpers/utils.js';
 import { kVmFunction, VM_FUNCTION_ANONYMOUS_NAME } from '../../helpers/constants.js';
 import { isVmFunction } from '../../helpers/types.js';
 import type { VmAny, VmValue } from './index.js';
 import { fromVmFunctionProxy } from './boundary.js';
-import { CpEnter, CpExit } from '../checkpoint.js';
 import type { VmLib } from '../lib/helpers.js';
 
 /**
@@ -37,8 +36,6 @@ export type VmFunctionInfo = {
     readonly returnsType?: string;
     /** 文档字符串 */
     readonly examples?: string[];
-    /** 如果添加了包装，返回原函数 */
-    readonly original?: VmFunctionLike;
     /** 标记为弃用 */
     readonly deprecated?: { use?: string; message: DiagnosticCode };
 };
@@ -47,8 +44,6 @@ export type VmFunctionInfo = {
 export type VmFunctionOption = Partial<Omit<VmFunctionInfo, 'original'>> & {
     /** 函数名称 */
     readonly name?: string | null | undefined;
-    /** 是否注入检查点 */
-    readonly injectCp?: boolean;
 };
 
 const nameIfNotAnonymous = <T>({ name }: { name: string | undefined }, fallback: T): string | T => {
@@ -76,7 +71,6 @@ export function VmFunction<T extends VmFunctionLike>(
         opt = {
             ...option,
             isLib: true,
-            injectCp: false,
             name: nameIfNotAnonymous(option, null),
         };
     } else {
@@ -96,20 +90,7 @@ export function VmFunction<T extends VmFunctionLike>(
         deprecated: opt.deprecated ?? undefined,
     };
     const name = opt.name ?? fn.name;
-    if (opt.injectCp) {
-        const original = fn;
-        info.original = original;
-        fn = ((...args) => {
-            try {
-                CpEnter();
-                const ret = original(...args);
-                return ret;
-            } finally {
-                CpExit();
-            }
-        }) as typeof fn;
-    }
     defineProperty(fn, 'name', { value: name, configurable: true });
-    defineProperty(fn, kVmFunction, { value: Object.freeze(info) });
+    defineProperty(fn, kVmFunction, { value: freeze(info) });
     return fn as VmFunction<T>;
 }

package/src/vm/types/index.ts

@@ -72,6 +72,7 @@ export {
     isVmValue,
     isVmWrapper,
     getVmFunctionInfo,
+    getVmType,
 } from '../../helpers/types.js';
 
 export { wrapToVmValue, unwrapFromVmValue } from './boundary.js';

package/bench/index.ts

@@ -1,45 +0,0 @@
-import { Bench } from 'tinybench';
-import { compile, compileSync, createVmContext } from '@mirascript/mirascript';
-
-const bench = new Bench({ name: 'simple benchmark', time: 100 });
-const source = `sin(x) + cos(y + PI / 2) + `.repeat(1) + '0';
-const env = { x: 1, y: 2 };
-
-bench
-    .add('compile', async () => {
-        await Promise.all(Array.from({ length: 10 }).map(async () => compile(source)));
-    })
-    .add('compileSync', () => {
-        compileSync(source);
-    });
-
-bench.add('createVmContext', () => {
-    return createVmContext(env);
-});
-
-const vmContext = createVmContext(env);
-const script = compileSync(source);
-bench.add('run', () => {
-    return script(vmContext);
-});
-
-bench.add('nativeCompile', () => {
-    // eslint-disable-next-line @typescript-eslint/no-implied-eval
-    return new Function('context', `const {sin,cos,PI,x,y} = context; return ${source};`);
-});
-bench.add('nativeCreateContext', () => {
-    return { __proto__: Math, ...env };
-});
-const nativeContext = { __proto__: Math, ...env };
-// eslint-disable-next-line @typescript-eslint/no-implied-eval
-const nativeScript = new Function('context', `const {sin,cos,PI,x,y} = context; return ${source};`) as (
-    context: Record<string, unknown>,
-) => unknown;
-
-bench.add('nativeRun', () => {
-    return nativeScript(nativeContext);
-});
-
-await bench.run();
-// eslint-disable-next-line no-console
-console.table(bench.table());