@mirascript/mirascript 0.1.76 → 0.1.79

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

@@ -0,0 +1,122 @@
+import type { VmConst } from '../../../types/index.js';
+import { size, num } from './helpers.js';
+import { VmLib, expectConst, throwError, iterate } from '../../helpers.js';
+
+export const invert = VmLib(
+    (a) => {
+        expectConst('a', a, null);
+        const [rows, cols] = size(a);
+        if (rows == null) return 1 / num(a); // 标量取倒数
+        if (cols == null) return iterate(a, (v) => 1 / num(v)); // 向量按元素取倒数
+
+        if (rows !== cols) throwError(`Matrix must be square`, a);
+        const m = a as VmConst[][];
+        // https://github.com/josdejong/mathjs
+        if (rows === 1) {
+            // 1x1 矩阵
+            const e = num(m[0]?.[0]);
+            // if (e === 0) {
+            //     throwError(`Matrix is singular`, null);
+            // }
+            return [[1 / e]];
+        }
+        if (rows === 2) {
+            // 2x2 矩阵
+            const a = num(m[0]?.[0]);
+            const b = num(m[0]?.[1]);
+            const c = num(m[1]?.[0]);
+            const d = num(m[1]?.[1]);
+
+            const det = a * d - b * c;
+            // if (det === 0) throwError(`Matrix is singular`, null);
+            return [
+                [d / det, -b / det],
+                [-c / det, a / det],
+            ];
+        }
+
+        // 更高阶矩阵 使用高斯消元法
+
+        // 初始化输入
+        const A: number[][] = [];
+        // 初始化结果为单位矩阵
+        const B: number[][] = [];
+        for (let r = 0; r < rows; r++) {
+            const Ar: number[] = [];
+            const Br: number[] = [];
+            A[r] = Ar;
+            B[r] = Br;
+            for (let c = 0; c < cols; c++) {
+                Ar[c] = num(m[r]?.[c]);
+                Br[c] = r === c ? 1 : 0;
+            }
+        }
+
+        // loop over all columns, and perform row reductions
+        for (let c = 0; c < cols; c++) {
+            // Pivoting: Swap row c with row r, where row r contains the largest element A[r][c]
+            let ABig = Math.abs(A[c]![c]!);
+            let rBig = c;
+            let r = c + 1;
+            while (r < rows) {
+                if (Math.abs(A[r]![c]!) > ABig) {
+                    ABig = Math.abs(A[r]![c]!);
+                    rBig = r;
+                }
+                r++;
+            }
+            // if (ABig === 0) {
+            //     throwError(`Matrix is singular`, null);
+            // }
+            r = rBig;
+            if (r !== c) {
+                const temp1 = A[c]!;
+                A[c] = A[r]!;
+                A[r] = temp1;
+                const temp2 = B[c]!;
+                B[c] = B[r]!;
+                B[r] = temp2;
+            }
+
+            // eliminate non-zero values on the other rows at column c
+            const Ac = A[c]!;
+            const Bc = B[c]!;
+            for (r = 0; r < rows; r++) {
+                const Ar = A[r]!;
+                const Br = B[r]!;
+                if (r !== c) {
+                    // eliminate value at column c and row r
+                    if (Ar[c] !== 0) {
+                        const f = -Ar[c]! / Ac[c]!;
+
+                        // add (f * row c) to row r to eliminate the value
+                        // at column c
+                        for (let s = c; s < cols; s++) {
+                            Ar[s] = Ar[s]! + f * Ac[s]!;
+                        }
+                        for (let s = 0; s < cols; s++) {
+                            Br[s] = Br[s]! + f * Bc[s]!;
+                        }
+                    }
+                } else {
+                    // normalize value at Acc to 1,
+                    // divide each value on row r with the value at Acc
+                    const f = Ac[c]!;
+                    for (let s = c; s < cols; s++) {
+                        Ar[s] = Ar[s]! / f;
+                    }
+                    for (let s = 0; s < cols; s++) {
+                        Br[s] = Br[s]! / f;
+                    }
+                }
+            }
+        }
+        return B;
+    },
+    {
+        summary: '矩阵求逆',
+        params: { a: { type: 'number | number[][]', description: '待求逆的矩阵' } },
+        returns: { type: 'number | number[][]' },
+        examples: ['matrix.invert([[1, 2], [3, 4]]) // [[-2, 1], [1.5, -0.5]]'],
+    },
+);

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

