@mirascript/mirascript 0.1.15 → 0.1.17

package/dist/{chunk-NT235HY3.js → chunk-W2I5XPIE.js}

@@ -1,42 +1,31 @@
 import {
-  $Add,
-  $Call,
-  $Div,
-  $Format,
-  $Mul,
-  $Same,
-  $Sub,
-  $ToBoolean,
-  $ToNumber,
-  $ToString,
-  $Type,
-  Cp,
   DiagnosticCode,
-  Element,
-  GlobalFallback,
   VM_ARRAY_MAX_LENGTH,
+  VM_FUNCTION_ANONYMOUS_NAME,
+  VM_SCRIPT_NAME,
   VmError,
-  VmFunction,
-  VmModule,
-  VmSharedContext,
   __export,
+  apply,
   create,
   defineProperty,
+  display,
   emit,
   entries,
-  formatDiagnostic,
+  formatDiagnostics,
   fromEntries,
   generateBytecode,
   generateBytecodeSync,
+  getPrototypeOf,
   hasOwn,
-  helpers_exports,
+  hasOwnEnumerable,
+  innerToString,
   isArray,
   isFinite,
   isInteger,
   isNaN,
   isSafeInteger,
+  isVmAny,
   isVmArray,
-  isVmArrayLikeRecordByEntires,
   isVmCallable,
   isVmConst,
   isVmExtern,
@@ -44,40 +33,1242 @@ import {
   isVmModule,
   isVmPrimitive,
   isVmRecord,
+  isVmWrapper,
+  kVmContext,
+  kVmExtern,
+  kVmFunction,
+  kVmFunctionProxy,
+  kVmModule,
+  kVmScript,
+  kVmWrapper,
   keys,
-  operations_exports,
   parseDiagnostics,
+  toString,
   values
-} from "./chunk-JVFUK7AN.js";
+} from "./chunk-JG3D67GF.js";
+
+// src/helpers/convert/index.ts
+var convert_exports = {};
+__export(convert_exports, {
+  toBoolean: () => toBoolean,
+  toFormat: () => toFormat,
+  toNumber: () => toNumber,
+  toString: () => toString
+});
+
+// src/helpers/convert/to-number.ts
+var { POSITIVE_INFINITY, NEGATIVE_INFINITY } = Number;
+function toNumber(value, fallback) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value == "boolean") {
+    return value ? 1 : 0;
+  }
+  if (typeof value == "string") {
+    value = value.trim();
+    if (value !== "") {
+      if (value === "inf" || value === "+inf" || value === "Infinity" || value === "+Infinity") {
+        return POSITIVE_INFINITY;
+      }
+      if (value === "-inf" || value === "-Infinity") {
+        return NEGATIVE_INFINITY;
+      }
+      if (value === "nan" || value === "NaN") {
+        return Number.NaN;
+      }
+      const num2 = Number(value);
+      if (!isNaN(num2)) return num2;
+    }
+  }
+  if (fallback === void 0) {
+    throw new VmError(`Failed to convert value to number: ${display(value)}`, Number.NaN);
+  }
+  return fallback;
+}
+
+// src/helpers/convert/to-format.ts
+function formatNumber(value) {
+  if (!isFinite(value)) return toString(value, void 0);
+  if (value === 0) return "0";
+  const s = value.toString();
+  let ps;
+  const abs3 = Math.abs(value);
+  if (abs3 >= 1e3 || abs3 < 1e-3) {
+    const ps1 = value.toExponential();
+    const ps2 = value.toExponential(5);
+    ps = ps1.length < ps2.length ? ps1 : ps2;
+  } else {
+    ps = value.toPrecision(6);
+  }
+  return ps.length < s.length ? ps : s;
+}
+function toFormat(value, format2) {
+  const f = format2 == null ? "" : format2.trim();
+  if (typeof value == "number") {
+    if (/^\.\d+$/.test(f)) {
+      let digits = Math.trunc(Number(f.slice(1)));
+      if (!(digits <= 100)) digits = 100;
+      return value.toFixed(digits);
+    } else {
+      return formatNumber(value);
+    }
+  }
+  return toString(value, void 0);
+}
+
+// src/helpers/convert/to-boolean.ts
+function toBoolean(value, fallback) {
+  if (typeof value === "boolean") return value;
+  if (fallback === void 0) {
+    throw new VmError(`Failed to convert value to boolean: ${display(value)}`, false);
+  }
+  return fallback;
+}
+
+// src/vm/operations.ts
+var operations_exports = {};
+__export(operations_exports, {
+  $Add: () => $Add,
+  $Aeq: () => $Aeq,
+  $And: () => $And,
+  $ArraySpread: () => $ArraySpread,
+  $AssertInit: () => $AssertInit,
+  $AssertNonNil: () => $AssertNonNil,
+  $Call: () => $Call,
+  $Concat: () => $Concat,
+  $Div: () => $Div,
+  $Eq: () => $Eq,
+  $Format: () => $Format,
+  $Get: () => $Get,
+  $Gt: () => $Gt,
+  $Gte: () => $Gte,
+  $Has: () => $Has,
+  $In: () => $In,
+  $IsArray: () => $IsArray,
+  $IsBoolean: () => $IsBoolean,
+  $IsNumber: () => $IsNumber,
+  $IsRecord: () => $IsRecord,
+  $IsString: () => $IsString,
+  $Iterable: () => $Iterable,
+  $Length: () => $Length,
+  $Lt: () => $Lt,
+  $Lte: () => $Lte,
+  $Mod: () => $Mod,
+  $Mul: () => $Mul,
+  $Naeq: () => $Naeq,
+  $Neg: () => $Neg,
+  $Neq: () => $Neq,
+  $Not: () => $Not,
+  $Nsame: () => $Nsame,
+  $Omit: () => $Omit,
+  $Or: () => $Or,
+  $Pick: () => $Pick,
+  $Pos: () => $Pos,
+  $Pow: () => $Pow,
+  $RecordSpread: () => $RecordSpread,
+  $Same: () => $Same,
+  $Set: () => $Set,
+  $Slice: () => $Slice,
+  $SliceExclusive: () => $SliceExclusive,
+  $Sub: () => $Sub,
+  $ToBoolean: () => $ToBoolean,
+  $ToNumber: () => $ToNumber,
+  $ToString: () => $ToString,
+  $Type: () => $Type
+});
+var { abs, min, trunc, ceil } = Math;
+var { slice, at } = Array.prototype;
+var isSame = (a, b) => {
+  if (typeof a == "number" && typeof b == "number") return a === b || isNaN(a) && isNaN(b);
+  if (a === b) return true;
+  if (a == null || typeof a != "object" || b == null || typeof b != "object") return false;
+  if (isVmWrapper(a)) return a.same(b);
+  if (isVmWrapper(b)) return b.same(a);
+  if (isVmArray(a) && isVmArray(b)) {
+    const len2 = a.length;
+    if (len2 !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < len2; i++) {
+      if (!isSame(a[i] ?? null, b[i] ?? null)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (!isVmArray(a) && !isVmArray(b)) {
+    const aKeys = keys(a);
+    const bKeys = keys(b);
+    if (aKeys.length !== bKeys.length) {
+      return false;
+    }
+    for (const key of aKeys) {
+      if (!hasOwnEnumerable(b, key)) {
+        return false;
+      }
+      const av = a[key] ?? null;
+      const bv = b[key] ?? null;
+      if (!isSame(av, bv)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+};
+var overloadNumberString = (a, b) => {
+  if (typeof a == "number" || typeof b == "number") return true;
+  if (typeof a == "string" || typeof b == "string") return false;
+  return true;
+};
+var $Add = (a, b) => {
+  return $ToNumber(a) + $ToNumber(b);
+};
+var $Sub = (a, b) => {
+  return $ToNumber(a) - $ToNumber(b);
+};
+var $Mul = (a, b) => {
+  return $ToNumber(a) * $ToNumber(b);
+};
+var $Div = (a, b) => {
+  return $ToNumber(a) / $ToNumber(b);
+};
+var $Mod = (a, b) => {
+  return $ToNumber(a) % $ToNumber(b);
+};
+var $Pow = (a, b) => {
+  return $ToNumber(a) ** $ToNumber(b);
+};
+var $And = (a, b) => {
+  return $ToBoolean(a) && $ToBoolean(b);
+};
+var $Or = (a, b) => {
+  return $ToBoolean(a) || $ToBoolean(b);
+};
+var $Gt = (a, b) => {
+  if (overloadNumberString(a, b)) {
+    return $ToNumber(a) > $ToNumber(b);
+  } else {
+    return $ToString(a) > $ToString(b);
+  }
+};
+var $Gte = (a, b) => {
+  if (overloadNumberString(a, b)) {
+    return $ToNumber(a) >= $ToNumber(b);
+  } else {
+    return $ToString(a) >= $ToString(b);
+  }
+};
+var $Lt = (a, b) => {
+  if (overloadNumberString(a, b)) {
+    return $ToNumber(a) < $ToNumber(b);
+  } else {
+    return $ToString(a) < $ToString(b);
+  }
+};
+var $Lte = (a, b) => {
+  if (overloadNumberString(a, b)) {
+    return $ToNumber(a) <= $ToNumber(b);
+  } else {
+    return $ToString(a) <= $ToString(b);
+  }
+};
+var $Eq = (a, b) => {
+  $AssertInit(a);
+  $AssertInit(b);
+  if (typeof a == "number" && typeof b == "number") return a === b;
+  return isSame(a, b);
+};
+var $Neq = (a, b) => {
+  return !$Eq(a, b);
+};
+var $Aeq = (a, b) => {
+  if (overloadNumberString(a, b)) {
+    const an = $ToNumber(a);
+    const bn = $ToNumber(b);
+    const EPS = 1e-15;
+    if (isNaN(an) || isNaN(bn)) return false;
+    if (an === bn) return true;
+    const absoluteDifference = abs(an - bn);
+    if (absoluteDifference < EPS) return true;
+    const base = min(abs(an), abs(bn));
+    return absoluteDifference < base * EPS;
+  } else {
+    const as = $ToString(a);
+    const bs = $ToString(b);
+    if (as === bs) return true;
+    const ai = as.toLowerCase();
+    const bi = bs.toLowerCase();
+    if (ai === bi) return true;
+    const an = ai.normalize("NFC");
+    const bn = bi.normalize("NFC");
+    return an === bn;
+  }
+};
+var $Naeq = (a, b) => {
+  return !$Aeq(a, b);
+};
+var $Same = (a, b) => {
+  $AssertInit(a);
+  $AssertInit(b);
+  return isSame(a, b);
+};
+var $Nsame = (a, b) => {
+  return !$Same(a, b);
+};
+var $In = (value, iterable) => {
+  $AssertInit(value);
+  $AssertInit(iterable);
+  if (iterable == null) return false;
+  if (typeof iterable != "object") return false;
+  if (isVmArray(iterable)) {
+    if (value == null) {
+      for (const item of iterable) if (item == null) return true;
+      return false;
+    }
+    if (isVmPrimitive(value)) return iterable.includes(value);
+    return iterable.some((item = null) => isSame(item, value));
+  }
+  const key = toString(value, void 0);
+  if (isVmWrapper(iterable)) return iterable.has(key);
+  return hasOwnEnumerable(iterable, key);
+};
+var $Concat = (...args) => {
+  return args.map((a) => toFormat(a, null)).join("");
+};
+var $Pos = (a) => {
+  return $ToNumber(a);
+};
+var $Neg = (a) => {
+  return -$ToNumber(a);
+};
+var $Not = (a) => {
+  return !$ToBoolean(a);
+};
+var $Length = (value) => {
+  $AssertInit(value);
+  if (isVmArray(value)) return value.length;
+  if (isVmRecord(value)) return keys(value).length;
+  if (isVmWrapper(value)) return value.keys().length;
+  throw new VmError(`Value has no length: ${display(value)}`, 0);
+};
+var $Omit = (value, omitted) => {
+  $AssertInit(value);
+  if (value == null || !isVmRecord(value)) return {};
+  const result = {};
+  const valueKeys = keys(value);
+  const omittedSet = new Set(omitted.map($ToString));
+  for (const key of valueKeys) {
+    if (!omittedSet.has(key)) {
+      result[key] = value[key] ?? null;
+    }
+  }
+  return result;
+};
+var $Pick = (value, picked) => {
+  $AssertInit(value);
+  if (value == null || !isVmRecord(value)) return {};
+  const result = {};
+  for (const key of picked) {
+    const k = $ToString(key);
+    if (hasOwnEnumerable(value, k)) {
+      result[k] = value[k] ?? null;
+    }
+  }
+  return result;
+};
+var sliceCore = (value, start, end, exclusive) => {
+  const { length } = value;
+  if (isNaN(start)) start = 0;
+  else if (start < 0) start = length + start;
+  if (isNaN(end)) end = exclusive ? length : length - 1;
+  else if (end < 0) end = length + end;
+  start = ceil(start);
+  if (exclusive || !isSafeInteger(end)) {
+    end = ceil(end);
+  } else {
+    end = end + 1;
+  }
+  return slice.call(value, start, end);
+};
+var $Slice = (value, start, end) => {
+  $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);
+};
+var $SliceExclusive = (value, start, end) => {
+  $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);
+};
+var $AssertInit = (value) => {
+  if (value === void 0) throw new VmError(`Uninitialized value`, null);
+};
+var $Call = (func, args) => {
+  for (const a of args) {
+    $AssertInit(a);
+  }
+  if (isVmExtern(func)) {
+    return func.call(args) ?? null;
+  }
+  if (isVmFunction(func)) {
+    return func(...args) ?? null;
+  }
+  throw new VmError(`Value is not callable: ${display(func)}`, null);
+};
+var $Type = (value) => {
+  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;
+};
+var $ToBoolean = (value) => {
+  if (typeof value == "boolean") return value;
+  $AssertInit(value);
+  return toBoolean(value, void 0);
+};
+var $ToString = (value) => {
+  if (typeof value == "string") return value;
+  $AssertInit(value);
+  return toString(value, void 0);
+};
+var $ToNumber = (value) => {
+  if (typeof value == "number") return value;
+  $AssertInit(value);
+  return toNumber(value, void 0);
+};
+var $IsBoolean = (value) => {
+  $AssertInit(value);
+  return typeof value == "boolean";
+};
+var $IsNumber = (value) => {
+  $AssertInit(value);
+  return typeof value == "number";
+};
+var $IsString = (value) => {
+  $AssertInit(value);
+  return typeof value == "string";
+};
+var $IsRecord = (value) => {
+  $AssertInit(value);
+  return isVmRecord(value);
+};
+var $IsArray = (value) => {
+  $AssertInit(value);
+  return isVmArray(value);
+};
+var $AssertNonNil = (value) => {
+  $AssertInit(value);
+  if (value !== null) return;
+  throw new VmError(`Expected non-nil value`, null);
+};
+var $Has = (obj, key) => {
+  $AssertInit(obj);
+  const pk = $ToString(key);
+  if (obj == null || typeof obj != "object") return false;
+  if (isVmWrapper(obj)) return obj.has(pk);
+  return hasOwnEnumerable(obj, pk);
+};
+var $Get = (obj, key) => {
+  $AssertInit(obj);
+  if (isVmArray(obj)) {
+    const index = $ToNumber(key);
+    if (isNaN(index)) return null;
+    return at.call(obj, trunc(index)) ?? null;
+  }
+  const pk = $ToString(key);
+  if (obj == null || typeof obj != "object") return null;
+  if (isVmWrapper(obj)) return obj.get(pk) ?? null;
+  if (!hasOwnEnumerable(obj, pk)) return null;
+  return obj[pk] ?? null;
+};
+var $Set = (obj, key, value) => {
+  $AssertInit(obj);
+  $AssertInit(value);
+  const pk = $ToString(key);
+  if (obj == null) return;
+  if (!isVmExtern(obj)) throw new VmError(`Expected extern, got ${display(obj)}`, void 0);
+  obj.set(pk, value);
+};
+var $Iterable = (value) => {
+  $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]);
+};
+var $RecordSpread = (record) => {
+  $AssertInit(record);
+  if (record == null || isVmRecord(record)) return record;
+  if (isVmArray(record)) {
+    const result = {};
+    const len2 = record.length;
+    for (let i = 0; i < len2; i++) {
+      const item = record[i];
+      result[i] = item ?? null;
+    }
+    return result;
+  }
+  if (isVmExtern(record)) {
+    const result = create(null);
+    for (const key of record.keys()) {
+      const value = record.get(key) ?? null;
+      if (isVmPrimitive(value)) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  throw new VmError(`Expected record, array, extern or nil, got ${display(record)}`, null);
+};
+var $ArraySpread = (array) => {
+  $AssertInit(array);
+  if (array == null) return [];
+  if (isVmArray(array)) return array;
+  if (isVmExtern(array) && typeof array.value[Symbol.iterator] == "function") {
+    const result = [];
+    for (const item of array.value) {
+      if (isVmPrimitive(item)) {
+        result.push(item);
+      } else {
+        result.push(null);
+      }
+    }
+    return result;
+  }
+  throw new VmError(`Expected array, iterable extern or nil, got ${display(array)}`, []);
+};
+var $Format = (value, format2) => {
+  $AssertInit(value);
+  const f = format2 == null ? "" : $ToString(format2);
+  return toFormat(value, f);
+};
+
+// src/vm/types/wrapper.ts
+var VmWrapper = class {
+  constructor(value) {
+    this.value = value;
+  }
+  /** Convert the object to JSON */
+  toJSON() {
+    return void 0;
+  }
+  /** 转为字符串 */
+  toString(useBraces) {
+    const { type, describe } = this;
+    if (!describe) return `<${type}>`;
+    return `<${type} ${describe}>`;
+  }
+};
+Object.defineProperty(VmWrapper.prototype, kVmWrapper, { value: true });
+
+// src/vm/types/boundary.ts
+function toVmFunctionProxy(fn) {
+  const cached = fn[kVmFunctionProxy];
+  if (cached != null) return cached;
+  const proxy = (...args) => {
+    const ret = $Call(
+      fn,
+      // 作为函数参数传入的值一定丢失了它的 this
+      args.map((v) => wrapToVmValue(v, null))
+    );
+    return unwrapFromVmValue(ret);
+  };
+  defineProperty(fn, kVmFunctionProxy, { value: proxy });
+  defineProperty(proxy, kVmFunctionProxy, { value: fn });
+  defineProperty(proxy, "name", {
+    value: fn.name,
+    configurable: true
+  });
+  return proxy;
+}
+function fromVmFunctionProxy(fn) {
+  if (isVmFunction(fn)) return fn;
+  const original = fn[kVmFunctionProxy];
+  if (original && isVmFunction(original)) return original;
+  return void 0;
+}
+function wrapToVmValue(value, thisArg = null, assumeVmValue) {
+  if (value == null) return null;
+  switch (typeof value) {
+    case "function": {
+      const unwrapped = fromVmFunctionProxy(value);
+      if (unwrapped) return unwrapped;
+      return new VmExtern(value, thisArg);
+    }
+    case "object": {
+      if (isVmWrapper(value)) return value;
+      if (value instanceof Date) return value.valueOf();
+      if (assumeVmValue?.(value)) return value;
+      return new VmExtern(value);
+    }
+    case "string":
+    case "number":
+    case "boolean":
+      return value;
+    case "bigint":
+      return Number(value);
+    case "symbol":
+    case "undefined":
+    default:
+      return null;
+  }
+}
+function unwrapFromVmValue(value) {
+  if (isVmFunction(value)) {
+    return toVmFunctionProxy(value);
+  }
+  if (value == null || typeof value != "object") return value;
+  if (!isVmExtern(value)) return value;
+  if (value.thisArg == null || typeof value.value != "function") {
+    return value.value;
+  }
+  const f = value;
+  const caller = f.thisArg.value;
+  return new Proxy(f.value, {
+    apply(target, thisArg, args) {
+      return apply(target, caller, args);
+    }
+  });
+}
+
+// src/vm/types/extern.ts
+var ObjectPrototype = Object.prototype;
+var ObjectToString = ObjectPrototype.toString;
+var FunctionToString = Function.prototype.toString;
+var ArrayToString = Array.prototype.toString;
+var ArrayMap = Array.prototype.map;
+var VmExtern = class extends VmWrapper {
+  constructor(value, thisArg = null) {
+    super(value);
+    this.thisArg = thisArg;
+  }
+  /** Check if the object has a property */
+  access(key, read) {
+    if (key.startsWith("_")) return false;
+    if (typeof this.value == "function" && (key === "prototype" || key === "arguments" || key === "caller"))
+      return false;
+    if (hasOwn(this.value, key)) return true;
+    if (!read) return true;
+    if (!(key in this.value)) return false;
+    if (key === "constructor") return false;
+    const prop = this.value[key];
+    if (key in Function.prototype && prop === Function.prototype[key]) return false;
+    if (key in Array.prototype && prop === Array.prototype[key]) return false;
+    if (key in Object.prototype && prop === Object.prototype[key]) return false;
+    return true;
+  }
+  /** 决定是否对属性进行包装 */
+  assumeVmValue(value, key) {
+    return false;
+  }
+  /** @inheritdoc */
+  has(key) {
+    return this.access(key, true);
+  }
+  /** @inheritdoc */
+  get(key) {
+    if (!this.has(key)) return void 0;
+    const prop = this.value[key];
+    return wrapToVmValue(prop, this, (v) => this.assumeVmValue(v, key));
+  }
+  /** Set a property on the object */
+  set(key, value) {
+    if (!this.access(key, false)) return false;
+    const prop = unwrapFromVmValue(value);
+    this.value[key] = prop;
+    return true;
+  }
+  /** Call extern value */
+  call(args) {
+    const { value } = this;
+    if (typeof value != "function") {
+      throw VmError.from(`Not a callable extern`, null, null);
+    }
+    const caller = this.thisArg?.value ?? null;
+    const unwrappedArgs = args.map(unwrapFromVmValue);
+    let ret;
+    try {
+      ret = apply(value, caller, unwrappedArgs);
+    } catch (ex) {
+      throw VmError.from(`Callable extern`, ex, null);
+    }
+    return wrapToVmValue(ret, null, (obj) => this.assumeVmValue(obj, void 0));
+  }
+  /** @inheritdoc */
+  keys() {
+    const keys4 = [];
+    for (const key in this.value) {
+      if (this.has(key)) keys4.push(key);
+    }
+    return keys4;
+  }
+  /** @inheritdoc */
+  same(other) {
+    if (!isVmExtern(other)) return false;
+    return this.value === other.value && this.thisArg === other.thisArg;
+  }
+  /** @inheritdoc */
+  toString(useBraces) {
+    const { toString: toString2 } = this.value;
+    if (typeof toString2 != "function" || toString2 === ObjectToString || toString2 === FunctionToString) {
+      return super.toString(useBraces);
+    }
+    if (toString2 === ArrayToString && isArray(this.value)) {
+      const mapped = ArrayMap.call(this.value, (item) => {
+        if (item === void 0) return "";
+        return innerToString(wrapToVmValue(item ?? null, null), true);
+      });
+      const str = mapped.join(", ");
+      if (useBraces) return `[${str}]`;
+      return str;
+    }
+    return String(this.value);
+  }
+  /** @inheritdoc */
+  get type() {
+    return "extern";
+  }
+  /** @inheritdoc */
+  get describe() {
+    const tag = ObjectToString.call(this.value).slice(8, -1);
+    if (isArray(this.value)) {
+      return `${tag}(${this.value.length})`;
+    } else if (tag === "Object") {
+      const proto = getPrototypeOf(this.value);
+      if (proto === ObjectPrototype) {
+        return "Object";
+      }
+      if (proto == null) {
+        return "Object: null prototype";
+      }
+      if (typeof proto.constructor === "function" && proto.constructor.name) {
+        return proto.constructor.name;
+      }
+    } else if (tag === "Function" && "prototype" in this.value && typeof this.value.prototype == "object") {
+      const { name } = this.value;
+      return `class ${name || "<anonymous>"}`;
+    } else if (tag === "Function") {
+      const { name } = this.value;
+      return `function ${name || "<anonymous>"}()`;
+    } else if (tag === "AsyncFunction") {
+      const { name } = this.value;
+      return `async function ${name || "<anonymous>"}()`;
+    } else if (tag === "GeneratorFunction") {
+      const { name } = this.value;
+      return `function* ${name || "<anonymous>"}()`;
+    } else if (tag === "AsyncGeneratorFunction") {
+      const { name } = this.value;
+      return `async function* ${name || "<anonymous>"}()`;
+    }
+    return tag;
+  }
+};
+Object.defineProperty(VmExtern.prototype, kVmExtern, { value: true });
+
+// src/vm/checkpoint.ts
+var MAX_DEPTH = 128;
+var cpDepth = 0;
+var cp = Number.NaN;
+var cpTimeout = 100;
+function Cp() {
+  if (!cp) {
+    cp = Date.now();
+  } else if (Date.now() - cp > cpTimeout) {
+    throw new RangeError("Execution timeout");
+  }
+}
+function CpEnter() {
+  cpDepth++;
+  if (cpDepth <= 1) {
+    cp = Date.now();
+    cpDepth = 1;
+  } else if (cpDepth > MAX_DEPTH) {
+    throw new RangeError("Maximum call depth exceeded");
+  } else {
+    Cp();
+  }
+}
+function CpExit() {
+  cpDepth--;
+  if (cpDepth < 1) {
+    cp = Number.NaN;
+    cpDepth = 0;
+  } else {
+    Cp();
+  }
+}
+function configCheckpoint(timeout = 100) {
+  if (typeof timeout !== "number" || timeout <= 0 || Number.isNaN(timeout)) {
+    throw new RangeError("Invalid timeout value");
+  }
+  cpTimeout = timeout;
+}
 
-// src/subtle.ts
-import { getModule } from "@mirascript/bindings";
+// src/vm/types/function.ts
+function VmFunction(fn, option = {}) {
+  if (typeof fn != "function") {
+    throw new TypeError("Invalid function");
+  }
+  const exists = fromVmFunctionProxy(fn);
+  if (exists) return exists;
+  const info = {
+    fullName: option.fullName ?? (fn.name === VM_FUNCTION_ANONYMOUS_NAME ? "" : fn.name),
+    isLib: option.isLib ?? false,
+    summary: option.summary || void 0,
+    params: option.params,
+    paramsType: option.paramsType,
+    returns: option.returns || void 0,
+    returnsType: option.returnsType || void 0,
+    examples: option.examples?.length ? option.examples : void 0
+  };
+  if (option.injectCp) {
+    const original = fn;
+    info.original = original;
+    fn = ((...args) => {
+      try {
+        CpEnter();
+        const ret = original(...args);
+        return ret;
+      } finally {
+        CpExit();
+      }
+    });
+    defineProperty(fn, "name", { value: original.name });
+  }
+  defineProperty(fn, kVmFunction, {
+    value: Object.freeze(info)
+  });
+  return fn;
+}
 
-// src/helpers/constants.ts
-var constants_exports = {};
-__export(constants_exports, {
-  REG_BIN: () => REG_BIN,
-  REG_HEX: () => REG_HEX,
-  REG_IDENTIFIER: () => REG_IDENTIFIER,
-  REG_NUMBER: () => REG_NUMBER,
-  REG_OCT: () => REG_OCT,
-  REG_ORDINAL: () => REG_ORDINAL,
-  REG_WHITESPACE: () => REG_WHITESPACE
+// src/vm/types/context.ts
+var { freeze } = Object;
+var VM_SHARED_CONTEXT = create(null);
+var VM_SHARED_CONTEXT_KEYS = null;
+function globalVarNotFound(name) {
+  throw new VmError(`Global variable '${name}' is not defined.`, null);
+}
+function defineVmContextValue(name, value, override = false) {
+  if (!override && name in VM_SHARED_CONTEXT) throw new Error(`Global variable '${name}' is already defined.`);
+  let v;
+  if (typeof value == "function") {
+    v = VmFunction(value, {
+      isLib: true,
+      fullName: `global.${name}`
+    });
+  } else {
+    v = value;
+  }
+  VM_SHARED_CONTEXT[name] = v ?? null;
+  VM_SHARED_CONTEXT_KEYS = null;
+}
+var DefaultVmContext = freeze({
+  [kVmContext]: true,
+  /** @inheritdoc */
+  keys() {
+    VM_SHARED_CONTEXT_KEYS ??= freeze(keys(VM_SHARED_CONTEXT));
+    return VM_SHARED_CONTEXT_KEYS;
+  },
+  /** @inheritdoc */
+  get(key) {
+    const val = VM_SHARED_CONTEXT[key];
+    if (val === void 0) globalVarNotFound(key);
+    return val;
+  },
+  /** @inheritdoc */
+  has(key) {
+    return key in VM_SHARED_CONTEXT;
+  }
 });
-var REG_IDENTIFIER = /(?:_+|@+|\$+|\p{XID_Start})\p{XID_Continue}*/u;
-var REG_ORDINAL = /(?:214748364[0-7]|21474836[0-3]\d|2147483[0-5]\d{2}|214748[0-2]\d{3}|21474[0-7]\d{4}|2147[0-3]\d{5}|214[0-6]\d{6}|21[0-3]\d{7}|20\d{8}|1\d{9}|[1-9]\d{0,8}|0)/;
-var REG_WHITESPACE = /[ \t\v\f\r\n]/u;
-var REG_HEX = /0[xX][a-fA-F0-9_]*[a-fA-F0-9]/;
-var REG_OCT = /0[oO][0-7_]*[0-7]/;
-var REG_BIN = /0[bB][01_]*[01]/;
-var REG_NUMBER = /\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?[\d_]*\d)?/u;
+var _a;
+_a = kVmContext;
+var ValueVmContext = class {
+  constructor(env, describe) {
+    this.env = env;
+    this.describe = describe;
+    this[_a] = true;
+    this.cachedKeys = null;
+  }
+  /** @inheritdoc */
+  keys() {
+    const defaultKeys = DefaultVmContext.keys();
+    if (this.cachedKeys?.[0] !== defaultKeys) {
+      const allKeys = freeze([...keys(this.env), ...defaultKeys]);
+      this.cachedKeys = freeze([defaultKeys, allKeys]);
+    }
+    return this.cachedKeys[1];
+  }
+  /** @inheritdoc */
+  get(key) {
+    const val = this.env[key];
+    if (val === void 0) globalVarNotFound(key);
+    return val;
+  }
+  /** @inheritdoc */
+  has(key) {
+    return key in this.env;
+  }
+};
+var _a2;
+_a2 = kVmContext;
+var FactoryVmContext = class {
+  constructor(getter, enumerator, describe) {
+    this.getter = getter;
+    this.enumerator = enumerator;
+    this.describe = describe;
+    this[_a2] = true;
+  }
+  /** @inheritdoc */
+  keys() {
+    if (!this.enumerator) return DefaultVmContext.keys();
+    return freeze([...this.enumerator(), ...DefaultVmContext.keys()]);
+  }
+  /** @inheritdoc */
+  get(key) {
+    const value = this.getter(key);
+    if (value !== void 0) return value;
+    return DefaultVmContext.get(key);
+  }
+  /** @inheritdoc */
+  has(key) {
+    return this.getter(key) !== void 0 || DefaultVmContext.has(key);
+  }
+};
+function createVmContext(...args) {
+  if (args[0] == null && args[1] == null) {
+    return { ...DefaultVmContext };
+  }
+  if (typeof args[0] == "function") {
+    const [getter, enumerator, describer2] = args;
+    return new FactoryVmContext(getter, enumerator ?? void 0, describer2 ?? void 0);
+  }
+  const [vmValues, externValues, describer] = args;
+  const env = create(VM_SHARED_CONTEXT);
+  if (vmValues) {
+    for (const [key, value] of entries(vmValues)) {
+      if (!isVmAny(value, false)) continue;
+      env[key] = value ?? null;
+    }
+  }
+  if (externValues) {
+    for (const [key, value] of entries(externValues)) {
+      env[key] = value == null ? null : wrapToVmValue(value, null);
+    }
+  }
+  return new ValueVmContext(env, describer ?? void 0);
+}
+
+// src/compiler/index.ts
+import { loadModule } from "@mirascript/bindings";
+
+// src/vm/helpers.ts
+var helpers_exports = {};
+__export(helpers_exports, {
+  ArrayRange: () => ArrayRange,
+  ArrayRangeExclusive: () => ArrayRangeExclusive,
+  Cp: () => Cp,
+  CpEnter: () => CpEnter,
+  CpExit: () => CpExit,
+  Element: () => Element,
+  ElementOpt: () => ElementOpt,
+  Function: () => Function2,
+  GlobalFallback: () => GlobalFallback,
+  Upvalue: () => Upvalue,
+  Vargs: () => Vargs
+});
+var Vargs = (varags) => {
+  for (let i = 0, l = varags.length; i < l; i++) {
+    const el = varags[i];
+    if (!isVmConst(el)) {
+      varags[i] = null;
+    }
+  }
+  return varags;
+};
+var Element = (value) => {
+  $AssertInit(value);
+  if (!isVmConst(value)) return null;
+  return value;
+};
+var ElementOpt = (key, value) => {
+  $AssertInit(value);
+  if (value == null || !isVmConst(value)) return {};
+  return { [key]: value };
+};
+var Function2 = (fn, name = VM_FUNCTION_ANONYMOUS_NAME) => {
+  defineProperty(fn, "name", { value: name });
+  return VmFunction(fn, { isLib: false, injectCp: false });
+};
+var Upvalue = (value) => {
+  $AssertInit(value);
+  return value;
+};
+var assertArrayLength = (start, end) => {
+  if (end - start > VM_ARRAY_MAX_LENGTH) {
+    throw new RangeError(`Array length exceeds maximum limit of ${VM_ARRAY_MAX_LENGTH}`);
+  }
+};
+var isEmptyRange = (start, end) => {
+  return !isFinite(start) || !isFinite(end) || start > end;
+};
+var ArrayRange = (start, end) => {
+  const s = $ToNumber(start);
+  const e = $ToNumber(end);
+  if (isEmptyRange(s, e)) return [];
+  assertArrayLength(s, e);
+  const arr = [];
+  for (let i = s; i <= e; i++) {
+    arr.push(i);
+  }
+  return arr;
+};
+var ArrayRangeExclusive = (start, end) => {
+  const s = $ToNumber(start);
+  const e = $ToNumber(end);
+  if (isEmptyRange(s, e)) return [];
+  assertArrayLength(s, e);
+  const arr = [];
+  for (let i = s; i < e; i++) {
+    arr.push(i);
+  }
+  return arr;
+};
+function GlobalFallback() {
+  return DefaultVmContext;
+}
+
+// src/vm/env.ts
+var keys2 = [];
+var values2 = [];
+for (const [key, value] of entries(operations_exports)) {
+  keys2.push(key);
+  values2.push(value);
+}
+for (const [key, value] of entries(helpers_exports)) {
+  keys2.push(key);
+  values2.push(value);
+}
+
+// src/compiler/create-script.ts
+function wrapScript(source, script) {
+  if (kVmScript in script) {
+    return script;
+  }
+  defineProperty(script, "name", { value: VM_SCRIPT_NAME });
+  defineProperty(script, kVmScript, { value: true });
+  if (typeof source === "string") {
+    defineProperty(script, "source", { value: source, configurable: true });
+  } else if (source instanceof Uint8Array) {
+    defineProperty(script, "source", { value: "<buffer>", configurable: true });
+  }
+  return script;
+}
+function createScript(source, code) {
+  let script;
+  try {
+    script = new Function(...keys2, code)(...values2);
+  } catch (error) {
+    throw new Error(`Failed to create script`, { cause: error });
+  }
+  return wrapScript(source, script);
+}
+
+// src/compiler/compile-fast.ts
+var REG_NUMBER_FULL = /^\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+var REG_IDENTIFIER_FAST = /^(?:\$+|@+)[a-zA-Z0-9_]*$/;
+var FAST_SCRIPT_MAX_LEN = 32;
+function compileScriptFast(code, options) {
+  if (code.length > FAST_SCRIPT_MAX_LEN) return void 0;
+  const trimmedCode = code.trim();
+  if (!trimmedCode) {
+    return wrapScript(code, () => null);
+  }
+  switch (trimmedCode) {
+    case "nil":
+      return wrapScript(code, () => null);
+    case "true":
+      return wrapScript(code, () => true);
+    case "false":
+      return wrapScript(code, () => false);
+    case "nan":
+      return wrapScript(code, () => 0 / 0);
+    case "inf":
+    case "+inf":
+      return wrapScript(code, () => 1 / 0);
+    case "-inf":
+      return wrapScript(code, () => -1 / 0);
+  }
+  if (REG_IDENTIFIER_FAST.test(trimmedCode)) {
+    const id = trimmedCode;
+    return wrapScript(code, (global = GlobalFallback()) => global.get(id));
+  }
+  if (REG_NUMBER_FULL.test(trimmedCode)) {
+    const num2 = Number(trimmedCode);
+    if (!isFinite(num2)) return void 0;
+    return wrapScript(code, () => num2);
+  }
+  return void 0;
+}
+var FAST_TEMPLATE_MAX_LEN = 1024;
+function compileTemplateFast(code, options) {
+  if (code.length > FAST_TEMPLATE_MAX_LEN) return void 0;
+  if (!code.includes("$")) {
+    return wrapScript(code, () => code);
+  }
+  return void 0;
+}
+function compileFast(code, options) {
+  if (options.sourceMap) return void 0;
+  return (options.input_mode === "Template" ? compileTemplateFast : compileScriptFast)(code, options);
+}
+
+// src/compiler/worker-manager.ts
+var worker;
+async function getWorker() {
+  if (worker) return worker;
+  worker = new Promise((resolve, reject) => {
+    const w = new Worker(new URL("#compiler/worker", import.meta.url), {
+      type: "module",
+      name: "@mirascript/compiler"
+    });
+    const onError = (e) => {
+      cleanUp();
+      reject(new Error(`Worker failed to start: ${e.message}`));
+    };
+    const onMessage = (e) => {
+      if (e.data === "ready") {
+        cleanUp();
+        resolve(w);
+      } else if (e.data instanceof Error) {
+        cleanUp();
+        reject(e.data);
+      }
+    };
+    w.addEventListener("error", onError);
+    w.addEventListener("message", onMessage);
+    const cleanUp = () => {
+      w.removeEventListener("error", onError);
+      w.removeEventListener("message", onMessage);
+    };
+    setTimeout(() => {
+      onError(new ErrorEvent("error", { message: "Worker did not respond in time" }));
+    }, 3e4);
+  });
+  return worker;
+}
+async function compileWorker(...args) {
+  const worker2 = await getWorker();
+  const seq = Math.random();
+  worker2.postMessage([seq, ...args]);
+  return await new Promise((resolve, reject) => {
+    const callback = (ev) => {
+      const data = ev.data;
+      if (!Array.isArray(data)) return;
+      const [retSeq, ...rest] = data;
+      if (seq !== retSeq) return;
+      worker2.removeEventListener("message", callback);
+      if (rest.length === 2) {
+        resolve(rest);
+      } else {
+        reject(rest[0]);
+      }
+    };
+    worker2.addEventListener("message", callback);
+  });
+}
+
+// src/compiler/index.ts
+await loadModule();
+var WORKER_MIN_LEN = typeof Worker != "function" ? Number.MAX_VALUE : 1024;
+function reportDiagnostic(source, diagnostics, fileName) {
+  const parsed = parseDiagnostics(source, diagnostics);
+  const messages = formatDiagnostics(parsed.errors, source, fileName);
+  throw new Error(`Failed to compile:
+${messages.join("\n")}`);
+}
+function emitScript(source, [code, diagnostics], options) {
+  if (!code) {
+    reportDiagnostic(source, diagnostics, options.fileName);
+  }
+  const sourcemaps = options.sourceMap ? parseDiagnostics(source, diagnostics, (c) => c === DiagnosticCode.SourceMap).sourcemaps : [];
+  const target = emit(source, code, sourcemaps, options);
+  return createScript(source, target);
+}
+async function compile(source, options = {}) {
+  if (options.sourceMap) {
+    options.diagnostic_sourcemap = true;
+    options.diagnostic_position_encoding ??= "Utf16";
+  }
+  if (typeof source == "string") {
+    const result = compileFast(source, options);
+    if (result) return result;
+  }
+  if (source.length < WORKER_MIN_LEN) {
+    const bc = await generateBytecode(source, options);
+    return emitScript(source, bc, options);
+  }
+  const [target, diagnostics] = await compileWorker(source, options);
+  if (target == null) {
+    reportDiagnostic(source, diagnostics, options.fileName);
+  }
+  return createScript(source, target);
+}
+function compileSync(source, options = {}) {
+  if (typeof source == "string") {
+    const result = compileFast(source, options);
+    if (result) return result;
+  }
+  const bc = generateBytecodeSync(source, options);
+  return emitScript(source, bc, options);
+}
+
+// src/vm/types/module.ts
+var VmModule = class extends VmWrapper {
+  constructor(name, value) {
+    super(value);
+    this.name = name;
+  }
+  /** @inheritdoc */
+  has(key) {
+    return hasOwnEnumerable(this.value, key);
+  }
+  /** @inheritdoc */
+  get(key) {
+    if (!this.has(key)) return void 0;
+    return this.value[key] ?? null;
+  }
+  /** @inheritdoc */
+  keys() {
+    return keys(this.value);
+  }
+  /** @inheritdoc */
+  same(other) {
+    return this === other;
+  }
+  /** @inheritdoc */
+  get type() {
+    return "module";
+  }
+  /** @inheritdoc */
+  get describe() {
+    return this.name;
+  }
+};
+Object.defineProperty(VmModule.prototype, kVmModule, { value: true });
 
 // src/vm/lib/global/index.ts
 var global_exports = {};
 __export(global_exports, {
   "@e": () => E,
   "@pi": () => PI,
-  abs: () => abs,
+  abs: () => abs2,
   acos: () => acos,
   acosh: () => acosh,
   all: () => all,
@@ -92,7 +1283,7 @@ __export(global_exports, {
   b_or: () => b_or,
   b_xor: () => b_xor,
   cbrt: () => cbrt,
-  ceil: () => ceil,
+  ceil: () => ceil2,
   chars: () => chars,
   contains: () => contains,
   cos: () => cos,
@@ -112,16 +1303,15 @@ __export(global_exports, {
   from_json: () => from_json,
   hypot: () => hypot,
   join: () => join,
-  keys: () => keys2,
+  keys: () => keys3,
   len: () => len,
   log: () => log,
   log10: () => log10,
   log1p: () => log1p,
   log2: () => log2,
   map: () => map2,
-  matrix: () => matrix,
   max: () => max,
-  min: () => min,
+  min: () => min2,
   panic: () => panic,
   pow: () => pow2,
   product: () => product,
@@ -154,22 +1344,31 @@ __export(global_exports, {
   trim: () => trim,
   trim_end: () => trim_end,
   trim_start: () => trim_start,
-  trunc: () => trunc,
-  values: () => values2,
+  trunc: () => trunc2,
+  values: () => values3,
   with: () => _with,
   zip: () => zip
 });
 
-// src/vm/lib/_helpers.ts
+// src/vm/lib/helpers.ts
 function throwError(message, recovered) {
   const recoveredValue = typeof recovered === "function" && !isVmFunction(recovered) ? recovered() : recovered;
   throw new VmError(message, recoveredValue);
 }
+function describeParam(name) {
+  if (name == null) return "Value";
+  if (typeof name == "string") {
+    if (!name) return "Argument";
+    return `Argument '${name}'`;
+  }
+  const pos = name <= 0 ? "first" : name <= 1 ? "second" : `${name + 1}th`;
+  return `Argument at the ${pos} position`;
+}
 function throwUnexpectedTypeError(name, expected, value, recovered) {
-  const actual = $Type(value);
-  if (typeof name == "string") throwError(`Expected ${expected} for parameter '${name}', got ${actual}`, recovered);
-  const pos = name <= 0 ? "first" : name <= 1 ? "second" : name + 1 + "th";
-  throwError(`Expected ${expected} at the ${pos} position, got ${actual}`, recovered);
+  throwError(`${describeParam(name)} is not ${expected}: ${display(value)}`, recovered);
+}
+function throwUnconvertedTypeError(name, expected, value, recovered) {
+  throwError(`${describeParam(name)} cannot be converted to ${expected}: ${display(value)}`, recovered);
 }
 function rethrowError(prefix, error, recovered) {
   const recoveredValue = typeof recovered === "function" && !isVmFunction(recovered) ? recovered() : recovered;
@@ -177,10 +1376,49 @@ function rethrowError(prefix, error, recovered) {
 }
 function required(name, value, recovered) {
   if (value === void 0) {
-    if (typeof name == "string") throwError(`Missing required parameter '${name}'`, recovered);
-    const pos = name <= 0 ? "first" : name <= 1 ? "second" : name + 1 + "th";
-    throwError(`Missing required parameter at the ${pos} position`, recovered);
+    throwError(`${describeParam(name)} is required`, recovered);
+  }
+}
+function expectNumber(name, value) {
+  required(name, value, Number.NaN);
+  const v = toNumber(value, null);
+  if (v == null) {
+    throwUnconvertedTypeError(name, "number", value, Number.NaN);
   }
+  return v;
+}
+function expectNumberRange(name, value, min3, max2) {
+  const v = expectNumber(name, value);
+  if (!isFinite(v)) {
+    throwError(`${describeParam(name)} is not a finite number: ${display(value)}`, Number.NaN);
+  }
+  if (v < min3) {
+    throwError(`${describeParam(name)} is less than minimum value ${min3}: ${display(value)}`, min3);
+  }
+  if (v > max2) {
+    throwError(`${describeParam(name)} is greater than maximum value ${max2}: ${display(value)}`, max2);
+  }
+  return v;
+}
+function expectInteger(name, value) {
+  required(name, value, 0);
+  const v = toNumber(value, null);
+  if (v == null) {
+    throwUnconvertedTypeError(name, "integer", value, 0);
+  }
+  const i = Math.trunc(v);
+  if (!isSafeInteger(i)) {
+    throwUnconvertedTypeError(name, "integer", value, 0);
+  }
+  return i;
+}
+function expectString(name, value) {
+  required(name, value, "");
+  const v = toString(value, null);
+  if (v == null) {
+    throwUnconvertedTypeError(name, "string", value, "");
+  }
+  return v;
 }
 function expectArray(name, value, recovered) {
   required(name, value, recovered);
@@ -214,18 +1452,25 @@ function expectCallable(name, value, recovered) {
 }
 function getNumbers(args) {
   if (args.length === 0) return [];
-  if (args.length === 1 && isVmArray(args[0])) args = args[0];
+  let useFirst = false;
+  if (args.length === 1 && isVmArray(args[0])) {
+    args = args[0];
+    useFirst = true;
+  }
   const numbers = [];
-  for (const arg of args) {
-    if (arg == null) continue;
-    numbers.push($ToNumber(arg));
+  for (let len2 = args.length, i = 0; i < len2; i++) {
+    numbers.push(expectNumber(useFirst ? null : i, args[i]));
   }
   return numbers;
 }
 function arrayLen(len2) {
-  if (len2 == null || isNaN(len2) || len2 <= 0) return 0;
+  if (len2 == null || isNaN(len2) || len2 <= -1) {
+    throwError("Array length must be a non-negative integer", null);
+  }
   len2 = Math.trunc(len2);
-  if (len2 > VM_ARRAY_MAX_LENGTH) throwError(`Array length exceeds maximum limit of ${VM_ARRAY_MAX_LENGTH}`, null);
+  if (len2 > VM_ARRAY_MAX_LENGTH) {
+    throwError(`Array length exceeds maximum limit of ${VM_ARRAY_MAX_LENGTH}`, null);
+  }
   return len2;
 }
 function map(data, mapper) {
@@ -281,7 +1526,7 @@ var max = VmLib(build(Math.max), {
   returnsType: "number",
   examples: ["max(3, 7, 2) // 7"]
 });
-var min = VmLib(build(Math.min), {
+var min2 = VmLib(build(Math.min), {
   summary: "返回一组数中的最小值",
   params: { "..values": "要比较的数值" },
   paramsType: { "..values": "number[]" },
@@ -328,11 +1573,10 @@ var { PI, E } = Math;
 // src/vm/lib/global/math-unary.ts
 function build2(f) {
   return (x) => {
-    required("x", x, Number.NaN);
-    return f($ToNumber(x));
+    return f(expectNumber("x", x));
   };
 }
-var trunc = VmLib(build2(Math.trunc), {
+var trunc2 = VmLib(build2(Math.trunc), {
   summary: "返回数值的整数部分（去除小数）",
   params: { x: "要取整数部分的数" },
   paramsType: { x: "number" },
@@ -344,7 +1588,7 @@ var floor = VmLib(build2(Math.floor), {
   paramsType: { x: "number" },
   returnsType: "number"
 });
-var ceil = VmLib(build2(Math.ceil), {
+var ceil2 = VmLib(build2(Math.ceil), {
   summary: "返回大于等于给定数的最小整数",
   params: { x: "要向上取整的数" },
   paramsType: { x: "number" },
@@ -373,7 +1617,7 @@ var sign = VmLib(build2(Math.sign), {
   paramsType: { x: "number" },
   returnsType: "number"
 });
-var abs = VmLib(build2(Math.abs), {
+var abs2 = VmLib(build2(Math.abs), {
   summary: "返回数值的绝对值",
   params: { x: "要取绝对值的数" },
   paramsType: { x: "number" },
@@ -523,8 +1767,7 @@ var GAMMA_P = [
 var SQRT_2_PI = sqrt2(2 * Math.PI);
 var factorial = VmLib(
   (x) => {
-    required("x", x, Number.NaN);
-    let n = $ToNumber(x);
+    let n = expectNumber("x", x);
     if (isNaN(n) || n < 0) return Number.NaN;
     if (n >= 171) return Number.POSITIVE_INFINITY;
     if (isInteger(n)) {
@@ -561,13 +1804,13 @@ var factorial = VmLib(
 
 // src/vm/lib/global/math.ts
 var { atan2: _atan2, pow: _pow } = Math;
-var atan2 = VmLib((x, y) => _atan2($ToNumber(x), $ToNumber(y)), {
+var atan2 = VmLib((x, y) => _atan2(expectNumber(0, x), expectNumber(1, y)), {
   summary: "返回从原点到点 (x, y) 的角度（弧度）",
   params: { x: "x 坐标", y: "y 坐标" },
   paramsType: { x: "number", y: "number" },
   returnsType: "number"
 });
-var pow2 = VmLib((x, y) => _pow($ToNumber(x), $ToNumber(y)), {
+var pow2 = VmLib((x, y) => _pow(expectNumber(0, x), expectNumber(1, y)), {
   summary: "返回 x 的 y 次幂",
   params: { x: "底数", y: "指数" },
   paramsType: { x: "number", y: "number" },
@@ -583,7 +1826,7 @@ var random = VmLib(Math.random, {
 // src/vm/lib/global/bit.ts
 var b_and = VmLib(
   (x, y) => {
-    return $ToNumber(x) & $ToNumber(y);
+    return expectNumber(0, x) & expectNumber(1, y);
   },
   {
     summary: "返回两个数的按位与",
@@ -595,7 +1838,7 @@ var b_and = VmLib(
 );
 var b_or = VmLib(
   (x, y) => {
-    return $ToNumber(x) | $ToNumber(y);
+    return expectNumber(0, x) | expectNumber(1, y);
   },
   {
     summary: "返回两个数的按位或",
@@ -607,7 +1850,7 @@ var b_or = VmLib(
 );
 var b_not = VmLib(
   (x) => {
-    return ~$ToNumber(x);
+    return ~expectNumber("x", x);
   },
   {
     summary: "返回一个数的按位取反",
@@ -619,7 +1862,7 @@ var b_not = VmLib(
 );
 var b_xor = VmLib(
   (x, y) => {
-    return $ToNumber(x) ^ $ToNumber(y);
+    return expectNumber(0, x) ^ expectNumber(1, y);
   },
   {
     summary: "返回两个数的按位异或",
@@ -631,7 +1874,7 @@ var b_xor = VmLib(
 );
 var shl = VmLib(
   (x, y) => {
-    return $ToNumber(x) << $ToNumber(y);
+    return expectNumber(0, x) << expectNumber(1, y);
   },
   {
     summary: "返回第一个操作数左移指定的位数",
@@ -643,7 +1886,7 @@ var shl = VmLib(
 );
 var sar = VmLib(
   (x, y) => {
-    return $ToNumber(x) >> $ToNumber(y);
+    return expectNumber(0, x) >> expectNumber(1, y);
   },
   {
     summary: "返回第一个操作数右移指定的位数",
@@ -655,7 +1898,7 @@ var sar = VmLib(
 );
 var shr = VmLib(
   (x, y) => {
-    return $ToNumber(x) >>> $ToNumber(y);
+    return expectNumber(0, x) >>> expectNumber(1, y);
   },
   {
     summary: "返回第一个操作数无符号右移指定的位数",
@@ -668,12 +1911,19 @@ var shr = VmLib(
 
 // src/vm/lib/global/sequence/with.ts
 var arrIndex = (index) => {
-  const idx = Math.trunc($ToNumber(index));
-  if (!isSafeInteger(idx) || idx < 0 || idx >= VM_ARRAY_MAX_LENGTH) {
-    return -1;
+  const idx = Math.trunc(toNumber(index, Number.NaN));
+  if (isNaN(idx) || idx < 0) {
+    throwError("Array index must be a non-negative integer", index);
+  }
+  if (idx >= VM_ARRAY_MAX_LENGTH) {
+    throwError(`Array index exceeds maximum limit of ${VM_ARRAY_MAX_LENGTH}`, index);
   }
   return idx;
 };
+var isArrIndex = (key) => {
+  if (typeof key != "number") return false;
+  return isInteger(key) && key >= 0 && key < VM_ARRAY_MAX_LENGTH;
+};
 var withInner = (obj, key, keyIndex, value) => {
   if (keyIndex >= key.length) {
     return value;
@@ -684,7 +1934,7 @@ var withInner = (obj, key, keyIndex, value) => {
     result = [...obj];
   } else if (isVmRecord(obj)) {
     result = { ...obj };
-  } else if (arrIndex(k) === k) {
+  } else if (isArrIndex(k)) {
     result = [];
   } else {
     result = {};
@@ -696,7 +1946,7 @@ var withInner = (obj, key, keyIndex, value) => {
     }
     result[index] = withInner(result[index], key, keyIndex + 1, value);
   } else {
-    const prop = $ToString(k);
+    const prop = toString(k, void 0);
     result[prop] = withInner(result[prop], key, keyIndex + 1, value);
   }
   return result;
@@ -738,11 +1988,9 @@ var _with = VmLib(
         let val;
         if (isVmArray(key)) {
           index = arrIndex(key[0]);
-          if (index < 0) continue;
           val = withInner(result[index], key, 1, value);
         } else {
           index = arrIndex(key);
-          if (index < 0) continue;
           val = value;
         }
         while (index > result.length) {
@@ -758,10 +2006,10 @@ var _with = VmLib(
         let val;
         if (isVmArray(key)) {
           const firstKey = key[0];
-          prop = $ToString(firstKey);
+          prop = toString(firstKey, void 0);
           val = withInner(result[prop], key, 1, value);
         } else {
-          prop = $ToString(key);
+          prop = toString(key, void 0);
           val = value;
         }
         result[prop] = val;
@@ -788,7 +2036,7 @@ var _with = VmLib(
 );
 
 // src/vm/lib/global/sequence/entries.ts
-var keys2 = VmLib(
+var keys3 = VmLib(
   (data) => {
     expectCompound("data", data, []);
     if (isVmArray(data)) {
@@ -812,7 +2060,7 @@ var keys2 = VmLib(
     examples: ["keys([10, 20]) // [0, 1]", 'keys((10, 20)) // ["0", "1"]']
   }
 );
-var values2 = VmLib(
+var values3 = VmLib(
   (data) => {
     expectArrayOrRecord("data", data, []);
     if (isVmArray(data)) {
@@ -894,7 +2142,7 @@ var map2 = VmLib(
 var filter = VmLib(
   (data, predicate) => mapImplWrapped(data, "predicate", predicate, (fn, value, key, data2) => {
     const ret = $Call(fn, [value, key, data2]);
-    return $ToBoolean(ret) ? value : void 0;
+    return toBoolean(ret, void 0) ? value : void 0;
   }),
   {
     summary: "过滤数组或记录中的元素，返回满足条件的元素",
@@ -937,7 +2185,7 @@ var find = VmLib(
     required("predicate", predicate, null);
     const p = isVmCallable(predicate) ? (value, key, data2) => {
       const ret = $Call(predicate, [value, key, data2]);
-      return $ToBoolean(ret);
+      return toBoolean(ret, void 0);
     } : (value) => $Same(predicate, value);
     if (isVmArray(data)) {
       const { length } = data;
@@ -979,7 +2227,7 @@ var find = VmLib(
 var flatten = VmLib(
   (data, depth = 1) => {
     expectArray("data", data, data);
-    return data.flat($ToNumber(depth));
+    return data.flat(expectNumber("depth", depth));
   },
   {
     summary: "将数组扁平化",
@@ -1014,7 +2262,7 @@ var zip = VmLib(
     let len2 = 0;
     for (const { 0: key, 1: arr } of ets) {
       if (!isVmArray(arr)) {
-        throwError(`data[${serialize(key)}] is not an array`, null);
+        throwError(`data[${display(key)}] is not an array: ${display(arr)}`, null);
       }
       len2 = Math.max(len2, arr.length);
     }
@@ -1053,7 +2301,7 @@ var all = VmLib(
         Cp();
         const value = data[i] ?? null;
         const ret = $Call(predicate, [value, i, data]);
-        if (!$ToBoolean(ret)) return false;
+        if (!toBoolean(ret, void 0)) return false;
       }
       return true;
     } else {
@@ -1061,7 +2309,7 @@ var all = VmLib(
         Cp();
         const value = v ?? null;
         const ret = $Call(predicate, [value, key, data]);
-        if (!$ToBoolean(ret)) return false;
+        if (!toBoolean(ret, void 0)) return false;
       }
       return true;
     }
@@ -1086,7 +2334,7 @@ var any = VmLib(
         Cp();
         const value = data[i] ?? null;
         const ret = $Call(predicate, [value, i, data]);
-        if ($ToBoolean(ret)) return true;
+        if (toBoolean(ret, void 0)) return true;
       }
       return false;
     } else {
@@ -1094,7 +2342,7 @@ var any = VmLib(
         Cp();
         const value = v ?? null;
         const ret = $Call(predicate, [value, key, data]);
-        if ($ToBoolean(ret)) return true;
+        if (toBoolean(ret, void 0)) return true;
       }
       return false;
     }
@@ -1121,8 +2369,8 @@ function defaultCompare(a = null, b = null) {
     if (a > b) return 1;
     return 0;
   }
-  const an = $ToNumber(a) || 0;
-  const bn = $ToNumber(b) || 0;
+  const an = toNumber(a, 0) || 0;
+  const bn = toNumber(b, 0) || 0;
   if (an < bn) return -1;
   if (an > bn) return 1;
   return 0;
@@ -1132,7 +2380,7 @@ function cmp(comparator, recovered) {
   expectCallable("comparator", comparator, recovered);
   return (a = null, b = null) => {
     const ret = $Call(comparator, [a, b]);
-    return $ToNumber(ret);
+    return toNumber(ret, 0);
   };
 }
 var sort = VmLib(
@@ -1198,8 +2446,7 @@ var sort_by = VmLib(
 var repeat = VmLib(
   (data, times) => {
     expectConst("data", data, []);
-    required("times", times, []);
-    const n = arrayLen($ToNumber(times));
+    const n = arrayLen(expectNumber("times", times));
     const result = [];
     result.length = n;
     result.fill(data);
@@ -1241,7 +2488,8 @@ var panic = VmLib(
   (message) => {
     if (message === void 0) console.error(...panic.prefix);
     else console.error(...panic.prefix, message);
-    const error = message == null ? "panic" : "panic: " + $ToString(message);
+    const mgsStr = toString(message, null);
+    const error = !mgsStr ? "panic" : "panic: " + mgsStr;
     throw new VmError(error, void 0);
   },
   {
@@ -1299,7 +2547,7 @@ var from_json = VmLib(
     try {
       return parse(json);
     } catch (ex) {
-      if (fallback != null) return fallback;
+      if (fallback !== void 0) return fallback;
       rethrowError("Invalid JSON", ex, null);
     }
   },
@@ -1314,48 +2562,57 @@ var from_json = VmLib(
 
 // src/vm/lib/global/to-primitive.ts
 var to_string = VmLib(
-  (data) => {
+  (data, fallback) => {
     required("data", data, "");
-    return $ToString(data);
+    return toString(data, fallback);
   },
   {
     summary: "将数据转换为字符串",
-    params: { data: "要转换的数据" },
-    paramsType: { data: "any" },
-    returnsType: "string",
+    params: {
+      data: "要转换的数据",
+      fallback: "转换失败时的返回值"
+    },
+    paramsType: { data: "any", fallback: "any" },
+    returnsType: "string | type(fallback)",
     examples: ['to_string([1, 2]) // "1, 2"']
   }
 );
 var to_number = VmLib(
-  (data) => {
+  (data, fallback) => {
     required("data", data, Number.NaN);
-    return $ToNumber(data);
+    return toNumber(data, fallback);
   },
   {
     summary: "将数据转换为数字",
-    params: { data: "要转换的数据" },
-    paramsType: { data: "any" },
-    returnsType: "number",
+    params: {
+      data: "要转换的数据",
+      fallback: "转换失败时的返回值"
+    },
+    paramsType: { data: "any", fallback: "any" },
+    returnsType: "number | type(fallback)",
     examples: ['to_number("1.5") // 1.5']
   }
 );
 var to_boolean = VmLib(
-  (data) => {
+  (data, fallback) => {
     required("data", data, false);
-    return $ToBoolean(data);
+    return toBoolean(data, fallback);
   },
   {
     summary: "将数据转换为布尔值",
-    params: { data: "要转换的数据" },
-    paramsType: { data: "any" },
-    returnsType: "boolean",
+    params: {
+      data: "要转换的数据",
+      fallback: "转换失败时的返回值"
+    },
+    paramsType: { data: "any", fallback: "any" },
+    returnsType: "boolean | type(fallback)",
     examples: ["to_boolean(nil) // false"]
   }
 );
 var format = VmLib(
   (data, format2) => {
     required("data", data, "");
-    return $Format(data, format2);
+    return toFormat(data, expectString("format", format2));
   },
   {
     summary: "将数据格式化为指定格式的字符串",
@@ -1369,8 +2626,7 @@ var format = VmLib(
 // src/vm/lib/global/string.ts
 var chars = VmLib(
   (str) => {
-    required("str", str, null);
-    return [...$ToString(str)];
+    return [...expectString("str", str)];
   },
   {
     summary: "将字符串转换为字符数组",
@@ -1382,9 +2638,7 @@ var chars = VmLib(
 );
 var starts_with = VmLib(
   (str, search) => {
-    required("str", str, null);
-    required("search", search, null);
-    return $ToString(str).startsWith($ToString(search));
+    return expectString("str", str).startsWith(expectString("search", search));
   },
   {
     summary: "检查字符串是否以指定子串开头",
@@ -1396,9 +2650,7 @@ var starts_with = VmLib(
 );
 var ends_with = VmLib(
   (str, search) => {
-    required("str", str, null);
-    required("search", search, null);
-    return $ToString(str).endsWith($ToString(search));
+    return expectString("str", str).endsWith(expectString("search", search));
   },
   {
     summary: "检查字符串是否以指定子串结尾",
@@ -1410,9 +2662,7 @@ var ends_with = VmLib(
 );
 var contains = VmLib(
   (str, search) => {
-    required("str", str, null);
-    required("search", search, null);
-    return $ToString(str).includes($ToString(search));
+    return expectString("str", str).includes(expectString("search", search));
   },
   {
     summary: "检查字符串是否包含指定子串",
@@ -1424,8 +2674,7 @@ var contains = VmLib(
 );
 var trim_start = VmLib(
   (str) => {
-    required("str", str, null);
-    return $ToString(str).trimStart();
+    return expectString("str", str).trimStart();
   },
   {
     summary: "去除字符串开头的空白字符",
@@ -1437,8 +2686,7 @@ var trim_start = VmLib(
 );
 var trim_end = VmLib(
   (str) => {
-    required("str", str, null);
-    return $ToString(str).trimEnd();
+    return expectString("str", str).trimEnd();
   },
   {
     summary: "去除字符串结尾的空白字符",
@@ -1450,8 +2698,7 @@ var trim_end = VmLib(
 );
 var trim = VmLib(
   (str) => {
-    required("str", str, null);
-    return $ToString(str).trim();
+    return expectString("str", str).trim();
   },
   {
     summary: "去除字符串两端的空白字符",
@@ -1463,9 +2710,10 @@ var trim = VmLib(
 );
 var replace = VmLib(
   (str, search, replacement = "") => {
-    required("str", str, null);
-    required("search", search, str);
-    return $ToString(str).replaceAll($ToString(search), $ToString(replacement));
+    return expectString("str", str).replaceAll(
+      expectString("search", search),
+      expectString("replacement", replacement)
+    );
   },
   {
     summary: "替换字符串中的指定子串",
@@ -1477,9 +2725,8 @@ var replace = VmLib(
 );
 var split = VmLib(
   (str, separator = "") => {
-    required("str", str, null);
-    const s = $ToString(str);
-    const p = $ToString(separator);
+    const s = expectString("str", str);
+    const p = expectString("separator", separator);
     if (!p) return [...s];
     return s.split(p);
   },
@@ -1494,8 +2741,8 @@ var split = VmLib(
 var join = VmLib(
   (arr, separator = "") => {
     expectArray("arr", arr, null);
-    const s = $ToString(separator);
-    return arr.map((v) => $ToString(v)).join(s);
+    const s = expectString("separator", separator);
+    return arr.map((v) => expectString(null, v)).join(s);
   },
   {
     summary: "将字符串数组连接为单个字符串",
@@ -1507,33 +2754,54 @@ var join = VmLib(
 );
 
 // src/vm/lib/global/time.ts
+var fromNumber = (datetime, fallback) => {
+  const n = new Date(datetime).getTime();
+  if (isFinite(n)) return n;
+  if (fallback) return null;
+  throwError(`${describeParam("datetime")} is an invalid timestamp: ${display(datetime)}`, Number.NaN);
+};
+var getTimestamp = (datetime, fallback) => {
+  if (datetime == null) {
+    return Date.now();
+  }
+  if (typeof datetime == "number") {
+    return fromNumber(datetime, fallback);
+  }
+  if (typeof datetime != "string") {
+    if (fallback) return null;
+    throwUnexpectedTypeError("datetime", "number | string", datetime, Number.NaN);
+  }
+  const num2 = toNumber(datetime, Number.NaN);
+  if (!isNaN(num2)) {
+    return fromNumber(num2, fallback);
+  }
+  const parsed = Date.parse(datetime);
+  if (isFinite(parsed)) return parsed;
+  if (fallback) return null;
+  throwError(`${describeParam("datetime")} cannot be parsed as datetime: ${display(datetime)}`, Number.NaN);
+};
 var to_timestamp = VmLib(
-  (datetime) => {
-    if (datetime == null) {
-      return Date.now();
-    }
-    if (typeof datetime == "number") {
-      return new Date(datetime).getTime();
-    }
-    const str = $ToString(datetime);
-    if (!str) return Number.NaN;
-    const num2 = $ToNumber(str);
-    if (isFinite(num2)) return num2;
-    return Date.parse(str);
+  (datetime, fallback) => {
+    const timestamp = getTimestamp(datetime, fallback !== void 0);
+    if (timestamp == null) return fallback;
+    return timestamp;
   },
   {
     summary: "将数据转换为 Unix 毫秒时间戳",
-    params: { datetime: "要转换的数据，默认为当前时间" },
-    paramsType: { datetime: "number | string" },
-    returnsType: "number",
+    params: {
+      datetime: "要转换的数据，默认为当前时间",
+      fallback: "转换失败时的返回值"
+    },
+    paramsType: { datetime: "number | string", fallback: "any" },
+    returnsType: "number | type(fallback)",
     examples: ['to_timestamp("1970-01-01T00:00:00Z") // 0']
   }
 );
 var to_datetime = VmLib(
-  (datetime, offset) => {
-    const timestamp = to_timestamp(datetime);
-    if (!isFinite(timestamp)) return null;
-    const o = $ToNumber(offset ?? 0) || 0;
+  (datetime, offset, fallback) => {
+    const timestamp = getTimestamp(datetime, fallback !== void 0);
+    if (timestamp == null) return fallback;
+    const o = expectNumberRange("offset", offset ?? 0, -24, 24);
     const dateOffset = new Date(timestamp + o * 1e3 * 60 * 60);
     return {
       year: dateOffset.getUTCFullYear(),
@@ -1551,10 +2819,11 @@ var to_datetime = VmLib(
     summary: "将数据转换为 Date 记录",
     params: {
       datetime: "要转换的数据，默认为当前时间",
-      offset: "时区偏移量（单位：小时），默认为 0"
+      offset: "时区偏移量（单位：小时），默认为 0",
+      fallback: "转换失败时的返回值"
     },
-    paramsType: { datetime: "number | string", offset: "number" },
-    returnsType: "Date",
+    paramsType: { datetime: "number | string", offset: "number", fallback: "any" },
+    returnsType: "Date | type(fallback)",
     examples: [
       `
 to_datetime(0)
@@ -1568,21 +2837,30 @@ to_datetime(0)
   }
 );
 var to_iso8601 = VmLib(
-  (datetime) => {
-    const timestamp = to_timestamp(datetime);
-    if (!isFinite(timestamp)) return null;
+  (datetime, fallback) => {
+    const timestamp = getTimestamp(datetime, fallback !== void 0);
+    if (timestamp == null) return fallback;
     return new Date(timestamp).toISOString();
   },
   {
     summary: "将数据转换为 ISO 8601 格式的字符串",
-    params: { datetime: "要转换的数据，默认为当前时间" },
-    paramsType: { datetime: "number | string" },
-    returnsType: "string",
+    params: {
+      datetime: "要转换的数据，默认为当前时间",
+      fallback: "转换失败时的返回值"
+    },
+    paramsType: { datetime: "number | string", fallback: "any" },
+    returnsType: "string | type(fallback)",
     examples: ['to_iso8601(0) // "1970-01-01T00:00:00.000Z"']
   }
 );
 
-// src/vm/lib/global/mod/matrix.ts
+// src/vm/lib/mod/index.ts
+var mod_exports = {};
+__export(mod_exports, {
+  matrix: () => matrix_exports
+});
+
+// src/vm/lib/mod/matrix.ts
 var matrix_exports = {};
 __export(matrix_exports, {
   add: () => add,
@@ -1599,12 +2877,12 @@ __export(matrix_exports, {
   transpose: () => transpose,
   zeros: () => zeros
 });
-function sizeImpl(matrix2) {
-  if (!isVmArray(matrix2)) return [];
-  if (matrix2.length === 0) return [0];
-  const numRows = matrix2.length;
+function sizeImpl(matrix) {
+  if (!isVmArray(matrix)) return [];
+  if (matrix.length === 0) return [0];
+  const numRows = matrix.length;
   let numCols = 0;
-  for (const row of matrix2) {
+  for (const row of matrix) {
     if (isVmArray(row)) {
       numCols = Math.max(numCols, row.length);
     } else {
@@ -1614,12 +2892,12 @@ function sizeImpl(matrix2) {
   return [numRows, numCols];
 }
 function num(v) {
-  return $ToNumber(v ?? null);
+  return toNumber(v, void 0);
 }
 var size = VmLib(
-  (matrix2) => {
-    required("matrix", matrix2, []);
-    return sizeImpl(matrix2);
+  (matrix) => {
+    required("matrix", matrix, []);
+    return sizeImpl(matrix);
   },
   {
     summary: "获取矩阵尺寸",
@@ -1630,16 +2908,16 @@ var size = VmLib(
   }
 );
 var transpose = VmLib(
-  (matrix2) => {
-    required("matrix", matrix2, []);
-    const [numRows, numCols] = sizeImpl(matrix2);
-    if (numRows == null || numCols == null) return matrix2;
+  (matrix) => {
+    required("matrix", matrix, []);
+    const [numRows, numCols] = sizeImpl(matrix);
+    if (numRows == null || numCols == null) return matrix;
     const transposed = [];
     for (let j = 0; j < numCols; j++) {
       Cp();
       const tj = [];
       for (let i = 0; i < numRows; i++) {
-        const row = matrix2[i] ?? null;
+        const row = matrix[i] ?? null;
         const item = row?.[j] ?? null;
         tj[i] = item;
       }
@@ -2039,7 +3317,7 @@ var identity = VmLib(
 var diagonal = VmLib(
   (x, k = 0) => {
     expectArray("x", x, []);
-    const fk = Math.round($ToNumber(k) || 0);
+    const fk = expectInteger("k", k);
     if (x.every((e) => isArray(e))) {
       const diag = [];
       for (let i = 0; i < x.length; i++) {
@@ -2080,13 +3358,7 @@ var diagonal = VmLib(
   }
 );
 
-// src/vm/lib/global/mod/index.ts
-var matrix = createModule("matrix", matrix_exports);
-
-// src/vm/lib/_loader.ts
-for (const [name, value] of entries(global_exports)) {
-  VmSharedContext[name] = wrapEntry(name, value, "global");
-}
+// src/vm/lib/loader.ts
 function wrapEntry(name, value, module) {
   if (typeof value == "function") {
     if (value.name !== name) {
@@ -2112,423 +3384,33 @@ function createModule(name, lib2) {
   }
   return new VmModule(name, mod);
 }
-var lib = global_exports;
-
-// src/helpers/serialize.ts
-var REG_IDENTIFIER_FULL = new RegExp(`^${REG_IDENTIFIER.source}$`, REG_IDENTIFIER.flags);
-var REG_ORDINAL_FULL = new RegExp(`^${REG_ORDINAL.source}$`, REG_ORDINAL.flags);
-var DEFAULT_OPTIONS = Object.freeze({
-  maxDepth: 128,
-  serializeNil,
-  serializeBoolean,
-  serializeNumber,
-  serializeString: serializeStringImpl,
-  serializeStringQuote: (value) => value,
-  serializeStringEscape: (value) => value,
-  serializeStringContent: (value) => value,
-  serializeArray,
-  serializeRecord,
-  serializePropName: String,
-  serializeFunction: serializeNil,
-  serializeModule: serializeNil,
-  serializeExtern: serializeNil
-});
-function isDefaultOptions(options) {
-  return options == null || options === DEFAULT_OPTIONS;
-}
-function getSerializeOptions(options) {
-  if (isDefaultOptions(options)) return DEFAULT_OPTIONS;
-  let opt = null;
-  for (const key in options) {
-    if (!hasOwn(options, key) || !hasOwn(DEFAULT_OPTIONS, key)) continue;
-    const el = options[key];
-    if (el == null) continue;
-    opt ??= { ...DEFAULT_OPTIONS };
-    opt[key] = el;
-  }
-  return opt ? Object.freeze(opt) : DEFAULT_OPTIONS;
-}
-function serializeStringImpl(value, options) {
-  if (!/[\p{C}'"`$\\]/u.test(value)) {
-    const oq = options.serializeStringQuote(`'`, true, options);
-    const cq = options.serializeStringQuote(`'`, false, options);
-    const c = options.serializeStringContent(value, options);
-    return oq + c + cq;
-  }
-  let ret = options.serializeStringQuote(`'`, true, options);
-  for (const char of value) {
-    if (char === "'") {
-      ret += options.serializeStringEscape(String.raw`\'`, options);
-    } else if (char === "\0") {
-      ret += options.serializeStringEscape(String.raw`\0`, options);
-    } else if (char === "\n") {
-      ret += options.serializeStringEscape(String.raw`\n`, options);
-    } else if (char === "\r") {
-      ret += options.serializeStringEscape(String.raw`\r`, options);
-    } else if (char === "	") {
-      ret += options.serializeStringEscape(String.raw`\t`, options);
-    } else if (char === "\b") {
-      ret += options.serializeStringEscape(String.raw`\b`, options);
-    } else if (char === "\f") {
-      ret += options.serializeStringEscape(String.raw`\f`, options);
-    } else if (char === "\v") {
-      ret += options.serializeStringEscape(String.raw`\v`, options);
-    } else if (char === "\\") {
-      ret += options.serializeStringEscape(String.raw`\\`, options);
-    } else if (char === "$") {
-      ret += options.serializeStringEscape(String.raw`\$`, options);
-    } else if (/\p{C}/u.test(char)) {
-      const code = char.codePointAt(0);
-      if (code <= 127) {
-        ret += options.serializeStringEscape(String.raw`\x${code.toString(16).padStart(2, "0")}`, options);
-      } else if (code >= 55296 && code <= 57343) {
-        ret += options.serializeStringContent("�", options);
-      } else {
-        ret += options.serializeStringEscape(String.raw`\u{${code.toString(16)}}`, options);
-      }
-    } else {
-      ret += options.serializeStringContent(char, options);
-    }
-  }
-  ret += options.serializeStringQuote(`'`, false, options);
-  return ret;
-}
-function serializeString(value, options) {
-  return serializeStringImpl(value, getSerializeOptions(options));
-}
-function serializeRecordKeyDefault(key) {
-  if (REG_ORDINAL_FULL.test(key) || REG_IDENTIFIER_FULL.test(key)) {
-    return key;
-  }
-  return serializeStringImpl(key, DEFAULT_OPTIONS);
-}
-function serializeRecordKeyOpt(value, options) {
-  if (isDefaultOptions(options)) {
-    return serializeRecordKeyDefault(value);
-  }
-  if (REG_ORDINAL_FULL.test(value)) {
-    return options.serializePropName(Number(value), options);
-  }
-  if (REG_IDENTIFIER_FULL.test(value)) {
-    return options.serializePropName(value, options);
-  }
-  return options.serializeString(value, options);
-}
-function serializeRecordKey(key, options) {
-  if (isDefaultOptions(options)) {
-    return serializeRecordKeyDefault(key);
-  }
-  return serializeRecordKeyOpt(key, getSerializeOptions(options));
-}
-function serializeNil() {
-  return "nil";
-}
-function serializeBoolean(value) {
-  return value ? "true" : "false";
-}
-function serializeNumber(value) {
-  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);
-}
-function serializeArray(value, depth, options) {
-  if (depth > options.maxDepth) return `[]`;
-  if (value.length === 0) return "[]";
-  let str = "[";
-  for (let i = 0; i < value.length; i++) {
-    if (i > 0) str += ", ";
-    str += serializeImpl(value[i], depth, options);
-  }
-  str += "]";
-  return str;
-}
-var { valueOf } = Object.prototype;
-function customValueOf(value) {
-  const thisValueOf = value.valueOf;
-  if (typeof thisValueOf != "function" || thisValueOf === valueOf) {
-    return void 0;
-  }
-  const customValue = thisValueOf.call(value);
-  if (customValue === value) return void 0;
-  return customValue;
-}
-function serializeRecord(value, depth, options) {
-  const customValue = customValueOf(value);
-  if (customValue !== void 0) {
-    return serializeImpl(customValue, depth - 1, options);
-  }
-  if (depth > options.maxDepth) return `()`;
-  const e = entries(value);
-  if (e.length === 0) return "()";
-  if (e.length === 1) {
-    const [k, v] = e[0];
-    if (k === "0") {
-      return `(${serializeImpl(v, depth, options)},)`;
-    }
-    return `(${serializeRecordKeyOpt(k, options)}: ${serializeImpl(v, depth, options)})`;
-  }
-  const omitKey = isVmArrayLikeRecordByEntires(e);
-  let str = "(";
-  for (const [key, val] of e) {
-    if (str.length > 1) str += ", ";
-    if (omitKey) {
-      str += serializeImpl(val, depth, options);
-    } else {
-      str += `${serializeRecordKeyOpt(key, options)}: ${serializeImpl(val, depth, options)}`;
-    }
-  }
-  str += ")";
-  return str;
-}
-function serializeImpl(value, depth, options) {
-  if (value == null) {
-    return options.serializeNil(options);
-  }
-  if (typeof value == "boolean") {
-    return options.serializeBoolean(value, options);
-  }
-  if (typeof value == "number") {
-    return options.serializeNumber(value, options);
-  }
-  if (typeof value == "string") {
-    return options.serializeString(value, options);
-  }
-  if (isVmFunction(value)) {
-    return options.serializeFunction(value, options);
-  }
-  if (isVmModule(value)) {
-    return options.serializeModule(value, depth + 1, options);
-  }
-  if (isVmExtern(value)) {
-    return options.serializeExtern(value, depth + 1, options);
-  }
-  if (isVmArray(value)) {
-    return options.serializeArray(value, depth + 1, options);
-  }
-  if (isVmRecord(value)) {
-    return options.serializeRecord(value, depth + 1, options);
-  }
-  value;
-  return options.serializeNil(options);
-}
-function serialize(value, options) {
-  return serializeImpl(value, 0, getSerializeOptions(options));
-}
-
-// src/compiler/index.ts
-import { loadModule } from "@mirascript/bindings";
-
-// src/vm/env.ts
-var keys3 = [];
-var values3 = [];
-for (const [key, value] of entries(operations_exports)) {
-  keys3.push(key);
-  values3.push(value);
-}
-for (const [key, value] of entries(helpers_exports)) {
-  keys3.push(key);
-  values3.push(value);
-}
-
-// src/compiler/create-script.ts
-var kVmScript = Symbol.for("mirascript.vm.script");
-function wrapScript(source, script) {
-  if (kVmScript in script) {
-    return script;
-  }
-  defineProperty(script, kVmScript, { value: true });
-  if (typeof source === "string") {
-    defineProperty(script, "source", { value: source, configurable: true });
-  } else if (source instanceof Uint8Array) {
-    defineProperty(script, "source", { value: "<buffer>", configurable: true });
-  }
-  return script;
-}
-function createScript(source, code) {
-  let script;
-  try {
-    script = new Function(...keys3, code)(...values3);
-  } catch (error) {
-    throw new Error(`Failed to create script`, { cause: error });
-  }
-  return wrapScript(source, script);
-}
-
-// src/compiler/compile-fast.ts
-var REG_NUMBER_FULL = /^\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
-var REG_IDENTIFIER_FAST = /^(?:\$+|@+)[a-zA-Z0-9_]*$/;
-var FAST_SCRIPT_MAX_LEN = 32;
-function compileScriptFast(code, options) {
-  if (code.length > FAST_SCRIPT_MAX_LEN) return void 0;
-  const trimmedCode = code.trim();
-  if (!trimmedCode) {
-    return wrapScript(code, () => null);
-  }
-  switch (trimmedCode) {
-    case "nil":
-      return wrapScript(code, () => null);
-    case "true":
-      return wrapScript(code, () => true);
-    case "false":
-      return wrapScript(code, () => false);
-    case "nan":
-      return wrapScript(code, () => 0 / 0);
-    case "inf":
-    case "+inf":
-      return wrapScript(code, () => 1 / 0);
-    case "-inf":
-      return wrapScript(code, () => -1 / 0);
-  }
-  if (REG_IDENTIFIER_FAST.test(trimmedCode)) {
-    const id = trimmedCode;
-    return wrapScript(code, (global = GlobalFallback()) => global.get(id));
-  }
-  if (REG_NUMBER_FULL.test(trimmedCode)) {
-    const num2 = Number(trimmedCode);
-    if (!isFinite(num2)) return void 0;
-    return wrapScript(code, () => num2);
-  }
-  return void 0;
-}
-var FAST_TEMPLATE_MAX_LEN = 1024;
-function compileTemplateFast(code, options) {
-  if (code.length > FAST_TEMPLATE_MAX_LEN) return void 0;
-  if (!code.includes("$")) {
-    return wrapScript(code, () => code);
-  }
-  return void 0;
-}
-function compileFast(code, options) {
-  if (options.sourceMap) return void 0;
-  return (options.input_mode === "Template" ? compileTemplateFast : compileScriptFast)(code, options);
-}
-
-// src/compiler/worker-manager.ts
-var worker;
-async function getWorker() {
-  if (worker) return worker;
-  worker = new Promise((resolve, reject) => {
-    const w = new Worker(new URL("#compiler/worker", import.meta.url), {
-      type: "module",
-      name: "@mirascript/compiler"
-    });
-    const onError = (e) => {
-      cleanUp();
-      reject(new Error(`Worker failed to start: ${e.message}`));
-    };
-    const onMessage = (e) => {
-      if (e.data === "ready") {
-        cleanUp();
-        resolve(w);
-      } else if (e.data instanceof Error) {
-        cleanUp();
-        reject(e.data);
-      }
-    };
-    w.addEventListener("error", onError);
-    w.addEventListener("message", onMessage);
-    const cleanUp = () => {
-      w.removeEventListener("error", onError);
-      w.removeEventListener("message", onMessage);
-    };
-    setTimeout(() => {
-      onError(new ErrorEvent("error", { message: "Worker did not respond in time" }));
-    }, 3e4);
-  });
-  return worker;
-}
-async function compileWorker(...args) {
-  const worker2 = await getWorker();
-  const seq = Math.random();
-  worker2.postMessage([seq, ...args]);
-  return await new Promise((resolve, reject) => {
-    const callback = (ev) => {
-      const data = ev.data;
-      if (!Array.isArray(data)) return;
-      const [retSeq, ...rest] = data;
-      if (seq !== retSeq) return;
-      worker2.removeEventListener("message", callback);
-      if (rest.length === 2) {
-        resolve(rest);
-      } else {
-        reject(rest[0]);
-      }
-    };
-    worker2.addEventListener("message", callback);
-  });
-}
 
-// src/compiler/index.ts
-await loadModule();
-var WORKER_MIN_LEN = typeof Worker != "function" ? Number.MAX_VALUE : 1024;
-function reportDiagnostic(source, diagnostics) {
-  const parsed = parseDiagnostics(source, diagnostics);
-  const messages = parsed.errors.map(formatDiagnostic);
-  throw new Error(`Failed to compile:
-${messages.join("\n")}`);
-}
-function emitScript(source, [code, diagnostics], options) {
-  if (!code) {
-    reportDiagnostic(source, diagnostics);
-  }
-  const sourcemaps = options.sourceMap ? parseDiagnostics(source, diagnostics, (c) => c === DiagnosticCode.SourceMap).sourcemaps : [];
-  const target = emit(source, code, sourcemaps, options);
-  return createScript(source, target);
-}
-async function compile(source, options = {}) {
-  if (options.sourceMap) {
-    options.diagnostic_sourcemap = true;
-    options.diagnostic_position_encoding ??= "Utf16";
-  }
-  if (typeof source == "string") {
-    const result = compileFast(source, options);
-    if (result) return result;
-  }
-  if (source.length < WORKER_MIN_LEN) {
-    const bc = await generateBytecode(source, options);
-    return emitScript(source, bc, options);
-  }
-  const [target, diagnostics] = await compileWorker(source, options);
-  if (target == null) {
-    reportDiagnostic(source, diagnostics);
-  }
-  return createScript(source, target);
+// src/vm/lib/index.ts
+for (const [name, value] of entries(global_exports)) {
+  VM_SHARED_CONTEXT[name] = wrapEntry(name, value, "global");
 }
-function compileSync(source, options = {}) {
-  if (typeof source == "string") {
-    const result = compileFast(source, options);
-    if (result) return result;
-  }
-  const bc = generateBytecodeSync(source, options);
-  return emitScript(source, bc, options);
+for (const [name, value] of entries(mod_exports)) {
+  const mod = createModule(name, value);
+  VM_SHARED_CONTEXT[name] = wrapEntry(name, mod, "global");
 }
-
-// src/subtle.ts
-var keywords = () => {
-  const kw = Object.freeze(getModule().keywords());
-  keywords = () => kw;
-  return kw;
-};
+var lib = Object.freeze(Object.assign(create(null), global_exports, mod_exports));
 
 export {
-  constants_exports,
+  convert_exports,
+  operations_exports,
+  VmExtern,
+  wrapToVmValue,
+  unwrapFromVmValue,
+  configCheckpoint,
+  VmFunction,
+  defineVmContextValue,
+  DefaultVmContext,
+  createVmContext,
   emitScript,
   compile,
   compileSync,
-  keywords,
+  VmModule,
   debug_print,
-  lib,
-  serializeString,
-  serializeRecordKey,
-  serializeNil,
-  serializeBoolean,
-  serializeNumber,
-  serializeArray,
-  serializeRecord,
-  serialize
-};
-//# sourceMappingURL=chunk-NT235HY3.js.map
+  lib
+};
+//# sourceMappingURL=chunk-W2I5XPIE.js.map