@mirascript/mirascript 0.1.0

package/dist/chunk-DCXIWIW5.js

@@ -0,0 +1,3419 @@
+import {
+  __export
+} from "./chunk-RAPJ3XLV.js";
+
+// src/helpers/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  REG_IDENTIFIER: () => REG_IDENTIFIER,
+  REG_ORDINAL: () => REG_ORDINAL
+});
+var REG_IDENTIFIER = /(?:_+|@+|\$+|\p{XID_Start})\p{XID_Continue}*/u;
+var REG_ORDINAL = /(?:0|[1-9]\d{0,8}|1\d{9}|20\d{8}|21[0-3]\d{7}|214[0-6]\d{6}|2147[0-3]\d{5}|21474[0-7]\d{4}|214748[0-2]\d{3}|2147483[0-5]\d{2}|21474836[0-3]\d|214748364[0-7])/;
+
+// src/helpers/utils.ts
+var { isArray } = Array;
+var { isFinite, isNaN, isInteger, isSafeInteger } = Number;
+var { hasOwn, keys, values, entries, create, getPrototypeOf, fromEntries, defineProperty } = Object;
+var hasOwnEnumerable = Function.call.bind(
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  Object.prototype.propertyIsEnumerable
+);
+
+// src/vm/error.ts
+var VmError = class _VmError extends Error {
+  constructor(message, recovered) {
+    super(message);
+    this.recovered = recovered;
+    this.name = "VmError";
+  }
+  /** 从其他错误构造 */
+  static from(prefix, error, recovered) {
+    if (prefix && !prefix.endsWith(": ")) prefix += ": ";
+    const vmError = new _VmError(`${prefix}${error instanceof Error ? error.message : String(error)}`, recovered);
+    vmError.stack = error instanceof Error ? error.stack : void 0;
+    return vmError;
+  }
+};
+
+// 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,
+  configCheckpoint: () => configCheckpoint
+});
+
+// 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
+});
+
+// src/vm/types/wrapper.ts
+var VmWrapper = class {
+  constructor(value) {
+    this.value = value;
+  }
+  /** Convert the object to JSON */
+  toJSON() {
+    return void 0;
+  }
+  /** 转为字符串 */
+  toString() {
+    return `<${this.type} ${this.describe}>`;
+  }
+};
+
+// src/vm/operations.ts
+var { abs, min, trunc, ceil } = Math;
+var { slice, at } = Array.prototype;
+var { POSITIVE_INFINITY, NEGATIVE_INFINITY } = Number;
+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 (a instanceof VmWrapper) return a.same(b);
+  if (b instanceof VmWrapper) return b.same(a);
+  if (isVmArray(a) && isVmArray(b)) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    const len2 = a.length;
+    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;
+      }
+      if (!isSame(a[key] ?? null, b[key] ?? null)) {
+        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) => !$Eq(a, b);
+var stringComparer = new Intl.Collator("en", {
+  usage: "sort",
+  numeric: false,
+  sensitivity: "base"
+});
+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;
+    return stringComparer.compare(as, bs) === 0;
+  }
+};
+var $Naeq = (a, b) => !$Aeq(a, b);
+var $Same = (a, b) => {
+  $AssertInit(a);
+  $AssertInit(b);
+  return isSame(a, b);
+};
+var $Nsame = (a, b) => !$Same(a, b);
+var $In = (value, iterable) => {
+  $AssertInit(value);
+  $AssertInit(iterable);
+  if (iterable == null) 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);
+    value;
+    return iterable.some((item = null) => isSame(item, value));
+  }
+  if (iterable instanceof VmWrapper) return iterable.has($ToString(value));
+  if (typeof iterable == "object") return hasOwnEnumerable(iterable, $ToString(value));
+  iterable;
+  return false;
+};
+var $Concat = (...args) => {
+  return args.map($Format).join("");
+};
+var $Pos = (a) => $ToNumber(a);
+var $Neg = (a) => -$ToNumber(a);
+var $Not = (a) => !$ToBoolean(a);
+var $Length = (value) => {
+  $AssertInit(value);
+  if (isVmArray(value)) return value.length;
+  if (isVmRecord(value)) return keys(value).length;
+  if (value instanceof VmWrapper) {
+    return value.keys().length;
+  }
+  return Number.NaN;
+};
+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 ${$Type(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 ${$Type(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 (func instanceof VmExtern) {
+    return func.call(args) ?? null;
+  }
+  if (isVmFunction(func)) {
+    return func(...args) ?? null;
+  }
+  throw new VmError(`Expected callable, got ${$Type(func)}`, null);
+};
+var $Type = (value) => {
+  if (value === void 0 || value === null) return "nil";
+  if (value instanceof VmExtern) return "extern";
+  if (value instanceof VmModule) return "module";
+  if (isVmArray(value)) return "array";
+  if (typeof value == "object") return "record";
+  return typeof value;
+};
+var $ToBoolean = (value) => {
+  $AssertInit(value);
+  return value != null && value !== false;
+};
+function numberToString(value) {
+  if (isNaN(value)) return "nan";
+  if (value === Infinity) return "inf";
+  if (value === -Infinity) return "-inf";
+  return String(value);
+}
+function innerToString(value, useBraces) {
+  if (value == null) return "nil";
+  if (value instanceof VmWrapper) return value.toString();
+  if (typeof value == "function") {
+    const name = getVmFunctionInfo(value)?.fullName;
+    return name ? `<function ${name}>` : `<function>`;
+  }
+  if (isVmArray(value)) {
+    const strings = [];
+    for (const item of value) {
+      strings.push(innerToString(item, true));
+    }
+    const results = strings.join(", ");
+    if (!useBraces) return results;
+    return `[${results}]`;
+  }
+  if (typeof value == "object") {
+    const entries3 = keys(value).map((key) => `${key}: ${innerToString(value[key], true)}`).join(", ");
+    if (!useBraces) return entries3;
+    return `(${entries3})`;
+  }
+  if (typeof value == "number") {
+    return numberToString(value);
+  }
+  return String(value);
+}
+var $ToString = (value) => {
+  $AssertInit(value);
+  if (typeof value == "string") return value;
+  if (value === null) return "";
+  return innerToString(value, false);
+};
+var $ToNumber = (value) => {
+  $AssertInit(value);
+  if (typeof value == "number") return value;
+  if (value == null) return 0;
+  if (typeof value == "string") {
+    value = value.trim();
+    if (value === "") return 0;
+    if (value === "inf" || value === "+inf" || value === "Infinity" || value === "+Infinity") {
+      return POSITIVE_INFINITY;
+    }
+    if (value === "-inf" || value === "-Infinity") {
+      return NEGATIVE_INFINITY;
+    }
+    return Number(value);
+  }
+  if (typeof value == "boolean") return value ? 1 : 0;
+  return Number.NaN;
+};
+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 (obj instanceof VmWrapper) 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 (obj instanceof VmWrapper) 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 ${$Type(obj)}`, void 0);
+  obj.set(pk, value);
+};
+var $Iterable = (value) => {
+  $AssertInit(value);
+  if (value instanceof VmWrapper) return value.keys();
+  if (isVmArray(value)) return value;
+  if (value != null && typeof value == "object") return keys(value);
+  throw new VmError(`Value is not iterable`, 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 ${$Type(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 ${$Type(array)}`, []);
+};
+function formatNumber(value) {
+  if (!Number.isFinite(value)) return numberToString(value);
+  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;
+}
+var $Format = (value, format2) => {
+  $AssertInit(value);
+  const f = format2 == null ? "" : typeof format2 == "string" ? format2.trim() : $ToString(format2);
+  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);
+};
+
+// src/vm/helpers.ts
+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) => {
+  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;
+};
+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;
+}
+function GlobalFallback() {
+  return DefaultVmContext;
+}
+
+// src/vm/types/function.ts
+var kVmFunction = Symbol.for("mirascript.vm.function");
+var kProxy = Symbol.for("mirascript.vm.function.proxy");
+function isVmFunction(value) {
+  return getVmFunctionInfo(value) != null;
+}
+function getVmFunctionInfo(value) {
+  if (typeof value != "function") return void 0;
+  return value[kVmFunction];
+}
+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,
+    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,
+      configurable: true
+    });
+  }
+  defineProperty(fn, kVmFunction, {
+    value: Object.freeze(info)
+  });
+  return fn;
+}
+function toVmFunctionProxy(fn) {
+  if (!isVmFunction(fn)) return fn;
+  const cached = fn[kProxy];
+  if (cached) return cached;
+  const proxy = (...args) => {
+    const ret = $Call(
+      fn,
+      // 作为函数参数传入的值一定丢失了它的 this
+      args.map((v) => wrapToVmValue(v, null))
+    );
+    return unwrapFromVmValue(ret);
+  };
+  defineProperty(fn, kProxy, { value: proxy });
+  defineProperty(proxy, kProxy, { value: fn });
+  defineProperty(proxy, "name", {
+    value: fn.name,
+    configurable: true
+  });
+  return proxy;
+}
+function fromVmFunctionProxy(fn) {
+  if (isVmFunction(fn)) return fn;
+  const original = fn[kProxy];
+  if (original && isVmFunction(original)) return original;
+  return void 0;
+}
+
+// src/vm/types/extern.ts
+var { apply } = Reflect;
+function wrapToVmValue(value, caller) {
+  if (value == null) return null;
+  switch (typeof value) {
+    case "function": {
+      const unwrapped = fromVmFunctionProxy(value);
+      if (unwrapped) return unwrapped;
+      return new VmExtern(value, caller);
+    }
+    case "object":
+      if (value instanceof VmWrapper) return value;
+      return new VmExtern(value, null);
+    case "string":
+    case "number":
+    case "boolean":
+      return value;
+    case "bigint":
+      return Number(value);
+    case "symbol":
+    case "undefined":
+    default:
+      return null;
+  }
+}
+function unwrapFromVmValue(value) {
+  if (typeof value == "function") {
+    return toVmFunctionProxy(value);
+  }
+  if (value == null || typeof value != "object") return value;
+  if (!(value instanceof VmExtern)) return value;
+  if (value.caller == null || typeof value.value != "function") {
+    return value.value;
+  }
+  const caller = value.caller.value;
+  const func = value.value;
+  return new Proxy(func, {
+    apply(target, thisArg, args) {
+      return apply(target, caller, args);
+    }
+  });
+}
+var ObjectPrototype = Object.prototype;
+var ObjectToString = ObjectPrototype.toString;
+var VmExtern = class _VmExtern extends VmWrapper {
+  constructor(value, caller = null) {
+    super(value);
+    this.caller = caller;
+  }
+  /** 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;
+  }
+  /** @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);
+  }
+  /** 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;
+    const caller = this.caller?.value ?? null;
+    const unwrappedArgs = args.map(unwrapFromVmValue);
+    try {
+      const ret = apply(value, caller, unwrappedArgs);
+      return wrapToVmValue(ret, null);
+    } catch (ex) {
+      throw VmError.from(`Not a callable extern`, ex, null);
+    }
+  }
+  /** @inheritdoc */
+  keys() {
+    const keys3 = [];
+    for (const key in this.value) {
+      if (this.has(key)) keys3.push(key);
+    }
+    return keys3;
+  }
+  /** @inheritdoc */
+  same(other) {
+    if (!(other instanceof _VmExtern)) return false;
+    return this.value === other.value && this.caller === other.caller;
+  }
+  /** @inheritdoc */
+  toString() {
+    const { toString } = this.value;
+    if (typeof toString != "function" || toString === ObjectToString) {
+      return super.toString();
+    }
+    try {
+      return String(this.value);
+    } catch {
+      return super.toString();
+    }
+  }
+  /** @inheritdoc */
+  get type() {
+    return "extern";
+  }
+  /** @inheritdoc */
+  get describe() {
+    const tag = ObjectToString.call(this.value).slice(8, -1);
+    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;
+      if (name) {
+        return `Class ${name}`;
+      } else {
+        return "Class";
+      }
+    }
+    return tag;
+  }
+};
+
+// 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;
+  }
+};
+
+// src/vm/types/script.ts
+var kVmScript = Symbol.for("mirascript.vm.script");
+function isVmScript(value) {
+  return typeof value === "function" && value[kVmScript] === true;
+}
+
+// src/vm/types/checker.ts
+var MAX_DEPTH2 = 32;
+function isVmArrayDeep(value, depth) {
+  const proto1 = getPrototypeOf(value);
+  if (!isArray(proto1)) return false;
+  if (!depth) return true;
+  return value.every((item) => isVmConstInner(item, depth));
+}
+function isVmRecordDeep(value, depth) {
+  let isRecord;
+  const proto1 = getPrototypeOf(value);
+  if (proto1 == null) {
+    isRecord = true;
+  } else {
+    const proto2 = getPrototypeOf(proto1);
+    if (proto2 != null) {
+      isRecord = false;
+    } else {
+      isRecord = "hasOwnProperty" in value;
+    }
+  }
+  if (!isRecord) return false;
+  if (!depth) return true;
+  return values(value).every((value2) => isVmConstInner(value2, depth));
+}
+function isVmConstInner(value, depth) {
+  if (depth++ >= MAX_DEPTH2) return false;
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "undefined":
+      return true;
+    case "object":
+      if (value == null) return true;
+      if (value instanceof VmWrapper) return false;
+      if (isArray(value)) {
+        return isVmArrayDeep(value, depth);
+      } else {
+        return isVmRecordDeep(value, depth);
+      }
+    case "function":
+    case "bigint":
+    case "symbol":
+    default:
+      return false;
+  }
+}
+function isVmConst(value, checkDeep = false) {
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+      return true;
+    case "object":
+      if (value == null) return true;
+      if (value instanceof VmWrapper) return false;
+      if (!checkDeep) {
+        if (isArray(value)) {
+          return isVmArrayDeep(value, 0);
+        } else {
+          return isVmRecordDeep(value, 0);
+        }
+      } else {
+        return isVmConstInner(value, 1);
+      }
+    case "undefined":
+    case "function":
+    case "bigint":
+    case "symbol":
+    default:
+      return false;
+  }
+}
+function isVmImmutable(value, checkDeep = false) {
+  return value instanceof VmModule || isVmFunction(value) || isVmConst(value, checkDeep);
+}
+function isVmValue(value, checkDeep = false) {
+  if (value === void 0) return false;
+  return isVmAny(value, checkDeep);
+}
+function isVmAny(value, checkDeep) {
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "undefined":
+      return true;
+    case "object":
+      if (value == null) return true;
+      if (value instanceof VmWrapper) return true;
+      return isVmConst(value, checkDeep);
+    case "function":
+      return isVmFunction(value);
+    case "bigint":
+    case "symbol":
+    default:
+      return false;
+  }
+}
+
+// src/vm/types/index.ts
+function isVmArray(value) {
+  if (!isArray(value)) return false;
+  value;
+  return true;
+}
+function isVmRecord(value) {
+  if (value == null || typeof value !== "object") return false;
+  if (value instanceof VmWrapper) return false;
+  if (isVmArray(value)) return false;
+  value;
+  return true;
+}
+function isVmPrimitive(value) {
+  if (value === null || typeof value == "number" || typeof value == "string" || typeof value == "boolean") {
+    value;
+    value;
+    return true;
+  }
+  return false;
+}
+function isVmExtern(value) {
+  return value instanceof VmExtern;
+}
+function isVmModule(value) {
+  return value instanceof VmModule;
+}
+var VM_ARRAY_MAX_LENGTH = 2 ** 31 - 1;
+
+// src/vm/types/context.ts
+var kVmContext = Symbol.for("mira:vm-context");
+var VmSharedContext = { __proto__: null };
+function defineVmContextValue(name, value, override = false) {
+  if (!override && name in VmSharedContext) 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;
+  }
+  VmSharedContext[name] = v ?? null;
+}
+var DefaultVmContext = Object.freeze({
+  [kVmContext]: true,
+  /** @inheritdoc */
+  keys() {
+    return keys(VmSharedContext);
+  },
+  /** @inheritdoc */
+  get(key) {
+    return VmSharedContext[key] ?? null;
+  },
+  /** @inheritdoc */
+  has(key) {
+    return key in VmSharedContext;
+  }
+});
+var _a;
+_a = kVmContext;
+var ValueVmContext = class {
+  constructor(env) {
+    this.env = env;
+    this[_a] = true;
+    this.cachedKeys = null;
+  }
+  /** @inheritdoc */
+  keys() {
+    this.cachedKeys ??= keys(this.env);
+    return [...this.cachedKeys, ...DefaultVmContext.keys()];
+  }
+  /** @inheritdoc */
+  get(key) {
+    return this.env[key] ?? null;
+  }
+  /** @inheritdoc */
+  has(key) {
+    return key in this.env;
+  }
+};
+var _a2;
+_a2 = kVmContext;
+var FactoryVmContext = class {
+  constructor(getter, enumerator) {
+    this.getter = getter;
+    this.enumerator = enumerator;
+    this[_a2] = true;
+  }
+  /** @inheritdoc */
+  keys() {
+    if (!this.enumerator) return DefaultVmContext.keys();
+    return [...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") {
+    return new FactoryVmContext(args[0], args[1]);
+  }
+  const [vmValues, externValues] = args;
+  const env = { __proto__: VmSharedContext };
+  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);
+}
+function isVmContext(context) {
+  if (context == null || typeof context != "object") return false;
+  return context[kVmContext] === true;
+}
+
+// src/vm/lib/global/index.ts
+var global_exports = {};
+__export(global_exports, {
+  "@e": () => E,
+  "@pi": () => PI,
+  abs: () => abs2,
+  acos: () => acos,
+  acosh: () => acosh,
+  all: () => all,
+  any: () => any,
+  asin: () => asin,
+  asinh: () => asinh,
+  atan: () => atan,
+  atan2: () => atan2,
+  atanh: () => atanh,
+  b_and: () => b_and,
+  b_not: () => b_not,
+  b_or: () => b_or,
+  b_xor: () => b_xor,
+  cbrt: () => cbrt,
+  ceil: () => ceil2,
+  chars: () => chars,
+  contains: () => contains,
+  cos: () => cos,
+  cosh: () => cosh,
+  debug_print: () => debug_print,
+  ends_with: () => ends_with,
+  entries: () => entries2,
+  exp: () => exp,
+  expm1: () => expm1,
+  factorial: () => factorial,
+  filter: () => filter,
+  filter_map: () => filter_map,
+  find: () => find,
+  flatten: () => flatten,
+  floor: () => floor,
+  format: () => format,
+  from_json: () => from_json,
+  hypot: () => hypot,
+  join: () => join,
+  keys: () => keys2,
+  len: () => len,
+  log: () => log,
+  log10: () => log10,
+  log1p: () => log1p,
+  log2: () => log2,
+  map: () => map2,
+  matrix: () => matrix,
+  max: () => max,
+  min: () => min2,
+  panic: () => panic,
+  pow: () => pow2,
+  product: () => product,
+  random: () => random,
+  repeat: () => repeat,
+  replace: () => replace,
+  reverse: () => reverse,
+  round: () => round,
+  sar: () => sar,
+  shl: () => shl,
+  shr: () => shr,
+  sign: () => sign,
+  sin: () => sin,
+  sinh: () => sinh,
+  sort: () => sort,
+  sort_by: () => sort_by,
+  split: () => split,
+  sqrt: () => sqrt,
+  starts_with: () => starts_with,
+  sum: () => sum,
+  tan: () => tan,
+  tanh: () => tanh,
+  to_boolean: () => to_boolean,
+  to_datetime: () => to_datetime,
+  to_iso8601: () => to_iso8601,
+  to_json: () => to_json,
+  to_number: () => to_number,
+  to_string: () => to_string,
+  to_timestamp: () => to_timestamp,
+  trim: () => trim,
+  trim_end: () => trim_end,
+  trim_start: () => trim_start,
+  trunc: () => trunc2,
+  values: () => values2,
+  with: () => _with,
+  zip: () => zip
+});
+
+// src/vm/lib/_helpers.ts
+function throwError(message, recovered) {
+  const recoveredValue = typeof recovered === "function" && !isVmFunction(recovered) ? recovered() : recovered;
+  throw new VmError(message, recoveredValue);
+}
+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);
+}
+function rethrowError(prefix, error, recovered) {
+  const recoveredValue = typeof recovered === "function" && !isVmFunction(recovered) ? recovered() : recovered;
+  throw VmError.from(prefix, error, recoveredValue);
+}
+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);
+  }
+}
+function expectArray(name, value, recovered) {
+  required(name, value, recovered);
+  if (!isVmArray(value)) {
+    throwUnexpectedTypeError(name, "array", value, recovered);
+  }
+}
+function expectArrayOrRecord(name, value, recovered) {
+  required(name, value, recovered);
+  if (!isVmArray(value) && !isVmRecord(value)) {
+    throwUnexpectedTypeError(name, "array | record", value, recovered);
+  }
+}
+function expectCompound(name, value, recovered) {
+  required(name, value, recovered);
+  if (isVmPrimitive(value) || isVmFunction(value)) {
+    throwUnexpectedTypeError(name, "array | record | module | extern", value, recovered);
+  }
+}
+function expectConst(name, value, recovered) {
+  required(name, value, recovered);
+  if (!isVmConst(value)) {
+    throwUnexpectedTypeError(name, "nil | number | boolean | string | array | record", value, recovered);
+  }
+}
+function expectCallable(name, value, recovered) {
+  required(name, value, recovered);
+  const callable = isVmFunction(value) || isVmExtern(value);
+  if (!callable) {
+    throwUnexpectedTypeError(name, "callable", value, recovered);
+  }
+}
+function getNumbers(args) {
+  if (args.length === 0) return [];
+  if (args.length === 1 && isVmArray(args[0])) args = args[0];
+  const numbers = [];
+  for (const arg of args) {
+    if (arg == null) continue;
+    numbers.push($ToNumber(arg));
+  }
+  return numbers;
+}
+function arrayLen(len2) {
+  if (len2 == null || isNaN(len2) || len2 <= 0) return 0;
+  len2 = Math.trunc(len2);
+  if (len2 > VM_ARRAY_MAX_LENGTH) throwError(`Array length exceeds maximum limit of ${VM_ARRAY_MAX_LENGTH}`, null);
+  return len2;
+}
+function map(data, mapper) {
+  if (isVmPrimitive(data)) {
+    return mapper(data, null, data) ?? null;
+  }
+  if (isVmArray(data)) {
+    const result = [];
+    const { length } = data;
+    for (let i = 0; i < length; i++) {
+      Cp();
+      const ret = mapper(data[i] ?? null, i, data);
+      if (ret === void 0) continue;
+      if (isVmConst(ret)) {
+        result.push(ret);
+      } else {
+        result.push(null);
+      }
+    }
+    return result;
+  } else {
+    const e = [];
+    for (const [key, value] of entries(data)) {
+      Cp();
+      const ret = mapper(value ?? null, key, data);
+      if (ret === void 0) continue;
+      if (isVmConst(ret)) {
+        e.push([key, ret]);
+      } else {
+        e.push([key, null]);
+      }
+    }
+    return fromEntries(e);
+  }
+}
+function VmLib(fn, option) {
+  if (typeof fn != "function") throw new TypeError("Invalid function");
+  if (isVmFunction(fn)) throw new TypeError("Cannot create VmLib from a VmFunction");
+  const ret = fn;
+  ret.params = option.params;
+  ret.paramsType = option.paramsType;
+  ret.returns = option.returns;
+  ret.returnsType = option.returnsType;
+  ret.summary = option.summary;
+  ret.examples = option.examples;
+  return ret;
+}
+
+// src/vm/lib/global/math-arr.ts
+function build(f) {
+  return (...values3) => {
+    const numbers = getNumbers(values3);
+    return f(...numbers);
+  };
+}
+var max = VmLib(build(Math.max), {
+  summary: "返回一组数中的最大值",
+  params: { "..values": "要比较的数值" },
+  paramsType: { "..values": "number[]" },
+  returnsType: "number",
+  examples: ["max(3, 7, 2) // 7"]
+});
+var min2 = VmLib(build(Math.min), {
+  summary: "返回一组数中的最小值",
+  params: { "..values": "要比较的数值" },
+  paramsType: { "..values": "number[]" },
+  returnsType: "number",
+  examples: ["min(3, 7, 2) // 2"]
+});
+var hypot = VmLib(build(Math.hypot), {
+  summary: "返回所有参数平方和的平方根",
+  params: { "..values": "要计算的数值" },
+  paramsType: { "..values": "number[]" },
+  returnsType: "number",
+  examples: ["hypot(3, 4) // 5"]
+});
+var sum = VmLib(
+  (...values3) => {
+    const numbers = getNumbers(values3);
+    return numbers.reduce((a, b) => a + b, 0);
+  },
+  {
+    summary: "返回一组数的总和",
+    params: { "..values": "要计算的数值" },
+    paramsType: { "..values": "number[]" },
+    returnsType: "number",
+    examples: ["sum(1, 2, 3, 4) // 10"]
+  }
+);
+var product = VmLib(
+  (...values3) => {
+    const numbers = getNumbers(values3);
+    return numbers.reduce((a, b) => a * b, 1);
+  },
+  {
+    summary: "返回一组数的乘积",
+    params: { "..values": "要计算的数值" },
+    paramsType: { "..values": "number[]" },
+    returnsType: "number",
+    examples: ["product(2, 3, 4) // 24"]
+  }
+);
+
+// src/vm/lib/global/math-const.ts
+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));
+  };
+}
+var trunc2 = VmLib(build2(Math.trunc), {
+  summary: "返回数值的整数部分（去除小数）",
+  params: { x: "要取整数部分的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var floor = VmLib(build2(Math.floor), {
+  summary: "返回小于等于给定数的最大整数",
+  params: { x: "要向下取整的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var ceil2 = VmLib(build2(Math.ceil), {
+  summary: "返回大于等于给定数的最小整数",
+  params: { x: "要向上取整的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var round = VmLib(build2(Math.round), {
+  summary: "返回四舍五入后的整数",
+  params: { x: "要四舍五入的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var sign = VmLib(build2(Math.sign), {
+  summary: "返回数值的符号（正数为 1，负数为 -1，零为 0）",
+  params: { x: "要判断符号的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var abs2 = VmLib(build2(Math.abs), {
+  summary: "返回数值的绝对值",
+  params: { x: "要取绝对值的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var acos = VmLib(build2(Math.acos), {
+  summary: "返回数值的反余弦值（弧度）",
+  params: { x: "要计算反余弦的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var acosh = VmLib(build2(Math.acosh), {
+  summary: "返回数值的反双曲余弦值",
+  params: { x: "要计算反双曲余弦的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var asin = VmLib(build2(Math.asin), {
+  summary: "返回数值的反正弦值（弧度）",
+  params: { x: "要计算反正弦的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var asinh = VmLib(build2(Math.asinh), {
+  summary: "返回数值的反双曲正弦值",
+  params: { x: "要计算反双曲正弦的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var atan = VmLib(build2(Math.atan), {
+  summary: "返回数值的反正切值（弧度）",
+  params: { x: "要计算反正切的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var atanh = VmLib(build2(Math.atanh), {
+  summary: "返回数值的反双曲正切值",
+  params: { x: "要计算反双曲正切的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var cos = VmLib(build2(Math.cos), {
+  summary: "返回数值的余弦值",
+  params: { x: "要计算余弦的数（弧度）" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var cosh = VmLib(build2(Math.cosh), {
+  summary: "返回数值的双曲余弦值",
+  params: { x: "要计算双曲余弦的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var sin = VmLib(build2(Math.sin), {
+  summary: "返回数值的正弦值",
+  params: { x: "要计算正弦的数（弧度）" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var sinh = VmLib(build2(Math.sinh), {
+  summary: "返回数值的双曲正弦值",
+  params: { x: "要计算双曲正弦的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var tan = VmLib(build2(Math.tan), {
+  summary: "返回数值的正切值",
+  params: { x: "要计算正切的数（弧度）" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var tanh = VmLib(build2(Math.tanh), {
+  summary: "返回数值的双曲正切值",
+  params: { x: "要计算双曲正切的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var exp = VmLib(build2(Math.exp), {
+  summary: "返回 e 的指定次幂",
+  params: { x: "指数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var expm1 = VmLib(build2(Math.expm1), {
+  summary: "返回 e 的 x 次幂减 1",
+  params: { x: "指数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var log = VmLib(build2(Math.log), {
+  summary: "返回数值的自然对数（以 e 为底）",
+  params: { x: "要取对数的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var log10 = VmLib(build2(Math.log10), {
+  summary: "返回数值的以 10 为底的对数",
+  params: { x: "要取对数的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var log1p = VmLib(build2(Math.log1p), {
+  summary: "返回 1 加上数值的自然对数",
+  params: { x: "要取对数的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var log2 = VmLib(build2(Math.log2), {
+  summary: "返回数值的以 2 为底的对数",
+  params: { x: "要取对数的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var sqrt = VmLib(build2(Math.sqrt), {
+  summary: "返回数值的平方根",
+  params: { x: "要开平方的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+var cbrt = VmLib(build2(Math.cbrt), {
+  summary: "返回数值的立方根",
+  params: { x: "要计算立方根的数" },
+  paramsType: { x: "number" },
+  returnsType: "number"
+});
+
+// src/vm/lib/global/math-additional.ts
+var { sqrt: sqrt2, pow, exp: exp2 } = Math;
+var GAMMA_G = 4.7421875;
+var GAMMA_P = [
+  0.9999999999999971,
+  57.15623566586292,
+  -59.59796035547549,
+  14.136097974741746,
+  -0.4919138160976202,
+  3399464998481189e-20,
+  4652362892704858e-20,
+  -9837447530487956e-20,
+  1580887032249125e-19,
+  -21026444172410488e-20,
+  21743961811521265e-20,
+  -1643181065367639e-19,
+  8441822398385275e-20,
+  -26190838401581408e-21,
+  36899182659531625e-22
+];
+var SQRT_2_PI = sqrt2(2 * Math.PI);
+var factorial = VmLib(
+  (x) => {
+    required("x", x, Number.NaN);
+    let n = $ToNumber(x);
+    if (isNaN(n) || n < 0) return Number.NaN;
+    if (n >= 171) return Number.POSITIVE_INFINITY;
+    if (isInteger(n)) {
+      if (n === 0 || n === 1) return 1;
+      let r = 1;
+      for (let i = 2; i <= n; i++) {
+        r *= i;
+      }
+      return r;
+    }
+    if (n > 85) {
+      n = n + 1;
+      const twoN = n * n;
+      const threeN = twoN * n;
+      const fourN = threeN * n;
+      const fiveN = fourN * n;
+      return sqrt2(2 * Math.PI / n) * pow(n / Math.E, n) * (1 + 1 / (12 * n) + 1 / (288 * twoN) - 139 / (51840 * threeN) - 571 / (2488320 * fourN) + 163879 / (209018880 * fiveN) + 5246819 / (75246796800 * fiveN * n));
+    }
+    let p = GAMMA_P[0];
+    for (let i = 1; i < GAMMA_P.length; ++i) {
+      p += GAMMA_P[i] / (n + i);
+    }
+    const t = n + GAMMA_G + 0.5;
+    return SQRT_2_PI * pow(t, n + 0.5) * exp2(-t) * p;
+  },
+  {
+    summary: "返回一个数的阶乘",
+    params: { x: "要计算阶乘的数值" },
+    paramsType: { x: "number" },
+    returnsType: "number",
+    examples: ["factorial(5) // 120"]
+  }
+);
+
+// src/vm/lib/global/math.ts
+var { atan2: _atan2, pow: _pow } = Math;
+var atan2 = VmLib((x, y) => _atan2($ToNumber(x), $ToNumber(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)), {
+  summary: "返回 x 的 y 次幂",
+  params: { x: "底数", y: "指数" },
+  paramsType: { x: "number", y: "number" },
+  returnsType: "number"
+});
+var random = VmLib(Math.random, {
+  summary: "返回 0 到 1 之间的伪随机数",
+  params: {},
+  paramsType: {},
+  returnsType: "number"
+});
+
+// src/vm/lib/global/bit.ts
+var b_and = VmLib(
+  (x, y) => {
+    return $ToNumber(x) & $ToNumber(y);
+  },
+  {
+    summary: "返回两个数的按位与",
+    params: { x: "第一个操作数", y: "第二个操作数" },
+    paramsType: { x: "number", y: "number" },
+    returnsType: "number",
+    examples: ["b_and(6, 3) // 2"]
+  }
+);
+var b_or = VmLib(
+  (x, y) => {
+    return $ToNumber(x) | $ToNumber(y);
+  },
+  {
+    summary: "返回两个数的按位或",
+    params: { x: "第一个操作数", y: "第二个操作数" },
+    paramsType: { x: "number", y: "number" },
+    returnsType: "number",
+    examples: ["b_or(5, 2) // 7"]
+  }
+);
+var b_not = VmLib(
+  (x) => {
+    return ~$ToNumber(x);
+  },
+  {
+    summary: "返回一个数的按位取反",
+    params: { x: "操作数" },
+    paramsType: { x: "number" },
+    returnsType: "number",
+    examples: ["b_not(0) // -1"]
+  }
+);
+var b_xor = VmLib(
+  (x, y) => {
+    return $ToNumber(x) ^ $ToNumber(y);
+  },
+  {
+    summary: "返回两个数的按位异或",
+    params: { x: "第一个操作数", y: "第二个操作数" },
+    paramsType: { x: "number", y: "number" },
+    returnsType: "number",
+    examples: ["b_xor(5, 3) // 6"]
+  }
+);
+var shl = VmLib(
+  (x, y) => {
+    return $ToNumber(x) << $ToNumber(y);
+  },
+  {
+    summary: "返回第一个操作数左移指定的位数",
+    params: { x: "第一个操作数", y: "位数" },
+    paramsType: { x: "number", y: "number" },
+    returnsType: "number",
+    examples: ["shl(3, 2) // 12"]
+  }
+);
+var sar = VmLib(
+  (x, y) => {
+    return $ToNumber(x) >> $ToNumber(y);
+  },
+  {
+    summary: "返回第一个操作数右移指定的位数",
+    params: { x: "第一个操作数", y: "位数" },
+    paramsType: { x: "number", y: "number" },
+    returnsType: "number",
+    examples: ["sar(-8, 1) // -4"]
+  }
+);
+var shr = VmLib(
+  (x, y) => {
+    return $ToNumber(x) >>> $ToNumber(y);
+  },
+  {
+    summary: "返回第一个操作数无符号右移指定的位数",
+    params: { x: "第一个操作数", y: "位数" },
+    paramsType: { x: "number", y: "number" },
+    returnsType: "number",
+    examples: ["shr(8, 1) // 4"]
+  }
+);
+
+// src/vm/lib/global/sequence/with.ts
+var _with = VmLib(
+  (data, ...entries3) => {
+    expectArrayOrRecord("data", data, data);
+    if (entries3.length % 2 !== 0) {
+      throwError("Expected even number of entries", data);
+    }
+    if (isVmArray(data)) {
+      const result = [...data];
+      for (let i = 0; i < entries3.length; i += 2) {
+        const index = Math.trunc($ToNumber(entries3[i]));
+        if (!isSafeInteger(index) || index < 0) continue;
+        const value = entries3[i + 1];
+        while (index > result.length) {
+          result.push(null);
+        }
+        result[index] = Element(value);
+      }
+      return result;
+    } else {
+      const result = { ...data };
+      for (let i = 0; i < entries3.length; i += 2) {
+        const key = $ToString(entries3[i]);
+        const value = entries3[i + 1];
+        result[key] = Element(value);
+      }
+      return result;
+    }
+  },
+  {
+    summary: "在数组或记录中设置多个键值对",
+    params: { data: "要设置的数组或记录", "..entries": "要设置的键值对，成对出现" },
+    paramsType: { data: "array | record", "..entries": "[..[string | number, any][]]" },
+    returnsType: "type(data)",
+    examples: ["with([10, 20], 2, 99) // [10, 20, 99]", 'with((a: 1), "b", 2) // (a: 1, b: 2)']
+  }
+);
+
+// src/vm/lib/global/sequence/entries.ts
+var keys2 = VmLib(
+  (data) => {
+    expectCompound("data", data, []);
+    if (isVmArray(data)) {
+      const arr = [];
+      const len2 = data.length;
+      for (let i = 0; i < len2; i++) {
+        arr.push(i);
+      }
+      return arr;
+    }
+    if (isVmRecord(data)) {
+      return keys(data);
+    }
+    return data.keys();
+  },
+  {
+    summary: "返回数组、记录、外部对象或模块的键列表",
+    params: { data: "要获取键的数组、记录、外部对象或模块" },
+    paramsType: { data: "array | record | extern | module" },
+    returnsType: "(string | number)[]",
+    examples: ["keys([10, 20]) // [0, 1]", 'keys((10, 20)) // ["0", "1"]']
+  }
+);
+var values2 = VmLib(
+  (data) => {
+    expectArrayOrRecord("data", data, []);
+    if (isVmArray(data)) {
+      return data;
+    }
+    return values(data);
+  },
+  {
+    summary: "返回数组或记录的值列表",
+    params: { data: "要获取值的数组或记录" },
+    paramsType: { data: "array | record" },
+    returnsType: "array",
+    examples: ["values((a: 1, b: 2)) // [1, 2]"]
+  }
+);
+var entries2 = VmLib(
+  (data) => {
+    expectArrayOrRecord("data", data, []);
+    if (isVmArray(data)) {
+      const arr = [];
+      const len2 = data.length;
+      for (let i = 0; i < len2; i++) {
+        arr.push({ 0: i, 1: data[i] ?? null });
+      }
+      return arr;
+    }
+    return entries(data).map(([key, value]) => ({ 0: key, 1: value ?? null }));
+  },
+  {
+    summary: "返回数组或记录的键值对列表",
+    params: { data: "要获取键值对的数组或记录" },
+    paramsType: { data: "array | record" },
+    returnsType: "(string | number, any)[]",
+    examples: ["entries([1]) // [(0, 1)]", 'entries((a: 1)) // [("a", 1)]']
+  }
+);
+
+// src/vm/lib/global/sequence/len.ts
+var len = VmLib(
+  (arr) => {
+    expectArray("arr", arr, Number.NaN);
+    return arr.length;
+  },
+  {
+    summary: "返回数组的长度",
+    params: { arr: "要求长度的数组" },
+    paramsType: { arr: "array" },
+    returnsType: "number",
+    examples: ["len([1, 2, 3]) // 3"]
+  }
+);
+
+// src/vm/lib/global/sequence/map-filter.ts
+function mapImplWrapped(data, fnName, fn, mapper) {
+  expectConst("data", data, null);
+  expectCallable(fnName, fn, data);
+  return map(data, (value, index, data2) => {
+    const ret = mapper(fn, value, index, data2);
+    if (ret === void 0 || isVmConst(ret)) return ret;
+    return null;
+  });
+}
+var map2 = VmLib(
+  (data, f) => mapImplWrapped(data, "f", f, (fn, value, key, data2) => $Call(fn, [value, key, data2])),
+  {
+    summary: "对数组或记录中的每个元素应用函数，并返回结果",
+    params: {
+      data: "要映射的数组或记录",
+      f: "应用于每个元素的函数"
+    },
+    paramsType: {
+      data: "array | record",
+      f: "fn(value: any, key: number | string | nil, input: type(data)) -> any"
+    },
+    returnsType: "type(data)",
+    examples: ["map([1, 2, 3], fn (v) { v * v }) // [1, 4, 9]"]
+  }
+);
+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;
+  }),
+  {
+    summary: "过滤数组或记录中的元素，返回满足条件的元素",
+    params: {
+      data: "要过滤的数组或记录",
+      predicate: "用于测试每个元素的函数，返回 true 或 false"
+    },
+    paramsType: {
+      data: "array | record",
+      predicate: "fn(value: any, key: number | string | nil, input: type(data)) -> boolean"
+    },
+    returnsType: "type(data)",
+    examples: ["filter([1, 2, 3, 4], fn (v) { v % 2 == 0 }) // [2, 4]"]
+  }
+);
+var filter_map = VmLib(
+  (data, f) => mapImplWrapped(data, "f", f, (fn, value, key, data2) => {
+    const ret = $Call(fn, [value, key, data2]);
+    return ret ?? void 0;
+  }),
+  {
+    summary: "对数组或记录中的每个元素应用函数，并返回非 nil 的结果",
+    params: {
+      data: "要映射的数组或记录",
+      f: "应用于每个元素的函数，返回 nil 或非 nil 的值"
+    },
+    paramsType: {
+      data: "array | record",
+      f: "fn(value: any, key: number | string | nil, input: type(data)) -> any | nil"
+    },
+    returnsType: "type(data)",
+    examples: ["filter_map([1, 2, 3], fn (v) { if v % 2 == 0 { v * v } else { nil } }) // [4]"]
+  }
+);
+
+// src/vm/lib/global/sequence/find.ts
+var find = VmLib(
+  (data, predicate) => {
+    expectArrayOrRecord("data", data, null);
+    expectCallable("predicate", predicate, data);
+    const p = (value, key, data2) => {
+      const ret = $Call(predicate, [value, key, data2]);
+      return $ToBoolean(ret);
+    };
+    if (isVmArray(data)) {
+      const { length } = data;
+      for (let i = 0; i < length; i++) {
+        Cp();
+        const value = data[i] ?? null;
+        const ret = p(value, i, data);
+        if (!ret) continue;
+        return { 0: i, 1: value };
+      }
+      return null;
+    } else {
+      for (const [key, v] of entries(data)) {
+        Cp();
+        const value = v ?? null;
+        const ret = p(value, key, data);
+        if (!ret) continue;
+        return { 0: key, 1: value };
+      }
+      return null;
+    }
+  },
+  {
+    summary: "查找数组或记录中的键值对，返回第一个满足条件的键值对",
+    params: {
+      data: "查的数组或记录",
+      predicate: "用于测试每个键值对的函数，返回 true 或 false"
+    },
+    paramsType: {
+      data: "array | record",
+      predicate: "fn(value: any, key: number | string | nil, input: type(data)) -> boolean"
+    },
+    returnsType: "(string | number, any) | nil",
+    examples: ["find([3, 5, 8], fn (v) { v % 2 == 0 }) // (2, 8)"]
+  }
+);
+
+// src/vm/lib/global/sequence/flatten.ts
+var flatten = VmLib(
+  (data, depth = 1) => {
+    expectArray("data", data, data);
+    return data.flat($ToNumber(depth));
+  },
+  {
+    summary: "将数组扁平化",
+    params: { data: "要扁平化的数组", depth: "扁平化的深度，默认为 1" },
+    paramsType: { data: "array", depth: "number" },
+    returnsType: "array",
+    examples: ["flatten([[1, 2], [3, [4]]], 2) // [1, 2, 3, 4]"]
+  }
+);
+
+// src/vm/lib/global/sequence/reverse.ts
+var reverse = VmLib(
+  (arr) => {
+    expectArray("arr", arr, null);
+    const dup = [...arr];
+    dup.reverse();
+    return dup;
+  },
+  {
+    summary: "返回数组的反转副本",
+    params: { arr: "要反转的数组" },
+    paramsType: { arr: "array" },
+    returnsType: "array",
+    examples: ["reverse([1, 2, 3]) // [3, 2, 1]"]
+  }
+);
+
+// src/vm/lib/global/sequence/zip.ts
+var zip = VmLib(
+  (data) => {
+    const ets = entries2(data);
+    let len2 = 0;
+    for (const { 0: key, 1: arr } of ets) {
+      if (!isVmArray(arr)) {
+        throwError(`data[${serialize(key)}] is not an array`, null);
+      }
+      len2 = Math.max(len2, arr.length);
+    }
+    if (len2 === 0) return [];
+    const result = [];
+    const isArr = isVmArray(data);
+    for (let i = 0; i < len2; i++) {
+      Cp();
+      const obj = isArr ? [] : {};
+      for (const { 0: key, 1: arr } of ets) {
+        obj[key] = arr[i] ?? null;
+      }
+      result.push(obj);
+    }
+    return result;
+  },
+  {
+    summary: "将数组的数组/记录转换为数组/记录的数组",
+    params: { data: "要转换的数组/记录" },
+    paramsType: { data: "array | record" },
+    returnsType: "(array | record)[]",
+    examples: [
+      'zip((x: [1, 2], y: ["a", "b"])) // [(x: 1, y: "a"), (x: 2, y: "b")]',
+      `zip([[1, 2], ["a", "b"]]) // [[1, "a"], [2, "b"]]`
+    ]
+  }
+);
+
+// src/vm/lib/global/sequence/all-any.ts
+var all = VmLib(
+  (data, predicate) => {
+    expectArrayOrRecord("data", data, null);
+    expectCallable("predicate", predicate, data);
+    if (isVmArray(data)) {
+      for (let i = 0; i < data.length; i++) {
+        Cp();
+        const value = data[i] ?? null;
+        const ret = $Call(predicate, [value, i, data]);
+        if (!$ToBoolean(ret)) return false;
+      }
+      return true;
+    } else {
+      for (const [key, v] of entries(data)) {
+        Cp();
+        const value = v ?? null;
+        const ret = $Call(predicate, [value, key, data]);
+        if (!$ToBoolean(ret)) return false;
+      }
+      return true;
+    }
+  },
+  {
+    summary: "检查数组或记录中的所有键值对是否都满足条件",
+    params: { data: "要检查的数组或记录", predicate: "用于测试每个键值对的函数，返回 true 或 false" },
+    paramsType: {
+      data: "array | record",
+      predicate: "fn(value: any, key: number | string, input: type(data)) -> boolean"
+    },
+    returnsType: "boolean",
+    examples: ["all([1, 2, 3], fn { it > 0 }) // true"]
+  }
+);
+var any = VmLib(
+  (data, predicate) => {
+    expectArrayOrRecord("data", data, null);
+    expectCallable("predicate", predicate, data);
+    if (isVmArray(data)) {
+      for (let i = 0; i < data.length; i++) {
+        Cp();
+        const value = data[i] ?? null;
+        const ret = $Call(predicate, [value, i, data]);
+        if ($ToBoolean(ret)) return true;
+      }
+      return false;
+    } else {
+      for (const [key, v] of entries(data)) {
+        Cp();
+        const value = v ?? null;
+        const ret = $Call(predicate, [value, key, data]);
+        if ($ToBoolean(ret)) return true;
+      }
+      return false;
+    }
+  },
+  {
+    summary: "检查数组或记录中的是否存在满足条件的键值对",
+    params: { data: "要检查的数组或记录", predicate: "用于测试每个键值对的函数，返回 true 或 false" },
+    paramsType: {
+      data: "array | record",
+      predicate: "fn(value: any, key: number | string, input: type(data)) -> boolean"
+    },
+    returnsType: "boolean",
+    examples: ["any([0, 1, 2], fn { it > 1 }) // true"]
+  }
+);
+
+// src/vm/lib/global/sequence/sort.ts
+function defaultCompare(a, b) {
+  a ??= "";
+  b ??= "";
+  if (typeof a == "string" && typeof b == "string") {
+    if (a < b) return -1;
+    if (a > b) return 1;
+    return 0;
+  }
+  if (Object.is(a, b)) return 0;
+  const an = $ToNumber(a) || 0;
+  const bn = $ToNumber(b) || 0;
+  return an - bn;
+}
+function cmp(comparator, recovered) {
+  if (comparator == null) return defaultCompare;
+  expectCallable("comparator", comparator, recovered);
+  return (a, b) => {
+    const ret = $Call(comparator, [a, b]);
+    return $ToNumber(ret);
+  };
+}
+var sort = VmLib(
+  (data, comparator) => {
+    expectArray("data", data, null);
+    const compare = cmp(comparator, data);
+    const arr = [];
+    for (const v of data) {
+      arr.push(v ?? null);
+    }
+    arr.sort(compare);
+    return arr;
+  },
+  {
+    summary: "对数组中的元素进行排序，并返回排序后的结果",
+    params: {
+      data: "要排序的数组",
+      comparator: "用于比较两个元素的函数，返回一个数字，表示它们的相对顺序，默认按升序排列"
+    },
+    paramsType: {
+      data: "array",
+      comparator: "fn(a: any, b: any) -> number"
+    },
+    returnsType: "array",
+    examples: ['sort(["c", "a", "b"]) // ["a", "b", "c"]']
+  }
+);
+var sort_by = VmLib(
+  (data, key_fn, comparator) => {
+    expectArray("data", data, null);
+    expectCallable("key_fn", key_fn, data);
+    const compare = cmp(comparator, data);
+    const arr = [];
+    const len2 = data.length;
+    for (let i = 0; i < len2; i++) {
+      const v = data[i] ?? null;
+      arr.push({
+        o: v,
+        k: $Call(key_fn, [v, i, data])
+      });
+    }
+    arr.sort((a, b) => compare(a.k, b.k));
+    return arr.map((e) => e.o);
+  },
+  {
+    summary: "根据键函数对数组中的元素进行排序，并返回排序后的结果",
+    params: {
+      data: "要排序的数组",
+      key_fn: "用于提取排序键的函数，接受一个元素并返回其排序键",
+      comparator: "用于比较两个排序键的函数，返回一个数字，表示它们的相对顺序，默认按升序排列"
+    },
+    paramsType: {
+      data: "array",
+      key_fn: "fn(value: any, index: number, arr: type(data)) -> any",
+      comparator: "fn(a: any, b: any) -> number"
+    },
+    returnsType: "array",
+    examples: ['sort_by([(0, "x"), (2, "y"), (1, "z")], fn (item) { item[0] }) // [(0, "x"), (1, "z"), (2, "y")]']
+  }
+);
+
+// src/vm/lib/global/sequence/repeat.ts
+var repeat = VmLib(
+  (data, times) => {
+    expectConst("data", data, []);
+    required("times", times, []);
+    const n = arrayLen($ToNumber(times));
+    const result = [];
+    result.length = n;
+    result.fill(data);
+    return result;
+  },
+  {
+    summary: "创建一个包含重复元素的数组",
+    params: {
+      data: "要重复的元素",
+      times: "重复的次数，必须是非负整数"
+    },
+    paramsType: {
+      data: "any",
+      times: "number"
+    },
+    returnsType: "type(data)[]",
+    examples: ["repeat(0, 5) // [0, 0, 0, 0, 0]", 'repeat("a", 3) // ["a", "a", "a"]']
+  }
+);
+
+// src/vm/lib/global/debug.ts
+var debug_print = VmLib(
+  (...args) => {
+    console.log("\x1B[46;30m MiraScript \x1B[0m", ...args);
+  },
+  {
+    summary: "打印调试信息到控制台",
+    params: { "..args": "要打印的调试信息，可以是任意类型" },
+    paramsType: { "..args": "any[]" },
+    returnsType: "nil",
+    examples: ['debug_print("value:", 42);']
+  }
+);
+var panic = VmLib(
+  (message) => {
+    if (message === void 0) console.error("\x1B[41;37m MiraScript \x1B[0m");
+    else console.error("\x1B[41;37m MiraScript \x1B[0m", message);
+    const error = message == null ? "panic" : "panic: " + $ToString(message);
+    throw new VmError(error, void 0);
+  },
+  {
+    summary: "产生错误，并打印错误信息到控制台",
+    params: { message: "要打印的错误信息" },
+    paramsType: { message: "string" },
+    returnsType: "never",
+    examples: ['panic("boom");']
+  }
+);
+
+// src/vm/lib/global/json.ts
+var { parse, stringify } = JSON;
+var to_json = VmLib(
+  (data) => {
+    required("data", data, null);
+    if (isVmExtern(data) || isVmModule(data)) {
+      try {
+        return stringify(data.value) ?? null;
+      } catch (ex) {
+        rethrowError("Failed to convert extern to JSON", ex, "{}");
+      }
+    }
+    if (typeof data == "function") return null;
+    return stringify(data);
+  },
+  {
+    summary: "将数据转换为 JSON 字符串",
+    params: { data: "要转换为 JSON 的数据" },
+    paramsType: { data: "any" },
+    returnsType: "string",
+    examples: ['to_json([1, 2, 3]) // "[1,2,3]"']
+  }
+);
+var from_json = VmLib(
+  (json, fallback) => {
+    required("json", json, null);
+    if (typeof json != "string") return json;
+    try {
+      return parse(json);
+    } catch (ex) {
+      if (fallback != null) return fallback;
+      rethrowError("Invalid JSON", ex, null);
+    }
+  },
+  {
+    summary: "将 JSON 字符串转换为数据",
+    params: { json: "要转换的 JSON 字符串", fallback: "如果转换失败，返回的默认值" },
+    paramsType: { json: "string", fallback: "any" },
+    returnsType: "any",
+    examples: [`from_json('{"a":1}') // (a: 1)`]
+  }
+);
+
+// src/vm/lib/global/to-primitive.ts
+var to_string = VmLib(
+  (data) => {
+    required("data", data, "");
+    return $ToString(data);
+  },
+  {
+    summary: "将数据转换为字符串",
+    params: { data: "要转换的数据" },
+    paramsType: { data: "any" },
+    returnsType: "string",
+    examples: ['to_string([1, 2]) // "1, 2"']
+  }
+);
+var to_number = VmLib(
+  (data) => {
+    required("data", data, Number.NaN);
+    return $ToNumber(data);
+  },
+  {
+    summary: "将数据转换为数字",
+    params: { data: "要转换的数据" },
+    paramsType: { data: "any" },
+    returnsType: "number",
+    examples: ['to_number("1.5") // 1.5']
+  }
+);
+var to_boolean = VmLib(
+  (data) => {
+    required("data", data, false);
+    return $ToBoolean(data);
+  },
+  {
+    summary: "将数据转换为布尔值",
+    params: { data: "要转换的数据" },
+    paramsType: { data: "any" },
+    returnsType: "boolean",
+    examples: ["to_boolean(nil) // false"]
+  }
+);
+var format = VmLib(
+  (data, format2) => {
+    required("data", data, "");
+    return $Format(data, format2);
+  },
+  {
+    summary: "将数据格式化为指定格式的字符串",
+    params: { data: "要格式化的数据", format: "格式字符串" },
+    paramsType: { data: "any", format: "string" },
+    returnsType: "string",
+    examples: ['format(12, ".3") // "12.000"']
+  }
+);
+
+// src/vm/lib/global/string.ts
+var chars = VmLib(
+  (str) => {
+    required("str", str, null);
+    return [...$ToString(str)];
+  },
+  {
+    summary: "将字符串转换为字符数组",
+    params: { str: "要转换的字符串" },
+    paramsType: { str: "string" },
+    returnsType: "string[]",
+    examples: ['chars("Mira") // ["M", "i", "r", "a"]']
+  }
+);
+var starts_with = VmLib(
+  (str, search) => {
+    required("str", str, null);
+    required("search", search, null);
+    return $ToString(str).startsWith($ToString(search));
+  },
+  {
+    summary: "检查字符串是否以指定子串开头",
+    params: { str: "要检查的字符串", search: "要匹配的子串" },
+    paramsType: { str: "string", search: "string" },
+    returnsType: "boolean",
+    examples: ['starts_with("mira", "mi") // true']
+  }
+);
+var ends_with = VmLib(
+  (str, search) => {
+    required("str", str, null);
+    required("search", search, null);
+    return $ToString(str).endsWith($ToString(search));
+  },
+  {
+    summary: "检查字符串是否以指定子串结尾",
+    params: { str: "要检查的字符串", search: "要匹配的子串" },
+    paramsType: { str: "string", search: "string" },
+    returnsType: "boolean",
+    examples: ['ends_with("mira", "ra") // true']
+  }
+);
+var contains = VmLib(
+  (str, search) => {
+    required("str", str, null);
+    required("search", search, null);
+    return $ToString(str).includes($ToString(search));
+  },
+  {
+    summary: "检查字符串是否包含指定子串",
+    params: { str: "要检查的字符串", search: "要匹配的子串" },
+    paramsType: { str: "string", search: "string" },
+    returnsType: "boolean",
+    examples: ['contains("hello", "ll") // true']
+  }
+);
+var trim_start = VmLib(
+  (str) => {
+    required("str", str, null);
+    return $ToString(str).trimStart();
+  },
+  {
+    summary: "去除字符串开头的空白字符",
+    params: { str: "要处理的字符串" },
+    paramsType: { str: "string" },
+    returnsType: "string",
+    examples: ['trim_start("  mira") // "mira"']
+  }
+);
+var trim_end = VmLib(
+  (str) => {
+    required("str", str, null);
+    return $ToString(str).trimEnd();
+  },
+  {
+    summary: "去除字符串结尾的空白字符",
+    params: { str: "要处理的字符串" },
+    paramsType: { str: "string" },
+    returnsType: "string",
+    examples: ['trim_end("mira  ") // "mira"']
+  }
+);
+var trim = VmLib(
+  (str) => {
+    required("str", str, null);
+    return $ToString(str).trim();
+  },
+  {
+    summary: "去除字符串两端的空白字符",
+    params: { str: "要处理的字符串" },
+    paramsType: { str: "string" },
+    returnsType: "string",
+    examples: ['trim("  mira  ") // "mira"']
+  }
+);
+var replace = VmLib(
+  (str, search, replacement = "") => {
+    required("str", str, null);
+    required("search", search, str);
+    return $ToString(str).replaceAll($ToString(search), $ToString(replacement));
+  },
+  {
+    summary: "替换字符串中的指定子串",
+    params: { str: "要处理的字符串", search: "要替换的子串", replacement: "替换后的字符串" },
+    paramsType: { str: "string", search: "string", replacement: "string" },
+    returnsType: "string",
+    examples: ['replace("foo bar foo", "foo", "baz") // "baz bar baz"']
+  }
+);
+var split = VmLib(
+  (str, separator = "") => {
+    required("str", str, null);
+    const s = $ToString(str);
+    const p = $ToString(separator);
+    if (!p) return [...s];
+    return s.split(p);
+  },
+  {
+    summary: "将字符串拆分为子串数组",
+    params: { str: "要拆分的字符串", separator: "分隔符" },
+    paramsType: { str: "string", separator: "string" },
+    returnsType: "string[]",
+    examples: ['split("a,b,c", ",") // ["a", "b", "c"]']
+  }
+);
+var join = VmLib(
+  (arr, separator = "") => {
+    expectArray("arr", arr, null);
+    const s = $ToString(separator);
+    return arr.map((v) => $ToString(v)).join(s);
+  },
+  {
+    summary: "将字符串数组连接为单个字符串",
+    params: { arr: "要连接的字符串数组", separator: "分隔符" },
+    paramsType: { arr: "string[]", separator: "string" },
+    returnsType: "string",
+    examples: ['join(["a", "b", "c"], "-") // "a-b-c"']
+  }
+);
+
+// src/vm/lib/global/time.ts
+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);
+  },
+  {
+    summary: "将数据转换为 Unix 毫秒时间戳",
+    params: { datetime: "要转换的数据，默认为当前时间" },
+    paramsType: { datetime: "string | number" },
+    returnsType: "number",
+    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;
+    const dateOffset = new Date(timestamp + o * 1e3 * 60 * 60);
+    return {
+      year: dateOffset.getUTCFullYear(),
+      month: dateOffset.getUTCMonth() + 1,
+      day: dateOffset.getUTCDate(),
+      hour: dateOffset.getUTCHours(),
+      minute: dateOffset.getUTCMinutes(),
+      second: dateOffset.getUTCSeconds(),
+      millisecond: dateOffset.getUTCMilliseconds(),
+      dayOfWeek: dateOffset.getUTCDay(),
+      offset: o
+    };
+  },
+  {
+    summary: "将数据转换为 Date 对象",
+    params: {
+      datetime: "要转换的数据，默认为当前时间",
+      offset: "时区偏移量（单位：小时），默认为 0"
+    },
+    paramsType: { datetime: "string | number", offset: "number" },
+    returnsType: "Date",
+    examples: [
+      "to_datetime(0) // (year: 1970, month: 1, day: 1, hour: 0, minute: 0, second: 0, millisecond: 0, dayOfWeek: 4, offset: 0)"
+    ]
+  }
+);
+var to_iso8601 = VmLib(
+  (datetime) => {
+    const timestamp = to_timestamp(datetime);
+    if (!isFinite(timestamp)) return null;
+    return new Date(timestamp).toISOString();
+  },
+  {
+    summary: "将数据转换为 ISO 8601 格式的字符串",
+    params: { datetime: "要转换的数据，默认为当前时间" },
+    paramsType: { datetime: "string | number" },
+    returnsType: "string",
+    examples: ['to_iso8601(0) // "1970-01-01T00:00:00.000Z"']
+  }
+);
+
+// src/vm/lib/global/mod/matrix.ts
+var matrix_exports = {};
+__export(matrix_exports, {
+  add: () => add,
+  diagonal: () => diagonal,
+  entrywise: () => entrywise,
+  entrywise_divide: () => entrywise_divide,
+  entrywise_multiply: () => entrywise_multiply,
+  identity: () => identity,
+  invert: () => invert,
+  multiply: () => multiply,
+  ones: () => ones,
+  size: () => size,
+  subtract: () => subtract,
+  transpose: () => transpose,
+  zeros: () => zeros
+});
+function sizeImpl(matrix2) {
+  if (!isVmArray(matrix2)) return [];
+  if (matrix2.length === 0) return [0];
+  const numRows = matrix2.length;
+  let numCols = 0;
+  for (const row of matrix2) {
+    if (isVmArray(row)) {
+      numCols = Math.max(numCols, row.length);
+    } else {
+      return [numRows];
+    }
+  }
+  return [numRows, numCols];
+}
+function num(v) {
+  return $ToNumber(v ?? null);
+}
+var size = VmLib(
+  (matrix2) => {
+    required("matrix", matrix2, []);
+    return sizeImpl(matrix2);
+  },
+  {
+    summary: "获取矩阵尺寸",
+    params: { matrix: "要获取尺寸的矩阵" },
+    paramsType: { matrix: "any[][]" },
+    returnsType: "[number, number]",
+    examples: ["matrix.size([[1, 2], [3, 4]]) // [2, 2]"]
+  }
+);
+var transpose = VmLib(
+  (matrix2) => {
+    required("matrix", matrix2, []);
+    const [numRows, numCols] = sizeImpl(matrix2);
+    if (numRows == null || numCols == null) return matrix2;
+    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 item = row?.[j] ?? null;
+        tj[i] = item;
+      }
+      transposed[j] = tj;
+    }
+    return transposed;
+  },
+  {
+    summary: "转置矩阵",
+    params: { matrix: "要转置的矩阵" },
+    paramsType: { matrix: "any[][]" },
+    returnsType: "any[][]",
+    examples: ["matrix.transpose([[1, 2], [3, 4]]) // [[1, 3], [2, 4]]"]
+  }
+);
+function entrywiseImpl(a, b, f, vvf, mmf, vmf, mvf) {
+  let [ar, ac] = sizeImpl(a);
+  let [br, bc] = sizeImpl(b);
+  if (ar == null) {
+    if (br == null) {
+      return f(a, b);
+    } else if (bc == null) {
+      const result2 = [];
+      for (let r = 0; r < br; r++) {
+        const bItem = b[r] ?? null;
+        result2[r] = f(a, bItem);
+      }
+      return result2;
+    } else {
+      const result2 = [];
+      for (let r = 0; r < br; r++) {
+        const bRow = b[r] ?? [];
+        const rRow = [];
+        result2[r] = rRow;
+        for (let c = 0; c < bc; c++) {
+          const bItem = bRow[c] ?? null;
+          rRow[c] = f(a, bItem);
+        }
+      }
+      return result2;
+    }
+  }
+  if (br == null) {
+    if (ac == null) {
+      const result2 = [];
+      for (let r = 0; r < ar; r++) {
+        const aItem = a[r] ?? null;
+        result2[r] = f(aItem, b);
+      }
+      return result2;
+    } else {
+      const result2 = [];
+      for (let r = 0; r < ar; r++) {
+        const aRow = a[r] ?? [];
+        const rRow = [];
+        result2[r] = rRow;
+        for (let c = 0; c < ac; c++) {
+          const aItem = aRow[c] ?? null;
+          rRow[c] = f(aItem, b);
+        }
+      }
+      return result2;
+    }
+  }
+  if (ac == null && bc == null) {
+    if (vvf != null) {
+      return vvf(a, b, ar, br);
+    }
+    const rr2 = Math.max(ar, br);
+    const result2 = [];
+    for (let r = 0; r < rr2; r++) {
+      const aItem = a[r] ?? null;
+      const bItem = b[r] ?? null;
+      result2[r] = f(aItem, bItem);
+    }
+    return result2;
+  }
+  if (ac == null) {
+    if (vmf != null) {
+      return vmf(a, b, ar, br, bc);
+    }
+    ac = ar;
+    ar = 1;
+    a = [a];
+  }
+  if (bc == null) {
+    if (mvf != null) {
+      return mvf(a, b, ar, ac, br);
+    }
+    bc = br;
+    br = 1;
+    b = [b];
+  }
+  if (mmf != null) {
+    return mmf(a, b, ar, ac, br, bc);
+  }
+  const rr = Math.max(ar, br);
+  const rc = Math.max(ac, bc);
+  const result = [];
+  for (let r = 0; r < rr; r++) {
+    const rRow = [];
+    result[r] = rRow;
+    for (let c = 0; c < rc; c++) {
+      const aItem = a[ar === 1 ? 0 : r]?.[ac === 1 ? 0 : c] ?? null;
+      const bItem = b[br === 1 ? 0 : r]?.[bc === 1 ? 0 : c] ?? null;
+      rRow[c] = f(aItem, bItem);
+    }
+  }
+  return result;
+}
+var entrywise = VmLib(
+  (a, b, f) => {
+    expectConst("a", a, null);
+    expectConst("b", b, null);
+    expectCallable("f", f, null);
+    return entrywiseImpl(a, b, (a2, b2) => {
+      Cp();
+      const ret = $Call(f, [a2, b2]);
+      if (!isVmConst(ret)) return null;
+      return ret;
+    });
+  },
+  {
+    summary: "逐项操作",
+    params: { a: "第一个操作数", b: "第二个操作数", f: "操作函数" },
+    paramsType: { a: "any | any[] | any[][]", b: "any | any[] | any[][]", f: "fn(a: any, b: any) -> any" },
+    returnsType: "any | any[] | any[][]",
+    examples: [`matrix.entrywise([1, 2], [3, 4], fn (x, y) { x + y }) // [4, 6]`]
+  }
+);
+var add = VmLib(
+  (a, b) => {
+    expectConst("a", a, null);
+    expectConst("b", b, null);
+    return entrywiseImpl(a, b, $Add);
+  },
+  {
+    summary: "逐项相加",
+    params: { a: "第一个操作数", b: "第二个操作数" },
+    paramsType: { a: "number | number[] | number[][]", b: "number | number[] | number[][]" },
+    returnsType: "number | number[] | number[][]",
+    examples: ["matrix.add([1, 2], [3, 4]) // [4, 6]"]
+  }
+);
+var subtract = VmLib(
+  (a, b) => {
+    expectConst("a", a, null);
+    expectConst("b", b, null);
+    return entrywiseImpl(a, b, $Sub);
+  },
+  {
+    summary: "逐项相减",
+    params: { a: "第一个操作数", b: "第二个操作数" },
+    paramsType: { a: "number | number[] | number[][]", b: "number | number[] | number[][]" },
+    returnsType: "number | number[] | number[][]",
+    examples: ["matrix.subtract([3, 4], [1, 2]) // [2, 2]"]
+  }
+);
+var entrywise_multiply = VmLib(
+  (a, b) => {
+    expectConst("a", a, null);
+    expectConst("b", b, null);
+    return entrywiseImpl(a, b, $Mul);
+  },
+  {
+    summary: "逐项相乘",
+    params: { a: "第一个操作数", b: "第二个操作数" },
+    paramsType: { a: "number | number[] | number[][]", b: "number | number[] | number[][]" },
+    returnsType: "number | number[] | number[][]",
+    examples: ["matrix.entrywise_multiply([1, 2], [3, 4]) // [3, 8]"]
+  }
+);
+var entrywise_divide = VmLib(
+  (a, b) => {
+    expectConst("a", a, null);
+    expectConst("b", b, null);
+    return entrywiseImpl(a, b, $Div);
+  },
+  {
+    summary: "逐项相除",
+    params: { a: "第一个操作数", b: "第二个操作数" },
+    paramsType: { a: "number | number[] | number[][]", b: "number | number[] | number[][]" },
+    returnsType: "number | number[] | number[][]",
+    examples: ["matrix.entrywise_divide([4, 6], [2, 3]) // [2, 2]"]
+  }
+);
+var multiply = VmLib(
+  (a, b) => {
+    expectConst("a", a, null);
+    expectConst("b", b, null);
+    return entrywiseImpl(
+      a,
+      b,
+      $Mul,
+      (a2, b2, al, bl) => {
+        const l = Math.max(al, bl);
+        let s = 0;
+        for (let i = 0; i < l; i++) {
+          s += num(a2[i]) * num(b2[i]);
+        }
+        return s;
+      },
+      (a2, b2, ar, ac, br, bc) => {
+        if (ac !== br) throwError(`Incompatible matrix dimensions`, null);
+        const result = [];
+        for (let r = 0; r < ar; r++) {
+          const rRow = [];
+          result[r] = rRow;
+          for (let c = 0; c < bc; c++) {
+            let item = 0;
+            for (let k = 0; k < ac; k++) {
+              item += num(a2[r]?.[k]) * num(b2[k]?.[c]);
+            }
+            rRow[c] = item;
+          }
+        }
+        return result;
+      },
+      (a2, b2, al, br, bc) => {
+        if (al !== br) throwError(`Incompatible matrix dimensions`, null);
+        const result = [];
+        for (let c = 0; c < bc; c++) {
+          let item = 0;
+          for (let k = 0; k < al; k++) {
+            item += num(a2[k]) * num(b2[k]?.[c]);
+          }
+          result[c] = item;
+        }
+        return result;
+      },
+      (a2, b2, ar, ac, bl) => {
+        if (ac !== bl) throwError(`Incompatible matrix dimensions`, null);
+        const result = [];
+        for (let r = 0; r < ar; r++) {
+          let item = 0;
+          for (let k = 0; k < ac; k++) {
+            item += num(a2[r]?.[k]) * num(b2[k]);
+          }
+          result[r] = item;
+        }
+        return result;
+      }
+    );
+  },
+  {
+    summary: "矩阵相乘",
+    params: { a: "第一个操作数", b: "第二个操作数" },
+    paramsType: { a: "number | number[] | number[][]", b: "number | number[] | number[][]" },
+    returnsType: "number | number[] | number[][]",
+    examples: ["matrix.multiply([[1, 2], [3, 4]], [5, 6]) // [17, 39]"]
+  }
+);
+var invert = VmLib(
+  (a) => {
+    expectConst("a", a, null);
+    const [rows, cols] = sizeImpl(a);
+    if (rows == null) return 1 / num(a);
+    if (cols == null) return map(a, (v) => 1 / num(v));
+    if (rows !== cols) throwError(`Matrix must be square`, a);
+    const m = a;
+    if (rows === 1) {
+      const e = num(m[0]?.[0]);
+      return [[1 / e]];
+    }
+    if (rows === 2) {
+      const a2 = num(m[0]?.[0]);
+      const b = num(m[0]?.[1]);
+      const c = num(m[1]?.[0]);
+      const d = num(m[1]?.[1]);
+      const det = a2 * d - b * c;
+      return [
+        [d / det, -b / det],
+        [-c / det, a2 / det]
+      ];
+    }
+    const A = [];
+    const B = [];
+    for (let r = 0; r < rows; r++) {
+      const Ar = [];
+      const Br = [];
+      A[r] = Ar;
+      B[r] = Br;
+      for (let c = 0; c < cols; c++) {
+        Ar[c] = num(m[r]?.[c]);
+        Br[c] = r === c ? 1 : 0;
+      }
+    }
+    for (let c = 0; c < cols; c++) {
+      let ABig = Math.abs(A[c][c]);
+      let rBig = c;
+      let r = c + 1;
+      while (r < rows) {
+        if (Math.abs(A[r][c]) > ABig) {
+          ABig = Math.abs(A[r][c]);
+          rBig = r;
+        }
+        r++;
+      }
+      r = rBig;
+      if (r !== c) {
+        const temp1 = A[c];
+        A[c] = A[r];
+        A[r] = temp1;
+        const temp2 = B[c];
+        B[c] = B[r];
+        B[r] = temp2;
+      }
+      const Ac = A[c];
+      const Bc = B[c];
+      for (r = 0; r < rows; r++) {
+        const Ar = A[r];
+        const Br = B[r];
+        if (r !== c) {
+          if (Ar[c] !== 0) {
+            const f = -Ar[c] / Ac[c];
+            for (let s = c; s < cols; s++) {
+              Ar[s] = Ar[s] + f * Ac[s];
+            }
+            for (let s = 0; s < cols; s++) {
+              Br[s] = Br[s] + f * Bc[s];
+            }
+          }
+        } else {
+          const f = Ac[c];
+          for (let s = c; s < cols; s++) {
+            Ar[s] = Ar[s] / f;
+          }
+          for (let s = 0; s < cols; s++) {
+            Br[s] = Br[s] / f;
+          }
+        }
+      }
+    }
+    return B;
+  },
+  {
+    summary: "矩阵求逆",
+    params: { a: "待求逆的矩阵" },
+    paramsType: { a: "number | number[][]" },
+    returnsType: "number | number[][]",
+    examples: ["matrix.invert([[1, 2], [3, 4]]) // [[-2, 1], [1.5, -0.5]]"]
+  }
+);
+function filled(size2, value) {
+  const s = getNumbers(size2);
+  if (s.length === 0) return [];
+  while (s.length > 0) {
+    const repeat2 = arrayLen(s.pop());
+    Cp();
+    const data = [];
+    data.length = repeat2;
+    data.fill(value);
+    value = data;
+  }
+  return value;
+}
+var zeros = VmLib((...size2) => filled(size2, 0), {
+  summary: "创建一个全零的矩阵",
+  params: { "..size": "矩阵的维度" },
+  paramsType: { "..size": "number[]" },
+  returnsType: "number[][]",
+  examples: ["matrix.zeros(2, 3) // [[0, 0, 0], [0, 0, 0]]"]
+});
+var ones = VmLib((...size2) => filled(size2, 1), {
+  summary: "创建一个全一的矩阵",
+  params: { "..size": "矩阵的维度" },
+  paramsType: { "..size": "number[]" },
+  returnsType: "number[][]",
+  examples: ["matrix.ones(2, 2) // [[1, 1], [1, 1]]"]
+});
+var identity = VmLib(
+  (...size2) => {
+    let s = getNumbers(size2);
+    if (s.length === 0) return [];
+    if (s.length > 2) throwError("Invalid matrix size", []);
+    if (s.length === 1) s = [s[0], s[0]];
+    const m = arrayLen(s[0]);
+    const n = arrayLen(s[1]);
+    const ret = [];
+    for (let i = 0; i < m; i++) {
+      const row = [];
+      ret[i] = row;
+      row.length = n;
+      row.fill(0);
+      if (i < n) row[i] = 1;
+    }
+    return ret;
+  },
+  {
+    summary: "创建一个单位矩阵",
+    params: { "..size": "矩阵的维度" },
+    paramsType: { "..size": "[number] | [number, number]" },
+    returnsType: "number[][]",
+    examples: ["matrix.identity(3) // [[1, 0, 0], [0, 1, 0], [0, 0, 1]]"]
+  }
+);
+var diagonal = VmLib(
+  (x, k = 0) => {
+    expectArray("x", x, []);
+    const fk = Math.round($ToNumber(k) || 0);
+    if (x.every((e) => isArray(e))) {
+      const diag = [];
+      for (let i = 0; i < x.length; i++) {
+        const row = x[i];
+        const r = i + fk;
+        if (r < 0) continue;
+        if (!row || r >= row.length) break;
+        diag.push(row[r] ?? null);
+      }
+      return diag;
+    }
+    const l = x.length;
+    const m = arrayLen(fk < 0 ? l - fk : l);
+    const n = arrayLen(fk > 0 ? l + fk : l);
+    const result = [];
+    for (let i = 0; i < m; i++) {
+      const row = [];
+      result[i] = row;
+      row.length = n;
+      row.fill(0);
+      for (let j = 0; j < n; j++) {
+        if (i + fk === j) {
+          row[j] = x[fk >= 0 ? i : j] ?? null;
+        }
+      }
+    }
+    return result;
+  },
+  {
+    summary: "创建一个对角矩阵或获取矩阵的对角线",
+    params: { x: "对角线元素或要获取对角线的矩阵", k: "对角线偏移量，默认为 0" },
+    paramsType: { x: "number[] | number[][]", k: "number" },
+    returnsType: "number[][] | number[]",
+    examples: [
+      "matrix.diagonal([1, 2, 3]) // [[1, 0, 0], [0, 2, 0], [0, 0, 3]]",
+      "matrix.diagonal([[1, 2], [3, 4]]) // [1, 4]"
+    ]
+  }
+);
+
+// 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);
+}
+function wrapEntry(name, value) {
+  if (typeof value == "function") {
+    if (value.name !== name) {
+      defineProperty(value, "name", {
+        value: name,
+        configurable: true
+      });
+    }
+    return VmFunction(value, {
+      isLib: true,
+      injectCp: true,
+      fullName: `global.${name}`,
+      ...value
+    });
+  } else {
+    return value;
+  }
+}
+function createModule(name, lib2) {
+  const mod = create(null);
+  for (const [key, value] of entries(lib2)) {
+    mod[key] = wrapEntry(key, value);
+  }
+  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 getSerializeOptions(options) {
+  if (options == null) return DEFAULT_OPTIONS;
+  const opt = { ...DEFAULT_OPTIONS };
+  for (const key in options) {
+    const el = options[key];
+    if (el != null) {
+      opt[key] = el;
+    }
+  }
+  return Object.freeze(opt);
+}
+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 serializePropNameImpl(value, options) {
+  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 serializePropName(value, options) {
+  return serializePropNameImpl(value, 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 `(${serializePropNameImpl(k, options)}: ${serializeImpl(v, depth, options)})`;
+  }
+  const omitKey = e.length < 10 && e.every(([key], index) => key === String(index));
+  let str = "(";
+  for (const [key, val] of e) {
+    if (str.length > 1) str += ", ";
+    if (omitKey) {
+      str += serializeImpl(val, depth, options);
+    } else {
+      str += `${serializePropNameImpl(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/diagnostic.ts
+import { DiagnosticCode, wasm } from "@mirascript/wasm";
+var diagnosticMessages = /* @__PURE__ */ new Map();
+function getDiagnosticMessage(code) {
+  if (!isSafeInteger(code) || code < 0 || code >= 65535) {
+    throw new RangeError(`Invalid DiagnosticCode: ${code}`);
+  }
+  if (diagnosticMessages.has(code)) {
+    return diagnosticMessages.get(code);
+  }
+  const msg = wasm.get_diagnostic_message(code);
+  diagnosticMessages.set(code, msg);
+  return msg;
+}
+function parseDiagnostics(source, diagnostics) {
+  const parsed = [];
+  const bufLen = diagnostics.length;
+  for (let i = 0; i < bufLen; i += 5) {
+    const startLineNumber = diagnostics[i];
+    const startColumn = diagnostics[i + 1];
+    const endLineNumber = diagnostics[i + 2];
+    const endColumn = diagnostics[i + 3];
+    const error = diagnostics[i + 4];
+    parsed.push({
+      code: error,
+      range: {
+        startLineNumber,
+        startColumn,
+        endLineNumber,
+        endColumn
+      }
+    });
+  }
+  const _errors = [];
+  const _warnings = [];
+  const _infos = [];
+  const _hints = [];
+  const _tags = [];
+  const _references = [];
+  const _tagsReferences = [];
+  for (let i = 0; i < parsed.length; i++) {
+    const diagnostic = parsed[i];
+    const { code } = diagnostic;
+    if (code > DiagnosticCode.ErrorStart && code < DiagnosticCode.ErrorEnd) {
+      _errors.push(diagnostic);
+    } else if (code > DiagnosticCode.WarningStart && code < DiagnosticCode.WarningEnd) {
+      _warnings.push(diagnostic);
+    } else if (code > DiagnosticCode.InfoStart && code < DiagnosticCode.InfoEnd) {
+      _infos.push(diagnostic);
+    } else if (code > DiagnosticCode.HintStart && code < DiagnosticCode.HintEnd) {
+      _hints.push(diagnostic);
+    } else if (code > DiagnosticCode.TagStart && code < DiagnosticCode.TagEnd) {
+      _tags.push(diagnostic);
+    } else {
+      continue;
+    }
+    diagnostic.references = [];
+    while (i + 1 < parsed.length) {
+      const ref = parsed[i + 1];
+      let isRef = false;
+      if (ref.code > DiagnosticCode.TagRefStart && ref.code < DiagnosticCode.TagRefEnd) {
+        isRef = true;
+        _tagsReferences.push(ref);
+      }
+      if (ref.code > DiagnosticCode.ReferenceStart && ref.code < DiagnosticCode.ReferenceEnd) {
+        isRef = true;
+        _references.push(ref);
+      }
+      if (!isRef) {
+        break;
+      }
+      i++;
+      ref.diagnostic = diagnostic;
+      diagnostic.references.push(ref);
+    }
+  }
+  return {
+    errors: _errors,
+    warnings: _warnings,
+    infos: _infos,
+    hints: _hints,
+    tags: _tags,
+    references: _references,
+    tagsReferences: _tagsReferences
+  };
+}
+function formatRange(range) {
+  if (range.startLineNumber === range.endLineNumber) {
+    if (range.startColumn === range.endColumn) {
+      return `${range.startLineNumber}:${range.startColumn}`;
+    }
+    return `${range.startLineNumber}:${range.startColumn}-${range.endColumn}`;
+  }
+  return `${range.startLineNumber}:${range.startColumn}-${range.endLineNumber}:${range.endColumn}`;
+}
+function formatDiagnostic(diagnostic) {
+  const range = formatRange(diagnostic.range);
+  const codeName = DiagnosticCode[diagnostic.code] || `Unknown(${diagnostic.code})`;
+  let message = getDiagnosticMessage(diagnostic.code);
+  for (const ref of diagnostic.references) {
+    const refRange = formatRange(ref.range);
+    message += `
+    (${refRange}): ${getDiagnosticMessage(ref.code)}`;
+  }
+  return `  ${codeName}(${range}): ${message}`;
+}
+
+export {
+  isFinite,
+  entries,
+  defineProperty,
+  VmError,
+  operations_exports,
+  VmSharedContext,
+  defineVmContextValue,
+  DefaultVmContext,
+  createVmContext,
+  isVmContext,
+  configCheckpoint,
+  GlobalFallback,
+  helpers_exports,
+  isVmFunction,
+  getVmFunctionInfo,
+  VmFunction,
+  wrapToVmValue,
+  unwrapFromVmValue,
+  VmExtern,
+  VmModule,
+  isVmScript,
+  isVmConst,
+  isVmImmutable,
+  isVmValue,
+  isVmAny,
+  isVmArray,
+  isVmRecord,
+  isVmPrimitive,
+  isVmExtern,
+  isVmModule,
+  VM_ARRAY_MAX_LENGTH,
+  constants_exports,
+  DiagnosticCode,
+  getDiagnosticMessage,
+  parseDiagnostics,
+  formatDiagnostic,
+  debug_print,
+  lib,
+  serializeString,
+  serializePropName,
+  serialize
+};
+//# sourceMappingURL=chunk-DCXIWIW5.js.map