@@ -0,0 +1,15 @@
+import { VmLib, required } from '../../helpers.js';
+import { size as sizeImpl } from './helpers.js';
+
+export const size = VmLib(
+    (matrix) => {
+        required('matrix', matrix, []);
+        return sizeImpl(matrix);
+    },
+    {
+        summary: '获取矩阵尺寸',
+        params: { matrix: { type: 'any[][]', description: '要获取尺寸的矩阵' } },
+        returns: { type: '[number, number]' },
+        examples: ['matrix.size([[1, 2], [3, 4]]) // [2, 2]'],
+    },
+);

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

@@ -0,0 +1,32 @@
+import { Cp } from '../../../checkpoint.js';
+import type { VmConst } from '../../../types/index.js';
+import { VmLib, required } from '../../helpers.js';
+import { size } from './helpers.js';
+
+export const transpose = VmLib(
+    (matrix) => {
+        required('matrix', matrix, []);
+        const [numRows, numCols] = size(matrix);
+        if (numRows == null || numCols == null) return matrix; // 一维数组或空数组无需转置
+
+        const m = matrix as VmConst[][];
+        const transposed: VmConst[][] = [];
+        for (let j = 0; j < numCols; j++) {
+            Cp();
+            const tj = [];
+            for (let i = 0; i < numRows; i++) {
+                const row = m[i] ?? null;
+                const item = row?.[j] ?? null;
+                tj[i] = item;
+            }
+            transposed[j] = tj;
+        }
+        return transposed;
+    },
+    {
+        summary: '转置矩阵',
+        params: { matrix: { type: 'any[][]', description: '要转置的矩阵' } },
+        returns: { type: 'any[][]' },
+        examples: ['matrix.transpose([[1, 2], [3, 4]]) // [[1, 3], [2, 4]]'],
+    },
+);

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

@@ -1,41 +1,29 @@
 import { isFinite } from '../../helpers/utils.js';
 import { VM_ARRAY_MAX_LENGTH } from '../../helpers/constants.js';
-import type { VmAny, VmArray } from '../types/index.js';
+import type { VmAny } from '../types/index.js';
 import { $ToNumber } from './convert.js';
 
