@mirascript/mirascript 0.1.74 → 0.1.78

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

@@ -1,19 +1,31 @@
-import { isVmExtern, isVmModule } from '../../types/index.js';
+import { isVmExtern, isVmModule, type VmValue } from '../../types/index.js';
 import { expectString, required, rethrowError, VmLib } from '../helpers.js';
 const { parse, stringify } = JSON;
 
 export const to_json = VmLib(
     (data) => {
         required('data', data, null);
-        if (isVmExtern(data) || isVmModule(data)) {
-            try {
-                return stringify(data.value) ?? null;
-            } catch (ex) {
-                rethrowError('Failed to convert extern to JSON', ex, '{}');
-            }
-        }
         if (typeof data == 'function') return null;
-        return stringify(data);
+        return stringify(data, (key, value: VmValue) => {
+            if (typeof value == 'function') {
+                return undefined;
+            }
+            if (isVmModule(value)) {
+                return value.value as JSONValue;
+            }
+            if (isVmExtern(value)) {
+                const extern = value.value;
+                if ('toJSON' in extern && typeof extern.toJSON == 'function') {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+                    return extern.toJSON() as JSONValue;
+                }
+                if (typeof extern == 'function') {
+                    return undefined;
+                }
+                return extern as JSONValue;
+            }
+            return value as JSONValue;
+        });
     },
     {
         summary: '将数据转换为 JSON 字符串',

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

@@ -26,5 +26,5 @@ export const random = VmLib(() => _random(), {
 export * from './arr.js';
 export * from './const.js';
 export * from './unary.js';
-export * from './round.js';
-export { gamma, factorial } from './gamma.js';
+export * from './to-int.js';
+export { gamma, factorial } from './tgamma.js';

package/src/vm/lib/global/math/{gamma.ts → tgamma.ts}

@@ -81,22 +81,16 @@ function sinpi(x: number): number {
 const N = 12;
 
 // static const double g = 6.024680040776729583740234375;
-const GMHALF = 5.524_680_040_776_729_583_740_234_375 as const;
+const GMHALF = 5.524680040776729583740234375 as const;
 
 const SNUM = [
-    23_531_376_880.410_759_688_572_007_674_451_636_754_734_846_804_94,
-    42_919_803_642.649_098_768_957_899_047_001_988_850_926_355_848_959,
-    35_711_959_237.355_668_049_440_185_451_547_166_705_960_488_635_843,
-    17_921_034_426.037_209_699_919_755_754_458_931_112_671_403_265_39,
-    6_039_542_586.352_028_005_064_291_644_307_297_921_069_938_842_070_8,
-    1_439_720_407.311_721_673_663_223_072_794_912_393_971_548_578_677_2,
-    248_874_557.862_054_156_511_460_386_413_229_423_216_321_251_278_01,
-    31_426_415.585_400_194_380_614_231_628_318_205_362_874_684_987_64,
-    2_876_370.628_935_372_441_225_409_051_620_849_613_599_114_537_876_8,
-    186_056.265_395_223_495_040_294_989_716_045_699_282_207_842_363_28,
-    8071.672_002_365_816_210_638_002_902_272_250_613_821_851_632_502_4,
-    210.824_277_751_579_345_872_509_733_920_713_362_711_669_695_802_91,
-    2.506_628_274_631_000_270_164_908_177_133_837_338_626_431_079_340_8,
+    23_531_376_880.41075968857200767445163675473484680494, 42_919_803_642.649098768957899047001988850926355848959,
+    35_711_959_237.355668049440185451547166705960488635843, 17_921_034_426.03720969991975575445893111267140326539,
+    6_039_542_586.3520280050642916443072979210699388420708, 1_439_720_407.3117216736632230727949123939715485786772,
+    248_874_557.86205415651146038641322942321632125127801, 31_426_415.58540019438061423162831820536287468498764,
+    2_876_370.6289353724412254090516208496135991145378768, 186_056.26539522349504029498971604569928220784236328,
+    8071.6720023658162106380029022722506138218516325024, 210.82427775157934587250973392071336271166969580291,
+    2.5066282746310002701649081771338373386264310793408,
 ] as const;
 
 const SDEN = [

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

@@ -56,8 +56,13 @@ export const entries = VmLib(
                 arr.push({ 0: i, 1: data[i] ?? null });
             }
             return arr;
+        } else {
+            const arr: Array<{ 0: string; 1: VmConst }> = [];
+            for (const [key, value] of _entries(data)) {
+                arr.push({ 0: key, 1: value ?? null });
+            }
+            return arr;
         }
-        return _entries(data).map(([key, value]) => ({ 0: key, 1: value ?? null }));
     },
     {
         summary: '返回数组或记录的键值对列表',

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

@@ -0,0 +1,30 @@
+import { $Call } from '../../../operations/index.js';
+import type { VmValue } from '../../../types/index.js';
+import { VmLib, expectCallable, expectConst, iterate, required } from '../../helpers.js';
+
+export const fold = VmLib(
+    (data, initial, f) => {
+        required('initial', initial, null);
+        expectConst('data', data, null);
+        expectCallable('f', f, data);
+
+        let acc: VmValue = initial;
+        iterate(data, (value, index, data) => {
+            acc = $Call(f, [acc, value, index, data]);
+        });
+        return acc;
+    },
+    {
+        summary: '对数组或记录中的每个元素应用函数，并返回累积结果',
+        params: {
+            data: { type: 'array | record', description: '要折叠的数组或记录' },
+            initial: { type: 'any', description: '初始累积值' },
+            f: {
+                type: 'fn(acc: type(initial), value: any, key: number | string, input: type(data)) -> type(initial)',
+                description: '应用于每个元素的函数',
+            },
+        },
+        returns: { type: 'type(initial)' },
+        examples: ['fold([1, 2, 3], 0, fn (acc, x) { acc + x }) // 6'],
+    },
+);

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

@@ -0,0 +1,37 @@
+import { toString } from '../../../../helpers/convert/to-string.js';
+import { fromEntries } from '../../../../helpers/utils.js';
+import { $Call } from '../../../operations/call.js';
+import type { VmConst } from '../../../types/index.js';
+import { VmLib, expectArray, expectCallable } from '../../helpers.js';
+
+export const group_by = VmLib(
+    (data, key) => {
+        expectArray('data', data, null);
+        expectCallable('key', key, data);
+        const result = new Map<string, VmConst[]>();
+        const len = data.length;
+        for (let i = 0; i < len; i++) {
+            const v = data[i] ?? null;
+            const k = toString($Call(key, [v, i, data]), undefined);
+            let arr = result.get(k);
+            if (!arr) {
+                arr = [];
+                result.set(k, arr);
+            }
+            arr.push(v);
+        }
+        return fromEntries(result);
+    },
+    {
+        summary: '根据指定的键函数对数组进行分组',
+        params: {
+            data: { type: 'array', description: '要分组的数组' },
+            key: {
+                type: 'fn(value: any, index: number, arr: type(data)) -> string',
+                description: '用于生成分组键的函数',
+            },
+        },
+        returns: { type: 'record' },
+        examples: ['group_by([1, 2, 3, 4], fn { it % 2 }) // ("0": [2, 4], "1": [1, 3])'],
+    },
+);

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

@@ -11,3 +11,5 @@ export * from './sort.js';
 export * from './unique.js';
 export * from './repeat.js';
 export * from './new.js';
+export * from './fold.js';
+export * from './group.js';

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

@@ -1,7 +1,7 @@
 import { toBoolean } from '../../../../helpers/convert/to-boolean.js';
 import { $Call } from '../../../operations/index.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, iterate } from '../../helpers.js';
 
 export * from './with.js';
 export * from './entries.js';
@@ -16,7 +16,7 @@ function mapImplWrapped(
 ): VmValue {
     expectConst('data', data, null);
     expectCallable(fnName, fn, data);
-    return mapImpl(data, (value, index, data) => {
+    return iterate(data, (value, index, data) => {
         const ret = mapper(fn, value, index, data);
         if (ret === undefined || isVmConst(ret)) return ret;
         return null;

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

@@ -1,7 +1,13 @@
 import type { VmArray, VmConst, VmRecord } from '../../../types/index.js';
 import { toString } from '../../../../helpers/convert/to-string.js';
 import { VM_ARRAY_MAX_LENGTH } from '../../../../helpers/constants.js';
-import { keys as _keys, values as _values, entries as _entries, PositiveInfinity } from '../../../../helpers/utils.js';
+import {
+    keys as _keys,
+    values as _values,
+    entries as _entries,
+    PositiveInfinity,
+    setRecord,
+} from '../../../../helpers/utils.js';
 import { $Call, $El, $Get } from '../../../operations/index.js';
 import { VmLib, expectCallable, expectIntegerRange } from '../../helpers.js';
 
@@ -15,7 +21,7 @@ export const new_record = VmLib(
             if (entry == null) continue;
             const key = $Get(entry, 0);
             const value = $El($Get(entry, 1));
-            result[toString(key)] = value;
+            setRecord(result, toString(key), value);
         }
         return result;
     },

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

@@ -1,16 +1,17 @@
 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, NotNumber } from '../../../../helpers/utils.js';
+import { isArray, isInteger, isFinite, NotNumber, setRecord, getRecord } from '../../../../helpers/utils.js';
 import { $El } from '../../../operations/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, NotNumber));
-    if (isNaN(idx) || idx < 0) {
+    const num = toNumber(index, NotNumber);
+    if (!isFinite(num) || num < 0) {
         throwError('Array index must be a non-negative integer', index);
     }
+    const idx = Math.trunc(num);
     if (idx >= VM_ARRAY_MAX_LENGTH) {
         throwError(`Array index exceeds maximum limit of ${VM_ARRAY_MAX_LENGTH}`, index);
     }
@@ -45,7 +46,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, undefined);
-        result[prop] = withInner(result[prop], key, keyIndex + 1, value);
+        setRecord(result, prop, withInner(result[prop], key, keyIndex + 1, value));
     }
     return result;
 };
@@ -109,12 +110,12 @@ const _with = VmLib(
                 if (isVmArray(key)) {
                     const firstKey = key[0]!;
                     prop = toString(firstKey, undefined);
-                    val = withInner(result[prop], key, 1, value);
+                    val = withInner(getRecord(result, prop), key, 1, value);
                 } else {
                     prop = toString(key, undefined);
                     val = value;
                 }
-                result[prop] = val;
+                setRecord(result, prop, val);
             }
             return result;
         }

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

@@ -1,12 +1,13 @@
 import { display } from '../../../../helpers/serialize.js';
+import { setRecord } from '../../../../helpers/utils.js';
 import { Cp } from '../../../checkpoint.js';
-import { isVmArray, type VmConst, type VmArray } from '../../../types/index.js';
+import { isVmArray, type VmConst, type VmArray, type VmRecord } from '../../../types/index.js';
 import { VmLib, throwError } from '../../helpers.js';
 import { entries } from './entries.js';
 
 export const zip = VmLib(
     (data) => {
-        const ets = entries(data);
+        const ets = entries(data) as Array<{ 0: string | number; 1: VmArray }>;
         let length = 0;
         for (const { 0: key, 1: arr } of ets) {
             if (!isVmArray(arr)) {
@@ -15,15 +16,25 @@ export const zip = VmLib(
             length = Math.max(length, arr.length);
         }
         if (length === 0) return [];
-        const result: Array<Record<number | string, VmConst>> = [];
-        const isArr = isVmArray(data);
-        for (let i = 0; i < length; i++) {
-            Cp();
-            const obj: Record<number | string, VmConst> = isArr ? ([] as Record<number, VmConst>) : {};
-            for (const { 0: key, 1: arr } of ets) {
-                obj[key] = (arr as VmArray)[i] ?? null;
+        const result: Array<VmArray | VmRecord> = [];
+        if (isVmArray(data)) {
+            for (let i = 0; i < length; i++) {
+                Cp();
+                const obj: VmConst[] = [];
+                for (const { 0: key, 1: arr } of ets) {
+                    obj[key as number] = arr[i] ?? null;
+                }
+                result.push(obj);
+            }
+        } else {
+            for (let i = 0; i < length; i++) {
+                Cp();
+                const obj: Record<string, VmConst> = {};
+                for (const { 0: key, 1: arr } of ets) {
+                    setRecord(obj, key as string, arr[i]);
+                }
+                result.push(obj);
             }
-            result.push(obj);
         }
         return result;
     },

package/src/vm/lib/helpers.ts

@@ -1,5 +1,5 @@
 import { VM_ARRAY_MAX_LENGTH } from '../../helpers/constants.js';
-import { isNaN, NotNumber, entries, fromEntries, isSafeInteger, isFinite } from '../../helpers/utils.js';
+import { NotNumber, entries, fromEntries, isSafeInteger, isFinite } from '../../helpers/utils.js';
 import { toBoolean, toNumber, toString } from '../../helpers/convert/index.js';
 import { display } from '../../helpers/serialize.js';
 import { isVmArray, isVmFunction, isVmPrimitive, isVmConst, isVmCallable, isVmRecord } from '../../helpers/types.js';
@@ -229,7 +229,7 @@ export function getNumbers(args: readonly VmAny[]): number[] {
 
 /** 将值转为数组长度 */
 export function arrayLen(len: number | null | undefined): number {
-    if (len == null || isNaN(len) || len <= -1) {
+    if (len == null || !isFinite(len) || len <= -1) {
         throwError('Array length must be a non-negative integer', null);
     }
     len = Math.trunc(len);
@@ -240,10 +240,10 @@ export function arrayLen(len: number | null | undefined): number {
 }
 
 /** 应用映射函数 */
-export function map(
-    data: VmConst,
+export function iterate<T extends VmConst>(
+    data: T,
     /** 返回 `undefined` 表示跳过该元素 */
-    mapper: (value: VmConst, index: number | string | null, data: VmConst) => VmConst | undefined,
+    mapper: (value: VmConst, index: number | string | null, data: T) => VmConst | undefined,
 ): VmConst {
     if (isVmPrimitive(data)) {
         return mapper(data, null, data) ?? null;
@@ -260,7 +260,7 @@ export function map(
         return result;
     } else {
         const e: Array<[string, VmConst]> = [];
-        for (const [key, value] of entries(data)) {
+        for (const [key, value] of entries<string, VmConst | undefined>(data)) {
             Cp();
             const ret = mapper(value ?? null, key, data);
             if (ret === undefined) continue;

package/src/vm/lib/mod/matrix.ts

@@ -12,7 +12,7 @@ import {
     throwError,
     getNumbers,
     arrayLen,
-    map,
+    iterate,
     expectInteger,
 } from '../helpers.js';
 
@@ -370,7 +370,7 @@ export const invert = VmLib(
         expectConst('a', a, null);
         const [rows, cols] = sizeImpl(a);
         if (rows == null) return 1 / num(a); // 标量取倒数
-        if (cols == null) return map(a, (v) => 1 / num(v)); // 向量按元素取倒数
+        if (cols == null) return iterate(a, (v) => 1 / num(v)); // 向量按元素取倒数
 
         if (rows !== cols) throwError(`Matrix must be square`, a);
         const m = a as VmConst[][];

package/src/vm/operations/array-range.ts

@@ -16,10 +16,12 @@ export const $ArrayRange = (start: VmAny, end: VmAny): VmArray => {
     const s = $ToNumber(start);
     const e = $ToNumber(end);
     if (isEmptyRange(s, e)) return [];
-    assertArrayLength(e - s + 1);
+    const n = Math.floor(e - s + 1);
+    assertArrayLength(n);
     const arr = [];
-    for (let i = s; i <= e; i++) {
-        arr.push(i);
+    arr.length = n;
+    for (let i = 0; i < n; i++) {
+        arr[i] = s + i;
     }
     return arr;
 };
@@ -28,10 +30,12 @@ export const $ArrayRangeExclusive = (start: VmAny, end: VmAny): VmArray => {
     const s = $ToNumber(start);
     const e = $ToNumber(end);
     if (isEmptyRange(s, e)) return [];
-    assertArrayLength(e - s);
+    const n = Math.ceil(e - s);
+    assertArrayLength(n);
     const arr = [];
-    for (let i = s; i < e; i++) {
-        arr.push(i);
+    arr.length = n;
+    for (let i = 0; i < n; i++) {
+        arr[i] = s + i;
     }
     return arr;
 };

package/src/vm/operations/compound.ts

@@ -1,5 +1,14 @@
 import { VmError } from '../../helpers/error.js';
-import { hasOwnEnumerable, NotNumber, keys, create, isFinite, keysLength } from '../../helpers/utils.js';
+import {
+    hasOwnEnumerable,
+    NotNumber,
+    keys,
+    create,
+    isFinite,
+    keysLength,
+    getRecord,
+    setRecord,
+} from '../../helpers/utils.js';
 import { toNumber, toString } from '../../helpers/convert/index.js';
 import { display } from '../../helpers/serialize.js';
 import {
@@ -63,8 +72,7 @@ export const $Omit = (value: VmAny, omitted: ReadonlyArray<number | string>): Vm
     const omittedSet = new Set(omitted.map($ToString));
     for (const key of valueKeys) {
         if (!omittedSet.has(key)) {
-            /* c8 ignore next */
-            result[key] = value[key] ?? null;
+            setRecord(result, key, value[key]);
         }
     }
     return result;
@@ -78,7 +86,7 @@ export const $Pick = (value: VmAny, picked: ReadonlyArray<number | string>): VmR
     for (const key of picked) {
         const k = $ToString(key);
         if (hasOwnEnumerable(value, k)) {
-            result[k] = value[k] ?? null;
+            setRecord(result, k, value[k]);
         }
     }
     return result;
@@ -114,8 +122,7 @@ export const $Get = (obj: VmAny, key: VmAny): VmValue => {
         }
         return obj.get(pk) ?? null;
     }
-    if (!hasOwnEnumerable(obj, pk)) return null;
-    return $El(obj[pk] ?? null);
+    return $El(getRecord(obj, pk) ?? null);
 };
 /** 设置字段 */
 export const $Set = (obj: VmAny, key: VmAny, value: VmAny): void => {

package/src/vm/types/extern.ts

@@ -140,7 +140,7 @@ export class VmExtern<const T extends object = object> extends VmWrapper<T> {
     override toString(useBraces: boolean): string {
         // eslint-disable-next-line @typescript-eslint/unbound-method
         const { toString } = this.value;
-        if (typeof toString != 'function' || toString === ObjectToString || toString === FunctionToString) {
+        if (typeof toString !== 'function' || toString === ObjectToString || toString === FunctionToString) {
             // When the toString method is not overridden or invalid, provide a better default representation
             return super.toString(useBraces);
         }