@mirascript/mirascript 0.1.78 → 0.1.80

package/src/compiler/emit/index.ts

@@ -1,5 +1,5 @@
 import { OpCode } from '@mirascript/constants';
-import { toString } from '../../helpers/convert/to-string.js';
+import { toString } from '../../helpers/convert/index.js';
 import type { VmPrimitive } from '../../vm/index.js';
 import type { ScriptInput, TranspileOptions } from '../types.js';
 import type { IRange } from '../diagnostic.js';

package/src/compiler/emit/sourcemap.ts

@@ -20,7 +20,7 @@ const { SOURCE_URL, SOURCE_MAPPING_URL } = ((source, mapping, url) => {
 const SOURCE_OFFSET = 4;
 
 /**
- * Node.js Buffer 类型的简易声明，@mirascript/playground 调试环境下会直接加载此文件
+ * Node.js Buffer 类型的简易声明，浏览器调试环境下会直接加载此文件
  */
 declare class Buffer {
     /** @inheritdoc */

package/src/compiler/load-module.ts

@@ -1,3 +1,7 @@
 import { loadModule } from '@mirascript/bindings';
 
-await loadModule();
+try {
+    await loadModule();
+} catch (error) {
+    // Ignore, will be rethrown when the module is actually used.
+}

package/src/helpers/convert/{to-boolean.ts → boolean.ts}

@@ -4,7 +4,7 @@ import { display } from '../serialize.js';
 
 /** 转换为 boolean */
 export function toBoolean<F = undefined>(value: VmAny, fallback?: F): boolean | Exclude<F, undefined> {
-    if (typeof value === 'boolean') return value;
+    if (typeof value == 'boolean') return value;
     if (fallback === undefined) {
         throw new VmError(`Failed to convert value to boolean: ${display(value)}`, false);
     }

package/src/helpers/convert/{to-format.ts → format.ts}

@@ -1,6 +1,6 @@
 import type { VmAny } from '../../vm/index.js';
 import { isFinite } from '../utils.js';
-import { toString } from './to-string.js';
+import { toString } from './string.js';
 
 /** 渲染数字 */
 function formatNumber(finite: number): string {

package/src/helpers/convert/index.ts

@@ -1,4 +1,4 @@
-export { toNumber } from './to-number.js';
-export { toString } from './to-string.js';
-export { toFormat } from './to-format.js';
-export { toBoolean } from './to-boolean.js';
+export { toNumber } from './number.js';
+export { toString } from './string.js';
+export { toFormat } from './format.js';
+export { toBoolean } from './boolean.js';

package/src/helpers/convert/{to-number.ts → number.ts}

@@ -3,28 +3,22 @@ import { VmError } from '../error.js';
 import { display } from '../serialize.js';
 import { NegativeInfinity, NotNumber, PositiveInfinity } from '../utils.js';
 
+const parseInt = (value: string, radix: number): number => Number.parseInt(value.slice(2), radix);
+
 /** 将字符串转换为数字 */
 function parseNumericLiteral(value: string): number | null {
     const ch0 = value.charAt(0);
-    if (ch0 < '0' || ch0 > '9') {
-        return null;
-    }
+    if (ch0 < '0' || ch0 > '9') return null;
+
     // 二进制
-    if (/^0[bB][01]+$/.test(value)) {
-        return Number.parseInt(value.slice(2), 2);
-    }
+    if (/^0[bB][01]+$/.test(value)) return parseInt(value, 2);
     // 八进制
-    if (/^0[oO][0-7]+$/.test(value)) {
-        return Number.parseInt(value.slice(2), 8);
-    }
+    if (/^0[oO][0-7]+$/.test(value)) return parseInt(value, 8);
     // 十六进制
-    if (/^0[xX][0-9a-fA-F]+$/.test(value)) {
-        return Number.parseInt(value.slice(2), 16);
-    }
+    if (/^0[xX][0-9a-fA-F]+$/.test(value)) return parseInt(value, 16);
     // 十进制/科学计数法
-    if (/^[0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?$/.test(value)) {
-        return Number.parseFloat(value);
-    }
+    if (/^[0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?$/.test(value)) return Number.parseFloat(value);
+
     return null;
 }
 
@@ -32,18 +26,13 @@ function parseNumericLiteral(value: string): number | null {
 function stringToNumber(value: string): number | null {
     value = value.trim();
     if (value === '') return null;
-    if (value === 'inf' || value === '+inf' || value === 'Infinity' || value === '+Infinity') {
-        return PositiveInfinity;
-    }
-    if (value === '-inf' || value === '-Infinity') {
-        return NegativeInfinity;
-    }
-    if (value === 'nan' || value === 'NaN') {
-        return NotNumber;
-    }
+    if (value === 'inf' || value === '+inf' || value === 'Infinity' || value === '+Infinity') return PositiveInfinity;
+    if (value === '-inf' || value === '-Infinity') return NegativeInfinity;
+    if (value === 'nan' || value === 'NaN') return NotNumber;
+
     if (value.startsWith('-')) {
         const num = parseNumericLiteral(value.slice(1));
-        if (num !== null) return -num;
+        if (num != null) return -num;
         return null;
     } else if (value.startsWith('+')) {
         return parseNumericLiteral(value.slice(1));
@@ -54,7 +43,7 @@ function stringToNumber(value: string): number | null {
 
 /** 转换为 number */
 export function toNumber<F = undefined>(value: VmAny, fallback?: F): number | Exclude<F, undefined> {
-    if (typeof value === 'number') return value;
+    if (typeof value == 'number') return value;
     if (typeof value == 'boolean') return value ? 1 : 0;
     if (typeof value == 'string') {
         const num = stringToNumber(value);

package/src/helpers/convert/{to-string.ts → string.ts}

@@ -1,5 +1,5 @@
 import type { VmAny, VmRecord } from '../../vm/index.js';
-import { isVmArray, isVmWrapper } from '../types.js';
+import { isVmArray, isVmWrapper } from '../types/index.js';
 import { VmError } from '../error.js';
 import { display, displayFunction } from '../serialize.js';
 import { keys, isNaN } from '../utils.js';
@@ -41,7 +41,7 @@ export function innerToString(value: VmAny, useBraces: boolean): string {
 
 /** 转换为 string */
 export function toString<F = undefined>(value: VmAny, fallback?: F): string | Exclude<F, undefined> {
-    if (typeof value === 'string') return value;
+    if (typeof value == 'string') return value;
     if (value == null) return '';
     try {
         return innerToString(value, false);

package/src/helpers/serialize.ts

@@ -9,8 +9,8 @@ import {
     isVmFunction,
     isVmModule,
     isVmRecord,
-} from './types.js';
-import { numberToString } from './convert/to-string.js';
+} from './types/index.js';
+import { numberToString } from './convert/string.js';
 
 /** 序列化 nil 值 */
 export function serializeNil(): string {
@@ -44,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 字面量。
  */
@@ -62,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;
     }
 
@@ -71,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;

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

@@ -29,6 +29,11 @@ export const hasOwnEnumerable = Function.call.bind(
     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.
@@ -37,7 +42,8 @@ export const setRecord = (obj: Record<string, VmConst | undefined>, key: string,
     if (!SPECIAL_KEYS.has(key)) {
         obj[key] = value ?? null;
     } else {
-        Object.defineProperty(obj, key, {
+        defineProperty(obj, key, {
+            __proto__: null,
             value: value ?? null,
             configurable: true,
             writable: true,

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

@@ -1,4 +1,4 @@
-import { toString } from '../../../../helpers/convert/to-string.js';
+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';

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

@@ -1,4 +1,4 @@
-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, iterate } from '../../helpers.js';

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

@@ -1,5 +1,5 @@
 import type { VmArray, VmConst, VmRecord } from '../../../types/index.js';
-import { toString } from '../../../../helpers/convert/to-string.js';
+import { toString } from '../../../../helpers/convert/index.js';
 import { VM_ARRAY_MAX_LENGTH } from '../../../../helpers/constants.js';
 import {
     keys as _keys,

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

@@ -1,4 +1,4 @@
-import { toNumber } from '../../../../helpers/convert/to-number.js';
+import { toNumber } from '../../../../helpers/convert/index.js';
 import { $Call } from '../../../operations/index.js';
 import type { VmAny, VmConst, VmValue } from '../../../types/index.js';
 import { VmLib, expectArray, expectCallable } from '../../helpers.js';

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

@@ -1,4 +1,4 @@
-import { toBoolean } from '../../../../helpers/convert/to-boolean.js';
+import { toBoolean } from '../../../../helpers/convert/index.js';
 import { $Call } from '../../../operations/call.js';
 import { isSame } from '../../../operations/utils.js';
 import type { VmAny, VmConst, VmValue } from '../../../types/index.js';

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

@@ -1,6 +1,6 @@
 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 { isVmArray, isVmRecord } from '../../../../helpers/types/index.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';

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

@@ -1,6 +1,6 @@
 import { describeParam, expectNumberRange, throwError, throwUnexpectedTypeError, VmLib } from '../helpers.js';
 import { isNaN, NotNumber, isFinite } from '../../../helpers/utils.js';
-import { toNumber } from '../../../helpers/convert/to-number.js';
+import { toNumber } from '../../../helpers/convert/index.js';
 import { display } from '../../../helpers/serialize.js';
 import type { VmAny } from '../../types/index.js';
 

package/src/vm/lib/helpers.ts

@@ -2,7 +2,14 @@ import { VM_ARRAY_MAX_LENGTH } from '../../helpers/constants.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';
+import {
+    isVmArray,
+    isVmFunction,
+    isVmPrimitive,
+    isVmConst,
+    isVmCallable,
+    isVmRecord,
+} from '../../helpers/types/index.js';
 import { VmError } from '../../helpers/error.js';
 import type {
     VmExtern,

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

@@ -1 +1 @@
-export * as matrix from './matrix.js';
+export * as matrix from './matrix/index.js';