@mirascript/mirascript 0.1.15 → 0.1.17

package/src/vm/checkpoint.ts

@@ -0,0 +1,42 @@
+const MAX_DEPTH = 128;
+
+let cpDepth = 0;
+let cp = Number.NaN;
+let cpTimeout = 100; // Default timeout in milliseconds
+/** 检查点 */
+export function Cp(): void {
+    if (!cp) {
+        cp = Date.now();
+    } else if (Date.now() - cp > cpTimeout) {
+        throw new RangeError('Execution timeout');
+    }
+}
+/** 检查点 */
+export function CpEnter(): void {
+    cpDepth++;
+    if (cpDepth <= 1) {
+        cp = Date.now();
+        cpDepth = 1;
+    } else if (cpDepth > MAX_DEPTH) {
+        throw new RangeError('Maximum call depth exceeded');
+    } else {
+        Cp();
+    }
+}
+/** 检查点 */
+export function CpExit(): void {
+    cpDepth--;
+    if (cpDepth < 1) {
+        cp = Number.NaN;
+        cpDepth = 0;
+    } else {
+        Cp();
+    }
+}
+/** 设置检查点超时时间 */
+export function configCheckpoint(timeout = 100): void {
+    if (typeof timeout !== 'number' || timeout <= 0 || Number.isNaN(timeout)) {
+        throw new RangeError('Invalid timeout value');
+    }
+    cpTimeout = timeout;
+}

package/src/vm/helpers.ts