-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 const $ArrayRange = (start: VmAny, end: VmAny): VmArray => {
+const makeArray = (start: VmAny, end: VmAny, exclusive: boolean): number[] => {
     const s = $ToNumber(start);
     const e = $ToNumber(end);
-    if (isEmptyRange(s, e)) return [];
-    const n = Math.floor(e - s + 1);
-    assertArrayLength(n);
+    if (!isFinite(s) || !isFinite(e) || s > e) {
+        return [];
+    }
+    const n = exclusive ? Math.ceil(e - s) : Math.floor(e - s + 1);
+    if (n > VM_ARRAY_MAX_LENGTH) {
+        throw new RangeError(`Array length exceeds maximum limit of ${VM_ARRAY_MAX_LENGTH}`);
+    }
     const arr = [];
-    arr.length = n;
     for (let i = 0; i < n; i++) {
         arr[i] = s + i;
     }
     return arr;
 };
+/** 构造范围数组 */
+export const $ArrayRange = (start: VmAny, end: VmAny): number[] => {
+    return makeArray(start, end, false);
+};
 /** 构造范围数组（不包含结束值） */
-export const $ArrayRangeExclusive = (start: VmAny, end: VmAny): VmArray => {
-    const s = $ToNumber(start);
-    const e = $ToNumber(end);
-    if (isEmptyRange(s, e)) return [];
-    const n = Math.ceil(e - s);
-    assertArrayLength(n);
-    const arr = [];
-    arr.length = n;
-    for (let i = 0; i < n; i++) {
-        arr[i] = s + i;
-    }
-    return arr;
+export const $ArrayRangeExclusive = (start: VmAny, end: VmAny): number[] => {
+    return makeArray(start, end, true);
 };

package/src/vm/operations/call.ts

@@ -1,6 +1,6 @@
 import { VmError } from '../../helpers/error.js';
 import { display } from '../../helpers/serialize.js';
-import { isVmExtern, isVmConst } from '../../helpers/types.js';
+import { isVmExtern, isVmConst } from '../../helpers/types/index.js';
 import type { VmExtern, VmFunction, VmAny, VmArray, VmValue } from '../types/index.js';
 import { $AssertInit } from './common.js';
 
@@ -27,7 +27,7 @@ type CallReturn<T extends VmValue> =
           : VmValue;
 
 /** 调用函数 */
-export function $Call<T extends VmValue, A extends readonly VmValue[]>(func: T, args: A): CallReturn<T> {
+export function $Call<T extends VmValue, const A extends readonly VmValue[]>(func: T, args: A): CallReturn<T> {
     const argsLen = args.length;
     for (let i = 0; i < argsLen; i++) {
         $AssertInit(args[i]);

package/src/vm/operations/compound.ts

@@ -1,19 +1,9 @@
 import { VmError } from '../../helpers/error.js';
-import { hasOwnEnumerable, NotNumber, keys, create, isFinite, keysLength } from '../../helpers/utils.js';
-import { toNumber, toString } from '../../helpers/convert/index.js';
+import { hasOwnEnumerable, NotNumber, isFinite, getRecord, keysLength } from '../../helpers/utils.js';
+import { toNumber } from '../../helpers/convert/index.js';
 import { display } from '../../helpers/serialize.js';
-import {
-    isVmPrimitive,
-    isVmArray,
-    isVmRecord,
-    isVmFunction,
-    isVmExtern,
-    isVmWrapper,
-    isVmConst,
-} from '../../helpers/types.js';
-import { wrapToVmConst } from '../types/boundary.js';
-import type { VmAny, VmRecord, VmValue, VmConst } from '../types/index.js';
-import { isSame } from './utils.js';
+import { isVmArray, isVmRecord, isVmExtern, isVmWrapper } from '../../helpers/types/index.js';
+import type { VmAny, VmValue } from '../types/index.js';
 import { $AssertInit } from './common.js';
 import { $ToString } from './convert.js';
 import { $El } from './helpers.js';
@@ -21,29 +11,6 @@ import { $El } from './helpers.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);
@@ -54,35 +21,6 @@ export const $Length = (value: VmAny): number => {
     throw new VmError(`Value has no length: ${display(value)}`, 0);
 };
 
-/** 删除记录中的指定字段 */
-export const $Omit = (value: VmAny, omitted: ReadonlyArray<number | string>): VmRecord => {
-    $AssertInit(value);
-    if (!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 (!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);
@@ -114,8 +52,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 => {
@@ -125,60 +62,3 @@ export const $Set = (obj: VmAny, key: VmAny, value: VmAny): void => {
     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;
-            if (isVmConst(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)) {
-        if (array.isArrayLike()) {
-            const result: VmConst[] = [];
-            for (let i = 0, len = array.value.length; i < len; i++) {
-                const item = array.value[i];
-                result.push(wrapToVmConst(item, (v) => array.assumeVmValue(v, i)));
-            }
-            return result;
-        } else if (typeof (array.value as Iterable<unknown>)[Symbol.iterator] == 'function') {
-            const result: VmConst[] = [];
-            for (const item of array.value as Iterable<unknown>) {
-                result.push(wrapToVmConst(item, (v) => array.assumeVmValue(v, Symbol.iterator as never)));
-            }
-            return result;
-        }
-    }
-    throw new VmError(`Expected array, iterable extern or nil, got ${display(array)}`, []);
-};

package/src/vm/operations/helpers.ts

@@ -1,6 +1,6 @@
 import { create, defineProperty, entries } from '../../helpers/utils.js';
 import { VM_FUNCTION_ANONYMOUS_NAME } from '../../helpers/constants.js';
-import { isVmConst } from '../../helpers/types.js';
+import { isVmConst } from '../../helpers/types/index.js';
 import type { VmFunctionLike } from '../types/function.js';
 import { DefaultVmContext, type VmContext } from '../types/context.js';
 import type { VmConst, VmAny, VmValue, VmImmutable } from '../types/index.js';

package/src/vm/operations/index.ts

@@ -5,6 +5,9 @@ export * from './operator.js';
 export * from './slice.js';
 export * from './helpers.js';
 export * from './compound.js';
+export * from './spread.js';
+export * from './record.js';
+export * from './iterable.js';
 export * from './cp.js';
 export * from './call.js';
 export * from './array-range.js';

package/src/vm/operations/iterable.ts

@@ -0,0 +1,40 @@
+import { VmError } from '../../helpers/error.js';
+import { hasOwnEnumerable, keys } from '../../helpers/utils.js';
+import { toString } from '../../helpers/convert/index.js';
+import { display } from '../../helpers/serialize.js';
+import { isVmPrimitive, isVmArray, isVmFunction, isVmWrapper } from '../../helpers/types/index.js';
+import type { VmAny, VmRecord, VmValue } from '../types/index.js';
+import { isSame } from './utils.js';
+import { $AssertInit } from './common.js';
+
+/** 检查值是否在可迭代对象中 */
+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 $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]);
+};

package/src/vm/operations/record.ts

@@ -0,0 +1,33 @@
+import { hasOwnEnumerable, keys, setRecord } from '../../helpers/utils.js';
+import { isVmRecord } from '../../helpers/types/index.js';
+import type { VmAny, VmRecord, VmConst } from '../types/index.js';
+import { $AssertInit } from './common.js';
+
+/** 删除记录中的指定字段 */
+export const $Omit = (value: VmAny, omitted: ReadonlyArray<number | string>): VmRecord => {
+    $AssertInit(value);
+    if (!isVmRecord(value)) return {};
+    const result: Record<string, VmConst> = {};
+    const valueKeys = keys(value);
+    const omittedSet = new Set(omitted.map(String));
+    for (const key of valueKeys) {
+        if (!omittedSet.has(key)) {
+            setRecord(result, key, value[key]);
+        }
+    }
+    return result;
+};
+
+/** 选择记录中的指定字段 */
+export const $Pick = (value: VmAny, picked: ReadonlyArray<number | string>): VmRecord => {
+    $AssertInit(value);
+    if (!isVmRecord(value)) return {};
+    const result: Record<string, VmConst> = {};
+    for (const key of picked) {
+        const k = String(key);
+        if (hasOwnEnumerable(value, k)) {
+            setRecord(result, k, value[k]);
+        }
+    }
+    return result;
+};

package/src/vm/operations/slice.ts

@@ -1,44 +1,45 @@
 import { VmError } from '../../helpers/error.js';
 import { display } from '../../helpers/serialize.js';
+import { toNumber } from '../../helpers/convert/number.js';
 import { isNaN, isSafeInteger } from '../../helpers/utils.js';
-import { isVmArray } from '../../helpers/types.js';
+import { isVmArray } from '../../helpers/types/index.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 sliceCore = (value: VmAny, start: VmAny, end: VmAny, exclusive: boolean): VmArray => {
+    $AssertInit(value);
+    $AssertInit(start);
+    $AssertInit(end);
+
+    if (!isVmArray(value)) {
+        throw new VmError(`Expected array, got ${display(value)}`, []);
+    }
     const { length } = value;
+    let s = start != null ? toNumber(start) : 0;
+    let e = end != null ? toNumber(end) : length - (exclusive ? 0 : 1);
 
-    if (isNaN(start)) start = 0;
-    else if (start < 0) start = length + start;
+    if (isNaN(s)) s = 0;
+    else if (s < 0) s = length + s;
 
-    if (isNaN(end)) end = exclusive ? length : length - 1;
-    else if (end < 0) end = length + end;
+    if (isNaN(e)) e = exclusive ? length : length - 1;
+    else if (e < 0) e = length + e;
 
-    start = ceil(start);
-    if (exclusive || !isSafeInteger(end)) {
-        end = ceil(end);
+    s = ceil(s);
+    if (exclusive || !isSafeInteger(e)) {
+        e = ceil(e);
     } else {
-        end = end + 1;
+        e = e + 1;
     }
-    return slice.call(value, start, end) satisfies unknown[] as VmArray;
+    return slice.call(value, s, e) 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);
+    return sliceCore(value, start, end, 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);
+    return sliceCore(value, start, end, true);
 };

package/src/vm/operations/spread.ts

@@ -0,0 +1,57 @@
+import { VmError } from '../../helpers/error.js';
+import { create } from '../../helpers/utils.js';
+import { display } from '../../helpers/serialize.js';
+import { isVmArray, isVmRecord, isVmExtern, isVmConst } from '../../helpers/types/index.js';
+import { wrapToVmConst } from '../types/boundary.js';
+import type { VmAny, VmRecord, VmConst } from '../types/index.js';
+import { $AssertInit } from './common.js';
+
+/** 展开记录 */
+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;
+            if (isVmConst(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)) {
+        if (array.isArrayLike()) {
+            const result: VmConst[] = [];
+            for (let i = 0, len = array.value.length; i < len; i++) {
+                const item = array.value[i];
+                result.push(wrapToVmConst(item, (v) => array.assumeVmValue(v, i)));
+            }
+            return result;
+        } else if (typeof (array.value as Iterable<unknown>)[Symbol.iterator] == 'function') {
+            const result: VmConst[] = [];
+            for (const item of array.value as Iterable<unknown>) {
+                result.push(wrapToVmConst(item, (v) => array.assumeVmValue(v, Symbol.iterator as never)));
+            }
+            return result;
+        }
+    }
+    throw new VmError(`Expected array, iterable extern or nil, got ${display(array)}`, []);
+};

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

@@ -1,5 +1,5 @@
 import { VmError } from '../../helpers/error.js';
-import { getVmType, isVmArray, isVmRecord } from '../../helpers/types.js';
+import { getVmType, isVmArray, isVmRecord } from '../../helpers/types/index.js';
 import type { VmTypeName, VmAny, VmArray, VmRecord, VmValue } from '../types/index.js';
 import { $AssertInit } from './common.js';