@mirascript/mirascript 0.1.62-alpha.7 → 0.1.62-alpha.8

package/dist/chunk-6CAGNGY6.js

@@ -0,0 +1,3980 @@
+import {
+  DiagnosticCode,
+  NegativeInfinity,
+  NotNumber,
+  PositiveInfinity,
+  VM_ARRAY_MAX_LENGTH,
+  VM_FUNCTION_ANONYMOUS_NAME,
+  VM_SCRIPT_NAME,
+  VmError,
+  __export,
+  apply,
+  create,
+  defineProperty,
+  display,
+  emit,
+  entries,
+  formatDiagnostics,
+  fromEntries,
+  getOwnPropertyNames,
+  getPrototypeOf,
+  hasOwn,
+  hasOwnEnumerable,
+  innerToString,
+  isArray,
+  isFinite,
+  isInteger,
+  isNaN,
+  isSafeInteger,
+  isVmArray,
+  isVmCallable,
+  isVmConst,
+  isVmExtern,
+  isVmFunction,
+  isVmModule,
+  isVmPrimitive,
+  isVmRecord,
+  isVmWrapper,
+  kVmContext,
+  kVmExtern,
+  kVmFunction,
+  kVmFunctionProxy,
+  kVmModule,
+  kVmScript,
+  kVmWrapper,
+  keys,
+  parseDiagnostics,
+  toString,
+  values
+} from "./chunk-VRGQ23AK.js";
+
+// src/compiler/load-module.ts
+import { loadModule } from "@mirascript/bindings";
+await loadModule();
+
+// src/helpers/convert/index.ts
+var convert_exports = {};
+__export(convert_exports, {
+  toBoolean: () => toBoolean,
+  toFormat: () => toFormat,
+  toNumber: () => toNumber,
+  toString: () => toString
+});
+
+// src/helpers/convert/to-number.ts
+function parseNumericLiteral(value) {
+  if (value === "") return null;
+  const ch0 = value.charAt(0);
+  if (ch0 < "0" || ch0 > "9") {
+    return null;
+  }
+  if (/^0[bB][01]+$/.test(value)) {
+    const num2 = Number.parseInt(value.slice(2), 2);
+    return isNaN(num2) ? null : num2;
+  }
+  if (/^0[oO][0-7]+$/.test(value)) {
+    const num2 = Number.parseInt(value.slice(2), 8);
+    return isNaN(num2) ? null : num2;
+  }
+  if (/^0[xX][0-9a-fA-F]+$/.test(value)) {
+    const num2 = Number.parseInt(value.slice(2), 16);
+    return isNaN(num2) ? null : num2;
+  }
+  if (/^[0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?$/.test(value)) {
+    const num2 = Number.parseFloat(value);
+    return isNaN(num2) ? null : num2;
+  }
+  return null;
+}
+function stringToNumber(value) {
+  value = value.trim();
+  if (value === "") return null;
+  if (value === "inf" || value === "+inf" || value === "Infinity" || value === "+Infinity") {
+    return PositiveInfinity;
+  }
+  if (value === "-inf" || value === "-Infinity") {
+    return NegativeInfinity;
+  }
+  if (value === "nan" || value === "NaN") {
+    return NotNumber;
+  }
+  if (value.startsWith("-")) {
+    const num2 = parseNumericLiteral(value.slice(1));
+    if (num2 !== null) return -num2;
+    return null;
+  } else if (value.startsWith("+")) {
+    return parseNumericLiteral(value.slice(1));
+  } else {
+    return parseNumericLiteral(value);
+  }
+}
+function toNumber(value, fallback) {
+  if (typeof value === "number") return value;
+  if (typeof value == "boolean") return value ? 1 : 0;
+  if (typeof value == "string") {
+    const num2 = stringToNumber(value);
+    if (num2 !== null) return num2;
+  }
+  if (fallback === void 0) {
+    throw new VmError(`Failed to convert value to number: ${display(value)}`, NotNumber);
+  }
+  return fallback;
+}
+
+// src/helpers/convert/to-format.ts
+function formatNumber(finite) {
+  if (finite === 0) return "0";
+  const s2 = finite.toString();
+  let ps;
+  const abs3 = Math.abs(finite);
+  if (abs3 >= 1e3 || abs3 < 1e-3) {
+    const ps1 = finite.toExponential();
+    const ps2 = finite.toExponential(5);
+    ps = ps1.length < ps2.length ? ps1 : ps2;
+  } else {
+    ps = finite.toPrecision(6);
+  }
+  return ps.length < s2.length ? ps : s2;
+}
+function toFormat(value, format2) {
+  const f = format2 == null ? "" : format2.trim();
+  if (typeof value == "number") {
+    if (!isFinite(value)) {
+      return toString(value, void 0);
+    }
+    if (/^\.\d+$/.test(f)) {
+      let digits = Math.trunc(Number(f.slice(1)));
+      if (!(digits <= 100)) digits = 100;
+      return value.toFixed(digits);
+    } else {
+      return formatNumber(value);
+    }
+  }
+  return toString(value, void 0);
+}
+
+// src/helpers/convert/to-boolean.ts
+function toBoolean(value, fallback) {
+  if (typeof value === "boolean") return value;
+  if (fallback === void 0) {
+    throw new VmError(`Failed to convert value to boolean: ${display(value)}`, false);
+  }
+  return fallback;
+}
+
+// src/vm/types/wrapper.ts
+var VmWrapper = class {
+  constructor(value) {
+    this.value = value;
+  }
+  /** 描述键对应的值 */
+  describe(key) {
+    return void 0;
+  }
+  /** 转为字符串 */
+  toString(useBraces) {
+    const { type, tag } = this;
+    if (!tag) return `<${type}>`;
+    return `<${type} ${tag}>`;
+  }
+};
+Object.defineProperty(VmWrapper.prototype, kVmWrapper, { value: true });
+
+// src/vm/operations/common.ts
+function $AssertInit(value) {
+  if (value === void 0) throw new VmError(`Uninitialized value`, null);
+}
+
+// src/vm/operations/call.ts
+function $Call(func, args) {
+  for (const a of args) {
+    $AssertInit(a);
+  }
+  if (isVmExtern(func)) {
+    return func.call(args) ?? null;
+  }
+  if (isVmFunction(func)) {
+    return func(...args) ?? null;
+  }
+  throw new VmError(`Value is not callable: ${display(func)}`, null);
+}
+function $VArgs(varags) {
+  for (let i = 0, l = varags.length; i < l; i++) {
+    const el = varags[i];
+    if (!isVmConst(el)) {
+      varags[i] = null;
+    }
+  }
+  return varags;
+}
+
+// src/vm/types/boundary.ts
+function toVmFunctionProxy(fn) {
+  const cached = fn[kVmFunctionProxy];
+  if (cached != null) return cached;
+  const proxy = (...args) => {
+    const ret = $Call(
+      fn,
+      // 作为函数参数传入的值一定丢失了它的 this
+      args.map((v) => wrapToVmValue(v, null, null))
+    );
+    return unwrapFromVmValue(ret, true);
+  };
+  defineProperty(fn, kVmFunctionProxy, { value: proxy });
+  defineProperty(proxy, kVmFunctionProxy, { value: fn });
+  defineProperty(proxy, "name", {
+    value: fn.name,
+    configurable: true
+  });
+  return proxy;
+}
+function fromVmFunctionProxy(fn) {
+  if (isVmFunction(fn)) return fn;
+  const original = fn[kVmFunctionProxy];
+  if (original && isVmFunction(original)) return original;
+  return null;
+}
+function wrapToVmConst(value, assumeVmValue = null) {
+  if (value == null) return null;
+  switch (typeof value) {
+    case "function":
+      return null;
+    case "object": {
+      if (isVmWrapper(value)) return null;
+      if (value instanceof Date) return value.valueOf();
+      if (assumeVmValue?.(value)) return value;
+      return null;
+    }
+    case "string":
+    case "number":
+    case "boolean":
+      return value;
+    case "bigint":
+      return Number(value);
+    case "symbol":
+    case "undefined":
+    default:
+      return null;
+  }
+}
+function wrapToVmValue(value, thisArg = null, assumeVmValue = null) {
+  if (value == null) return null;
+  if (typeof value == "function") {
+    const unwrapped = fromVmFunctionProxy(value);
+    if (unwrapped != null) return unwrapped;
+    return new VmExtern(value, thisArg);
+  }
+  const constValue = wrapToVmConst(value, assumeVmValue);
+  if (constValue != null) return constValue;
+  if (typeof value == "object") {
+    if (isVmWrapper(value)) return value;
+    return new VmExtern(value);
+  }
+  return null;
+}
+function bindThis(fn, thisArg) {
+  if (thisArg == null) return fn;
+  return new Proxy(fn, {
+    apply(target, _thisArg, args) {
+      return apply(target, thisArg, args);
+    }
+  });
+}
+function unwrapFromVmValue(value, bindThisArg = true) {
+  if (isVmFunction(value)) {
+    return toVmFunctionProxy(value);
+  }
+  if (value == null || typeof value != "object") return value;
+  if (!isVmExtern(value)) return value;
+  if (value.thisArg == null || typeof value.value != "function") {
+    return value.value;
+  }
+  const f = value;
+  return bindThisArg ? bindThis(f.value, f.thisArg) : f.value;
+}
+
+// src/vm/types/extern.ts
+var ObjectPrototype = Object.prototype;
+var ObjectToString = ObjectPrototype.toString;
+var FunctionToString = Function.prototype.toString;
+var ArrayToString = Array.prototype.toString;
+var ArrayMap = Array.prototype.map;
+var TypedArrayToString = Uint8Array.prototype.toString;
+function classNameOf(kls) {
+  const { displayName } = kls;
+  if (typeof displayName === "string" && displayName.trim()) {
+    return displayName.trim();
+  }
+  const { name } = kls;
+  if (typeof name == "string" && name.length > 2) {
+    return name;
+  }
+  return null;
+}
+var VmExtern = class extends VmWrapper {
+  constructor(value, thisArg = null) {
+    super(value);
+    this.thisArg = thisArg;
+  }
+  /**
+   * Check if the object has a property
+   * This method will be used in {@link get}, {@link set}, {@link has}, and {@link keys} methods
+   */
+  access(key, read) {
+    if (key.startsWith("_")) return false;
+    if (typeof this.value == "function" && (key === "prototype" || key === "arguments" || key === "caller"))
+      return false;
+    if (hasOwn(this.value, key)) return true;
+    if (!read) return true;
+    if (!(key in this.value)) return false;
+    if (key === "constructor") return false;
+    const prop = this.value[key];
+    if (key in Function.prototype && prop === Function.prototype[key]) return false;
+    if (key in Array.prototype && prop === Array.prototype[key]) return false;
+    if (key in Object.prototype && prop === Object.prototype[key]) return false;
+    return true;
+  }
+  /** 决定是否对属性进行包装 */
+  assumeVmValue(value, key) {
+    return false;
+  }
+  /** @inheritdoc */
+  has(key) {
+    return this.access(key, true);
+  }
+  /** @inheritdoc */
+  get(key) {
+    if (!(key in this.value)) return void 0;
+    if (!this.access(key, true)) return void 0;
+    const prop = this.value[key];
+    return wrapToVmValue(prop, this.value, (v) => this.assumeVmValue(v, key));
+  }
+  /** Set a property on the object */
+  set(key, value) {
+    if (!this.access(key, false)) return false;
+    const prop = unwrapFromVmValue(value, true);
+    this.value[key] = prop;
+    return true;
+  }
+  /** Call extern value */
+  call(args) {
+    const { value } = this;
+    if (typeof value != "function") {
+      throw VmError.from(`Not a callable extern`, null, null);
+    }
+    const caller = this.thisArg;
+    const unwrappedArgs = args.map((arg) => unwrapFromVmValue(arg, true));
+    let ret;
+    try {
+      ret = apply(value, caller, unwrappedArgs);
+    } catch (ex) {
+      throw VmError.from(`Callable extern`, ex, null);
+    }
+    return wrapToVmValue(ret, null, (obj) => this.assumeVmValue(obj, void 0));
+  }
+  /** @inheritdoc */
+  keys(includeNonEnumerable = false) {
+    if (!includeNonEnumerable) {
+      const keys4 = [];
+      for (const key in this.value) {
+        if (this.access(key, true)) keys4.push(key);
+      }
+      return keys4;
+    } else {
+      const keys4 = /* @__PURE__ */ new Set();
+      let e2 = this.value;
+      while (e2 != null && (typeof e2 == "object" || typeof e2 == "function")) {
+        for (const key of getOwnPropertyNames(e2)) {
+          keys4.add(key);
+        }
+        e2 = getPrototypeOf(e2);
+      }
+      return Array.from(keys4).filter((key) => this.access(key, true));
+    }
+  }
+  /** @inheritdoc */
+  same(other) {
+    if (!isVmExtern(other)) return false;
+    return this.value === other.value && this.thisArg === other.thisArg;
+  }
+  /**
+   * Should this extern be treated as array-like?
+   *
+   * By default, this method returns true if the wrapped value is an Array or a TypedArray.
+   */
+  isArrayLike() {
+    return isArray(this.value) || ArrayBuffer.isView(this.value) && "length" in this.value;
+  }
+  /** @inheritdoc */
+  toString(useBraces) {
+    const { toString: toString2 } = this.value;
+    if (typeof toString2 != "function" || toString2 === ObjectToString || toString2 === FunctionToString) {
+      return super.toString(useBraces);
+    }
+    if ((toString2 === ArrayToString || toString2 === TypedArrayToString) && this.isArrayLike()) {
+      const mapped = ArrayMap.call(this.value, (item) => {
+        if (item === void 0) return "";
+        return innerToString(wrapToVmValue(item ?? null, null, null), true);
+      });
+      const str = mapped.join(", ");
+      if (useBraces) return `[${str}]`;
+      return str;
+    }
+    return String(this.value);
+  }
+  /** @inheritdoc */
+  get type() {
+    return "extern";
+  }
+  /** @inheritdoc */
+  get tag() {
+    const tag = ObjectToString.call(this.value).slice(8, -1);
+    if (this.isArrayLike()) {
+      return `${tag}(${this.value.length})`;
+    } else if (tag === "Object") {
+      const proto = getPrototypeOf(this.value);
+      if (proto === ObjectPrototype) {
+        return "Object";
+      }
+      if (proto == null) {
+        return "Object: null prototype";
+      }
+      if (typeof proto.constructor === "function") {
+        return classNameOf(proto.constructor) ?? "Object";
+      }
+    } else if (tag === "Function" && "prototype" in this.value && typeof this.value.prototype == "object") {
+      const className = classNameOf(this.value);
+      if (!className) return `class`;
+      return `class ${className}`;
+    } else if (tag === "Function") {
+      return `function`;
+    } else if (tag === "AsyncFunction") {
+      return `async function`;
+    } else if (tag === "GeneratorFunction") {
+      return `function*`;
+    } else if (tag === "AsyncGeneratorFunction") {
+      return `async function*`;
+    }
+    return tag;
+  }
+};
+Object.defineProperty(VmExtern.prototype, kVmExtern, { value: true });
+
+// src/vm/checkpoint.ts
+var { now } = Date;
+var TIME_ORIGIN = now() - 1e3 * 3600 * 12;
+var timestamp = () => now() - TIME_ORIGIN | 0;
+var CP_DEFAULT_INTERVAL = 100;
+var MAX_DEPTH = 128;
+var CP_UNSET = -1;
+var CP_DEFAULT_TIMEOUT = 100;
+var cpTimeout = CP_DEFAULT_TIMEOUT | 0;
+var cpInterval = CP_DEFAULT_INTERVAL | 0;
+var cpDepth = 0;
+var cp = CP_UNSET | 0;
+var cpCounter = 0;
+function Cp() {
+  if ((cpCounter = cpCounter + 1 | 0) % (cpInterval | 0) !== 0) {
+    return;
+  }
+  cpCounter = 0;
+  if ((cp | 0) === (CP_UNSET | 0)) {
+    cp = timestamp() | 0;
+  } else if ((timestamp() | 0) - (cp | 0) >= (cpTimeout | 0)) {
+    throw new RangeError("Execution timed out");
+  }
+}
+function CpEnter() {
+  cpDepth = (cpDepth | 0) + 1;
+  if ((cpDepth | 0) <= 1) {
+    cp = CP_UNSET | 0;
+    cpCounter = 0;
+    cpDepth = 1;
+  } else if ((cpDepth | 0) > MAX_DEPTH) {
+    throw new RangeError("Maximum call depth exceeded");
+  } else {
+    Cp();
+  }
+}
+function CpExit() {
+  cpDepth = (cpDepth | 0) - 1;
+  if ((cpDepth | 0) < 1) {
+    cp = CP_UNSET | 0;
+    cpCounter = 0;
+    cpDepth = 0;
+  } else {
+    Cp();
+  }
+}
+var INT_MAX = 2147483647;
+function configCheckpoint(timeout = CP_DEFAULT_TIMEOUT, checkInterval = CP_DEFAULT_INTERVAL) {
+  if (typeof timeout !== "number" || timeout <= 0 || isNaN(timeout)) {
+    throw new RangeError("Invalid timeout value");
+  } else if (timeout > INT_MAX) {
+    timeout = INT_MAX;
+  }
+  if (typeof checkInterval !== "number" || checkInterval <= 0 || isNaN(checkInterval)) {
+    throw new RangeError("Invalid check interval value");
+  } else if (checkInterval > INT_MAX) {
+    checkInterval = INT_MAX;
+  }
+  cpTimeout = timeout | 0;
+  cpInterval = checkInterval | 0;
+}
+
+// src/vm/types/function.ts
+var nameIfNotAnonymous = ({ name }, fallback) => {
+  if (!name) return fallback;
+  if (name === VM_FUNCTION_ANONYMOUS_NAME) return fallback;
+  return name;
+};
+function VmFunction(fn, option = {}) {
+  if (typeof fn != "function") {
+    throw new TypeError("Invalid function");
+  }
+  const exists = fromVmFunctionProxy(fn);
+  if (exists) return exists;
+  let opt;
+  if (isVmFunction(option)) {
+    opt = { ...option[kVmFunction], name: nameIfNotAnonymous(option, null) };
+  } else if (typeof option == "function") {
+    opt = {
+      ...option,
+      isLib: true,
+      injectCp: false,
+      name: nameIfNotAnonymous(option, null)
+    };
+  } else {
+    opt = option;
+  }
+  const info = {
+    __proto__: null,
+    fullName: opt.fullName ?? nameIfNotAnonymous(fn, ""),
+    isLib: opt.isLib ?? false,
+    summary: opt.summary || void 0,
+    params: opt.params,
+    paramsType: opt.paramsType,
+    returns: opt.returns || void 0,
+    returnsType: opt.returnsType || void 0,
+    examples: opt.examples?.length ? opt.examples : void 0,
+    deprecated: opt.deprecated ?? void 0
+  };
+  const name = opt.name ?? fn.name;
+  if (opt.injectCp) {
+    const original = fn;
+    info.original = original;
+    fn = ((...args) => {
+      try {
+        CpEnter();
+        const ret = original(...args);
+        return ret;
+      } finally {
+        CpExit();
+      }
+    });
+  }
+  defineProperty(fn, "name", { value: name, configurable: true });
+  defineProperty(fn, kVmFunction, { value: Object.freeze(info) });
+  return fn;
+}
+
+// src/vm/types/context.ts
+var { freeze } = Object;
+var VM_SHARED_CONTEXT = create(null);
+var VM_SHARED_CONTEXT_DESCRIPTIONS = create(null);
+var VM_SHARED_CONTEXT_KEYS = null;
+function globalVarNotFound(name) {
+  throw new VmError(`Global variable '${name}' is not defined.`, null);
+}
+function defineVmContextValue(name, value, override = false, description = void 0) {
+  if (!override && name in VM_SHARED_CONTEXT) throw new Error(`Global variable '${name}' is already defined.`);
+  let v;
+  if (typeof value == "function") {
+    v = VmFunction(value, {
+      name,
+      isLib: true,
+      fullName: `global.${name}`
+    });
+  } else {
+    v = value;
+  }
+  VM_SHARED_CONTEXT[name] = v ?? null;
+  if (description) VM_SHARED_CONTEXT_DESCRIPTIONS[name] = description;
+  VM_SHARED_CONTEXT_KEYS = null;
+}
+var DefaultVmContext = freeze({
+  __proto__: null,
+  [kVmContext]: true,
+  /** @inheritdoc */
+  keys() {
+    VM_SHARED_CONTEXT_KEYS ??= freeze(keys(VM_SHARED_CONTEXT));
+    return VM_SHARED_CONTEXT_KEYS;
+  },
+  /** @inheritdoc */
+  get(key) {
+    const val = VM_SHARED_CONTEXT[key];
+    if (val !== void 0) return val;
+    return globalVarNotFound(key);
+  },
+  /** @inheritdoc */
+  has(key) {
+    return key in VM_SHARED_CONTEXT;
+  },
+  /** @inheritdoc */
+  describe(key) {
+    return VM_SHARED_CONTEXT_DESCRIPTIONS[key];
+  }
+});
+var ValueVmContext = class {
+  constructor(env, describer) {
+    this.env = env;
+    this.describer = describer;
+  }
+  /** @inheritdoc */
+  keys() {
+    return [...keys(this.env), ...DefaultVmContext.keys()];
+  }
+  /** @inheritdoc */
+  get(key) {
+    if (hasOwn(this.env, key)) return this.env[key] ?? null;
+    {
+      const val = VM_SHARED_CONTEXT[key];
+      if (val !== void 0) return val;
+      return globalVarNotFound(key);
+    }
+  }
+  /** @inheritdoc */
+  has(key) {
+    return hasOwn(this.env, key) || key in VM_SHARED_CONTEXT;
+  }
+  /** @inheritdoc */
+  describe(key) {
+    if (hasOwn(this.env, key)) return this.describer?.(key);
+    return VM_SHARED_CONTEXT_DESCRIPTIONS[key];
+  }
+};
+defineProperty(ValueVmContext.prototype, kVmContext, { value: true });
+freeze(ValueVmContext.prototype);
+var Value2VmContext = class {
+  constructor(env, extern, describer) {
+    this.env = env;
+    this.extern = extern;
+    this.describer = describer;
+    this.externCache = /* @__PURE__ */ new WeakMap();
+  }
+  /** @inheritdoc */
+  keys() {
+    return [...this.env == null ? [] : keys(this.env), ...keys(this.extern), ...DefaultVmContext.keys()];
+  }
+  /** @inheritdoc */
+  get(key) {
+    if (this.env != null && hasOwn(this.env, key)) return this.env[key] ?? null;
+    if (hasOwn(this.extern, key)) {
+      const val2 = this.extern[key];
+      if (val2 == null) return null;
+      if (typeof val2 != "object" && typeof val2 != "function") {
+        return wrapToVmValue(val2, null, null);
+      }
+      let cached = this.externCache.get(val2);
+      if (cached == null) {
+        cached = wrapToVmValue(val2, null, null);
+        this.externCache.set(val2, cached);
+      }
+      return cached;
+    }
+    const val = VM_SHARED_CONTEXT[key];
+    if (val !== void 0) return val;
+    return globalVarNotFound(key);
+  }
+  /** @inheritdoc */
+  has(key) {
+    return this.env != null && hasOwn(this.env, key) || hasOwn(this.extern, key) || key in VM_SHARED_CONTEXT;
+  }
+  /** @inheritdoc */
+  describe(key) {
+    if (this.env != null && hasOwn(this.env, key) || hasOwn(this.extern, key)) return this.describer?.(key);
+    return VM_SHARED_CONTEXT_DESCRIPTIONS[key];
+  }
+};
+defineProperty(Value2VmContext.prototype, kVmContext, { value: true });
+freeze(Value2VmContext.prototype);
+var FactoryVmContext = class {
+  constructor(getter, enumerator, describer) {
+    this.getter = getter;
+    this.enumerator = enumerator;
+    this.describer = describer;
+  }
+  /** @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;
+    const val = VM_SHARED_CONTEXT[key];
+    if (val !== void 0) return val;
+    return globalVarNotFound(key);
+  }
+  /** @inheritdoc */
+  has(key) {
+    return this.getter(key) !== void 0 || key in VM_SHARED_CONTEXT;
+  }
+  /** @inheritdoc */
+  describe(key) {
+    if (this.getter(key) !== void 0) return this.describer?.(key);
+    return VM_SHARED_CONTEXT_DESCRIPTIONS[key];
+  }
+};
+defineProperty(FactoryVmContext.prototype, kVmContext, { value: true });
+freeze(FactoryVmContext.prototype);
+function createVmContext(arg0 = null, arg1 = null, describer = null) {
+  if (typeof arg0 == "function") {
+    const getter = arg0;
+    const enumerator = arg1;
+    return new FactoryVmContext(getter, enumerator, describer);
+  }
+  const vmValues = arg0;
+  const externValues = arg1;
+  if (externValues == null) {
+    if (vmValues == null) {
+      return DefaultVmContext;
+    }
+    return new ValueVmContext(vmValues, describer);
+  }
+  return new Value2VmContext(vmValues, externValues, describer);
+}
+
+// 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 tag() {
+    return this.name;
+  }
+};
+Object.defineProperty(VmModule.prototype, kVmModule, { value: true });
+
+// src/vm/operations/index.ts
+var operations_exports = {};
+__export(operations_exports, {
+  $Add: () => $Add,
+  $Aeq: () => $Aeq,
+  $And: () => $And,
+  $ArrayRange: () => $ArrayRange,
+  $ArrayRangeExclusive: () => $ArrayRangeExclusive,
+  $ArraySpread: () => $ArraySpread,
+  $AssertInit: () => $AssertInit,
+  $AssertNonNil: () => $AssertNonNil,
+  $Call: () => $Call,
+  $Concat: () => $Concat,
+  $Cp: () => Cp,
+  $CpEnter: () => CpEnter,
+  $CpExit: () => CpExit,
+  $Div: () => $Div,
+  $El: () => $El,
+  $ElOpt: () => $ElOpt,
+  $Eq: () => $Eq,
+  $Fn: () => $Fn,
+  $Format: () => $Format,
+  $Get: () => $Get,
+  $GlobalFallback: () => $GlobalFallback,
+  $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,
+  $Module: () => $Module,
+  $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,
+  $Upvalue: () => $Upvalue,
+  $VArgs: () => $VArgs
+});
+
+// src/vm/operations/convert.ts
+function $ToBoolean(value) {
+  if (typeof value == "boolean") return value;
+  $AssertInit(value);
+  return toBoolean(value, void 0);
+}
+function $ToString(value) {
+  if (typeof value == "string") return value;
+  $AssertInit(value);
+  return toString(value, void 0);
+}
+function $ToNumber(value) {
+  if (typeof value == "number") return value;
+  $AssertInit(value);
+  return toNumber(value, void 0);
+}
+function $Format(value, format2) {
+  $AssertInit(value);
+  return toFormat(value, format2);
+}
+
+// src/vm/operations/type-check.ts
+function $Type(value) {
+  if (value == null) return "nil";
+  if (isVmWrapper(value)) return value.type;
+  if (isVmArray(value)) return "array";
+  if (typeof value == "object") return "record";
+  return typeof value;
+}
+function $IsBoolean(value) {
+  $AssertInit(value);
+  return typeof value == "boolean";
+}
+function $IsNumber(value) {
+  $AssertInit(value);
+  return typeof value == "number";
+}
+function $IsString(value) {
+  $AssertInit(value);
+  return typeof value == "string";
+}
+function $IsRecord(value) {
+  $AssertInit(value);
+  return isVmRecord(value);
+}
+function $IsArray(value) {
+  $AssertInit(value);
+  return isVmArray(value);
+}
+function $AssertNonNil(value) {
+  $AssertInit(value);
+  if (value !== null) return;
+  throw new VmError(`Expected non-nil value`, null);
+}
+
+// src/vm/operations/utils.ts
+function overloadNumberString(a, b) {
+  if (typeof a == "number" || typeof b == "number") return true;
+  if (typeof a == "string" || typeof b == "string") return false;
+  return true;
+}
+function isSame(a, b) {
+  if (typeof a == "number" && typeof b == "number") {
+    return a === b || isNaN(a) && isNaN(b);
+  }
+  if (a === b) return true;
+  if (a == null || typeof a != "object" || b == null || typeof b != "object") return false;
+  if (isVmWrapper(a)) return a.same(b);
+  if (isVmWrapper(b)) return b.same(a);
+  if (isVmArray(a) && isVmArray(b)) {
+    const len2 = a.length;
+    if (len2 !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < len2; i++) {
+      if (!isSame(a[i] ?? null, b[i] ?? null)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (!isVmArray(a) && !isVmArray(b)) {
+    const aKeys = keys(a);
+    const bKeys = keys(b);
+    const len2 = aKeys.length;
+    if (len2 !== bKeys.length) return false;
+    if (len2 === 0) return true;
+    let i = len2;
+    while (i--) {
+      const key = aKeys[i];
+      if (!hasOwnEnumerable(b, key)) return false;
+      const av = a[key] ?? null;
+      const bv = b[key] ?? null;
+      if (!isSame(av, bv)) return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+// src/vm/operations/operator.ts
+function $Concat(...args) {
+  return args.map((a) => toFormat(a, null)).join("");
+}
+function $Pos(a) {
+  return $ToNumber(a);
+}
+function $Neg(a) {
+  return -$ToNumber(a);
+}
+function $Not(a) {
+  return !$ToBoolean(a);
+}
+function $Add(a, b) {
+  return $ToNumber(a) + $ToNumber(b);
+}
+function $Sub(a, b) {
+  return $ToNumber(a) - $ToNumber(b);
+}
+function $Mul(a, b) {
+  return $ToNumber(a) * $ToNumber(b);
+}
+function $Div(a, b) {
+  return $ToNumber(a) / $ToNumber(b);
+}
+function $Mod(a, b) {
+  return $ToNumber(a) % $ToNumber(b);
+}
+function $Pow(a, b) {
+  return $ToNumber(a) ** $ToNumber(b);
+}
+function $And(a, b) {
+  return $ToBoolean(a) && $ToBoolean(b);
+}
+function $Or(a, b) {
+  return $ToBoolean(a) || $ToBoolean(b);
+}
+function $Gt(a, b) {
+  if (overloadNumberString(a, b)) {
+    return $ToNumber(a) > $ToNumber(b);
+  } else {
+    return $ToString(a) > $ToString(b);
+  }
+}
+function $Gte(a, b) {
+  if (overloadNumberString(a, b)) {
+    return $ToNumber(a) >= $ToNumber(b);
+  } else {
+    return $ToString(a) >= $ToString(b);
+  }
+}
+function $Lt(a, b) {
+  if (overloadNumberString(a, b)) {
+    return $ToNumber(a) < $ToNumber(b);
+  } else {
+    return $ToString(a) < $ToString(b);
+  }
+}
+function $Lte(a, b) {
+  if (overloadNumberString(a, b)) {
+    return $ToNumber(a) <= $ToNumber(b);
+  } else {
+    return $ToString(a) <= $ToString(b);
+  }
+}
+function $Eq(a, b) {
+  $AssertInit(a);
+  $AssertInit(b);
+  if (typeof a == "number" && typeof b == "number") return a === b;
+  return isSame(a, b);
+}
+function $Neq(a, b) {
+  return !$Eq(a, b);
+}
+var { abs, min } = Math;
+function $Aeq(a, b) {
+  if (overloadNumberString(a, b)) {
+    const an = $ToNumber(a);
+    const bn = $ToNumber(b);
+    const EPS = 1e-15;
+    if (isNaN(an) || isNaN(bn)) return false;
+    if (an === bn) return true;
+    const absoluteDifference = abs(an - bn);
+    if (absoluteDifference < EPS) return true;
+    const base = min(abs(an), abs(bn));
+    return absoluteDifference < base * EPS;
+  } else {
+    const as = $ToString(a);
+    const bs = $ToString(b);
+    if (as === bs) return true;
+    const ai = as.toLowerCase();
+    const bi = bs.toLowerCase();
+    if (ai === bi) return true;
+    const an = ai.normalize("NFC");
+    const bn = bi.normalize("NFC");
+    return an === bn;
+  }
+}
+function $Naeq(a, b) {
+  return !$Aeq(a, b);
+}
+function $Same(a, b) {
+  $AssertInit(a);
+  $AssertInit(b);
+  return isSame(a, b);
+}
+function $Nsame(a, b) {
+  return !$Same(a, b);
+}
+
+// src/vm/operations/slice.ts
+var { ceil } = Math;
+var { slice } = Array.prototype;
+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);
+};
+function $Slice(value, start, end) {
+  $AssertInit(value);
+  if (!isVmArray(value)) throw new VmError(`Expected array, got ${display(value)}`, []);
+  const s2 = start != null ? $ToNumber(start) : 0;
+  const e2 = end != null ? $ToNumber(end) : value.length - 1;
+  return sliceCore(value, s2, e2, false);
+}
+function $SliceExclusive(value, start, end) {
+  $AssertInit(value);
+  if (!isVmArray(value)) throw new VmError(`Expected array, got ${display(value)}`, []);
+  const s2 = start != null ? $ToNumber(start) : 0;
+  const e2 = end != null ? $ToNumber(end) : value.length;
+  return sliceCore(value, s2, e2, true);
+}
+
+// src/vm/operations/helpers.ts
+function $Module(name, body) {
+  const mod = create(null);
+  for (const [key, get] of entries(body)) {
+    defineProperty(mod, key, { __proto__: null, get, enumerable: true });
+  }
+  return new VmModule(name, mod);
+}
+function $El(value) {
+  $AssertInit(value);
+  if (!isVmConst(value)) return null;
+  return value;
+}
+var EMPTY = create(null);
+function $ElOpt(key, value) {
+  $AssertInit(value);
+  if (value == null || !isVmConst(value)) return EMPTY;
+  return { __proto__: null, [key]: value };
+}
+function $Fn(name, fn) {
+  return VmFunction(fn, { isLib: false, injectCp: false, name: name || VM_FUNCTION_ANONYMOUS_NAME });
+}
+function $Upvalue(value) {
+  $AssertInit(value);
+  return value;
+}
+var assertArrayLength = (len2) => {
+  if (len2 > 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;
+};
+function $ArrayRange(start, end) {
+  const s2 = $ToNumber(start);
+  const e2 = $ToNumber(end);
+  if (isEmptyRange(s2, e2)) return [];
+  assertArrayLength(e2 - s2 + 1);
+  const arr = [];
+  for (let i = s2; i <= e2; i++) {
+    arr.push(i);
+  }
+  return arr;
+}
+function $ArrayRangeExclusive(start, end) {
+  const s2 = $ToNumber(start);
+  const e2 = $ToNumber(end);
+  if (isEmptyRange(s2, e2)) return [];
+  assertArrayLength(e2 - s2);
+  const arr = [];
+  for (let i = s2; i < e2; i++) {
+    arr.push(i);
+  }
+  return arr;
+}
+function $GlobalFallback() {
+  return DefaultVmContext;
+}
+
+// src/vm/operations/compound.ts
+var { trunc } = Math;
+var { at } = Array.prototype;
+function $In(value, iterable) {
+  $AssertInit(value);
+  $AssertInit(iterable);
+  if (iterable == null) return false;
+  if (typeof iterable != "object") return false;
+  if (isVmArray(iterable)) {
+    if (value == null) {
+      for (const item of iterable) if (item == null) return true;
+      return false;
+    }
+    if (isVmPrimitive(value)) return iterable.includes(value);
+    return iterable.some((item = null) => isSame(item, value));
+  }
+  const key = toString(value, void 0);
+  if (isVmWrapper(iterable)) return iterable.has(key);
+  return hasOwnEnumerable(iterable, key);
+}
+function $Length(value) {
+  $AssertInit(value);
+  if (isVmArray(value)) return value.length;
+  if (isVmRecord(value)) return keys(value).length;
+  if (isVmWrapper(value)) return value.keys().length;
+  throw new VmError(`Value has no length: ${display(value)}`, 0);
+}
+function $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;
+}
+function $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;
+}
+function $Has(obj, key) {
+  $AssertInit(obj);
+  const pk = $ToString(key);
+  if (obj == null || typeof obj != "object") return false;
+  if (isVmWrapper(obj)) return obj.has(pk);
+  return hasOwnEnumerable(obj, pk);
+}
+function $Get(obj, key) {
+  $AssertInit(obj);
+  if (isVmArray(obj)) {
+    $AssertInit(key);
+    const index = toNumber(key, NotNumber);
+    if (isNaN(index)) return null;
+    return $El(at.call(obj, trunc(index)) ?? null);
+  }
+  const pk = $ToString(key);
+  if (obj == null || typeof obj != "object") return null;
+  if (isVmWrapper(obj)) {
+    if (isFinite(key) && isVmExtern(obj) && obj.isArrayLike()) {
+      let index = trunc(key);
+      const { length } = obj.value;
+      if (index < 0) index += length;
+      if (index >= 0 && index < length) {
+        return obj.get(String(index)) ?? null;
+      }
+    }
+    return obj.get(pk) ?? null;
+  }
+  if (!hasOwnEnumerable(obj, pk)) return null;
+  return $El(obj[pk] ?? null);
+}
+function $Set(obj, key, value) {
+  $AssertInit(obj);
+  $AssertInit(value);
+  const pk = $ToString(key);
+  if (obj == null) return;
+  if (!isVmExtern(obj)) throw new VmError(`Expected extern, got ${display(obj)}`, void 0);
+  obj.set(pk, value);
+}
+function $Iterable(value) {
+  $AssertInit(value);
+  if (isVmWrapper(value)) return value.keys();
+  if (isVmArray(value)) return value;
+  if (value != null && typeof value == "object") return keys(value);
+  throw new VmError(`Value is not iterable: ${display(value)}`, isVmFunction(value) ? [] : [value]);
+}
+function $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 (isVmConst(value)) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  throw new VmError(`Expected record, array, extern or nil, got ${display(record)}`, null);
+}
+function $ArraySpread(array) {
+  $AssertInit(array);
+  if (array == null) return [];
+  if (isVmArray(array)) return array;
+  if (isVmExtern(array)) {
+    if (array.isArrayLike()) {
+      const result = [];
+      for (let i = 0, len2 = array.value.length; i < len2; i++) {
+        const item = array.value[i];
+        result.push(wrapToVmConst(item, (v) => array.assumeVmValue(v, i)));
+      }
+      return result;
+    } else if (typeof array.value[Symbol.iterator] == "function") {
+      const result = [];
+      for (const item of array.value) {
+        result.push(wrapToVmConst(item, (v) => array.assumeVmValue(v, Symbol.iterator)));
+      }
+      return result;
+    }
+  }
+  throw new VmError(`Expected array, iterable extern or nil, got ${display(array)}`, []);
+}
+
+// src/compiler/create-script.ts
+function wrapScript(source, mode, script) {
+  if (kVmScript in script) {
+    return script;
+  }
+  defineProperty(script, "name", { value: VM_SCRIPT_NAME });
+  defineProperty(script, kVmScript, { value: mode });
+  if (typeof source === "string") {
+    defineProperty(script, "source", { value: source });
+  } else if (source instanceof Uint8Array) {
+    defineProperty(script, "source", { value: "<buffer>" });
+  }
+  return script;
+}
+var [keys2, values2] = (() => {
+  const keys4 = [];
+  const values4 = [];
+  for (const [key, value] of entries(operations_exports)) {
+    keys4.push(key);
+    values4.push(value);
+  }
+  return [keys4.join(","), values4];
+})();
+function createScript(source, mode, code) {
+  let script;
+  try {
+    script = new Function(keys2, `'use strict';
+return ${code}`)(...values2);
+  } catch (error) {
+    throw new Error(`Failed to create script`, { cause: error });
+  }
+  return wrapScript(source, mode, script);
+}
+
+// src/compiler/emit-script.ts
+function reportDiagnostic(source, diagnostics, fileName) {
+  const parsed = parseDiagnostics(source, diagnostics);
+  const messages = formatDiagnostics(parsed.errors, source, fileName);
+  throw new Error(`Failed to compile:
+${messages.join("\n")}`);
+}
+function emitScript(source, [code, diagnostics], options) {
+  if (!code) {
+    reportDiagnostic(source, diagnostics, options.fileName);
+  }
+  const sourcemaps = options.sourceMap ? parseDiagnostics(source, diagnostics, (c) => c === DiagnosticCode.SourceMap).sourcemaps : [];
+  const target = emit(source, code, sourcemaps, options);
+  return createScript(source, options.input_mode ?? "Script", target);
+}
+
+// src/vm/lib/global/index.ts
+var global_exports = {};
+__export(global_exports, {
+  E: () => E,
+  LN10: () => LN10,
+  LN2: () => LN2,
+  LOG10E: () => LOG10E,
+  LOG2E: () => LOG2E,
+  PI: () => PI,
+  SQRT1_2: () => SQRT1_2,
+  SQRT2: () => SQRT2,
+  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,
+  e: () => e,
+  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,
+  gamma: () => gamma,
+  hypot: () => hypot,
+  join: () => join,
+  keys: () => keys3,
+  len: () => len,
+  log: () => log,
+  log10: () => log10,
+  log1p: () => log1p,
+  log2: () => log2,
+  map: () => map2,
+  max: () => max,
+  min: () => min2,
+  new_array: () => new_array,
+  new_record: () => new_record,
+  panic: () => panic,
+  pi: () => pi,
+  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_datetime: () => to_datetime,
+  to_iso8601: () => to_iso8601,
+  to_json: () => to_json,
+  to_lowercase: () => to_lowercase,
+  to_number: () => to_number,
+  to_string: () => to_string,
+  to_timestamp: () => to_timestamp,
+  to_uppercase: () => to_uppercase,
+  trim: () => trim,
+  trim_end: () => trim_end,
+  trim_start: () => trim_start,
+  trunc: () => trunc2,
+  unique: () => unique,
+  unique_by: () => unique_by,
+  values: () => values3,
+  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 describeParam(name) {
+  if (name == null) return "Value";
+  if (typeof name == "string") {
+    if (!name) return "Argument";
+    return `Argument '${name}'`;
+  }
+  const pos = name <= 0 ? "first" : name <= 1 ? "second" : `${name + 1}th`;
+  return `Argument at the ${pos} position`;
+}
+function throwUnexpectedTypeError(name, expected, value, recovered) {
+  throwError(`${describeParam(name)} is not ${expected}: ${display(value)}`, recovered);
+}
+function throwUnconvertedTypeError(name, expected, value, recovered) {
+  throwError(`${describeParam(name)} cannot be converted to ${expected}: ${display(value)}`, recovered);
+}
+function rethrowError(prefix, error, recovered) {
+  const recoveredValue = typeof recovered === "function" && !isVmFunction(recovered) ? recovered() : recovered;
+  throw VmError.from(prefix, error, recoveredValue);
+}
+function required(name, value, recovered) {
+  if (value === void 0) {
+    throwError(`${describeParam(name)} is required`, recovered);
+  }
+}
+function expectNumber(name, value) {
+  required(name, value, NotNumber);
+  const v = toNumber(value, null);
+  if (v == null) {
+    throwUnconvertedTypeError(name, "number", value, NotNumber);
+  }
+  return v;
+}
+function expectNumberRange(name, value, min3, max2) {
+  const v = expectNumber(name, value);
+  if (!isFinite(v)) {
+    throwError(`${describeParam(name)} is not a finite number: ${display(value)}`, NotNumber);
+  }
+  if (v < min3) {
+    throwError(`${describeParam(name)} is less than minimum value ${min3}: ${display(value)}`, min3);
+  }
+  if (v > max2) {
+    throwError(`${describeParam(name)} is greater than maximum value ${max2}: ${display(value)}`, max2);
+  }
+  return v;
+}
+function expectIntegerRange(name, value, min3, max2) {
+  const i = expectInteger(name, value);
+  if (i < min3) {
+    throwError(`${describeParam(name)} is less than minimum value ${min3}: ${display(value)}`, min3);
+  }
+  if (i > max2) {
+    throwError(`${describeParam(name)} is greater than maximum value ${max2}: ${display(value)}`, max2);
+  }
+  return i;
+}
+function expectInteger(name, value) {
+  required(name, value, 0);
+  const v = toNumber(value, null);
+  if (v == null) {
+    throwUnconvertedTypeError(name, "integer", value, 0);
+  }
+  const i = Math.trunc(v);
+  if (!isSafeInteger(i)) {
+    throwUnconvertedTypeError(name, "integer", value, 0);
+  }
+  return i;
+}
+function expectString(name, value) {
+  required(name, value, "");
+  const v = toString(value, null);
+  if (v == null) {
+    throwUnconvertedTypeError(name, "string", value, "");
+  }
+  return v;
+}
+function expectArray(name, value, recovered) {
+  required(name, value, recovered);
+  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);
+  if (!isVmCallable(value)) {
+    throwUnexpectedTypeError(name, "callable", value, recovered);
+  }
+}
+function getNumbers(args) {
+  if (args.length === 0) return [];
+  let useFirst = false;
+  if (args.length === 1 && isVmArray(args[0])) {
+    args = args[0];
+    useFirst = true;
+  }
+  const numbers = [];
+  for (let len2 = args.length, i = 0; i < len2; i++) {
+    numbers.push(expectNumber(useFirst ? null : i, args[i]));
+  }
+  return numbers;
+}
+function arrayLen(len2) {
+  if (len2 == null || isNaN(len2) || len2 <= -1) {
+    throwError("Array length must be a non-negative integer", null);
+  }
+  len2 = Math.trunc(len2);
+  if (len2 > VM_ARRAY_MAX_LENGTH) {
+    throwError(`Array length exceeds maximum limit of ${VM_ARRAY_MAX_LENGTH}`, null);
+  }
+  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;
+      result.push(ret);
+    }
+    return result;
+  } else {
+    const e2 = [];
+    for (const [key, value] of entries(data)) {
+      Cp();
+      const ret = mapper(value ?? null, key, data);
+      if (ret === void 0) continue;
+      e2.push([key, ret]);
+    }
+    return fromEntries(e2);
+  }
+}
+function VmLib(value, option, properties) {
+  if (isVmFunction(value)) throw new TypeError("Cannot create VmLib from a VmFunction");
+  const ret = typeof value == "function" ? value : { __proto__: null, value };
+  Object.defineProperties(ret, {
+    summary: { enumerable: true, value: option.summary },
+    params: { enumerable: true, value: option.params },
+    paramsType: { enumerable: true, value: option.paramsType },
+    returns: { enumerable: true, value: option.returns },
+    returnsType: { enumerable: true, value: option.returnsType },
+    examples: { enumerable: true, value: option.examples },
+    deprecated: { enumerable: true, value: option.deprecated ?? void 0 }
+  });
+  Object.assign(ret, properties);
+  return ret;
+}
+
+// src/vm/lib/global/math/arr.ts
+function build(f) {
+  return (...values4) => {
+    const numbers = getNumbers(values4);
+    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(
+  (...values4) => {
+    const numbers = getNumbers(values4);
+    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(
+  (...values4) => {
+    const numbers = getNumbers(values4);
+    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
+import { DiagnosticCode as DiagnosticCode2 } from "@mirascript/constants";
+var PI = VmLib(Math.PI, {
+  summary: "圆周率",
+  returnsType: "number"
+});
+var E = VmLib(Math.E, {
+  summary: "自然对数的底数",
+  returnsType: "number"
+});
+var pi = VmLib(Math.PI, {
+  summary: "圆周率",
+  returnsType: "number",
+  deprecated: {
+    use: "PI",
+    message: DiagnosticCode2.PreferUppercaseConstant
+  }
+});
+var e = VmLib(Math.E, {
+  summary: "自然对数的底数",
+  returnsType: "number",
+  deprecated: {
+    use: "E",
+    message: DiagnosticCode2.PreferUppercaseConstant
+  }
+});
+var SQRT1_2 = VmLib(Math.SQRT1_2, {
+  summary: "½ 的平方根",
+  returnsType: "number"
+});
+var SQRT2 = VmLib(Math.SQRT2, {
+  summary: "2 的平方根",
+  returnsType: "number"
+});
+var LN2 = VmLib(Math.LN2, {
+  summary: "2 的自然对数",
+  returnsType: "number"
+});
+var LN10 = VmLib(Math.LN10, {
+  summary: "10 的自然对数",
+  returnsType: "number"
+});
+var LOG2E = VmLib(Math.LOG2E, {
+  summary: "e 以 2 为底的对数",
+  returnsType: "number"
+});
+var LOG10E = VmLib(Math.LOG10E, {
+  summary: "e 以 10 为底的对数",
+  returnsType: "number"
+});
+
+// src/vm/lib/global/math/unary.ts
+function build2(f) {
+  return (x) => {
+    return f(expectNumber("x", x));
+  };
+}
+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/round.ts
+function build3(f) {
+  return (x, n) => {
+    const xn = expectNumber("x", x);
+    const nn = n != null ? expectIntegerRange("n", n, 0, 15) : 0;
+    if (!nn) return f(xn);
+    const factor = 10 ** nn;
+    return f(xn * factor) / factor;
+  };
+}
+var trunc2 = VmLib(build3(Math.trunc), {
+  summary: "向零方向舍入数值",
+  params: { x: "要舍入的数", n: "小数位数，默认为 0" },
+  paramsType: { x: "number", n: "number | nil" },
+  returnsType: "number"
+});
+var floor = VmLib(build3(Math.floor), {
+  summary: "向下舍入数值",
+  params: { x: "要舍入的数", n: "小数位数，默认为 0" },
+  paramsType: { x: "number", n: "number | nil" },
+  returnsType: "number"
+});
+var ceil2 = VmLib(build3(Math.ceil), {
+  summary: "向上舍入数值",
+  params: { x: "要舍入的数", n: "小数位数，默认为 0" },
+  paramsType: { x: "number", n: "number | nil" },
+  returnsType: "number"
+});
+var _round = Math.round;
+var _abs = Math.abs;
+var round = VmLib(
+  build3((x) => {
+    let rounded = _round(x);
+    if (_abs(x - rounded) === 0.5) {
+      rounded = 2 * _round(x / 2);
+    }
+    return rounded;
+  }),
+  {
+    summary: "四舍五入数值",
+    params: { x: "要舍入的数", n: "小数位数，默认为 0" },
+    paramsType: { x: "number", n: "number" },
+    returnsType: "number"
+  }
+);
+
+// src/vm/lib/global/math/gamma.ts
+var { PI: PI2, exp: exp2, floor: floor2, cos: cos2, sin: sin2, pow, trunc: trunc3 } = Math;
+var MEM = new DataView(new ArrayBuffer(8));
+function f64ToBits(value) {
+  MEM.setFloat64(0, value, false);
+  return MEM.getBigUint64(0, false);
+}
+function f64FromBits(bits) {
+  MEM.setBigUint64(0, bits, false);
+  return MEM.getFloat64(0, false);
+}
+function sinpi(x) {
+  x = x * 0.5;
+  x = 2 * (x - floor2(x));
+  let n = trunc3(4 * x);
+  n = trunc3((n + 1) / 2);
+  x -= n * 0.5;
+  x *= PI2;
+  switch (n) {
+    case 1:
+      return cos2(x);
+    case 2:
+      return sin2(-x);
+    case 3:
+      return -cos2(x);
+    default:
+      return sin2(x);
+  }
+}
+var N = 12;
+var GMHALF = 5.52468004077673;
+var SNUM = [
+  2353137688041076e-5,
+  429198036426491e-4,
+  3571195923735567e-5,
+  1792103442603721e-5,
+  6039542586352028e-6,
+  14397204073117216e-7,
+  24887455786205417e-8,
+  31426415585400194e-9,
+  2.8763706289353725e6,
+  186056.26539522348,
+  8071.672002365816,
+  210.82427775157936,
+  2.5066282746310002
+];
+var SDEN = [
+  0,
+  39916800,
+  120543840,
+  150917976,
+  105258076,
+  45995730,
+  13339535,
+  2637558,
+  357423,
+  32670,
+  1925,
+  66,
+  1
+];
+function s(x) {
+  let num2 = 0;
+  let den = 0;
+  if (x < 8) {
+    for (let i = N; i >= 0; i--) {
+      num2 = num2 * x + SNUM[i];
+      den = den * x + SDEN[i];
+    }
+  } else {
+    for (let i = 0; i <= N; i++) {
+      num2 = num2 / x + SNUM[i];
+      den = den / x + SDEN[i];
+    }
+  }
+  return num2 / den;
+}
+function tgamma(x) {
+  const u = f64ToBits(x);
+  const ix = Number(u >> 32n & 0x7fffffffn);
+  const sign2 = u >> 63n !== 0n;
+  if (ix >= 2146435072) {
+    return x + PositiveInfinity;
+  }
+  if (ix < 1023 - 54 << 20) {
+    return 1 / x;
+  }
+  if (x === floor2(x)) {
+    if (sign2) {
+      return NotNumber;
+    }
+    if (x <= FACT_MAX) {
+      return fact(trunc3(x) - 1);
+    }
+  }
+  if (ix >= 1080492032) {
+    if (sign2) {
+      if (floor2(x) * 0.5 === floor2(x * 0.5)) {
+        return 0;
+      } else {
+        return -0;
+      }
+    }
+    const x1p1023 = f64FromBits(0x7fe0000000000000n);
+    return x * x1p1023;
+  }
+  const absx = sign2 ? -x : x;
+  const y = absx + GMHALF;
+  let dy;
+  if (absx > GMHALF) {
+    dy = y - absx;
+    dy -= GMHALF;
+  } else {
+    dy = y - GMHALF;
+    dy -= absx;
+  }
+  let z = absx - 0.5;
+  let r = s(absx) * exp2(-y);
+  if (x < 0) {
+    r = -PI2 / (sinpi(absx) * absx * r);
+    dy = -dy;
+    z = -z;
+  }
+  r += dy * (GMHALF + 0.5) * r / y;
+  const zHalf = pow(y, 0.5 * z);
+  return r * zHalf * zHalf;
+}
+var gamma = VmLib(
+  (x) => {
+    const n = expectNumber("x", x);
+    return tgamma(n);
+  },
+  {
+    summary: "返回 Gamma 函数的值",
+    params: { x: "要计算 Gamma 函数的数值" },
+    paramsType: { x: "number" },
+    returnsType: "number",
+    examples: ["gamma(5) // 24"]
+  }
+);
+var FACT_MAX = 171;
+var FACT = [1, 1];
+function fact(n) {
+  const cached = FACT[n];
+  if (cached != null) return cached;
+  let r = 1n;
+  for (let i = 2; i <= n; i++) {
+    r *= BigInt(i);
+    FACT[i] = Number(r);
+  }
+  return FACT[n];
+}
+var factorial = VmLib(
+  (x) => {
+    const n = expectNumber("x", x);
+    if (isNaN(n) || n < 0) return NotNumber;
+    return tgamma(n + 1);
+  },
+  {
+    summary: "返回一个数的阶乘",
+    params: { x: "要计算阶乘的数值" },
+    paramsType: { x: "number" },
+    returnsType: "number",
+    examples: ["factorial(5) // 120"]
+  }
+);
+
+// src/vm/lib/global/math/index.ts
+var { atan2: _atan2, pow: _pow, random: _random } = Math;
+var atan2 = VmLib((x, y) => _atan2(expectNumber(0, x), expectNumber(1, y)), {
+  summary: "返回从原点到点 (x, y) 的角度（弧度）",
+  params: { x: "x 坐标", y: "y 坐标" },
+  paramsType: { x: "number", y: "number" },
+  returnsType: "number"
+});
+var pow2 = VmLib((x, y) => _pow(expectNumber(0, x), expectNumber(1, y)), {
+  summary: "返回 x 的 y 次幂",
+  params: { x: "底数", y: "指数" },
+  paramsType: { x: "number", y: "number" },
+  returnsType: "number"
+});
+var random = VmLib(() => _random(), {
+  summary: "返回 [0, 1) 之间的伪随机数",
+  params: {},
+  paramsType: {},
+  returnsType: "number"
+});
+
+// src/vm/lib/global/bit.ts
+var b_and = VmLib(
+  (x, y) => {
+    return expectNumber(0, x) & expectNumber(1, 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 expectNumber(0, x) | expectNumber(1, y);
+  },
+  {
+    summary: "返回两个数的按位或",
+    params: { x: "第一个操作数", y: "第二个操作数" },
+    paramsType: { x: "number", y: "number" },
+    returnsType: "number",
+    examples: ["b_or(5, 2) // 7"]
+  }
+);
+var b_not = VmLib(
+  (x) => {
+    return ~expectNumber("x", x);
+  },
+  {
+    summary: "返回一个数的按位取反",
+    params: { x: "操作数" },
+    paramsType: { x: "number" },
+    returnsType: "number",
+    examples: ["b_not(0) // -1"]
+  }
+);
+var b_xor = VmLib(
+  (x, y) => {
+    return expectNumber(0, x) ^ expectNumber(1, y);
+  },
+  {
+    summary: "返回两个数的按位异或",
+    params: { x: "第一个操作数", y: "第二个操作数" },
+    paramsType: { x: "number", y: "number" },
+    returnsType: "number",
+    examples: ["b_xor(5, 3) // 6"]
+  }
+);
+var shl = VmLib(
+  (x, y) => {
+    return expectNumber(0, x) << expectNumber(1, y);
+  },
+  {
+    summary: "返回第一个操作数左移指定的位数",
+    params: { x: "第一个操作数", y: "位数" },
+    paramsType: { x: "number", y: "number" },
+    returnsType: "number",
+    examples: ["shl(3, 2) // 12"]
+  }
+);
+var sar = VmLib(
+  (x, y) => {
+    return expectNumber(0, x) >> expectNumber(1, y);
+  },
+  {
+    summary: "返回第一个操作数右移指定的位数",
+    params: { x: "第一个操作数", y: "位数" },
+    paramsType: { x: "number", y: "number" },
+    returnsType: "number",
+    examples: ["sar(-8, 1) // -4"]
+  }
+);
+var shr = VmLib(
+  (x, y) => {
+    return expectNumber(0, x) >>> expectNumber(1, 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 arrIndex = (index) => {
+  const idx = Math.trunc(toNumber(index, NotNumber));
+  if (isNaN(idx) || idx < 0) {
+    throwError("Array index must be a non-negative integer", index);
+  }
+  if (idx >= VM_ARRAY_MAX_LENGTH) {
+    throwError(`Array index exceeds maximum limit of ${VM_ARRAY_MAX_LENGTH}`, index);
+  }
+  return idx;
+};
+var isArrIndex = (key) => {
+  if (typeof key != "number") return false;
+  return isInteger(key) && key >= 0 && key < VM_ARRAY_MAX_LENGTH;
+};
+var withInner = (obj, key, keyIndex, value) => {
+  if (keyIndex >= key.length) {
+    return value;
+  }
+  const k = key[keyIndex];
+  let result;
+  if (isVmArray(obj)) {
+    result = [...obj];
+  } else if (isVmRecord(obj)) {
+    result = { ...obj };
+  } else if (isArrIndex(k)) {
+    result = [];
+  } else {
+    result = {};
+  }
+  if (isArray(result)) {
+    const index = arrIndex(k);
+    while (index > result.length) {
+      result.push(null);
+    }
+    result[index] = withInner(result[index], key, keyIndex + 1, value);
+  } else {
+    const prop = toString(k, void 0);
+    result[prop] = withInner(result[prop], key, keyIndex + 1, value);
+  }
+  return result;
+};
+var normalizeEntries = (data, entries3) => {
+  if (entries3.length % 2 !== 0) {
+    throwError("Expected even number of entries", data);
+  }
+  const entryData = /* @__PURE__ */ new Map();
+  for (let i = 0; i < entries3.length; i += 2) {
+    let key = entries3[i];
+    expectConst("key", key, data);
+    if (key == null) {
+      continue;
+    }
+    if (isVmArray(key)) {
+      if (key.length === 0 || key.includes(null) || key.includes(void 0)) {
+        continue;
+      } else if (key.length === 1) {
+        key = key[0];
+      }
+    }
+    const value = entries3[i + 1];
+    entryData.set(key, $El(value));
+  }
+  return entryData;
+};
+var _with = VmLib(
+  (data, ...entries3) => {
+    expectArrayOrRecord("data", data, data);
+    if (entries3.length === 0) {
+      return data;
+    }
+    const entryData = normalizeEntries(data, entries3);
+    if (isVmArray(data)) {
+      const result = [...data];
+      for (const [key, value] of entryData) {
+        let index;
+        let val;
+        if (isVmArray(key)) {
+          index = arrIndex(key[0]);
+          val = withInner(result[index], key, 1, value);
+        } else {
+          index = arrIndex(key);
+          val = value;
+        }
+        while (index > result.length) {
+          result.push(null);
+        }
+        result[index] = val;
+      }
+      return result;
+    } else {
+      const result = { ...data };
+      for (const [key, value] of entryData) {
+        let prop;
+        let val;
+        if (isVmArray(key)) {
+          const firstKey = key[0];
+          prop = toString(firstKey, void 0);
+          val = withInner(result[prop], key, 1, value);
+        } else {
+          prop = toString(key, void 0);
+          val = value;
+        }
+        result[prop] = val;
+      }
+      return result;
+    }
+  },
+  {
+    summary: "在数组或记录中设置多个键值对",
+    params: {
+      data: "要设置的数组或记录",
+      "..entries": "要设置的键值对，成对出现；键可以是一个值或一个数组（表示嵌套路径）"
+    },
+    paramsType: {
+      data: "array | record",
+      "..entries": `[..[number | string | (number | string)[], any][]]`
+    },
+    returnsType: "type(data)",
+    examples: [
+      `with([10, 20], 2, 99, 3 ,100) // [10, 20, 99, 100]`,
+      `(a: 1)::with(["b", 1], 2) // (a: 1, b: [nil, 2])`
+    ]
+  }
+);
+
+// src/vm/lib/global/sequence/entries.ts
+var keys3 = 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: "number[] | string[]",
+    examples: ["keys([10, 20]) // [0, 1]", 'keys((10, 20)) // ["0", "1"]']
+  }
+);
+var values3 = 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: "(number, any)[] | (string, any)[]",
+    examples: ["entries([1]) // [(0, 1)]", 'entries((a: 1)) // [("a", 1)]']
+  }
+);
+
+// src/vm/lib/global/sequence/len.ts
+var len = VmLib(
+  (arr) => {
+    if (isVmExtern(arr)) {
+      if (!arr.isArrayLike()) {
+        throwUnexpectedTypeError("arr", "array-like extern", arr, NotNumber);
+      }
+      return arr.value.length;
+    }
+    expectArray("arr", arr, NotNumber);
+    return arr.length;
+  },
+  {
+    summary: "返回数组的长度",
+    params: { arr: "要求长度的数组" },
+    paramsType: { arr: "array | extern" },
+    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, 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, void 0) ? value : void 0;
+  }),
+  {
+    summary: "过滤数组或记录中的元素，返回满足条件的元素",
+    params: {
+      data: "要过滤的数组或记录",
+      predicate: "用于测试每个元素的函数"
+    },
+    paramsType: {
+      data: "array | record",
+      predicate: "fn(value: any, key: number | string, 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: "应用于每个元素的函数"
+    },
+    paramsType: {
+      data: "array | record",
+      f: "fn(value: any, key: number | string, 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);
+    required("predicate", predicate, null);
+    const p = isVmCallable(predicate) ? (value, key, data2) => {
+      const ret = $Call(predicate, [value, key, data2]);
+      return toBoolean(ret, void 0);
+    } : (value) => $Same(predicate, value);
+    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: "用于测试每个键值对的函数，或要查找的值"
+    },
+    paramsType: {
+      data: "array | record",
+      predicate: "(fn(value: any, key: number | string, input: type(data)) -> boolean) | any"
+    },
+    returnsType: "(number | string, any) | nil",
+    examples: ["find([3, 5, 8], fn (v) { v % 2 == 0 }) // (2, 8)", `find((x: 1, y: 2, z: 3), 2) // ('y', 2)`]
+  }
+);
+
+// src/vm/lib/global/sequence/flatten.ts
+var flatten = VmLib(
+  (data, depth = 1) => {
+    expectArray("data", data, data);
+    return data.flat(expectNumber("depth", 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[${display(key)}] is not an array: ${display(arr)}`, 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, void 0)) 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, void 0)) 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, void 0)) 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, void 0)) 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 = null, b = null) {
+  if (Object.is(a, b)) return 0;
+  if ((typeof a == "string" || a == null) && (typeof b == "string" || b == null)) {
+    a ??= "";
+    b ??= "";
+    if (a < b) return -1;
+    if (a > b) return 1;
+    return 0;
+  }
+  const an = toNumber(a, 0) || 0;
+  const bn = toNumber(b, 0) || 0;
+  if (an < bn) return -1;
+  if (an > bn) return 1;
+  return 0;
+}
+function cmp(comparator, recovered) {
+  if (comparator == null) return defaultCompare;
+  expectCallable("comparator", comparator, recovered);
+  return (a = null, b = null) => {
+    const ret = $Call(comparator, [a, b]);
+    return toNumber(ret, void 0);
+  };
+}
+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, comparator) => {
+    expectArray("data", data, null);
+    expectCallable("key", key, 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, [v, i, data])
+      });
+    }
+    arr.sort((a, b) => compare(a.k, b.k));
+    return arr.map((e2) => e2.o);
+  },
+  {
+    summary: "根据键函数对数组中的元素进行排序，并返回排序后的结果",
+    params: {
+      data: "要排序的数组",
+      key: "用于提取排序键的函数，接受一个元素并返回其排序键",
+      comparator: "用于比较两个排序键的函数，返回一个数字，表示它们的相对顺序，默认按升序排列"
+    },
+    paramsType: {
+      data: "array",
+      key: "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/unique.ts
+function defaultEqual(a = null, b = null) {
+  return isSame(a, b);
+}
+function eq(equaler, recovered) {
+  if (equaler == null) return defaultEqual;
+  expectCallable("equal", equaler, recovered);
+  return (a = null, b = null) => {
+    const ret = $Call(equaler, [a, b]);
+    return toBoolean(ret, void 0);
+  };
+}
+var unique = VmLib(
+  (data, equal) => {
+    expectArray("data", data, null);
+    const e2 = eq(equal, data);
+    const arr = [];
+    for (const v of data) {
+      let found = false;
+      for (const u of arr) {
+        if (e2(v, u)) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) arr.push(v ?? null);
+    }
+    return arr;
+  },
+  {
+    summary: "对数组中的元素进行去重，并返回去重后的结果",
+    params: {
+      data: "要去重的数组",
+      equal: "用于判等两个元素的函数，返回一个布尔值，默认使用严格相等比较"
+    },
+    paramsType: {
+      data: "array",
+      equal: "fn(a: any, b: any) -> boolean"
+    },
+    returnsType: "array",
+    examples: ["unique([1, 2, 2, 3]) // [1, 2, 3]"]
+  }
+);
+var unique_by = VmLib(
+  (data, key, equal) => {
+    expectArray("data", data, null);
+    expectCallable("key", key, data);
+    const e2 = eq(equal, data);
+    const arr = [];
+    const keys4 = [];
+    const len2 = data.length;
+    for (let i = 0; i < len2; i++) {
+      const v = data[i] ?? null;
+      const k = $Call(key, [v, i, data]);
+      let found = false;
+      const keysLen = keys4.length;
+      for (let j = 0; j < keysLen; j++) {
+        if (e2(k, keys4[j])) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        arr.push(v);
+        keys4.push(k);
+      }
+    }
+    return arr;
+  },
+  {
+    summary: "根据键函数对数组中的元素进行去重，并返回去重后的结果",
+    params: {
+      data: "要去重的数组",
+      key: "用于提取去重键的函数，接受一个元素并返回其去重键",
+      equal: "用于判同两个元素的函数，返回一个布尔值，默认使用严格相等比较"
+    },
+    paramsType: {
+      data: "array",
+      key: "fn(value: any, index: number, arr: type(data)) -> any",
+      equal: "fn(a: any, b: any) -> boolean"
+    },
+    returnsType: "array",
+    examples: ['unique_by(["apple", "banana", "apricot"], fn { chars(it)[0] }) // ["apple", "banana"]']
+  }
+);
+
+// src/vm/lib/global/sequence/repeat.ts
+var repeat = VmLib(
+  (data, times) => {
+    expectConst("data", data, []);
+    const n = arrayLen(expectNumber("times", 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/sequence/new.ts
+var new_record = VmLib(
+  (size2, generator) => {
+    const n = expectIntegerRange("size", size2, 0, PositiveInfinity);
+    expectCallable("generator", generator, null);
+    const result = {};
+    for (let i = 0; i < n; i++) {
+      const entry = $Call(generator, [i]);
+      if (entry == null) continue;
+      const key = $Get(entry, 0);
+      const value = $El($Get(entry, 1));
+      result[toString(key)] = value;
+    }
+    return result;
+  },
+  {
+    summary: "根据生成器函数创建一个记录",
+    params: { size: "记录的大小", generator: "生成器函数，返回键值对或 nil（表示跳过该条目）" },
+    paramsType: { size: "number", generator: "fn(index: number) -> (string, any) | nil" },
+    returnsType: "record",
+    examples: ["new_record(3, fn { (it, it * 2) }) // (0, 2, 4)"]
+  }
+);
+var new_array = VmLib(
+  (length, generator) => {
+    const n = expectIntegerRange("length", length, 0, VM_ARRAY_MAX_LENGTH);
+    expectCallable("generator", generator, null);
+    const result = [];
+    for (let i = 0; i < n; i++) {
+      result.push($El($Call(generator, [i])));
+    }
+    return result;
+  },
+  {
+    summary: "根据生成器函数创建一个数组",
+    params: { length: "数组的长度", generator: "生成器函数，返回数组元素的值" },
+    paramsType: { length: "number", generator: "fn(index: number) -> any" },
+    returnsType: "array",
+    examples: ["new_array(5, fn { it * it }) // [0, 1, 4, 9, 16]"]
+  }
+);
+
+// src/vm/lib/global/debug.ts
+import supportsColor from "supports-color";
+function defaultSerializer(arg, format2) {
+  return null;
+}
+function serializeValue(options, arg, format2) {
+  const { serializer } = options;
+  if (serializer == null || serializer === defaultSerializer) {
+    return defaultSerializer(arg, format2);
+  }
+  try {
+    return serializer.call(options, arg, format2);
+  } catch {
+    return defaultSerializer(arg, format2);
+  }
+}
+function buildFormatString(options, args) {
+  const [prefix, ...additional] = options.prefix;
+  if (typeof args[0] != "string" || !args[0].includes("%")) {
+    return [prefix || "", [...additional, ...args]];
+  } else {
+    const [arg0, ...argsRest] = args;
+    const values4 = [...additional, ...argsRest];
+    if (!prefix) {
+      return [arg0, argsRest];
+    } else {
+      return [`${prefix} ${arg0}`, values4];
+    }
+  }
+}
+var printParser = function(args) {
+  const [format2, values4] = buildFormatString(this, args);
+  const templates = [];
+  const formats = [];
+  let valIndex = 0;
+  if (format2.includes("%")) {
+    const parts = format2.split(/(%[%\w])/g);
+    let prevIsTemplate = true;
+    for (let i = 0; i < parts.length; i++) {
+      if (i % 2 === 0) {
+        if (prevIsTemplate && templates.length) {
+          templates[templates.length - 1] += parts[i];
+        } else {
+          templates.push(parts[i]);
+        }
+        prevIsTemplate = true;
+        continue;
+      }
+      let specifier = parts[i];
+      if (specifier === "%%" || valIndex >= values4.length) {
+        if (specifier === "%%") specifier = "%";
+        if (!templates.length) {
+          templates.push(specifier);
+        } else {
+          templates[templates.length - 1] += specifier;
+        }
+        prevIsTemplate = true;
+        continue;
+      }
+      prevIsTemplate = false;
+      formats.push(specifier);
+      valIndex++;
+    }
+  } else if (format2) {
+    templates.push(format2);
+  }
+  if (valIndex < values4.length) {
+    if (templates.length) {
+      templates[templates.length - 1] += " ";
+    } else {
+      templates.push("");
+    }
+    for (let i = valIndex; i < values4.length; i++) {
+      formats.push("");
+      templates.push(i < values4.length - 1 ? " " : "");
+    }
+    valIndex++;
+  }
+  return {
+    templates,
+    values: values4,
+    formats
+  };
+};
+var printFormatter = function({
+  templates,
+  formats,
+  values: values4
+}) {
+  let format2 = "";
+  const formattedValues = [];
+  let needAwait = false;
+  for (let i = 0; i < templates.length; i++) {
+    format2 += templates[i].replaceAll("%", "%%");
+    if (i < values4.length) {
+      const f = formats[i] ?? "";
+      const v = values4[i];
+      const serialized = serializeValue(this, v, f);
+      if (serialized == null) {
+        format2 += f || (typeof v == "string" ? "%s" : "%o");
+        formattedValues.push(v);
+      } else if (typeof serialized == "string") {
+        format2 += "%s";
+        formattedValues.push(serialized);
+      } else {
+        needAwait = true;
+        format2 += "%s";
+        formattedValues.push(serialized);
+      }
+    }
+  }
+  if (!needAwait) {
+    return [format2, ...formattedValues];
+  } else {
+    return Promise.all(formattedValues).then((resolvedValues) => {
+      return [format2, ...resolvedValues];
+    });
+  }
+};
+var createPrintOptions = (consoleMethod) => {
+  return {
+    prefix: ["MiraScript"],
+    serializer: defaultSerializer,
+    parser: printParser,
+    formatter: printFormatter,
+    logger: consoleMethod
+  };
+};
+function doPrint(opt, args) {
+  const formatResult = opt.parser(args);
+  void Promise.resolve(opt.formatter(formatResult)).then((printed) => opt.logger(...printed));
+}
+var debug_print = VmLib(
+  (...args) => {
+    doPrint(debug_print, args);
+  },
+  {
+    summary: "打印调试信息到控制台",
+    params: { "..args": "要打印的调试信息，可以是任意类型" },
+    paramsType: { "..args": "any[]" },
+    returnsType: "nil",
+    examples: ['debug_print("value:", 42);']
+  },
+  // eslint-disable-next-line no-console
+  createPrintOptions(console.log.bind(console))
+);
+var panic = VmLib(
+  (message) => {
+    doPrint(panic, message === void 0 ? [] : [message]);
+    const mgsStr = toString(message, null);
+    const error = !mgsStr ? "panic" : "panic: " + mgsStr;
+    throw new VmError(error, void 0);
+  },
+  {
+    summary: "产生错误，并打印错误信息到控制台",
+    params: { message: "要打印的错误信息" },
+    paramsType: { message: "string" },
+    returnsType: "never",
+    examples: ['panic("boom");']
+  },
+  // eslint-disable-next-line no-console
+  createPrintOptions(console.error.bind(console))
+);
+if (typeof location != "undefined") {
+  const badge = "%cMiraScript%c";
+  const common = "display: inline-block; padding: 1px 4px; border-radius: 3px;";
+  const reset = "";
+  debug_print.prefix = [badge, `${common} background: #007acc; color: #fff;`, reset];
+  panic.prefix = [badge, `${common} background: #d23d3d; color: #fff;`, reset];
+} else {
+  if (supportsColor.stdout) {
+    debug_print.prefix = ["\x1B[44;37m MiraScript \x1B[0m"];
+  }
+  if (supportsColor.stderr) {
+    panic.prefix = ["\x1B[41;37m MiraScript \x1B[0m"];
+  }
+}
+
+// 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) => {
+    const j = expectString("json", json);
+    try {
+      return parse(j);
+    } catch (ex) {
+      if (fallback !== void 0) 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, fallback) => {
+    required("data", data, "");
+    return toString(data, fallback);
+  },
+  {
+    summary: "将数据转换为字符串",
+    params: {
+      data: "要转换的数据",
+      fallback: "转换失败时的返回值"
+    },
+    paramsType: { data: "any", fallback: "any" },
+    returnsType: "string | type(fallback)",
+    examples: ['to_string([1, 2]) // "1, 2"']
+  }
+);
+var to_number = VmLib(
+  (data, fallback) => {
+    required("data", data, NotNumber);
+    return toNumber(data, fallback);
+  },
+  {
+    summary: "将数据转换为数字",
+    params: {
+      data: "要转换的数据",
+      fallback: "转换失败时的返回值"
+    },
+    paramsType: { data: "string | number | boolean", fallback: "any" },
+    returnsType: "number | type(fallback)",
+    examples: ['to_number("1.5") // 1.5']
+  }
+);
+var format = VmLib(
+  (data, format2) => {
+    required("data", data, "");
+    return toFormat(data, expectString("format", format2));
+  },
+  {
+    summary: "将数据格式化为指定格式的字符串",
+    params: { data: "要格式化的数据", format: "格式字符串" },
+    paramsType: { data: "any", format: "string" },
+    returnsType: "string",
+    examples: ['format(12, ".3") // "12.000"']
+  }
+);
+
+// src/vm/lib/global/string/trim.ts
+var trim_start = VmLib(
+  (str) => {
+    return expectString("str", str).trimStart();
+  },
+  {
+    summary: "去除字符串开头的空白字符",
+    params: { str: "要处理的字符串" },
+    paramsType: { str: "string" },
+    returnsType: "string",
+    examples: ['trim_start("  mira") // "mira"']
+  }
+);
+var trim_end = VmLib(
+  (str) => {
+    return expectString("str", str).trimEnd();
+  },
+  {
+    summary: "去除字符串结尾的空白字符",
+    params: { str: "要处理的字符串" },
+    paramsType: { str: "string" },
+    returnsType: "string",
+    examples: ['trim_end("mira  ") // "mira"']
+  }
+);
+var trim = VmLib(
+  (str) => {
+    return expectString("str", str).trim();
+  },
+  {
+    summary: "去除字符串两端的空白字符",
+    params: { str: "要处理的字符串" },
+    paramsType: { str: "string" },
+    returnsType: "string",
+    examples: ['trim("  mira  ") // "mira"']
+  }
+);
+
+// src/vm/lib/global/string/case.ts
+var to_uppercase = VmLib(
+  (str) => {
+    return expectString("str", str).toUpperCase();
+  },
+  {
+    summary: "将字符串转换为大写",
+    params: { str: "要转换的字符串" },
+    paramsType: { str: "string" },
+    returnsType: "string",
+    examples: ['to_uppercase("mira") // "MIRA"']
+  }
+);
+var to_lowercase = VmLib(
+  (str) => {
+    return expectString("str", str).toLowerCase();
+  },
+  {
+    summary: "将字符串转换为小写",
+    params: { str: "要转换的字符串" },
+    paramsType: { str: "string" },
+    returnsType: "string",
+    examples: ['to_lowercase("MIRA") // "mira"']
+  }
+);
+
+// src/vm/lib/global/string/search.ts
+var starts_with = VmLib(
+  (str, search) => {
+    return expectString("str", str).startsWith(expectString("search", search));
+  },
+  {
+    summary: "检查字符串是否以指定子串开头",
+    params: { str: "要检查的字符串", search: "要匹配的子串" },
+    paramsType: { str: "string", search: "string" },
+    returnsType: "boolean",
+    examples: ['starts_with("mira", "mi") // true']
+  }
+);
+var ends_with = VmLib(
+  (str, search) => {
+    return expectString("str", str).endsWith(expectString("search", search));
+  },
+  {
+    summary: "检查字符串是否以指定子串结尾",
+    params: { str: "要检查的字符串", search: "要匹配的子串" },
+    paramsType: { str: "string", search: "string" },
+    returnsType: "boolean",
+    examples: ['ends_with("mira", "ra") // true']
+  }
+);
+var contains = VmLib(
+  (str, search) => {
+    return expectString("str", str).includes(expectString("search", search));
+  },
+  {
+    summary: "检查字符串是否包含指定子串",
+    params: { str: "要检查的字符串", search: "要匹配的子串" },
+    paramsType: { str: "string", search: "string" },
+    returnsType: "boolean",
+    examples: ['contains("hello", "ll") // true']
+  }
+);
+
+// src/vm/lib/global/string/index.ts
+var chars = VmLib(
+  (str) => {
+    return Array.from(expectString("str", str));
+  },
+  {
+    summary: "将字符串转换为字符数组",
+    params: { str: "要转换的字符串" },
+    paramsType: { str: "string" },
+    returnsType: "string[]",
+    examples: ['chars("Mira") // ["M", "i", "r", "a"]']
+  }
+);
+var replace = VmLib(
+  (str, search, replacement = "") => {
+    return expectString("str", str).replaceAll(
+      expectString("search", search),
+      expectString("replacement", 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 = "") => {
+    const s2 = expectString("str", str);
+    const p = expectString("separator", separator);
+    if (!p) return [...s2];
+    return s2.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 s2 = expectString("separator", separator);
+    return arr.map((v) => expectString(null, v)).join(s2);
+  },
+  {
+    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 fromNumber = (datetime, fallback) => {
+  const n = new Date(datetime).getTime();
+  if (isFinite(n)) return n;
+  if (fallback) return null;
+  throwError(`${describeParam("datetime")} is an invalid timestamp: ${display(datetime)}`, NotNumber);
+};
+var getTimestamp = (datetime, fallback) => {
+  if (datetime == null) {
+    return Date.now();
+  }
+  if (typeof datetime == "number") {
+    return fromNumber(datetime, fallback);
+  }
+  if (typeof datetime != "string") {
+    if (fallback) return null;
+    throwUnexpectedTypeError("datetime", "number | string", datetime, NotNumber);
+  }
+  const num2 = toNumber(datetime, NotNumber);
+  if (!isNaN(num2)) {
+    return fromNumber(num2, fallback);
+  }
+  const parsed = Date.parse(datetime);
+  if (isFinite(parsed)) return parsed;
+  if (fallback) return null;
+  throwError(`${describeParam("datetime")} cannot be parsed as datetime: ${display(datetime)}`, NotNumber);
+};
+var to_timestamp = VmLib(
+  (datetime, fallback) => {
+    const timestamp2 = getTimestamp(datetime, fallback !== void 0);
+    if (timestamp2 == null) return fallback;
+    return timestamp2;
+  },
+  {
+    summary: "将数据转换为 Unix 毫秒时间戳",
+    params: {
+      datetime: "要转换的数据，默认为当前时间",
+      fallback: "转换失败时的返回值"
+    },
+    paramsType: { datetime: "number | string | nil", fallback: "any" },
+    returnsType: "number | type(fallback)",
+    examples: ['to_timestamp("1970-01-01T00:00:00Z") // 0']
+  }
+);
+var to_datetime = VmLib(
+  (datetime, offset, fallback) => {
+    const timestamp2 = getTimestamp(datetime, fallback !== void 0);
+    if (timestamp2 == null) return fallback;
+    const o = expectNumberRange("offset", offset ?? 0, -24, 24);
+    const dateOffset = new Date(timestamp2 + 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: "将数据转换为 DateTime 记录",
+    params: {
+      datetime: "要转换的数据，默认为当前时间",
+      offset: "时区偏移量（单位：小时），默认为 0",
+      fallback: "转换失败时的返回值"
+    },
+    paramsType: { datetime: "number | string | nil", offset: "number | nil", fallback: "any" },
+    returnsType: "DateTime | type(fallback)",
+    examples: [
+      `
+to_datetime(0)
+// (
+//   year: 1970, month: 1, day: 1,
+//   hour: 0, minute: 0, second: 0,
+//   millisecond: 0,
+//   dayOfWeek: 4, offset: 0
+// )
+            `.trim()
+    ]
+  }
+);
+var to_iso8601 = VmLib(
+  (datetime, fallback) => {
+    const timestamp2 = getTimestamp(datetime, fallback !== void 0);
+    if (timestamp2 == null) return fallback;
+    return new Date(timestamp2).toISOString();
+  },
+  {
+    summary: "将数据转换为 ISO 8601 格式的字符串",
+    params: {
+      datetime: "要转换的数据，默认为当前时间",
+      fallback: "转换失败时的返回值"
+    },
+    paramsType: { datetime: "number | string | nil", fallback: "any" },
+    returnsType: "string | type(fallback)",
+    examples: ['to_iso8601(0) // "1970-01-01T00:00:00.000Z"']
+  }
+);
+
+// src/vm/lib/mod/index.ts
+var mod_exports = {};
+__export(mod_exports, {
+  matrix: () => matrix_exports
+});
+
+// src/vm/lib/mod/matrix.ts
+var matrix_exports = {};
+__export(matrix_exports, {
+  add: () => add,
+  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(matrix) {
+  if (!isVmArray(matrix)) return [];
+  if (matrix.length === 0) return [0];
+  const numRows = matrix.length;
+  let numCols = 0;
+  for (const row of matrix) {
+    if (isVmArray(row)) {
+      numCols = Math.max(numCols, row.length);
+    } else {
+      return [numRows];
+    }
+  }
+  return [numRows, numCols];
+}
+function num(v) {
+  return toNumber(v, void 0);
+}
+var size = VmLib(
+  (matrix) => {
+    required("matrix", matrix, []);
+    return sizeImpl(matrix);
+  },
+  {
+    summary: "获取矩阵尺寸",
+    params: { matrix: "要获取尺寸的矩阵" },
+    paramsType: { matrix: "any[][]" },
+    returnsType: "[number, number]",
+    examples: ["matrix.size([[1, 2], [3, 4]]) // [2, 2]"]
+  }
+);
+var transpose = VmLib(
+  (matrix) => {
+    required("matrix", matrix, []);
+    const [numRows, numCols] = sizeImpl(matrix);
+    if (numRows == null || numCols == null) return matrix;
+    const transposed = [];
+    for (let j = 0; j < numCols; j++) {
+      Cp();
+      const tj = [];
+      for (let i = 0; i < numRows; i++) {
+        const row = matrix[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 s2 = 0;
+        for (let i = 0; i < l; i++) {
+          s2 += num(a2[i]) * num(b2[i]);
+        }
+        return s2;
+      },
+      (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 e2 = num(m[0]?.[0]);
+      return [[1 / e2]];
+    }
+    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 s2 = c; s2 < cols; s2++) {
+              Ar[s2] = Ar[s2] + f * Ac[s2];
+            }
+            for (let s2 = 0; s2 < cols; s2++) {
+              Br[s2] = Br[s2] + f * Bc[s2];
+            }
+          }
+        } else {
+          const f = Ac[c];
+          for (let s2 = c; s2 < cols; s2++) {
+            Ar[s2] = Ar[s2] / f;
+          }
+          for (let s2 = 0; s2 < cols; s2++) {
+            Br[s2] = Br[s2] / 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 s2 = getNumbers(size2);
+  if (s2.length === 0) return [];
+  while (s2.length > 0) {
+    const repeat2 = arrayLen(s2.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 s2 = getNumbers(size2);
+    if (s2.length === 0) return [];
+    if (s2.length > 2) throwError("Invalid matrix size", []);
+    if (s2.length === 1) s2 = [s2[0], s2[0]];
+    const m = arrayLen(s2[0]);
+    const n = arrayLen(s2[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 = expectInteger("k", k);
+    if (x.every((e2) => isArray(e2))) {
+      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/loader.ts
+var VmBuiltinModule = class extends VmModule {
+  constructor(name, value, descriptions) {
+    super(name, value);
+    this.descriptions = descriptions;
+  }
+  /** @inheritdoc */
+  describe(key) {
+    return this.descriptions[key];
+  }
+};
+function wrapEntry(name, value, module) {
+  if (isVmModule(value)) {
+    return [value, void 0];
+  }
+  if (typeof value != "function") {
+    if (value == null || typeof value != "object" || !("value" in value)) {
+      throw new TypeError(`Cannot wrap non-function, non-const value: ${name} in module ${module}`);
+    }
+    return [value.value, value.summary || void 0];
+  }
+  if (value.name !== name) {
+    defineProperty(value, "name", { value: name });
+  }
+  defineProperty(value, "fullName", { enumerable: true, value: `${module}.${name}` });
+  return [VmFunction(value, value), value.summary || void 0];
+}
+function createModule(name, lib2) {
+  const mod = create(null);
+  const descriptions = create(null);
+  for (const [key, value] of entries(lib2)) {
+    const [wrappedValue, description] = wrapEntry(key, value, name);
+    mod[key] = wrappedValue;
+    descriptions[key] = description;
+  }
+  return new VmBuiltinModule(name, mod, descriptions);
+}
+
+// src/vm/lib/index.ts
+for (const [name, value] of entries(global_exports)) {
+  const [wrappedValue, description] = wrapEntry(name, value, "global");
+  VM_SHARED_CONTEXT[name] = wrappedValue;
+  VM_SHARED_CONTEXT_DESCRIPTIONS[name] = description;
+}
+for (const [name, value] of entries(mod_exports)) {
+  const mod = createModule(name, value);
+  const [wrappedValue, description] = wrapEntry(name, mod, "global");
+  VM_SHARED_CONTEXT[name] = wrappedValue;
+  VM_SHARED_CONTEXT_DESCRIPTIONS[name] = description;
+}
+var lib = Object.freeze(Object.assign(create(null), global_exports, mod_exports));
+
+export {
+  convert_exports,
+  VmExtern,
+  wrapToVmValue,
+  unwrapFromVmValue,
+  configCheckpoint,
+  VmFunction,
+  defineVmContextValue,
+  DefaultVmContext,
+  createVmContext,
+  VmModule,
+  $GlobalFallback,
+  operations_exports,
+  wrapScript,
+  createScript,
+  reportDiagnostic,
+  emitScript,
+  lib
+};
+//# sourceMappingURL=chunk-6CAGNGY6.js.map