@@ -1,16 +1,13 @@
+import { 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 {
-    isVmConst,
-    VmFunction,
-    type VmConst,
-    type VmAny,
-    type VmArray,
-    type VmValue,
-    VM_ARRAY_MAX_LENGTH,
-} from './types/index.js';
-import { isFinite } from '../helpers/utils.js';
+import type { VmConst, VmAny, VmArray, VmValue } from './types/index.js';
+import { VmFunction } from './types/function.js';
+
+export { Cp, CpEnter, CpExit } from './checkpoint.js';
 
 export const Vargs = (varags: VmAny[]): VmArray => {
     for (let i = 0, l = varags.length; i < l; i++) {
@@ -33,7 +30,8 @@ export const ElementOpt = (key: string, value: VmAny): VmConst => {
     return { [key]: value };
 };
 
-export const Function = (fn: VmFunctionLike): VmFunction => {
+export const Function = (fn: VmFunctionLike, name: string = VM_FUNCTION_ANONYMOUS_NAME): VmFunction => {
+    defineProperty(fn, 'name', { value: name });
     return VmFunction(fn, { isLib: false, injectCp: false });
 };
 
@@ -73,48 +71,6 @@ export const ArrayRangeExclusive = (start: VmAny, end: VmAny): VmArray => {
     return arr;
 };
 
-const MAX_DEPTH = 128;
-
-let cpDepth = 0;
-let cp = Number.NaN;
-let cpTimeout = 100; // Default timeout in milliseconds
-/** 检查点 */
-export function Cp(): void {
-    if (!cp) {
-        cp = Date.now();
-    } else if (Date.now() - cp > cpTimeout) {
-        throw new RangeError('Execution timeout');
-    }
-}
-/** 检查点 */
-export function CpEnter(): void {
-    cpDepth++;
-    if (cpDepth <= 1) {
-        cp = Date.now();
-        cpDepth = 1;
-    } else if (cpDepth > MAX_DEPTH) {
-        throw new RangeError('Maximum call depth exceeded');
-    } else {
-        Cp();
-    }
-}
-/** 检查点 */
-export function CpExit(): void {
-    cpDepth--;
-    if (cpDepth < 1) {
-        cp = Number.NaN;
-        cpDepth = 0;
-    } else {
-        Cp();
-    }
-}
-/** 设置检查点超时时间 */
-export function configCheckpoint(timeout = 100): void {
-    if (typeof timeout !== 'number' || timeout <= 0 || Number.isNaN(timeout)) {
-        throw new RangeError('Invalid timeout value');
-    }
-    cpTimeout = timeout;
-}
 /** 默认执行上下文 */
 export function GlobalFallback(): VmContext {
     return DefaultVmContext;

package/src/vm/index.ts

@@ -1,5 +1,5 @@
-import './lib/_loader.js';
+import './lib/index.js';
 
-export * from './error.js';
+export { VmError } from '../helpers/error.js';
 export * from './types/index.js';
-export { configCheckpoint } from './helpers.js';
+export { configCheckpoint } from './checkpoint.js';

package/src/vm/lib/global/bit.ts

@@ -1,9 +1,8 @@
-import { $ToNumber } from '../../operations.js';
-import { VmLib } from '../_helpers.js';
+import { VmLib, expectNumber } from '../helpers.js';
 
 export const b_and = VmLib(
     (x, y) => {
-        return $ToNumber(x) & $ToNumber(y);
+        return expectNumber(0, x) & expectNumber(1, y);
     },
     {
         summary: '返回两个数的按位与',
@@ -16,7 +15,7 @@ export const b_and = VmLib(
 
 export const b_or = VmLib(
     (x, y) => {
-        return $ToNumber(x) | $ToNumber(y);
+        return expectNumber(0, x) | expectNumber(1, y);
     },
     {
         summary: '返回两个数的按位或',
@@ -29,7 +28,7 @@ export const b_or = VmLib(
 
 export const b_not = VmLib(
     (x) => {
-        return ~$ToNumber(x);
+        return ~expectNumber('x', x);
     },
     {
         summary: '返回一个数的按位取反',
@@ -42,7 +41,7 @@ export const b_not = VmLib(
 
 export const b_xor = VmLib(
     (x, y) => {
-        return $ToNumber(x) ^ $ToNumber(y);
+        return expectNumber(0, x) ^ expectNumber(1, y);
     },
     {
         summary: '返回两个数的按位异或',
@@ -55,7 +54,7 @@ export const b_xor = VmLib(
 
 export const shl = VmLib(
     (x, y) => {
-        return $ToNumber(x) << $ToNumber(y);
+        return expectNumber(0, x) << expectNumber(1, y);
     },
     {
         summary: '返回第一个操作数左移指定的位数',
@@ -68,7 +67,7 @@ export const shl = VmLib(
 
 export const sar = VmLib(
     (x, y) => {
-        return $ToNumber(x) >> $ToNumber(y);
+        return expectNumber(0, x) >> expectNumber(1, y);
     },
     {
         summary: '返回第一个操作数右移指定的位数',
@@ -81,7 +80,7 @@ export const sar = VmLib(
 
 export const shr = VmLib(
     (x, y) => {
-        return $ToNumber(x) >>> $ToNumber(y);
+        return expectNumber(0, x) >>> expectNumber(1, y);
     },
     {
         summary: '返回第一个操作数无符号右移指定的位数',

package/src/vm/lib/global/debug.ts

@@ -1,8 +1,8 @@
 import supportsColor from 'supports-color';
-import { VmError } from '../../error.js';
-import { $ToString } from '../../operations.js';
+import { VmError } from '../../../helpers/error.js';
+import { toString } from '../../../helpers/convert/to-string.js';
 import type { VmAny } from '../../types/index.js';
-import { VmLib } from '../_helpers.js';
+import { VmLib } from '../helpers.js';
 
 export const debug_print = VmLib(
     (...args) => {
@@ -27,7 +27,8 @@ export const panic = VmLib(
         if (message === undefined) console.error(...panic.prefix);
         // eslint-disable-next-line no-console
         else console.error(...panic.prefix, message);
-        const error = message == null ? 'panic' : 'panic: ' + $ToString(message);
+        const mgsStr = toString(message, null);
+        const error = !mgsStr ? 'panic' : 'panic: ' + mgsStr;
         throw new VmError(error, undefined);
     },
     {

package/src/vm/lib/global/index.ts

@@ -6,4 +6,3 @@ export * from './json.js';
 export * from './to-primitive.js';
 export * from './string.js';
 export * from './time.js';
-export * from './mod/index.js';

package/src/vm/lib/global/json.ts

@@ -1,5 +1,5 @@
 import { isVmExtern, isVmModule } from '../../types/index.js';
-import { required, rethrowError, VmLib } from '../_helpers.js';
+import { required, rethrowError, VmLib } from '../helpers.js';
 const { parse, stringify } = JSON;
 
 export const to_json = VmLib(
@@ -31,7 +31,7 @@ export const from_json = VmLib(
         try {
             return parse(json);
         } catch (ex) {
-            if (fallback != null) return fallback;
+            if (fallback !== undefined) return fallback;
             rethrowError('Invalid JSON', ex, null);
         }
     },

package/src/vm/lib/global/math-additional.ts

@@ -1,7 +1,6 @@
 /* eslint-disable no-loss-of-precision */
 import { isInteger, isNaN } from '../../../helpers/utils.js';
-import { $ToNumber } from '../../operations.js';
-import { required, VmLib } from '../_helpers.js';
+import { expectNumber, VmLib } from '../helpers.js';
 const { sqrt, pow, exp } = Math;
 
 const GAMMA_G = 4.742_187_5;
@@ -18,8 +17,7 @@ const SQRT_2_PI = sqrt(2 * Math.PI);
 
 export const factorial = VmLib(
     (x): number => {
-        required('x', x, Number.NaN);
-        let n = $ToNumber(x);
+        let n = expectNumber('x', x);
         if (isNaN(n) || n < 0) return Number.NaN;
         if (n >= 171) return Number.POSITIVE_INFINITY; // will overflow
 

package/src/vm/lib/global/math-arr.ts

@@ -1,5 +1,5 @@
 import type { VmAny } from '../../types/index.js';
-import { getNumbers, VmLib } from '../_helpers.js';
+import { getNumbers, VmLib } from '../helpers.js';
 
 /** 生成函数 */
 function build(f: (...values: readonly number[]) => number): (...values: readonly VmAny[]) => number {

package/src/vm/lib/global/math-unary.ts

@@ -1,12 +1,10 @@
 import type { VmAny } from '../../index.js';
-import { $ToNumber } from '../../operations.js';
-import { required, VmLib } from '../_helpers.js';
+import { expectNumber, VmLib } from '../helpers.js';
 
 /** 生成函数 */
 function build(f: (x: number) => number): (x: VmAny) => number {
     return (x) => {
-        required('x', x, Number.NaN);
-        return f($ToNumber(x));
+        return f(expectNumber('x', x));
     };
 }
 

package/src/vm/lib/global/math.ts

@@ -1,14 +1,13 @@
-import { $ToNumber } from '../../operations.js';
-import { VmLib } from '../_helpers.js';
+import { expectNumber, VmLib } from '../helpers.js';
 const { atan2: _atan2, pow: _pow } = Math;
 
-export const atan2 = VmLib((x, y) => _atan2($ToNumber(x), $ToNumber(y)), {
+export const atan2 = VmLib((x, y) => _atan2(expectNumber(0, x), expectNumber(1, y)), {
     summary: '返回从原点到点 (x, y) 的角度（弧度）',
     params: { x: 'x 坐标', y: 'y 坐标' },
     paramsType: { x: 'number', y: 'number' },
     returnsType: 'number',
 });
-export const pow = VmLib((x, y) => _pow($ToNumber(x), $ToNumber(y)), {
+export const pow = VmLib((x, y) => _pow(expectNumber(0, x), expectNumber(1, y)), {
     summary: '返回 x 的 y 次幂',
     params: { x: '底数', y: '指数' },
     paramsType: { x: 'number', y: 'number' },

package/src/vm/lib/global/sequence/all-any.ts

@@ -1,8 +1,9 @@
+import { toBoolean } from '../../../../helpers/convert/to-boolean.js';
 import { entries } from '../../../../helpers/utils.js';
 import { Cp } from '../../../helpers.js';
-import { $Call, $ToBoolean } from '../../../operations.js';
+import { $Call } from '../../../operations.js';
 import { isVmArray } from '../../../types/index.js';
-import { expectArrayOrRecord, expectCallable, VmLib } from '../../_helpers.js';
+import { expectArrayOrRecord, expectCallable, VmLib } from '../../helpers.js';
 
 export const all = VmLib(
     (data, predicate) => {
@@ -11,17 +12,19 @@ export const all = VmLib(
         if (isVmArray(data)) {
             for (let i = 0; i < data.length; i++) {
                 Cp();
+                /* c8 ignore next */
                 const value = data[i] ?? null;
                 const ret = $Call(predicate, [value, i, data]);
-                if (!$ToBoolean(ret)) return false;
+                if (!toBoolean(ret, undefined)) return false;
             }
             return true;
         } else {
             for (const [key, v] of entries(data)) {
                 Cp();
+                /* c8 ignore next */
                 const value = v ?? null;
                 const ret = $Call(predicate, [value, key, data]);
-                if (!$ToBoolean(ret)) return false;
+                if (!toBoolean(ret, undefined)) return false;
             }
             return true;
         }
@@ -45,17 +48,19 @@ export const any = VmLib(
         if (isVmArray(data)) {
             for (let i = 0; i < data.length; i++) {
                 Cp();
+                /* c8 ignore next */
                 const value = data[i] ?? null;
                 const ret = $Call(predicate, [value, i, data]);
-                if ($ToBoolean(ret)) return true;
+                if (toBoolean(ret, undefined)) return true;
             }
             return false;
         } else {
             for (const [key, v] of entries(data)) {
                 Cp();
+                /* c8 ignore next */
                 const value = v ?? null;
                 const ret = $Call(predicate, [value, key, data]);
-                if ($ToBoolean(ret)) return true;
+                if (toBoolean(ret, undefined)) return true;
             }
             return false;
         }

package/src/vm/lib/global/sequence/entries.ts

@@ -1,5 +1,5 @@
 import { isVmArray, isVmRecord, type VmConst } from '../../../types/index.js';
-import { VmLib, expectArrayOrRecord, expectCompound } from '../../_helpers.js';
+import { VmLib, expectArrayOrRecord, expectCompound } from '../../helpers.js';
 import { keys as _keys, values as _values, entries as _entries } from '../../../../helpers/utils.js';
 
 export const keys = VmLib(

package/src/vm/lib/global/sequence/find.ts

@@ -1,8 +1,9 @@
+import { toBoolean } from '../../../../helpers/convert/to-boolean.js';
 import { entries } from '../../../../helpers/utils.js';
 import { Cp } from '../../../helpers.js';
-import { $Call, $Same, $ToBoolean } from '../../../operations.js';
+import { $Call, $Same } from '../../../operations.js';
 import { type VmValue, isVmArray, isVmCallable } from '../../../types/index.js';
-import { VmLib, expectArrayOrRecord, required } from '../../_helpers.js';
+import { VmLib, expectArrayOrRecord, required } from '../../helpers.js';
 
 export const find = VmLib(
     (data, predicate) => {
@@ -11,7 +12,7 @@ export const find = VmLib(
         const p = isVmCallable(predicate)
             ? (value: VmValue, key: number | string, data: VmValue) => {
                   const ret = $Call(predicate, [value, key, data]);
-                  return $ToBoolean(ret);
+                  return toBoolean(ret, undefined);
               }
             : (value: VmValue) => $Same(predicate, value);
         if (isVmArray(data)) {

package/src/vm/lib/global/sequence/flatten.ts

@@ -1,10 +1,9 @@
-import { $ToNumber } from '../../../operations.js';
-import { VmLib, expectArray } from '../../_helpers.js';
+import { VmLib, expectArray, expectNumber } from '../../helpers.js';
 
 export const flatten = VmLib(
     (data, depth = 1) => {
         expectArray('data', data, data);
-        return data.flat($ToNumber(depth) as 1);
+        return data.flat(expectNumber('depth', depth) as 1);
     },
     {
         summary: '将数组扁平化',

package/src/vm/lib/global/sequence/len.ts

@@ -1,4 +1,4 @@
-import { VmLib, expectArray } from '../../_helpers.js';
+import { VmLib, expectArray } from '../../helpers.js';
 
 export const len = VmLib(
     (arr) => {

package/src/vm/lib/global/sequence/map-filter.ts

@@ -1,6 +1,7 @@
-import { $Call, $ToBoolean } from '../../../operations.js';
+import { toBoolean } from '../../../../helpers/convert/to-boolean.js';
+import { $Call } from '../../../operations.js';
 import { isVmConst, type VmAny, type VmValue } from '../../../types/index.js';
-import { VmLib, expectCallable, expectConst, map as mapImpl } from '../../_helpers.js';
+import { VmLib, expectCallable, expectConst, map as mapImpl } from '../../helpers.js';
 
 export * from './with.js';
 export * from './entries.js';
@@ -43,7 +44,7 @@ export const filter = VmLib(
     (data, predicate) =>
         mapImplWrapped(data, 'predicate', predicate, (fn, value, key, data) => {
             const ret = $Call(fn, [value, key, data]);
-            return $ToBoolean(ret) ? value : undefined;
+            return toBoolean(ret, undefined) ? value : undefined;
         }),
     {
         summary: '过滤数组或记录中的元素，返回满足条件的元素',

package/src/vm/lib/global/sequence/repeat.ts

@@ -1,12 +1,10 @@
-import { $ToNumber } from '../../../operations.js';
 import type { VmConst } from '../../../types/index.js';
-import { arrayLen, expectConst, required, VmLib } from '../../_helpers.js';
+import { arrayLen, expectConst, expectNumber, VmLib } from '../../helpers.js';
 
 export const repeat = VmLib(
     (data, times) => {
         expectConst('data', data, []);
-        required('times', times, []);
-        const n = arrayLen($ToNumber(times));
+        const n = arrayLen(expectNumber('times', times));
         const result: VmConst[] = [];
         result.length = n;
         result.fill(data);

package/src/vm/lib/global/sequence/reverse.ts

@@ -1,4 +1,4 @@
-import { VmLib, expectArray } from '../../_helpers.js';
+import { VmLib, expectArray } from '../../helpers.js';
 
 export const reverse = VmLib(
     (arr) => {

package/src/vm/lib/global/sequence/sort.ts

@@ -1,6 +1,7 @@
-import { $Call, $ToNumber } from '../../../operations.js';
+import { toNumber } from '../../../../helpers/convert/to-number.js';
+import { $Call } from '../../../operations.js';
 import type { VmAny, VmConst, VmValue } from '../../../types/index.js';
-import { VmLib, expectArray, expectCallable } from '../../_helpers.js';
+import { VmLib, expectArray, expectCallable } from '../../helpers.js';
 
 /** 默认比较 */
 function defaultCompare(a: VmValue = null, b: VmValue = null): number {
@@ -13,8 +14,8 @@ function defaultCompare(a: VmValue = null, b: VmValue = null): number {
         return 0;
     }
     // nan is treated as 0
-    const an = $ToNumber(a) || 0;
-    const bn = $ToNumber(b) || 0;
+    const an = toNumber(a, 0) || 0;
+    const bn = toNumber(b, 0) || 0;
     if (an < bn) return -1;
     if (an > bn) return 1;
     return 0;
@@ -26,7 +27,7 @@ function cmp(comparator: VmAny, recovered: VmValue): typeof defaultCompare {
     expectCallable('comparator', comparator, recovered);
     return (a: VmValue = null, b: VmValue = null) => {
         const ret = $Call(comparator, [a, b]);
-        return $ToNumber(ret);
+        return toNumber(ret, 0);
     };
 }
 

package/src/vm/lib/global/sequence/with.ts

@@ -1,24 +1,27 @@
-import { isArray, isSafeInteger } from '../../../../helpers/utils.js';
+import { VM_ARRAY_MAX_LENGTH } from '../../../../helpers/constants.js';
+import { toNumber, toString } from '../../../../helpers/convert/index.js';
+import { isVmArray, isVmRecord } from '../../../../helpers/types.js';
+import { isArray, isInteger, isNaN } from '../../../../helpers/utils.js';
 import { Element } from '../../../helpers.js';
-import { $ToNumber, $ToString } from '../../../operations.js';
-import {
-    isVmArray,
-    isVmRecord,
-    VM_ARRAY_MAX_LENGTH,
-    type VmArray,
-    type VmConst,
-    type VmValue,
-} from '../../../types/index.js';
-import { VmLib, expectArrayOrRecord, expectConst, throwError } from '../../_helpers.js';
+import type { VmArray, VmConst, VmValue } from '../../../types/index.js';
+import { VmLib, expectArrayOrRecord, expectConst, throwError } from '../../helpers.js';
 
 const arrIndex = (index: NonNullable<VmConst>): number => {
-    const idx = Math.trunc($ToNumber(index));
-    if (!isSafeInteger(idx) || idx < 0 || idx >= VM_ARRAY_MAX_LENGTH) {
-        return -1;
+    const idx = Math.trunc(toNumber(index, Number.NaN));
+    if (isNaN(idx) || idx < 0) {
+        throwError('Array index must be a non-negative integer', index);
+    }
+    if (idx >= VM_ARRAY_MAX_LENGTH) {
+        throwError(`Array index exceeds maximum limit of ${VM_ARRAY_MAX_LENGTH}`, index);
     }
     return idx;
 };
 
+const isArrIndex = (key: NonNullable<VmConst>): key is number => {
+    if (typeof key != 'number') return false;
+    return isInteger(key) && key >= 0 && key < VM_ARRAY_MAX_LENGTH;
+};
+
 const withInner = (obj: VmConst | undefined, key: VmArray, keyIndex: number, value: VmConst): VmConst => {
     if (keyIndex >= key.length) {
         return value;
@@ -29,7 +32,7 @@ const withInner = (obj: VmConst | undefined, key: VmArray, keyIndex: number, val
         result = [...obj];
     } else if (isVmRecord(obj)) {
         result = { ...obj };
-    } else if (arrIndex(k) === k) {
+    } else if (isArrIndex(k)) {
         result = [];
     } else {
         result = {};
@@ -41,7 +44,7 @@ const withInner = (obj: VmConst | undefined, key: VmArray, keyIndex: number, val
         }
         result[index] = withInner(result[index], key, keyIndex + 1, value);
     } else {
-        const prop = $ToString(k);
+        const prop = toString(k, undefined);
         result[prop] = withInner(result[prop], key, keyIndex + 1, value);
     }
     return result;
@@ -86,11 +89,9 @@ const _with = VmLib(
                 let val: VmConst;
                 if (isVmArray(key)) {
                     index = arrIndex(key[0]!);
-                    if (index < 0) continue;
                     val = withInner(result[index], key, 1, value);
                 } else {
                     index = arrIndex(key);
-                    if (index < 0) continue;
                     val = value;
                 }
                 while (index > result.length) {
@@ -106,10 +107,10 @@ const _with = VmLib(
                 let val: VmConst;
                 if (isVmArray(key)) {
                     const firstKey = key[0]!;
-                    prop = $ToString(firstKey);
+                    prop = toString(firstKey, undefined);
                     val = withInner(result[prop], key, 1, value);
                 } else {
-                    prop = $ToString(key);
+                    prop = toString(key, undefined);
                     val = value;
                 }
                 result[prop] = val;

package/src/vm/lib/global/sequence/zip.ts

@@ -1,7 +1,7 @@
-import { serialize } from '../../../../subtle.js';
+import { display } from '../../../../helpers/serialize.js';
 import { Cp } from '../../../helpers.js';
 import { isVmArray, type VmConst, type VmArray } from '../../../types/index.js';
-import { VmLib, throwError } from '../../_helpers.js';
+import { VmLib, throwError } from '../../helpers.js';
 import { entries } from './entries.js';
 
 export const zip = VmLib(
@@ -10,7 +10,7 @@ export const zip = VmLib(
         let len = 0;
         for (const { 0: key, 1: arr } of ets) {
             if (!isVmArray(arr)) {
-                throwError(`data[${serialize(key)}] is not an array`, null);
+                throwError(`data[${display(key)}] is not an array: ${display(arr)}`, null);
             }
             len = Math.max(len, arr.length);
         }