@mirascript/mirascript 0.1.78 → 0.1.80

package/src/vm/operations/compound.ts

@@ -1,28 +1,9 @@
 import { VmError } from '../../helpers/error.js';
-import {
-    hasOwnEnumerable,
-    NotNumber,
-    keys,
-    create,
-    isFinite,
-    keysLength,
-    getRecord,
-    setRecord,
-} 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';
@@ -30,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);
@@ -63,34 +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)) {
-            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 = $ToString(key);
-        if (hasOwnEnumerable(value, k)) {
-            setRecord(result, k, value[k]);
-        }
-    }
-    return result;
-};
 /** 检查是否拥有字段 */
 export const $Has = (obj: VmAny, key: VmAny): boolean => {
     $AssertInit(obj);
@@ -132,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';
 

package/src/vm/operations/utils.ts

@@ -1,6 +1,6 @@
-import { hasOwnEnumerable, isNaN, keys } from '../../helpers/utils.js';
-import { isVmArray, isVmWrapper } from '../../helpers/types.js';
-import type { VmAny, VmValue } from '../types/index.js';
+import { isNaN, keys, getRecord } from '../../helpers/utils.js';
+import { getVmType, isVmWrapper } from '../../helpers/types/index.js';
+import type { VmAny, VmArray, VmRecord, VmValue } from '../types/index.js';
 
 /**
  * 确定操作的重载
@@ -12,6 +12,38 @@ export const overloadNumberString = (a: VmAny, b: VmAny): boolean => {
     return true;
 };
 
+const isArraySame = (a: VmArray, b: VmArray): boolean => {
+    const len = a.length;
+    if (len !== b.length) return false;
+
+    for (let i = 0; i < len; i++) {
+        if (!isSame(a[i] ?? null, b[i] ?? null)) {
+            return false;
+        }
+    }
+    return true;
+};
+
+const isRecordSame = (a: VmRecord, b: VmRecord): boolean => {
+    const aKeys = keys(a);
+    const bKeys = keys(b);
+
+    const len = aKeys.length;
+    if (len !== bKeys.length) return false;
+    if (len === 0) return true;
+
+    for (let i = 0; i < len; i++) {
+        const key = aKeys[i]!;
+        const av = a[key] ?? null;
+        const bv = getRecord(b, key);
+        // Key not found in b
+        if (bv === undefined) return false;
+        // Key found in b, but values are not the same
+        if (!isSame(av, bv)) return false;
+    }
+    return true;
+};
+
 /**
  * 检查两个 VmValue 是否相同
  */
@@ -24,43 +56,19 @@ export const isSame = (a: VmValue, b: VmValue): boolean => {
     if (a === b) return true;
     // Any primitives and functions arrive here are not equal
     if (a == null || typeof a != 'object' || b == null || typeof b != 'object') return false;
-    // Handle wrapper values
-    if (isVmWrapper(a)) return a.same(b);
-    if (isVmWrapper(b)) return b.same(a);
+    const aType = getVmType(a);
+    const bType = getVmType(b);
+    if (aType !== bType) return false;
     // Handle array values
-    if (isVmArray(a) && isVmArray(b)) {
-        const len = a.length;
-        if (len !== b.length) {
-            return false;
-        }
-        // Compare array items
-        for (let i = 0; i < len; i++) {
-            if (!isSame(a[i] ?? null, b[i] ?? null)) {
-                return false;
-            }
-        }
-        return true;
+    if (aType === 'array') {
+        return isArraySame(a as VmArray, b as VmArray);
     }
     // Handle record values
-    if (!isVmArray(a) && !isVmArray(b)) {
-        // Compare record fields
-        const aKeys = keys(a);
-        const bKeys = keys(b);
-
-        const len = aKeys.length;
-        if (len !== bKeys.length) return false;
-
-        if (len === 0) return true;
-
-        let i = len;
-        while (i--) {
-            const key = aKeys[i]!;
-            if (!hasOwnEnumerable(b, key)) return false;
-            const av = a[key] ?? null;
-            const bv = b[key] ?? null;
-            if (!isSame(av, bv)) return false;
-        }
-        return true;
+    if (aType === 'record') {
+        return isRecordSame(a as VmRecord, b as VmRecord);
     }
+    // Handle wrapper values
+    if (isVmWrapper(a)) return a.same(b);
+    if (isVmWrapper(b)) return b.same(a);
     return false;
 };

package/src/vm/types/boundary.ts

@@ -1,10 +1,10 @@
 import { defineProperty, apply } from '../../helpers/utils.js';
-import { isVmExtern, isVmFunction, isVmWrapper } from '../../helpers/types.js';
+import { isVmExtern, isVmFunction, isVmWrapper } from '../../helpers/types/index.js';
 import { kVmFunctionProxy } from '../../helpers/constants.js';
 import { $Call } from '../operations/call.js';
 import type { VmAny, VmConst, VmModule, VmPrimitive, VmValue } from './index.js';
 import type { VmFunctionLike, VmFunction } from './function.js';
-import { VmExtern } from './extern.js';
+import { VmExtern } from './extern/index.js';
 
 /** 创建 Mirascript 函数在宿主语言运行的代理 */
 export function toVmFunctionProxy<T extends VmFunctionLike>(fn: VmFunction<T>): T {

package/src/vm/types/extern/access.ts

@@ -0,0 +1,24 @@
+import { hasOwn } from '../../../helpers/utils.js';
+
+const pFunction = Function.prototype;
+const pArray = Array.prototype;
+const pObject = Object.prototype;
+/**
+ * Can property be accessed on the extern object?
+ */
+export function canAccessProperty(value: object, key: string, read: boolean): boolean {
+    // __proto__ and other “private” properties are not accessible
+    if (key.startsWith('_')) return false;
+    // Function-specific properties are not accessible
+    if (typeof value == 'function' && (key === 'prototype' || key === 'arguments' || key === 'caller')) return false;
+    if (hasOwn(value, key)) return true;
+    if (!read) return true;
+    if (!(key in value)) return false;
+    if (key === 'constructor') return false; // constructor is not accessible
+    // property is not readable if it is the same as the prototype's property
+    const prop = (value as Record<string, unknown>)[key];
+    if (key in pFunction && prop === pFunction[key as keyof (() => void)]) return false;
+    if (key in pArray && prop === pArray[key as keyof unknown[]]) return false;
+    if (key in pObject && prop === pObject[key as keyof object]) return false;
+    return true;
+}

package/src/vm/types/extern/index.ts

@@ -0,0 +1,124 @@
+import { VmError } from '../../../helpers/error.js';
+import { apply } from '../../../helpers/utils.js';
+import { innerToString } from '../../../helpers/convert/string.js';
+import { isVmExtern } from '../../../helpers/types/index.js';
+import { kVmExtern } from '../../../helpers/constants.js';
+import type { VmTypeName, VmAny, VmConst, VmPrimitive, VmValue } from '../index.js';
+import { VmWrapper } from '../wrapper.js';
+import { unwrapFromVmValue, wrapToVmValue } from '../boundary.js';
+import { getTag } from './tag.js';
+import { getKeys, isArrayLike, hasCustomToString } from './utils.js';
+import { canAccessProperty } from './access.js';
+
+const ArrayMap = Array.prototype.map;
+
+/** 包装 Mirascript `extern` 类型的对象 */
+export class VmExtern<const T extends object = object> extends VmWrapper<T> {
+    constructor(
+        /** 包装值 */
+        value: T,
+        /** 当 {@link value} 是函数时，绑定的 this 参数 */
+        readonly thisArg: ThisParameterType<T> | null = null,
+    ) {
+        super(value);
+    }
+
+    /**
+     * Check if the object has a property
+     * This method will be used in {@link get}, {@link set}, {@link has}, and {@link keys} methods
+     */
+    protected access(key: string, read: boolean): boolean {
+        return canAccessProperty(this.value, key, read);
+    }
+
+    /** 决定是否对属性进行包装 */
+    assumeVmValue(value: object, key: keyof T | undefined): value is Exclude<VmConst, VmPrimitive> {
+        return false;
+    }
+
+    /** @inheritdoc */
+    override has(key: string): boolean {
+        return this.access(key, true);
+    }
+    /** @inheritdoc */
+    override get(key: string): VmAny {
+        if (!(key in this.value)) return undefined;
+        if (!this.access(key, true)) return undefined;
+        const prop = (this.value as Record<string, unknown>)[key];
+        return wrapToVmValue(prop, this.value, (v) => this.assumeVmValue(v, key as keyof T));
+    }
+    /** Set a property on the object */
+    set(key: string, value: VmValue): boolean {
+        if (!this.access(key, false)) return false;
+        const prop = unwrapFromVmValue(value, true);
+        (this.value as Record<string, unknown>)[key] = prop;
+        return true;
+    }
+    /** Call extern value */
+    call(args: readonly VmValue[]): VmAny {
+        const { value } = this;
+        if (typeof value != 'function') {
+            throw VmError.from(`Not a callable extern`, null, null);
+        }
+        const caller = this.thisArg;
+        const unwrappedArgs = args.map((arg) => unwrapFromVmValue(arg, true));
+        let ret: unknown;
+        try {
+            ret = apply(value, caller, unwrappedArgs);
+        } catch (ex) {
+            throw VmError.from(`Callable extern`, ex, null);
+        }
+        return wrapToVmValue(ret, null, (obj) => this.assumeVmValue(obj, undefined));
+    }
+    /** @inheritdoc */
+    override keys(includeNonEnumerable = false): string[] {
+        const keys = getKeys(this.value, includeNonEnumerable);
+        return keys.filter((key) => this.access(key, true));
+    }
+    /** @inheritdoc */
+    override same(other: VmAny): boolean {
+        if (!isVmExtern(other)) return false;
+        return this.value === other.value && this.thisArg === other.thisArg;
+    }
+    /**
+     * Should this extern be treated as array-like?
+     *
+     * By default, this method returns true if the wrapped value is an Array or a TypedArray.
+     */
+    isArrayLike(): this is VmExtern<ArrayLike<unknown>> {
+        return isArrayLike(this.value);
+    }
+    /** @inheritdoc */
+    override toString(useBraces: boolean): string {
+        if (hasCustomToString(this.value)) {
+            // Use the wrapped object's toString method
+            return String(this.value);
+        }
+        if (this.isArrayLike()) {
+            // Handle array-like externs specially when using default toString
+            const mapped = ArrayMap.call(this.value, (item: unknown) => {
+                if (item === undefined) return '';
+                return innerToString(wrapToVmValue(item ?? null, null, null), true);
+            });
+            const str = mapped.join(', ');
+            if (useBraces) return `[${str}]`;
+            return str;
+        }
+        // When the toString method is not overridden or invalid, provide a better default representation
+        return super.toString(useBraces);
+    }
+    /** @inheritdoc */
+    override get type(): VmTypeName {
+        return 'extern';
+    }
+    /** @inheritdoc */
+    override get tag(): string {
+        const tag = getTag(this.value);
+        if (this.isArrayLike()) {
+            return `${tag}(${this.value.length})`;
+        }
+        return tag;
+    }
+}
+
+Object.defineProperty(VmExtern.prototype, kVmExtern, { value: true });