@mirascript/mirascript 0.1.76 → 0.1.79

package/src/helpers/error.ts

@@ -6,12 +6,14 @@ import type { VmAny } from '../vm/types/index.js';
 export class VmError extends Error {
     constructor(
         message: string,
+        // eslint-disable-next-line unicorn/custom-error-definition
         readonly recovered: VmAny,
     ) {
         super(message);
-        this.name = 'VmError';
     }
 
+    override readonly name = 'VmError';
+
     /** 从其他错误构造 */
     static from(prefix: string, error: unknown, recovered: VmAny): VmError {
         if (prefix) {

package/src/helpers/serialize.ts

@@ -1,6 +1,6 @@
 import { REG_IDENTIFIER_FULL, REG_ORDINAL_FULL } from '@mirascript/constants';
 import type { VmArray, VmExtern, VmFunction, VmModule, VmAny, VmRecord } from '../vm/index.js';
-import { entries, hasOwn, isFinite, isNaN } from '../helpers/utils.js';
+import { entries, hasOwn } from '../helpers/utils.js';
 import {
     getVmFunctionInfo,
     isVmArray,
@@ -9,7 +9,8 @@ import {
     isVmFunction,
     isVmModule,
     isVmRecord,
-} from './types.js';
+} from './types/index.js';
+import { numberToString } from './convert/string.js';
 
 /** 序列化 nil 值 */
 export function serializeNil(): string {
@@ -23,13 +24,7 @@ export function serializeBoolean(value: boolean): string {
 
 /** 序列化数字 */
 export function serializeNumber(value: number): string {
-    if (isNaN(value)) return 'nan';
-    if (!isFinite(value)) return value < 0 ? '-inf' : 'inf';
-    if (value === 0) {
-        if (1 / value < 0) return '-0';
-        return '0';
-    }
-    return String(value);
+    return numberToString(value, true);
 }
 
 /**
@@ -49,6 +44,44 @@ function serializeStringContent(value: string, options: Readonly<SerializeOption
 const STRING_QUOTE = `'`;
 const STRING_REG = new RegExp(String.raw`[${STRING_QUOTE}\\\$\p{C}\u2028\u2029]`, 'gu');
 const STRING_MARK = /^[\p{M}]$/u;
+
+/**
+ * 序列化为特殊字符
+ */
+function serializeSpecialChar(char: string, options: Readonly<SerializeOptions>): string {
+    if (char === STRING_QUOTE) {
+        return serializeStringEscaped(STRING_QUOTE, options);
+    } else if (char === '\0') {
+        return serializeStringEscaped(`0`, options);
+    } else if (char === '\n') {
+        return serializeStringEscaped(`n`, options);
+    } else if (char === '\r') {
+        return serializeStringEscaped(`r`, options);
+    } else if (char === '\t') {
+        return serializeStringEscaped(`t`, options);
+    } else if (char === '\b') {
+        return serializeStringEscaped(`b`, options);
+    } else if (char === '\f') {
+        return serializeStringEscaped(`f`, options);
+    } else if (char === '\v') {
+        return serializeStringEscaped(`v`, options);
+    } else if (char === '\\') {
+        return serializeStringEscaped(`\\`, options);
+    } else if (char === '$') {
+        return serializeStringEscaped(`$`, options);
+    } else {
+        const code = char.codePointAt(0)!;
+        if (code <= 0x7f) {
+            return serializeStringEscaped(`x${code.toString(16).padStart(2, '0')}`, options);
+        } else if (code >= 0xd800 && code <= 0xdfff) {
+            // 无效的代理对
+            return serializeStringContent('�', options);
+        } else {
+            return serializeStringEscaped(`u{${code.toString(16)}}`, options);
+        }
+    }
+}
+
 /**
  * 将 MiraScript 字符串序列化为 MiraScript 字面量。
  */
@@ -67,8 +100,7 @@ function serializeStringImpl(value: string, options: Readonly<SerializeOptions>)
         const cp = value.codePointAt(lastIndex)!;
         const ch = String.fromCodePoint(cp);
         if (!STRING_MARK.test(ch)) break;
-        const c = serializeStringEscaped(`u{${cp.toString(16)}}`, options);
-        ret += c;
+        ret += serializeStringEscaped(`u{${cp.toString(16)}}`, options);
         lastIndex += ch.length;
     }
 
@@ -76,40 +108,9 @@ function serializeStringImpl(value: string, options: Readonly<SerializeOptions>)
     STRING_REG.lastIndex = lastIndex;
     let match: RegExpExecArray | null;
     while ((match = STRING_REG.exec(value)) !== null) {
-        const char = match[0];
         ret += serializeStringContent(value.slice(lastIndex, match.index), options);
         lastIndex = STRING_REG.lastIndex;
-        if (char === STRING_QUOTE) {
-            ret += serializeStringEscaped(STRING_QUOTE, options);
-        } else if (char === '\0') {
-            ret += serializeStringEscaped(`0`, options);
-        } else if (char === '\n') {
-            ret += serializeStringEscaped(`n`, options);
-        } else if (char === '\r') {
-            ret += serializeStringEscaped(`r`, options);
-        } else if (char === '\t') {
-            ret += serializeStringEscaped(`t`, options);
-        } else if (char === '\b') {
-            ret += serializeStringEscaped(`b`, options);
-        } else if (char === '\f') {
-            ret += serializeStringEscaped(`f`, options);
-        } else if (char === '\v') {
-            ret += serializeStringEscaped(`v`, options);
-        } else if (char === '\\') {
-            ret += serializeStringEscaped(`\\`, options);
-        } else if (char === '$') {
-            ret += serializeStringEscaped(`$`, options);
-        } else {
-            const code = char.codePointAt(0)!;
-            if (code <= 0x7f) {
-                ret += serializeStringEscaped(`x${code.toString(16).padStart(2, '0')}`, options);
-            } else if (code >= 0xd800 && code <= 0xdfff) {
-                // 无效的代理对
-                ret += serializeStringContent('�', options);
-            } else {
-                ret += serializeStringEscaped(`u{${code.toString(16)}}`, options);
-            }
-        }
+        ret += serializeSpecialChar(match[0], options);
     }
     ret += serializeStringContent(value.slice(lastIndex), options);
     ret += cq;
@@ -177,7 +178,7 @@ const { valueOf } = Object.prototype;
 function customValueOf(value: VmRecord): VmAny | undefined {
     // eslint-disable-next-line @typescript-eslint/unbound-method
     const thisValueOf = value.valueOf;
-    if (typeof thisValueOf != 'function' || thisValueOf === valueOf) {
+    if (typeof thisValueOf !== 'function' || thisValueOf === valueOf) {
         return undefined;
     }
     const customValue = thisValueOf.call(value) as VmAny | undefined;

package/src/helpers/types/array-like.ts

@@ -0,0 +1,32 @@
+import type { VmRecord } from '../../vm/types/index.js';
+import { VM_ARRAY_MAX_LENGTH } from '../constants.js';
+import { keys } from '../utils.js';
+
+/** 检查是否为仅包含从 0 开始的连续数字键的 MiraScript 记录 */
+export function isVmArrayLikeRecordByEntries(entries: ReadonlyArray<readonly [string, unknown]>): boolean {
+    const { length } = entries;
+    if (length === 0) return true;
+    if (length > VM_ARRAY_MAX_LENGTH) return false;
+    const firstKey = entries[0]![0];
+    if (firstKey !== '0') return false;
+    const lastKey = entries[length - 1]![0];
+    if (lastKey !== String(length - 1)) return false;
+    return true;
+}
+
+/** 检查是否为仅包含从 0 开始的连续数字键的 MiraScript 记录 */
+export function isVmArrayLikeRecordByKeys(keys: readonly string[]): boolean {
+    const { length } = keys;
+    if (length === 0) return true;
+    if (length > VM_ARRAY_MAX_LENGTH) return false;
+    const firstKey = keys[0]!;
+    if (firstKey !== '0') return false;
+    const lastKey = keys[length - 1]!;
+    if (lastKey !== String(length - 1)) return false;
+    return true;
+}
+
+/** 检查是否为仅包含从 0 开始的连续数字键的 MiraScript 记录 */
+export function isVmArrayLikeRecord(value: VmRecord): boolean {
+    return isVmArrayLikeRecordByKeys(keys(value));
+}

package/src/helpers/types/basic.ts

@@ -0,0 +1,82 @@
+import type { VmScript } from '../../compiler/index.js';
+import type {
+    VmAny,
+    VmArray,
+    VmContext,
+    VmExtern,
+    VmFunction,
+    VmFunctionInfo,
+    VmFunctionLike,
+    VmImmutable,
+    VmModule,
+    VmPrimitive,
+    VmRecord,
+} from '../../vm/types/index.js';
+import type { VmWrapper } from '../../vm/types/wrapper.js';
+import { kVmContext, kVmExtern, kVmFunction, kVmModule, kVmScript, kVmWrapper } from '../constants.js';
+import { isArray } from '../utils.js';
+
+/** 检查是否为 Mirascript 脚本 */
+export function isVmScript(value: unknown): value is VmScript {
+    return typeof value === 'function' && kVmScript in value;
+}
+
+/** 检查是否为执行上下文 */
+export function isVmContext(context: unknown): context is VmContext {
+    return context != null && typeof context == 'object' && kVmContext in context;
+}
+/** 检查是否为 Mirascript 函数 */
+export function isVmFunction<T extends VmFunctionLike>(value: unknown): value is VmFunction<T> {
+    return typeof value == 'function' && kVmFunction in value;
+}
+/** 检查是否为 Mirascript 函数，并获取其信息 */
+export function getVmFunctionInfo(value: unknown): VmFunctionInfo | undefined {
+    if (typeof value != 'function') return undefined;
+    return (value as VmFunction)[kVmFunction];
+}
+/** 检查值是否为 MiraScript 包装器 */
+export function isVmWrapper<T extends object>(value: unknown): value is VmWrapper<T> {
+    return value != null && typeof value == 'object' && kVmWrapper in value;
+}
+/** 检查值是否为 Mirascript 模块 */
+export function isVmModule<T extends Record<string, VmImmutable>>(value: unknown): value is VmModule<T> {
+    return value != null && typeof value == 'object' && kVmModule in value;
+}
+/** 检查值是否为 Mirascript 外部值 */
+export function isVmExtern<T extends object>(value: unknown): value is VmExtern<T> {
+    return value != null && typeof value == 'object' && kVmExtern in value;
+}
+
+/** 检查值是否为 Mirascript 可调用值 */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+export function isVmCallable<E extends Function, F extends VmFunctionLike>(
+    value: unknown,
+): value is VmFunction<F> | VmExtern<E> {
+    return isVmFunction<F>(value) || (isVmExtern<E>(value) && typeof value.value == 'function');
+}
+
+/** 检查值是否为 Mirascript 原始值 */
+export function isVmPrimitive(value: unknown): value is VmPrimitive {
+    if (value === null || typeof value == 'number' || typeof value == 'string' || typeof value == 'boolean') {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        value as VmPrimitive satisfies typeof value;
+        value satisfies VmPrimitive;
+        return true;
+    }
+    return false;
+}
+
+/** 检查值是否为 Mirascript 数组 */
+export function isVmArray(value: VmAny): value is VmArray {
+    if (!isArray(value)) return false;
+    value as VmArray satisfies VmArray;
+    return true;
+}
+
+/** 检查值是否为 Mirascript 记录 */
+export function isVmRecord(value: VmAny): value is VmRecord {
+    if (value == null || typeof value != 'object') return false;
+    if (isVmWrapper(value) || isVmArray(value)) return false;
+    value satisfies VmRecord;
+    return true;
+}

package/src/helpers/types/composed.ts

@@ -0,0 +1,27 @@
+import type { VmAny, VmImmutable, VmValue } from '../../vm/types/index.js';
+import { isVmFunction, isVmModule, isVmWrapper } from './basic.js';
+import { isVmConst } from './const.js';
+
+/** 检查是否为 Mirascript 不可变值 */
+export function isVmImmutable(value: VmAny): value is VmImmutable;
+/** 检查是否为 Mirascript 不可变值 */
+export function isVmImmutable(value: unknown, checkDeep: boolean): value is VmImmutable;
+/** 检查是否为 Mirascript 不可变值 */
+export function isVmImmutable(value: unknown, checkDeep = false): value is VmImmutable {
+    return isVmModule(value) || isVmFunction(value) || isVmConst(value, checkDeep);
+}
+
+/** 检查是否为 Mirascript 合法值 */
+export function isVmValue(value: VmAny): value is VmValue;
+/** 检查是否为 Mirascript 合法值 */
+export function isVmValue(value: unknown, checkDeep: boolean): value is VmValue;
+/** 检查是否为 Mirascript 合法值 */
+export function isVmValue(value: unknown, checkDeep = false): value is VmValue {
+    return isVmWrapper(value) || isVmFunction(value) || isVmConst(value, checkDeep);
+}
+
+/** 检查是否为 Mirascript 值 */
+export function isVmAny(value: unknown, checkDeep: boolean): value is VmAny {
+    if (value == null) return true;
+    return isVmValue(value, checkDeep);
+}

package/src/helpers/types/const.ts

@@ -0,0 +1,44 @@
+import type { VmAny, VmArray, VmConst, VmRecord } from '../../vm/types/index.js';
+import { isArray, values } from '../utils.js';
+import { isVmWrapper } from './basic.js';
+import { isPlainArray, isPlainObject } from './proto.js';
+
+const MAX_DEPTH = 16;
+/** 检查是否为 Mirascript 数组 */
+function isVmArrayDeep(value: readonly unknown[], depth: number): value is VmArray {
+    if (!isPlainArray(value)) return false;
+    if (depth <= 0) return true;
+    const inner_depth = depth - 1;
+    return value.every((item) => isVmConstInner(item, inner_depth));
+}
+/** 检查是否为 Mirascript 记录 */
+function isVmRecordDeep(value: object, depth: number): value is VmRecord {
+    if (!isPlainObject(value)) return false;
+    if (depth <= 0) return true;
+    const inner_depth = depth - 1;
+    return values(value).every((value) => isVmConstInner(value, inner_depth));
+}
+/** 检查是否为 Mirascript 值语义值 */
+function isVmConstInner(value: unknown, depth: number): value is VmConst {
+    if (value == null) return true; // undefined 在复合类型内部被视为 nil
+    if (typeof value == 'string' || typeof value == 'number' || typeof value == 'boolean') return true;
+    if (typeof value == 'object') {
+        if (isVmWrapper(value)) return false;
+        if (isArray(value)) {
+            return isVmArrayDeep(value, depth);
+        } else {
+            return isVmRecordDeep(value, depth);
+        }
+    }
+    return false; // Other types are not valid
+}
+
+/** 检查是否为 Mirascript 值语义值 */
+export function isVmConst(value: VmAny): value is VmConst;
+/** 检查是否为 Mirascript 值语义值 */
+export function isVmConst(value: unknown, checkDeep: boolean): value is VmConst;
+/** 检查是否为 Mirascript 值语义值 */
+export function isVmConst(value: unknown, checkDeep = false): value is VmConst {
+    if (value === undefined) return false;
+    return isVmConstInner(value, checkDeep ? MAX_DEPTH : 0);
+}

package/src/helpers/types/get-type.ts

@@ -0,0 +1,16 @@
+import type { VmValue, VmTypeName, VmAny } from '../../vm/index.js';
+import { isVmWrapper, isVmArray } from './basic.js';
+
+/** 获取 MiraScript 类型 */
+export function getVmType(value: VmValue): VmTypeName;
+/** 获取 MiraScript 类型 */
+export function getVmType(value: VmAny): VmTypeName | 'uninitialized';
+/** 获取 MiraScript 类型 */
+export function getVmType(value: VmAny): VmTypeName | 'uninitialized' {
+    if (value === undefined) return 'uninitialized';
+    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;
+}

package/src/helpers/types/index.ts

@@ -0,0 +1,5 @@
+export * from './basic.js';
+export * from './const.js';
+export * from './get-type.js';
+export * from './array-like.js';
+export * from './composed.js';

package/src/helpers/types/proto.ts

@@ -0,0 +1,21 @@
+import { getPrototypeOf, hasOwn, isArray } from '../utils.js';
+
+/** 检查是否为普通数组 */
+export function isPlainArray(value: readonly unknown[]): boolean {
+    // value 的原型应当为 Array.prototype
+    const proto: unknown = getPrototypeOf(value);
+    // 使用 isArray 检查原型是否为 Array.prototype，避免直接比较原型对象，防止跨环境问题
+    return isArray(proto) && hasOwn(proto, 'push');
+}
+
+/** 检查是否为普通对象或空原型对象 */
+export function isPlainObject(value: object): boolean {
+    // value 的原型应当为 Object.prototype 或 null
+    const proto1: unknown = getPrototypeOf(value);
+    if (proto1 == null) return true;
+    // Object.prototype 的原型应当为 null
+    const proto2: unknown = getPrototypeOf(proto1);
+    if (proto2 != null) return false;
+    // 检查是否具有 Object.prototype 的方法，避免直接比较原型对象，防止跨环境问题
+    return hasOwn(proto1, 'hasOwnProperty');
+}

package/src/helpers/utils.ts

@@ -1,3 +1,5 @@
+import type { VmConst, VmRecord } from '../vm/index.js';
+
 export const { isArray } = Array;
 export const {
     isFinite,
@@ -26,3 +28,34 @@ export const hasOwnEnumerable = Function.call.bind(
     // eslint-disable-next-line @typescript-eslint/unbound-method
     Object.prototype.propertyIsEnumerable,
 ) as (o: object, v: PropertyKey) => boolean;
+
+/**
+ * Snapshot the inherited keys that require data-property semantics when written
+ * to a VM record. The host is expected not to mutate `Object.prototype` after
+ * MiraScript has been initialized.
+ */
+const SPECIAL_KEYS = new Set(getOwnPropertyNames(Object.prototype));
+/**
+ * Set property on an vm record.
+ */
+export const setRecord = (obj: Record<string, VmConst | undefined>, key: string, value: VmConst | undefined): void => {
+    if (!SPECIAL_KEYS.has(key)) {
+        obj[key] = value ?? null;
+    } else {
+        defineProperty(obj, key, {
+            __proto__: null,
+            value: value ?? null,
+            configurable: true,
+            writable: true,
+            enumerable: true,
+        });
+    }
+};
+
+/**
+ * Get property from an vm record.
+ */
+export const getRecord = (obj: VmRecord, key: string): VmConst | undefined => {
+    if (!hasOwnEnumerable(obj, key)) return undefined;
+    return obj[key] ?? null;
+};

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

@@ -33,7 +33,7 @@ function serializeValue(
     format: SerializeFormat,
 ): string | null | PromiseLike<string> {
     const { serializer } = options;
-    if (serializer == null || serializer === defaultSerializer) {
+    if (serializer === defaultSerializer || serializer === null) {
         return defaultSerializer(arg, format);
     }
     try {
@@ -113,11 +113,7 @@ const printParser: PrintOptions['parser'] = function (args) {
             templates.push(i < values.length - 1 ? ' ' : '');
         }
     }
-    return {
-        templates,
-        values,
-        formats,
-    };
+    return { templates, values, formats };
 };
 
 /** 默认格式化函数 */
@@ -234,9 +230,9 @@ if (typeof location != 'undefined') {
     panic.prefix = [badge, `${common} background: #d23d3d; color: #fff;`, reset];
 } else {
     if (supportsColor.stdout) {
-        debug_print.prefix = ['\u001B[44;37m MiraScript \u001B[0m'];
+        debug_print.prefix = ['\u{1B}[44;37m MiraScript \u{1B}[0m'];
     }
     if (supportsColor.stderr) {
-        panic.prefix = ['\u001B[41;37m MiraScript \u001B[0m'];
+        panic.prefix = ['\u{1B}[41;37m MiraScript \u{1B}[0m'];
     }
 }

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/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/all-any.ts

@@ -1,4 +1,4 @@
-import { toBoolean } from '../../../../helpers/convert/to-boolean.js';
+import { toBoolean } from '../../../../helpers/convert/index.js';
 import { entries } from '../../../../helpers/utils.js';
 import { Cp } from '../../../checkpoint.js';
 import { $Call } from '../../../operations/index.js';

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/find.ts

@@ -1,4 +1,4 @@
-import { toBoolean } from '../../../../helpers/convert/to-boolean.js';
+import { toBoolean } from '../../../../helpers/convert/index.js';
 import { entries } from '../../../../helpers/utils.js';
 import { Cp } from '../../../checkpoint.js';
 import { $Call, $Same } from '../../../operations/index.js';

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/index.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 { toBoolean } from '../../../../helpers/convert/index.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;