@mirascript/mirascript 0.1.12 → 0.1.14

package/dist/chunk-55FKP56O.js

@@ -0,0 +1,2317 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/vm/error.ts
+var VmError = class _VmError extends Error {
+  constructor(message, recovered) {
+    super(message);
+    this.recovered = recovered;
+    this.name = "VmError";
+  }
+  /** 从其他错误构造 */
+  static from(prefix, error, recovered) {
+    if (prefix) {
+      if (prefix.endsWith(":")) {
+        prefix += " ";
+      } else if (!prefix.endsWith(": ")) {
+        prefix += ": ";
+      }
+    }
+    let vmError;
+    if (error instanceof Error) {
+      vmError = new _VmError(`${prefix}${error.message}`, recovered);
+      vmError.stack = error.stack;
+    } else {
+      vmError = new _VmError(`${prefix}${String(error)}`, recovered);
+    }
+    vmError.cause = error;
+    return vmError;
+  }
+};
+
+// src/vm/operations.ts
+var operations_exports = {};
+__export(operations_exports, {
+  $Add: () => $Add,
+  $Aeq: () => $Aeq,
+  $And: () => $And,
+  $ArraySpread: () => $ArraySpread,
+  $AssertInit: () => $AssertInit,
+  $AssertNonNil: () => $AssertNonNil,
+  $Call: () => $Call,
+  $Concat: () => $Concat,
+  $Div: () => $Div,
+  $Eq: () => $Eq,
+  $Format: () => $Format,
+  $Get: () => $Get,
+  $Gt: () => $Gt,
+  $Gte: () => $Gte,
+  $Has: () => $Has,
+  $In: () => $In,
+  $InnerToString: () => $InnerToString,
+  $IsArray: () => $IsArray,
+  $IsBoolean: () => $IsBoolean,
+  $IsNumber: () => $IsNumber,
+  $IsRecord: () => $IsRecord,
+  $IsString: () => $IsString,
+  $Iterable: () => $Iterable,
+  $Length: () => $Length,
+  $Lt: () => $Lt,
+  $Lte: () => $Lte,
+  $Mod: () => $Mod,
+  $Mul: () => $Mul,
+  $Naeq: () => $Naeq,
+  $Neg: () => $Neg,
+  $Neq: () => $Neq,
+  $Not: () => $Not,
+  $Nsame: () => $Nsame,
+  $Omit: () => $Omit,
+  $Or: () => $Or,
+  $Pick: () => $Pick,
+  $Pos: () => $Pos,
+  $Pow: () => $Pow,
+  $RecordSpread: () => $RecordSpread,
+  $Same: () => $Same,
+  $Set: () => $Set,
+  $Slice: () => $Slice,
+  $SliceExclusive: () => $SliceExclusive,
+  $Sub: () => $Sub,
+  $ToBoolean: () => $ToBoolean,
+  $ToNumber: () => $ToNumber,
+  $ToString: () => $ToString,
+  $Type: () => $Type
+});
+
+// src/helpers/utils.ts
+var { isArray } = Array;
+var { isFinite, isNaN, isInteger, isSafeInteger } = Number;
+var { hasOwn, keys, values, entries, create, getPrototypeOf, fromEntries, defineProperty } = Object;
+var { apply } = Reflect;
+var hasOwnEnumerable = Function.call.bind(
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  Object.prototype.propertyIsEnumerable
+);
+
+// src/vm/helpers.ts
+var helpers_exports = {};
+__export(helpers_exports, {
+  ArrayRange: () => ArrayRange,
+  ArrayRangeExclusive: () => ArrayRangeExclusive,
+  Cp: () => Cp,
+  CpEnter: () => CpEnter,
+  CpExit: () => CpExit,
+  Element: () => Element,
+  ElementOpt: () => ElementOpt,
+  Function: () => Function2,
+  GlobalFallback: () => GlobalFallback,
+  Upvalue: () => Upvalue,
+  Vargs: () => Vargs,
+  configCheckpoint: () => configCheckpoint
+});
+
+// src/vm/types/context.ts
+var kVmContext = Symbol.for("mirascript.vm.context");
+var VmSharedContext = create(null);
+var VmSharedContextKeys = null;
+function defineVmContextValue(name, value, override = false) {
+  if (!override && name in VmSharedContext) throw new Error(`Global variable '${name}' is already defined.`);
+  let v;
+  if (typeof value == "function") {
+    v = VmFunction(value, {
+      isLib: true,
+      fullName: `global.${name}`
+    });
+  } else {
+    v = value;
+  }
+  VmSharedContext[name] = v ?? null;
+  VmSharedContextKeys = null;
+}
+var DefaultVmContext = Object.freeze({
+  [kVmContext]: true,
+  /** @inheritdoc */
+  keys() {
+    VmSharedContextKeys ??= Object.freeze(keys(VmSharedContext));
+    return VmSharedContextKeys;
+  },
+  /** @inheritdoc */
+  get(key) {
+    return VmSharedContext[key] ?? null;
+  },
+  /** @inheritdoc */
+  has(key) {
+    return key in VmSharedContext;
+  }
+});
+var _a;
+_a = kVmContext;
+var ValueVmContext = class {
+  constructor(env, describe) {
+    this.env = env;
+    this.describe = describe;
+    this[_a] = true;
+    this.cachedKeys = null;
+  }
+  /** @inheritdoc */
+  keys() {
+    this.cachedKeys ??= keys(this.env);
+    return [...this.cachedKeys, ...DefaultVmContext.keys()];
+  }
+  /** @inheritdoc */
+  get(key) {
+    return this.env[key] ?? null;
+  }
+  /** @inheritdoc */
+  has(key) {
+    return key in this.env;
+  }
+};
+var _a2;
+_a2 = kVmContext;
+var FactoryVmContext = class {
+  constructor(getter, enumerator, describe) {
+    this.getter = getter;
+    this.enumerator = enumerator;
+    this.describe = describe;
+    this[_a2] = true;
+  }
+  /** @inheritdoc */
+  keys() {
+    if (!this.enumerator) return DefaultVmContext.keys();
+    return [...this.enumerator(), ...DefaultVmContext.keys()];
+  }
+  /** @inheritdoc */
+  get(key) {
+    const value = this.getter(key);
+    if (value !== void 0) return value;
+    return DefaultVmContext.get(key);
+  }
+  /** @inheritdoc */
+  has(key) {
+    return this.getter(key) !== void 0 || DefaultVmContext.has(key);
+  }
+};
+function createVmContext(...args) {
+  if (args[0] == null && args[1] == null) {
+    return { ...DefaultVmContext };
+  }
+  if (typeof args[0] == "function") {
+    const [getter, enumerator, describer2] = args;
+    return new FactoryVmContext(getter, enumerator ?? void 0, describer2 ?? void 0);
+  }
+  const [vmValues, externValues, describer] = args;
+  const env = create(VmSharedContext);
+  if (vmValues) {
+    for (const [key, value] of entries(vmValues)) {
+      if (!isVmAny(value, false)) continue;
+      env[key] = value ?? null;
+    }
+  }
+  if (externValues) {
+    for (const [key, value] of entries(externValues)) {
+      env[key] = value == null ? null : wrapToVmValue(value, null);
+    }
+  }
+  return new ValueVmContext(env, describer ?? void 0);
+}
+function isVmContext(context) {
+  if (context == null || typeof context != "object") return false;
+  return context[kVmContext] === true;
+}
+
+// src/vm/helpers.ts
+var Vargs = (varags) => {
+  for (let i = 0, l = varags.length; i < l; i++) {
+    const el = varags[i];
+    if (!isVmConst(el)) {
+      varags[i] = null;
+    }
+  }
+  return varags;
+};
+var Element = (value) => {
+  $AssertInit(value);
+  if (!isVmConst(value)) return null;
+  return value;
+};
+var ElementOpt = (key, value) => {
+  $AssertInit(value);
+  if (value == null || !isVmConst(value)) return {};
+  return { [key]: value };
+};
+var Function2 = (fn) => {
+  return VmFunction(fn, { isLib: false, injectCp: false });
+};
+var Upvalue = (value) => {
+  $AssertInit(value);
+  return value;
+};
+var assertArrayLength = (start, end) => {
+  if (end - start > VM_ARRAY_MAX_LENGTH) {
+    throw new RangeError(`Array length exceeds maximum limit of ${VM_ARRAY_MAX_LENGTH}`);
+  }
+};
+var isEmptyRange = (start, end) => {
+  return !isFinite(start) || !isFinite(end) || start > end;
+};
+var ArrayRange = (start, end) => {
+  const s = $ToNumber(start);
+  const e = $ToNumber(end);
+  if (isEmptyRange(s, e)) return [];
+  assertArrayLength(s, e);
+  const arr = [];
+  for (let i = s; i <= e; i++) {
+    arr.push(i);
+  }
+  return arr;
+};
+var ArrayRangeExclusive = (start, end) => {
+  const s = $ToNumber(start);
+  const e = $ToNumber(end);
+  if (isEmptyRange(s, e)) return [];
+  assertArrayLength(s, e);
+  const arr = [];
+  for (let i = s; i < e; i++) {
+    arr.push(i);
+  }
+  return arr;
+};
+var MAX_DEPTH = 128;
+var cpDepth = 0;
+var cp = Number.NaN;
+var cpTimeout = 100;
+function Cp() {
+  if (!cp) {
+    cp = Date.now();
+  } else if (Date.now() - cp > cpTimeout) {
+    throw new RangeError("Execution timeout");
+  }
+}
+function CpEnter() {
+  cpDepth++;
+  if (cpDepth <= 1) {
+    cp = Date.now();
+    cpDepth = 1;
+  } else if (cpDepth > MAX_DEPTH) {
+    throw new RangeError("Maximum call depth exceeded");
+  } else {
+    Cp();
+  }
+}
+function CpExit() {
+  cpDepth--;
+  if (cpDepth < 1) {
+    cp = Number.NaN;
+    cpDepth = 0;
+  } else {
+    Cp();
+  }
+}
+function configCheckpoint(timeout = 100) {
+  if (typeof timeout !== "number" || timeout <= 0 || Number.isNaN(timeout)) {
+    throw new RangeError("Invalid timeout value");
+  }
+  cpTimeout = timeout;
+}
+function GlobalFallback() {
+  return DefaultVmContext;
+}
+
+// src/vm/types/function.ts
+var kVmFunction = Symbol.for("mirascript.vm.function");
+function isVmFunction(value) {
+  return getVmFunctionInfo(value) != null;
+}
+function getVmFunctionInfo(value) {
+  if (typeof value != "function") return void 0;
+  return value[kVmFunction];
+}
+function VmFunction(fn, option = {}) {
+  if (typeof fn != "function") {
+    throw new TypeError("Invalid function");
+  }
+  const exists = fromVmFunctionProxy(fn);
+  if (exists) return exists;
+  const info = {
+    fullName: option.fullName ?? fn.name,
+    isLib: option.isLib ?? false,
+    summary: option.summary || void 0,
+    params: option.params,
+    paramsType: option.paramsType,
+    returns: option.returns || void 0,
+    returnsType: option.returnsType || void 0,
+    examples: option.examples?.length ? option.examples : void 0
+  };
+  if (option.injectCp) {
+    const original = fn;
+    info.original = original;
+    fn = ((...args) => {
+      try {
+        CpEnter();
+        const ret = original(...args);
+        return ret;
+      } finally {
+        CpExit();
+      }
+    });
+    defineProperty(fn, "name", {
+      value: original.name,
+      configurable: true
+    });
+  }
+  defineProperty(fn, kVmFunction, {
+    value: Object.freeze(info)
+  });
+  return fn;
+}
+
+// src/vm/types/wrapper.ts
+var VmWrapper = class {
+  constructor(value) {
+    this.value = value;
+  }
+  /** Convert the object to JSON */
+  toJSON() {
+    return void 0;
+  }
+  /** 转为字符串 */
+  toString(useBraces) {
+    const { type, describe } = this;
+    if (!describe) return `<${type}>`;
+    return `<${type} ${describe}>`;
+  }
+};
+var kVmWrapper = Symbol.for("mirascript.vm.wrapper");
+Object.defineProperty(VmWrapper.prototype, kVmWrapper, { value: true });
+function isVmWrapper(value) {
+  return value != null && typeof value == "object" && kVmWrapper in 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 VmExtern = class extends VmWrapper {
+  constructor(value, thisArg = null) {
+    super(value);
+    this.thisArg = thisArg;
+  }
+  /** Check if the object has a property */
+  access(key, read) {
+    if (key.startsWith("_")) return false;
+    if (typeof this.value == "function" && (key === "prototype" || key === "arguments" || key === "caller"))
+      return false;
+    if (hasOwn(this.value, key)) return true;
+    if (!read) return true;
+    if (!(key in this.value)) return false;
+    if (key === "constructor") return false;
+    const prop = this.value[key];
+    if (key in Function.prototype && prop === Function.prototype[key]) return false;
+    if (key in Array.prototype && prop === Array.prototype[key]) return false;
+    if (key in Object.prototype && prop === Object.prototype[key]) return false;
+    return true;
+  }
+  /** 决定是否对属性进行包装 */
+  assumeVmValue(value, key) {
+    return false;
+  }
+  /** @inheritdoc */
+  has(key) {
+    return this.access(key, true);
+  }
+  /** @inheritdoc */
+  get(key) {
+    if (!this.has(key)) return void 0;
+    const prop = this.value[key];
+    return wrapToVmValue(prop, this, (v) => this.assumeVmValue(v, key));
+  }
+  /** Set a property on the object */
+  set(key, value) {
+    if (!this.access(key, false)) return false;
+    const prop = unwrapFromVmValue(value);
+    this.value[key] = prop;
+    return true;
+  }
+  /** Call extern value */
+  call(args) {
+    const { value } = this;
+    if (typeof value != "function") {
+      throw VmError.from(`Not a callable extern`, null, null);
+    }
+    const caller = this.thisArg?.value ?? null;
+    const unwrappedArgs = args.map(unwrapFromVmValue);
+    let ret;
+    try {
+      ret = apply(value, caller, unwrappedArgs);
+    } catch (ex) {
+      throw VmError.from(`Callable extern`, ex, null);
+    }
+    return wrapToVmValue(ret, null, (obj) => this.assumeVmValue(obj, void 0));
+  }
+  /** @inheritdoc */
+  keys() {
+    const keys2 = [];
+    for (const key in this.value) {
+      if (this.has(key)) keys2.push(key);
+    }
+    return keys2;
+  }
+  /** @inheritdoc */
+  same(other) {
+    if (!isVmExtern(other)) return false;
+    return this.value === other.value && this.thisArg === other.thisArg;
+  }
+  /** @inheritdoc */
+  toString(useBraces) {
+    const { toString } = this.value;
+    if (typeof toString != "function" || toString === ObjectToString || toString === FunctionToString) {
+      return super.toString(useBraces);
+    }
+    if (toString === ArrayToString && isArray(this.value)) {
+      const mapped = ArrayMap.call(this.value, (item) => {
+        if (item === void 0) return "";
+        return $InnerToString(wrapToVmValue(item ?? null, null), true);
+      });
+      const str = mapped.join(", ");
+      if (useBraces) return `[${str}]`;
+      return str;
+    }
+    try {
+      return String(this.value);
+    } catch {
+      return super.toString(useBraces);
+    }
+  }
+  /** @inheritdoc */
+  get type() {
+    return "extern";
+  }
+  /** @inheritdoc */
+  get describe() {
+    const tag = ObjectToString.call(this.value).slice(8, -1);
+    if (isArray(this.value)) {
+      return `${tag}(${this.value.length})`;
+    } else if (tag === "Object") {
+      const proto = getPrototypeOf(this.value);
+      if (proto === ObjectPrototype) {
+        return "Object";
+      }
+      if (proto == null) {
+        return "Object: null prototype";
+      }
+      if (typeof proto.constructor === "function" && proto.constructor.name) {
+        return proto.constructor.name;
+      }
+    } else if (tag === "Function" && "prototype" in this.value && typeof this.value.prototype == "object") {
+      const { name } = this.value;
+      return `class ${name || "<anonymous>"}`;
+    } else if (tag === "Function") {
+      const { name } = this.value;
+      return `function ${name || "<anonymous>"}()`;
+    } else if (tag === "AsyncFunction") {
+      const { name } = this.value;
+      return `async function ${name || "<anonymous>"}()`;
+    } else if (tag === "GeneratorFunction") {
+      const { name } = this.value;
+      return `function* ${name || "<anonymous>"}()`;
+    } else if (tag === "AsyncGeneratorFunction") {
+      const { name } = this.value;
+      return `async function* ${name || "<anonymous>"}()`;
+    }
+    return tag;
+  }
+};
+var kVmExtern = Symbol.for("mirascript.vm.extern");
+Object.defineProperty(VmExtern.prototype, kVmExtern, { value: true });
+function isVmExtern(value) {
+  return value != null && typeof value == "object" && kVmExtern in value;
+}
+
+// src/vm/types/boundary.ts
+var kProxy = Symbol.for("mirascript.vm.function.proxy");
+function toVmFunctionProxy(fn) {
+  if (!isVmFunction(fn)) return fn;
+  const cached = fn[kProxy];
+  if (cached != null) return cached;
+  const proxy = (...args) => {
+    const ret = $Call(
+      fn,
+      // 作为函数参数传入的值一定丢失了它的 this
+      args.map((v) => wrapToVmValue(v, null))
+    );
+    return unwrapFromVmValue(ret);
+  };
+  defineProperty(fn, kProxy, { value: proxy });
+  defineProperty(proxy, kProxy, { value: fn });
+  defineProperty(proxy, "name", {
+    value: fn.name,
+    configurable: true
+  });
+  return proxy;
+}
+function fromVmFunctionProxy(fn) {
+  if (isVmFunction(fn)) return fn;
+  const original = fn[kProxy];
+  if (original && isVmFunction(original)) return original;
+  return void 0;
+}
+function wrapToVmValue(value, thisArg = null, assumeVmValue) {
+  if (value == null) return null;
+  switch (typeof value) {
+    case "function": {
+      const unwrapped = fromVmFunctionProxy(value);
+      if (unwrapped) return unwrapped;
+      return new VmExtern(value, thisArg);
+    }
+    case "object": {
+      if (isVmWrapper(value)) return value;
+      if (value instanceof Date) return value.valueOf();
+      if (assumeVmValue?.(value)) return value;
+      return new VmExtern(value);
+    }
+    case "string":
+    case "number":
+    case "boolean":
+      return value;
+    case "bigint":
+      return Number(value);
+    case "symbol":
+    case "undefined":
+    default:
+      return null;
+  }
+}
+function unwrapFromVmValue(value) {
+  if (typeof value == "function") {
+    return toVmFunctionProxy(value);
+  }
+  if (value == null || typeof value != "object") return value;
+  if (!isVmExtern(value)) return value;
+  if (value.thisArg == null || typeof value.value != "function") {
+    return value.value;
+  }
+  const f = value;
+  const caller = f.thisArg.value;
+  return new Proxy(f.value, {
+    apply(target, thisArg, args) {
+      return apply(target, caller, args);
+    }
+  });
+}
+
+// src/vm/types/script.ts
+var kVmScript = Symbol.for("mirascript.vm.script");
+function isVmScript(value) {
+  return typeof value === "function" && value[kVmScript] === true;
+}
+
+// src/vm/types/callable.ts
+function isVmCallable(value) {
+  return isVmFunction(value) || isVmExtern(value) && typeof value.value == "function";
+}
+
+// src/vm/types/array.ts
+var VM_ARRAY_MAX_LENGTH = 2 ** 31 - 1;
+function isVmArray(value) {
+  if (!isArray(value)) return false;
+  value;
+  return true;
+}
+
+// src/vm/types/record.ts
+function isVmRecord(value) {
+  if (value == null || typeof value !== "object") return false;
+  if (isVmWrapper(value)) return false;
+  if (isVmArray(value)) return false;
+  value;
+  return true;
+}
+function isVmArrayLikeRecordByEntires(entries2) {
+  const { length } = entries2;
+  if (length === 0) return true;
+  if (length > VM_ARRAY_MAX_LENGTH) return false;
+  const firstKey = entries2[0][0];
+  if (firstKey !== "0") return false;
+  const lastKey = entries2[length - 1][0];
+  if (lastKey !== String(length - 1)) return false;
+  return true;
+}
+function isVmArrayLikeRecordByKeys(keys2) {
+  const { length } = keys2;
+  if (length === 0) return true;
+  if (length > VM_ARRAY_MAX_LENGTH) return false;
+  const firstKey = keys2[0];
+  if (firstKey !== "0") return false;
+  const lastKey = keys2[length - 1];
+  if (lastKey !== String(length - 1)) return false;
+  return true;
+}
+function isVmArrayLikeRecord(value) {
+  return isVmArrayLikeRecordByKeys(keys(value));
+}
+
+// src/vm/types/primitive.ts
+function isVmPrimitive(value) {
+  if (value === null || typeof value == "number" || typeof value == "string" || typeof value == "boolean") {
+    value;
+    value;
+    return true;
+  }
+  return false;
+}
+
+// src/vm/types/const.ts
+var MAX_DEPTH2 = 32;
+function isVmArrayDeep(value, depth) {
+  const proto1 = getPrototypeOf(value);
+  if (!isArray(proto1)) return false;
+  if (!depth) return true;
+  return value.every((item) => isVmConstInner(item, depth));
+}
+function isVmRecordDeep(value, depth) {
+  let isRecord;
+  const proto1 = getPrototypeOf(value);
+  if (proto1 == null) {
+    isRecord = true;
+  } else {
+    const proto2 = getPrototypeOf(proto1);
+    if (proto2 != null) {
+      isRecord = false;
+    } else {
+      isRecord = "hasOwnProperty" in value;
+    }
+  }
+  if (!isRecord) return false;
+  if (!depth) return true;
+  return values(value).every((value2) => isVmConstInner(value2, depth));
+}
+function isVmConstInner(value, depth) {
+  if (depth++ >= MAX_DEPTH2) return false;
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "undefined":
+      return true;
+    case "object":
+      if (value == null) return true;
+      if (isVmWrapper(value)) return false;
+      if (isArray(value)) {
+        return isVmArrayDeep(value, depth);
+      } else {
+        return isVmRecordDeep(value, depth);
+      }
+    case "function":
+    case "bigint":
+    case "symbol":
+    default:
+      return false;
+  }
+}
+function isVmConst(value, checkDeep = false) {
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+      return true;
+    case "object":
+      if (value == null) return true;
+      if (isVmWrapper(value)) return false;
+      if (!checkDeep) {
+        if (isArray(value)) {
+          return isVmArrayDeep(value, 0);
+        } else {
+          return isVmRecordDeep(value, 0);
+        }
+      } else {
+        return isVmConstInner(value, 1);
+      }
+    case "undefined":
+    case "function":
+    case "bigint":
+    case "symbol":
+    default:
+      return false;
+  }
+}
+
+// src/vm/types/module.ts
+var VmModule = class extends VmWrapper {
+  constructor(name, value) {
+    super(value);
+    this.name = name;
+  }
+  /** @inheritdoc */
+  has(key) {
+    return hasOwnEnumerable(this.value, key);
+  }
+  /** @inheritdoc */
+  get(key) {
+    if (!this.has(key)) return void 0;
+    return this.value[key] ?? null;
+  }
+  /** @inheritdoc */
+  keys() {
+    return keys(this.value);
+  }
+  /** @inheritdoc */
+  same(other) {
+    return this === other;
+  }
+  /** @inheritdoc */
+  get type() {
+    return "module";
+  }
+  /** @inheritdoc */
+  get describe() {
+    return this.name;
+  }
+};
+var kVmModule = Symbol.for("mirascript.vm.module");
+Object.defineProperty(VmModule.prototype, kVmModule, { value: true });
+function isVmModule(value) {
+  return value != null && typeof value == "object" && kVmModule in value;
+}
+
+// src/vm/types/immutable.ts
+function isVmImmutable(value, checkDeep = false) {
+  return isVmModule(value) || isVmFunction(value) || isVmConst(value, checkDeep);
+}
+
+// src/vm/types/any.ts
+function isVmAny(value, checkDeep) {
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "undefined":
+      return true;
+    case "object":
+      if (value == null) return true;
+      if (isVmWrapper(value)) return true;
+      return isVmConst(value, checkDeep);
+    case "function":
+      return isVmFunction(value);
+    case "bigint":
+    case "symbol":
+    default:
+      return false;
+  }
+}
+
+// src/vm/types/value.ts
+function isVmValue(value, checkDeep = false) {
+  if (value === void 0) return false;
+  return isVmAny(value, checkDeep);
+}
+
+// src/vm/operations.ts
+var { abs, min, trunc, ceil } = Math;
+var { slice, at } = Array.prototype;
+var { POSITIVE_INFINITY, NEGATIVE_INFINITY } = Number;
+var isSame = (a, b) => {
+  if (typeof a == "number" && typeof b == "number") return a === b || isNaN(a) && isNaN(b);
+  if (a === b) return true;
+  if (a == null || typeof a != "object" || b == null || typeof b != "object") return false;
+  if (isVmWrapper(a)) return a.same(b);
+  if (isVmWrapper(b)) return b.same(a);
+  if (isVmArray(a) && isVmArray(b)) {
+    const len = a.length;
+    if (len !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < len; i++) {
+      if (!isSame(a[i] ?? null, b[i] ?? null)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (!isVmArray(a) && !isVmArray(b)) {
+    const aKeys = keys(a);
+    const bKeys = keys(b);
+    if (aKeys.length !== bKeys.length) {
+      return false;
+    }
+    for (const key of aKeys) {
+      if (!hasOwnEnumerable(b, key)) {
+        return false;
+      }
+      if (!isSame(a[key] ?? null, b[key] ?? null)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+};
+var overloadNumberString = (a, b) => {
+  if (typeof a == "number" || typeof b == "number") return true;
+  if (typeof a == "string" || typeof b == "string") return false;
+  return true;
+};
+var $Add = (a, b) => {
+  return $ToNumber(a) + $ToNumber(b);
+};
+var $Sub = (a, b) => {
+  return $ToNumber(a) - $ToNumber(b);
+};
+var $Mul = (a, b) => {
+  return $ToNumber(a) * $ToNumber(b);
+};
+var $Div = (a, b) => {
+  return $ToNumber(a) / $ToNumber(b);
+};
+var $Mod = (a, b) => {
+  return $ToNumber(a) % $ToNumber(b);
+};
+var $Pow = (a, b) => {
+  return $ToNumber(a) ** $ToNumber(b);
+};
+var $And = (a, b) => {
+  return $ToBoolean(a) && $ToBoolean(b);
+};
+var $Or = (a, b) => {
+  return $ToBoolean(a) || $ToBoolean(b);
+};
+var $Gt = (a, b) => {
+  if (overloadNumberString(a, b)) {
+    return $ToNumber(a) > $ToNumber(b);
+  } else {
+    return $ToString(a) > $ToString(b);
+  }
+};
+var $Gte = (a, b) => {
+  if (overloadNumberString(a, b)) {
+    return $ToNumber(a) >= $ToNumber(b);
+  } else {
+    return $ToString(a) >= $ToString(b);
+  }
+};
+var $Lt = (a, b) => {
+  if (overloadNumberString(a, b)) {
+    return $ToNumber(a) < $ToNumber(b);
+  } else {
+    return $ToString(a) < $ToString(b);
+  }
+};
+var $Lte = (a, b) => {
+  if (overloadNumberString(a, b)) {
+    return $ToNumber(a) <= $ToNumber(b);
+  } else {
+    return $ToString(a) <= $ToString(b);
+  }
+};
+var $Eq = (a, b) => {
+  $AssertInit(a);
+  $AssertInit(b);
+  if (typeof a == "number" && typeof b == "number") return a === b;
+  return isSame(a, b);
+};
+var $Neq = (a, b) => {
+  return !$Eq(a, b);
+};
+var $Aeq = (a, b) => {
+  if (overloadNumberString(a, b)) {
+    const an = $ToNumber(a);
+    const bn = $ToNumber(b);
+    const EPS = 1e-15;
+    if (isNaN(an) || isNaN(bn)) return false;
+    if (an === bn) return true;
+    const absoluteDifference = abs(an - bn);
+    if (absoluteDifference < EPS) return true;
+    const base = min(abs(an), abs(bn));
+    return absoluteDifference < base * EPS;
+  } else {
+    const as = $ToString(a);
+    const bs = $ToString(b);
+    if (as === bs) return true;
+    const ai = as.toLowerCase();
+    const bi = bs.toLowerCase();
+    if (ai === bi) return true;
+    const an = ai.normalize("NFC");
+    const bn = bi.normalize("NFC");
+    return an === bn;
+  }
+};
+var $Naeq = (a, b) => {
+  return !$Aeq(a, b);
+};
+var $Same = (a, b) => {
+  $AssertInit(a);
+  $AssertInit(b);
+  return isSame(a, b);
+};
+var $Nsame = (a, b) => {
+  return !$Same(a, b);
+};
+var $In = (value, iterable) => {
+  $AssertInit(value);
+  $AssertInit(iterable);
+  if (iterable == null) return false;
+  if (isVmArray(iterable)) {
+    if (value == null) {
+      for (const item of iterable) {
+        if (item == null) return true;
+      }
+      return false;
+    }
+    if (isVmPrimitive(value)) return iterable.includes(value);
+    value;
+    return iterable.some((item = null) => isSame(item, value));
+  }
+  if (isVmWrapper(iterable)) return iterable.has($ToString(value));
+  if (typeof iterable == "object") return hasOwnEnumerable(iterable, $ToString(value));
+  iterable;
+  return false;
+};
+var $Concat = (...args) => {
+  return args.map($Format).join("");
+};
+var $Pos = (a) => {
+  return $ToNumber(a);
+};
+var $Neg = (a) => {
+  return -$ToNumber(a);
+};
+var $Not = (a) => {
+  return !$ToBoolean(a);
+};
+var $Length = (value) => {
+  $AssertInit(value);
+  if (isVmArray(value)) return value.length;
+  if (isVmRecord(value)) return keys(value).length;
+  if (isVmWrapper(value)) {
+    return value.keys().length;
+  }
+  return Number.NaN;
+};
+var $Omit = (value, omitted) => {
+  $AssertInit(value);
+  if (value == null || !isVmRecord(value)) return {};
+  const result = {};
+  const valueKeys = keys(value);
+  const omittedSet = new Set(omitted.map($ToString));
+  for (const key of valueKeys) {
+    if (!omittedSet.has(key)) {
+      result[key] = value[key] ?? null;
+    }
+  }
+  return result;
+};
+var $Pick = (value, picked) => {
+  $AssertInit(value);
+  if (value == null || !isVmRecord(value)) return {};
+  const result = {};
+  for (const key of picked) {
+    const k = $ToString(key);
+    if (hasOwnEnumerable(value, k)) {
+      result[k] = value[k] ?? null;
+    }
+  }
+  return result;
+};
+var sliceCore = (value, start, end, exclusive) => {
+  const { length } = value;
+  if (isNaN(start)) start = 0;
+  else if (start < 0) start = length + start;
+  if (isNaN(end)) end = exclusive ? length : length - 1;
+  else if (end < 0) end = length + end;
+  start = ceil(start);
+  if (exclusive || !isSafeInteger(end)) {
+    end = ceil(end);
+  } else {
+    end = end + 1;
+  }
+  return slice.call(value, start, end);
+};
+var $Slice = (value, start, end) => {
+  $AssertInit(value);
+  if (!isVmArray(value)) throw new VmError(`Expected array, got ${$Type(value)}`, []);
+  const s = start != null ? $ToNumber(start) : 0;
+  const e = end != null ? $ToNumber(end) : value.length - 1;
+  return sliceCore(value, s, e, false);
+};
+var $SliceExclusive = (value, start, end) => {
+  $AssertInit(value);
+  if (!isVmArray(value)) throw new VmError(`Expected array, got ${$Type(value)}`, []);
+  const s = start != null ? $ToNumber(start) : 0;
+  const e = end != null ? $ToNumber(end) : value.length;
+  return sliceCore(value, s, e, true);
+};
+var $AssertInit = (value) => {
+  if (value === void 0) throw new VmError(`Uninitialized value`, null);
+};
+var $Call = (func, args) => {
+  for (const a of args) {
+    $AssertInit(a);
+  }
+  if (isVmExtern(func)) {
+    return func.call(args) ?? null;
+  }
+  if (isVmFunction(func)) {
+    return func(...args) ?? null;
+  }
+  throw new VmError(`Expected callable, got ${$Type(func)}`, null);
+};
+var $Type = (value) => {
+  if (value === void 0 || value === null) return "nil";
+  if (isVmExtern(value)) return "extern";
+  if (isVmModule(value)) return "module";
+  if (isVmArray(value)) return "array";
+  if (typeof value == "object") return "record";
+  return typeof value;
+};
+var $ToBoolean = (value) => {
+  $AssertInit(value);
+  return value != null && value !== false;
+};
+function numberToString(value) {
+  if (isNaN(value)) return "nan";
+  if (value === Infinity) return "inf";
+  if (value === -Infinity) return "-inf";
+  return String(value);
+}
+function $InnerToString(value, useBraces) {
+  if (value == null) return "nil";
+  if (isVmWrapper(value)) return value.toString(useBraces);
+  if (typeof value == "function") {
+    const name = getVmFunctionInfo(value)?.fullName;
+    return name ? `<function ${name}>` : `<function>`;
+  }
+  if (isVmArray(value)) {
+    const strings = [];
+    for (const item of value) {
+      strings.push($InnerToString(item, true));
+    }
+    const results = strings.join(", ");
+    if (!useBraces) return results;
+    return `[${results}]`;
+  }
+  if (typeof value == "object") {
+    const entries2 = keys(value).map((key) => `${key}: ${$InnerToString(value[key], true)}`).join(", ");
+    if (!useBraces) return entries2;
+    return `(${entries2})`;
+  }
+  if (typeof value == "number") {
+    return numberToString(value);
+  }
+  return String(value);
+}
+var $ToString = (value) => {
+  $AssertInit(value);
+  if (typeof value == "string") return value;
+  if (value === null) return "";
+  return $InnerToString(value, false);
+};
+var $ToNumber = (value) => {
+  $AssertInit(value);
+  if (typeof value == "number") return value;
+  if (value == null) return 0;
+  if (typeof value == "string") {
+    value = value.trim();
+    if (value === "") return 0;
+    if (value === "inf" || value === "+inf" || value === "Infinity" || value === "+Infinity") {
+      return POSITIVE_INFINITY;
+    }
+    if (value === "-inf" || value === "-Infinity") {
+      return NEGATIVE_INFINITY;
+    }
+    return Number(value);
+  }
+  if (typeof value == "boolean") return value ? 1 : 0;
+  return Number.NaN;
+};
+var $IsBoolean = (value) => {
+  $AssertInit(value);
+  return typeof value == "boolean";
+};
+var $IsNumber = (value) => {
+  $AssertInit(value);
+  return typeof value == "number";
+};
+var $IsString = (value) => {
+  $AssertInit(value);
+  return typeof value == "string";
+};
+var $IsRecord = (value) => {
+  $AssertInit(value);
+  return isVmRecord(value);
+};
+var $IsArray = (value) => {
+  $AssertInit(value);
+  return isVmArray(value);
+};
+var $AssertNonNil = (value) => {
+  $AssertInit(value);
+  if (value !== null) return;
+  throw new VmError("Expected non-nil value", null);
+};
+var $Has = (obj, key) => {
+  $AssertInit(obj);
+  const pk = $ToString(key);
+  if (obj == null || typeof obj != "object") return false;
+  if (isVmWrapper(obj)) return obj.has(pk);
+  return hasOwnEnumerable(obj, pk);
+};
+var $Get = (obj, key) => {
+  $AssertInit(obj);
+  if (isVmArray(obj)) {
+    const index = $ToNumber(key);
+    if (isNaN(index)) return null;
+    return at.call(obj, trunc(index)) ?? null;
+  }
+  const pk = $ToString(key);
+  if (obj == null || typeof obj != "object") return null;
+  if (isVmWrapper(obj)) return obj.get(pk) ?? null;
+  if (!hasOwnEnumerable(obj, pk)) return null;
+  return obj[pk] ?? null;
+};
+var $Set = (obj, key, value) => {
+  $AssertInit(obj);
+  $AssertInit(value);
+  const pk = $ToString(key);
+  if (obj == null) return;
+  if (!isVmExtern(obj)) throw new VmError(`Expected extern, got ${$Type(obj)}`, void 0);
+  obj.set(pk, value);
+};
+var $Iterable = (value) => {
+  $AssertInit(value);
+  if (isVmWrapper(value)) return value.keys();
+  if (isVmArray(value)) return value;
+  if (value != null && typeof value == "object") return keys(value);
+  throw new VmError(`Value is not iterable`, isVmFunction(value) ? [] : [value]);
+};
+var $RecordSpread = (record) => {
+  $AssertInit(record);
+  if (record == null || isVmRecord(record)) return record;
+  if (isVmArray(record)) {
+    const result = {};
+    const len = record.length;
+    for (let i = 0; i < len; i++) {
+      const item = record[i];
+      result[i] = item ?? null;
+    }
+    return result;
+  }
+  if (isVmExtern(record)) {
+    const result = create(null);
+    for (const key of record.keys()) {
+      const value = record.get(key) ?? null;
+      if (isVmPrimitive(value)) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  throw new VmError(`Expected record, array, extern or nil, got ${$Type(record)}`, null);
+};
+var $ArraySpread = (array) => {
+  $AssertInit(array);
+  if (array == null) return [];
+  if (isVmArray(array)) return array;
+  if (isVmExtern(array) && typeof array.value[Symbol.iterator] == "function") {
+    const result = [];
+    for (const item of array.value) {
+      if (isVmPrimitive(item)) {
+        result.push(item);
+      } else {
+        result.push(null);
+      }
+    }
+    return result;
+  }
+  throw new VmError(`Expected array, iterable extern or nil, got ${$Type(array)}`, []);
+};
+function formatNumber(value) {
+  if (!Number.isFinite(value)) return numberToString(value);
+  if (value === 0) return "0";
+  const s = value.toString();
+  let ps;
+  const abs2 = Math.abs(value);
+  if (abs2 >= 1e3 || abs2 < 1e-3) {
+    const ps1 = value.toExponential();
+    const ps2 = value.toExponential(5);
+    ps = ps1.length < ps2.length ? ps1 : ps2;
+  } else {
+    ps = value.toPrecision(6);
+  }
+  return ps.length < s.length ? ps : s;
+}
+var $Format = (value, format) => {
+  $AssertInit(value);
+  const f = format == null ? "" : typeof format == "string" ? format.trim() : $ToString(format);
+  if (typeof value == "number") {
+    if (/^\.\d+$/.test(f)) {
+      let digits = Math.trunc(Number(f.slice(1)));
+      if (!(digits <= 100)) digits = 100;
+      return value.toFixed(digits);
+    } else {
+      return formatNumber(value);
+    }
+  }
+  return $ToString(value);
+};
+
+// src/compiler/diagnostic.ts
+import { DiagnosticCode, getModule } from "@mirascript/bindings";
+var diagnosticMessages = /* @__PURE__ */ new Map();
+function getDiagnosticMessage(code) {
+  if (!isSafeInteger(code) || code < 0 || code >= 65535) {
+    throw new RangeError(`Invalid DiagnosticCode: ${code}`);
+  }
+  if (diagnosticMessages.has(code)) {
+    return diagnosticMessages.get(code) || null;
+  }
+  const mod = getModule();
+  const msg = mod.getDiagnosticMessage(code);
+  diagnosticMessages.set(code, msg);
+  return msg;
+}
+function parseDiagnostics(source, diagnostics, filter) {
+  const parsed = [];
+  const bufLen = diagnostics.length;
+  for (let i = 0; i < bufLen; i += 5) {
+    const code = diagnostics[i + 4];
+    if (filter && !filter(code)) {
+      continue;
+    }
+    const startLineNumber = diagnostics[i];
+    const startColumn = diagnostics[i + 1];
+    const endLineNumber = diagnostics[i + 2];
+    const endColumn = diagnostics[i + 3];
+    parsed.push({
+      code,
+      range: {
+        startLineNumber,
+        startColumn,
+        endLineNumber,
+        endColumn
+      }
+    });
+  }
+  const _errors = [];
+  const _warnings = [];
+  const _infos = [];
+  const _hints = [];
+  const _tags = [];
+  const _references = [];
+  const _tagsReferences = [];
+  const _sourcemaps = [];
+  for (let i = 0; i < parsed.length; i++) {
+    const diagnostic = parsed[i];
+    const { code } = diagnostic;
+    if (code > DiagnosticCode.ErrorStart && code < DiagnosticCode.ErrorEnd) {
+      _errors.push(diagnostic);
+    } else if (code > DiagnosticCode.WarningStart && code < DiagnosticCode.WarningEnd) {
+      _warnings.push(diagnostic);
+    } else if (code > DiagnosticCode.InfoStart && code < DiagnosticCode.InfoEnd) {
+      _infos.push(diagnostic);
+    } else if (code > DiagnosticCode.HintStart && code < DiagnosticCode.HintEnd) {
+      _hints.push(diagnostic);
+    } else if (code > DiagnosticCode.TagStart && code < DiagnosticCode.TagEnd) {
+      _tags.push(diagnostic);
+    } else if (code === DiagnosticCode.SourceMap) {
+      _sourcemaps.push(diagnostic.range);
+      continue;
+    } else {
+      continue;
+    }
+    diagnostic.references = [];
+    while (i + 1 < parsed.length) {
+      const ref = parsed[i + 1];
+      let isRef = false;
+      if (ref.code > DiagnosticCode.TagRefStart && ref.code < DiagnosticCode.TagRefEnd) {
+        isRef = true;
+        _tagsReferences.push(ref);
+      }
+      if (ref.code > DiagnosticCode.ReferenceStart && ref.code < DiagnosticCode.ReferenceEnd) {
+        isRef = true;
+        _references.push(ref);
+      }
+      if (!isRef) {
+        break;
+      }
+      i++;
+      ref.diagnostic = diagnostic;
+      diagnostic.references.push(ref);
+    }
+  }
+  return {
+    errors: _errors,
+    warnings: _warnings,
+    infos: _infos,
+    hints: _hints,
+    tags: _tags,
+    references: _references,
+    tagsReferences: _tagsReferences,
+    sourcemaps: _sourcemaps
+  };
+}
+function formatRange(range) {
+  if (range.startLineNumber === range.endLineNumber) {
+    if (range.startColumn === range.endColumn) {
+      return `${range.startLineNumber}:${range.startColumn}`;
+    }
+    return `${range.startLineNumber}:${range.startColumn}-${range.endColumn}`;
+  }
+  return `${range.startLineNumber}:${range.startColumn}-${range.endLineNumber}:${range.endColumn}`;
+}
+function formatDiagnostic(diagnostic) {
+  const range = formatRange(diagnostic.range);
+  const codeName = DiagnosticCode[diagnostic.code] || `Unknown(${diagnostic.code})`;
+  let message = getDiagnosticMessage(diagnostic.code);
+  for (const ref of diagnostic.references) {
+    const refRange = formatRange(ref.range);
+    message += `
+    (${refRange}): ${getDiagnosticMessage(ref.code)}`;
+  }
+  return `  ${codeName}(${range}): ${message}`;
+}
+
+// src/compiler/emit.ts
+import { OpCode } from "@mirascript/bindings";
+import { SourceMapGenerator } from "source-map-js";
+function emit(source, chunk, sourcemaps, options) {
+  const gen = new Emitter(source, chunk, sourcemaps, options);
+  gen.read();
+  const code = gen.codeLines.join("\n");
+  return code;
+}
+function readConst(reader, offset) {
+  const type = reader.getUint8(offset);
+  switch (type) {
+    /* c8 ignore next 2 */
+    case 0:
+      return [null, 1];
+    case 1:
+      return [true, 1];
+    case 2:
+      return [false, 1];
+    case 3: {
+      const ordinal = reader.getInt32(offset + 1, true);
+      return [ordinal, 5];
+    }
+    case 4: {
+      const num = reader.getFloat64(offset + 1, true);
+      return [num, 9];
+    }
+    case 5: {
+      const len = reader.getUint32(offset + 1, true);
+      const str = new TextDecoder().decode(new Uint8Array(reader.buffer, reader.byteOffset + offset + 5, len));
+      return [str, 5 + len];
+    }
+    /* c8 ignore next 2 */
+    default:
+      throw new Error(`Unknown constant type: ${type}`);
+  }
+}
+function toJavascript(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value == "object" || typeof value == "string") {
+    return JSON.stringify(value);
+  }
+  if (value === 0) {
+    if (1 / value === -Infinity) return "-0";
+    return "0";
+  }
+  return String(value);
+}
+var ORIGIN = `mira://MiraScript/`;
+var sourceId = 1;
+function createArray(length, fn) {
+  const result = [];
+  for (let i = 0; i < length; i++) {
+    result.push(fn(i));
+  }
+  return result;
+}
+var SCRIPT_PREFIX = `'use strict'; return ((global = GlobalFallback()) => { try { CpEnter();`;
+var GLOBAL_HINT = `/* globals */`;
+var Emitter = class {
+  constructor(source, chunk, sourcemaps, options) {
+    this.source = source;
+    this.chunk = chunk;
+    this.sourcemaps = sourcemaps;
+    this.options = options;
+    this.constVals = [];
+    this.constLits = [];
+    this.codeOffset = 0;
+    this.closureCounter = 0;
+    this.identCounter = 0;
+    this.globals = /* @__PURE__ */ new Map();
+    this.codeLines = [];
+    this.pretty = options.pretty ?? false;
+    const reader = new DataView(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+    this.chunkSize = reader.getUint32(0, true);
+    this.codeSize = reader.getUint32(4, true);
+    this.constSize = reader.getUint32(8 + this.codeSize, true);
+    this.codeReader = new DataView(chunk.buffer, chunk.byteOffset + 8, this.codeSize);
+    this.constReader = new DataView(chunk.buffer, chunk.byteOffset + 12 + this.codeSize, this.constSize);
+  }
+  /** 读取常量表 */
+  readConsts() {
+    for (let i = 0, index = 0; i < this.constSize; index++) {
+      const [constant, size] = readConst(this.constReader, i);
+      this.constVals.push(constant);
+      this.constLits.push(toJavascript(constant));
+      i += size;
+    }
+  }
+  /** 制造缩进 */
+  ident(len = 0) {
+    if (!this.pretty) return "";
+    return "  ".repeat(this.identCounter + len);
+  }
+  /** 读取全局变量 */
+  rg(constIdx, eager) {
+    const cached = this.globals.get(constIdx);
+    if (cached != null) {
+      if (eager && !cached[2]) {
+        cached[2] = true;
+        cached[3] = cached[0];
+      }
+      return cached[3];
+    }
+    const constName = this.constVals[constIdx];
+    const name = $ToString(constName);
+    const lit = typeof constName == "string" ? this.constLits[constIdx] : JSON.stringify(name);
+    const val = `g${this.globals.size + 1}`;
+    const expr = eager ? val : `(${val} === undefined ? (${val} = global.get(${lit})) : ${val})`;
+    this.globals.set(constIdx, [val, lit, eager, expr, name]);
+    return expr;
+  }
+  /** Read variable */
+  rv(i, level = 0) {
+    if (!i) return "null";
+    const c = this.closureCounter - level;
+    return `var_${c}_${i}`;
+  }
+  /** Write variable */
+  wv(i, level = 0) {
+    if (!i) return "_";
+    return this.rv(i, level);
+  }
+  /** 读取 code param */
+  readParam(wide) {
+    const value = wide ? this.codeReader.getUint32(this.codeOffset, true) : this.codeReader.getUint8(this.codeOffset);
+    this.codeOffset += wide ? 4 : 1;
+    return value;
+  }
+  /** 读取 code param */
+  readIndex(wide) {
+    const value = wide ? this.codeReader.getInt32(this.codeOffset, true) : this.codeReader.getInt8(this.codeOffset);
+    this.codeOffset += wide ? 4 : 1;
+    return value;
+  }
+  /** 读取闭包 */
+  readClosure() {
+    this.closureCounter++;
+    this.identCounter++;
+    while (this.codeOffset < this.codeSize) {
+      const opcode_raw = this.codeReader.getUint8(this.codeOffset);
+      const opcode = opcode_raw & 127;
+      if (opcode !== OpCode.FuncEnd) {
+        this.readCode();
+        continue;
+      }
+      this.codeOffset++;
+      const body = this.ident(-1) + `} finally { CpExit(); } });`;
+      this.codeLines.push(body);
+      this.closureCounter--;
+      this.identCounter--;
+      break;
+    }
+  }
+  /** 读取块结束 */
+  readBlockEnd(end) {
+    while (this.codeOffset < this.codeSize) {
+      const opcode_raw = this.codeReader.getUint8(this.codeOffset);
+      const opcode = opcode_raw & 127;
+      if (opcode !== end) {
+        this.readCode();
+        continue;
+      }
+      this.codeOffset++;
+      this.identCounter--;
+      if (end === OpCode.LoopEnd) {
+        this.closureCounter--;
+      }
+      const body = this.ident() + `};`;
+      this.codeLines.push(body);
+      break;
+    }
+  }
+  /** 读取 if else 或 if 结束 */
+  readIfElse() {
+    this.identCounter++;
+    while (this.codeOffset < this.codeSize) {
+      const opcode_raw = this.codeReader.getUint8(this.codeOffset);
+      const opcode = opcode_raw & 127;
+      if (opcode === OpCode.IfEnd) {
+        return this.readBlockEnd(OpCode.IfEnd);
+      }
+      if (opcode === OpCode.Else) {
+        this.codeOffset++;
+        const body = this.ident(-1) + `} else {`;
+        this.codeLines.push(body);
+        break;
+      }
+      if (opcode === OpCode.ElIf) {
+        this.codeOffset++;
+        const body = this.ident(-1) + `} else `;
+        this.codeLines.push(body);
+        return this.readCode();
+      }
+      this.readCode();
+    }
+    return this.readBlockEnd(OpCode.IfEnd);
+  }
+  /** 读取 record */
+  readRecord(obj) {
+    this.identCounter++;
+    while (this.codeOffset < this.codeSize) {
+      const opcode_raw = this.codeReader.getUint8(this.codeOffset++);
+      const opcode = opcode_raw & 127;
+      const wide = opcode_raw >= 128;
+      const read = () => this.readParam(wide);
+      let code = "";
+      switch (opcode) {
+        case OpCode.FieldOpt:
+        case OpCode.Field: {
+          const field = read();
+          const field_name = this.constLits[field];
+          if (!field_name) {
+            throw new Error(`Unknown field ${field}`);
+          }
+          const value = read();
+          const opt = opcode === OpCode.FieldOpt;
+          code = opt ? `...ElementOpt(${field_name}, ${this.rv(value)}),` : `[${field_name}]: Element(${this.rv(value)}),`;
+          break;
+        }
+        case OpCode.FieldOptDyn:
+        case OpCode.FieldDyn: {
+          const field = read();
+          const value = read();
+          const opt = opcode === OpCode.FieldOptDyn;
+          code = opt ? `...ElementOpt(${this.rv(field)}, ${this.rv(value)}),` : `[${this.rv(field)}]: Element(${this.rv(value)}),`;
+          break;
+        }
+        case OpCode.FieldOptIndex:
+        case OpCode.FieldIndex: {
+          const field = this.readIndex(wide);
+          const value = read();
+          const opt = opcode === OpCode.FieldOptIndex;
+          code = opt ? `...ElementOpt(${field}, ${this.rv(value)}),` : `[${field}]: Element(${this.rv(value)}),`;
+          break;
+        }
+        case OpCode.Spread: {
+          const value = read();
+          code = `...$RecordSpread(${this.rv(value)}),`;
+          break;
+        }
+        case OpCode.Freeze: {
+          this.identCounter--;
+          code = `});`;
+          break;
+        }
+        default: {
+          code = `// ?${OpCode[opcode] ?? opcode}`;
+          break;
+        }
+      }
+      const ident = this.ident();
+      this.codeLines.push(ident + code);
+      if (opcode === OpCode.Freeze) {
+        return;
+      }
+    }
+  }
+  /** 读取 array */
+  readArray(arr) {
+    this.identCounter++;
+    while (this.codeOffset < this.codeSize) {
+      const opcode_raw = this.codeReader.getUint8(this.codeOffset++);
+      const opcode = opcode_raw & 127;
+      const wide = opcode_raw >= 128;
+      const read = () => this.readParam(wide);
+      let code = "";
+      switch (opcode) {
+        case OpCode.Item: {
+          const value = read();
+          code = `Element(${this.rv(value)}),`;
+          break;
+        }
+        case OpCode.ItemRange: {
+          const start = this.readIndex(wide);
+          const end = this.readIndex(wide);
+          code = `...ArrayRange(${start}, ${end}),`;
+          break;
+        }
+        case OpCode.ItemRangeDyn: {
+          const start = read();
+          const end = read();
+          code = `...ArrayRange(${this.rv(start)}, ${this.rv(end)}),`;
+          break;
+        }
+        case OpCode.ItemRangeExclusiveDyn: {
+          const start = read();
+          const end = read();
+          code = `...ArrayRangeExclusive(${this.rv(start)}, ${this.rv(end)}),`;
+          break;
+        }
+        case OpCode.Spread: {
+          const value = read();
+          code = `...$ArraySpread(${this.rv(value)}),`;
+          break;
+        }
+        case OpCode.Freeze: {
+          this.identCounter--;
+          code = `]);`;
+          break;
+        }
+        default: {
+          code = `// ?${OpCode[opcode] ?? opcode}`;
+          break;
+        }
+      }
+      const ident = this.ident();
+      this.codeLines.push(ident + code);
+      if (opcode === OpCode.Freeze) {
+        return;
+      }
+    }
+  }
+  /** 读取代码 */
+  readCode() {
+    const opcode_raw = this.codeReader.getUint8(this.codeOffset++);
+    const opcode = opcode_raw & 127;
+    const wide = opcode_raw >= 128;
+    const read = () => this.readParam(wide);
+    const readIndex = () => this.readIndex(wide);
+    const ident = this.ident();
+    let code = "";
+    let reg = 0;
+    switch (opcode) {
+      case OpCode.FuncVarg:
+      case OpCode.Func: {
+        const startFunc = this.codeOffset === 1;
+        reg = read();
+        const varg = opcode === OpCode.FuncVarg;
+        const argn = read();
+        const regn = read();
+        const args = createArray(argn, (i) => {
+          const wv = this.wv(i + 1, -1);
+          if (varg && i === argn - 1) {
+            return `...vargs`;
+          }
+          return `${wv} = null`;
+        });
+        const regs = createArray(regn - argn + 1, (i) => i ? this.wv(i + argn, -1) : this.wv(0, -1)).join(
+          ", "
+        );
+        const script = startFunc && !varg && argn === 0;
+        if (script) {
+          code = `${SCRIPT_PREFIX} var ${regs};`;
+        } else {
+          code = `${this.wv(reg)} = Function((${args.join(", ")}) => { try { CpEnter(); var ${regs};`;
+        }
+        if (varg) {
+          code += ` var ${this.wv(argn, -1)} = Vargs(vargs);`;
+        }
+        break;
+      }
+      case OpCode.Constant: {
+        reg = read();
+        const i = read();
+        const c = this.constLits[i];
+        code = `${this.wv(reg)} = ${c};`;
+        break;
+      }
+      case OpCode.Uninit: {
+        reg = read();
+        code = `${this.wv(reg)} = undefined;`;
+        break;
+      }
+      case OpCode.Return: {
+        reg = read();
+        code = `return ${this.rv(reg)};`;
+        break;
+      }
+      case OpCode.Add:
+      case OpCode.Sub:
+      case OpCode.Mul:
+      case OpCode.Div:
+      case OpCode.Mod:
+      case OpCode.Pow:
+      case OpCode.Gt:
+      case OpCode.Gte:
+      case OpCode.Lt:
+      case OpCode.Lte:
+      case OpCode.Eq:
+      case OpCode.Neq:
+      case OpCode.Aeq:
+      case OpCode.Naeq:
+      case OpCode.Same:
+      case OpCode.Nsame:
+      case OpCode.In:
+      case OpCode.And:
+      case OpCode.Or:
+      case OpCode.Format: {
+        reg = read();
+        const left = read();
+        const right = read();
+        code = `${this.wv(reg)} = $${OpCode[opcode]}(${this.rv(left)}, ${this.rv(right)});`;
+        break;
+      }
+      case OpCode.InGlobal: {
+        reg = read();
+        const left = read();
+        code = `${this.wv(reg)} = global.has($ToString(${this.rv(left)}));`;
+        break;
+      }
+      case OpCode.Concat: {
+        reg = read();
+        const n = read();
+        const args = createArray(n, () => read());
+        code = `${this.wv(reg)} = $${OpCode[opcode]}(${args.map((a) => this.rv(a)).join(", ")});`;
+        break;
+      }
+      case OpCode.Omit:
+      case OpCode.Pick: {
+        reg = read();
+        const value = read();
+        const n = read();
+        const args = createArray(n, () => this.constLits[read()]);
+        code = `${this.wv(reg)} = $${OpCode[opcode]}(${this.rv(value)}, [${args.join(", ")}]);`;
+        break;
+      }
+      case OpCode.Call:
+      case OpCode.CallDyn: {
+        reg = read();
+        const func = read();
+        const n = read();
+        const args = createArray(n, () => read());
+        const ns = read();
+        const spreads = createArray(ns, () => read());
+        const callTarget = opcode === OpCode.Call ? this.rg(func, this.identCounter <= 1) : this.rv(func);
+        code = `${this.wv(reg)} = $Call(${callTarget}, [${args.map((a, i) => {
+          if (spreads.includes(i)) return `...$ArraySpread(${this.rv(a)})`;
+          else return this.rv(a);
+        }).join(", ")}]);`;
+        break;
+      }
+      case OpCode.Assign: {
+        reg = read();
+        const value = read();
+        code = `${this.wv(reg)} = ${this.rv(value)};`;
+        break;
+      }
+      case OpCode.Pos:
+      case OpCode.Neg:
+      case OpCode.Not:
+      case OpCode.Type:
+      case OpCode.ToBoolean:
+      case OpCode.ToNumber:
+      case OpCode.ToString:
+      case OpCode.IsBoolean:
+      case OpCode.IsNumber:
+      case OpCode.IsString:
+      case OpCode.IsRecord:
+      case OpCode.IsArray:
+      case OpCode.Length: {
+        reg = read();
+        const value = read();
+        code = `${this.wv(reg)} = $${OpCode[opcode]}(${this.rv(value)});`;
+        break;
+      }
+      case OpCode.AssertInit:
+      case OpCode.AssertNonNil: {
+        reg = read();
+        code = `$${OpCode[opcode]}(${this.rv(reg)})`;
+        break;
+      }
+      case OpCode.Get: {
+        reg = read();
+        const obj = read();
+        const prop = this.constLits[read()];
+        code = `${this.wv(reg)} = $Get(${this.rv(obj)}, ${prop});`;
+        break;
+      }
+      case OpCode.GetIndex: {
+        reg = read();
+        const obj = read();
+        const index = readIndex();
+        code = `${this.wv(reg)} = $Get(${this.rv(obj)}, ${index});`;
+        break;
+      }
+      case OpCode.GetDyn: {
+        reg = read();
+        const obj = read();
+        const index = read();
+        code = `${this.wv(reg)} = $Get(${this.rv(obj)}, ${this.rv(index)});`;
+        break;
+      }
+      case OpCode.Has: {
+        reg = read();
+        const obj = read();
+        const prop = this.constLits[read()];
+        code = `${this.wv(reg)} = $Has(${this.rv(obj)}, ${prop});`;
+        break;
+      }
+      case OpCode.HasIndex: {
+        reg = read();
+        const obj = read();
+        const index = readIndex();
+        code = `${this.wv(reg)} = $Has(${this.rv(obj)}, ${index});`;
+        break;
+      }
+      case OpCode.HasDyn: {
+        reg = read();
+        const obj = read();
+        const index = read();
+        code = `${this.wv(reg)} = $Has(${this.rv(obj)}, ${this.rv(index)});`;
+        break;
+      }
+      case OpCode.Set: {
+        reg = read();
+        const obj = read();
+        const prop = this.constLits[read()];
+        code = `$Set(${this.rv(obj)}, ${prop}, ${this.rv(reg)});`;
+        break;
+      }
+      case OpCode.SetIndex: {
+        reg = read();
+        const obj = read();
+        const index = readIndex();
+        code = `$Set(${this.rv(obj)}, ${index}, ${this.rv(reg)});`;
+        break;
+      }
+      case OpCode.SetDyn: {
+        reg = read();
+        const obj = read();
+        const index = read();
+        code = `$Set(${this.rv(obj)}, ${this.rv(index)}, ${this.rv(reg)});`;
+        break;
+      }
+      case OpCode.GetGlobal: {
+        reg = read();
+        const i = read();
+        code = `${this.wv(reg)} = ${this.rg(i, this.identCounter <= 1)};`;
+        break;
+      }
+      case OpCode.GetGlobalDyn: {
+        reg = read();
+        const name = read();
+        code = `${this.wv(reg)} = global.get($ToString(${this.rv(name)}));`;
+        break;
+      }
+      case OpCode.GetUpvalue: {
+        reg = read();
+        const level = read();
+        const up = read();
+        code = `${this.wv(reg)} = Upvalue(${this.rv(up, level)});`;
+        break;
+      }
+      case OpCode.SetUpvalue: {
+        reg = read();
+        const level = read();
+        const up = read();
+        code = `${this.wv(up, level)} = ${this.rv(reg)};`;
+        break;
+      }
+      case OpCode.Slice: {
+        reg = read();
+        const obj = read();
+        const start = readIndex();
+        const end = readIndex();
+        code = `${this.wv(reg)} = $Slice(${this.rv(obj)}, ${start}, ${end});`;
+        break;
+      }
+      case OpCode.SliceStart: {
+        reg = read();
+        const obj = read();
+        const end = readIndex();
+        code = `${this.wv(reg)} = $Slice(${this.rv(obj)}, null, ${end});`;
+        break;
+      }
+      case OpCode.SliceEnd: {
+        reg = read();
+        const obj = read();
+        const start = readIndex();
+        code = `${this.wv(reg)} = $Slice(${this.rv(obj)}, ${start}, null);`;
+        break;
+      }
+      case OpCode.SliceDyn: {
+        reg = read();
+        const obj = read();
+        const start = read();
+        const end = read();
+        code = `${this.wv(reg)} = $Slice(${this.rv(obj)}, ${this.rv(start)}, ${this.rv(end)});`;
+        break;
+      }
+      case OpCode.SliceExclusiveDyn: {
+        reg = read();
+        const obj = read();
+        const start = read();
+        const end = read();
+        code = `${this.wv(reg)} = $SliceExclusive(${this.rv(obj)}, ${this.rv(start)}, ${this.rv(end)});`;
+        break;
+      }
+      case OpCode.Record: {
+        reg = read();
+        code = `${this.wv(reg)} = ({`;
+        break;
+      }
+      case OpCode.Array: {
+        reg = read();
+        code = `${this.wv(reg)} = ([`;
+        break;
+      }
+      case OpCode.If: {
+        const cond = read();
+        code = `if (${this.rv(cond)} !== false && $ToBoolean(${this.rv(cond)}) !== false) {`;
+        break;
+      }
+      case OpCode.IfNot: {
+        const cond = read();
+        code = `if (${this.rv(cond)} !== true && $ToBoolean(${this.rv(cond)}) !== true) {`;
+        break;
+      }
+      case OpCode.IfInit: {
+        const cond = read();
+        code = `if (${this.rv(cond)} !== undefined) {`;
+        break;
+      }
+      case OpCode.IfNotInit: {
+        const cond = read();
+        code = `if (${this.rv(cond)} === undefined) {`;
+        break;
+      }
+      case OpCode.IfNil: {
+        const cond = read();
+        code = `if (${this.rv(cond)} === null) {`;
+        break;
+      }
+      case OpCode.IfNotNil: {
+        const cond = read();
+        code = `if (${this.rv(cond)} !== null) {`;
+        break;
+      }
+      case OpCode.LoopFor: {
+        const nreg = read();
+        const iterable = read();
+        const regs = createArray(nreg - 1, (i) => this.wv(i + 2, -1));
+        regs.unshift("_");
+        const ir = this.wv(1, -1);
+        code = `for (let ${ir} of $Iterable(${this.rv(iterable)})) { ${ir} ??= null; Cp(); let ${regs.join(", ")};`;
+        break;
+      }
+      case OpCode.LoopRange:
+      case OpCode.LoopRangeExclusive: {
+        const nreg = read();
+        const start = read();
+        const end = read();
+        const exclusive = opcode === OpCode.LoopRangeExclusive;
+        const regs = createArray(nreg - 1, (i2) => this.wv(i2 + 2, -1));
+        regs.unshift("_");
+        const i = this.wv(1, -1);
+        code = `for (let start = $ToNumber(${this.rv(start)}), end = $ToNumber(${this.rv(end)}), ${i} = start; ${i} ${exclusive ? "<" : "<="} end; ${i} += 1) { Cp(); let ${regs.join(", ")};`;
+        break;
+      }
+      case OpCode.Loop: {
+        const nreg = read();
+        const regs = createArray(nreg, (i) => this.wv(i + 1, -1));
+        regs.unshift("_");
+        code = `while (true) { Cp(); let ${regs.join(", ")};`;
+        break;
+      }
+      case OpCode.Break: {
+        code = `break;`;
+        break;
+      }
+      case OpCode.Continue: {
+        code = `continue;`;
+        break;
+      }
+      case OpCode.Noop: {
+        return;
+      }
+      default: {
+        code = `; // ${OpCode[opcode] ?? opcode}`;
+        break;
+      }
+    }
+    this.codeLines.push(ident + code);
+    switch (opcode) {
+      case OpCode.FuncVarg:
+      case OpCode.Func: {
+        this.readClosure();
+        break;
+      }
+      case OpCode.If:
+      case OpCode.IfNot:
+      case OpCode.IfNil:
+      case OpCode.IfNotNil:
+      case OpCode.IfInit:
+      case OpCode.IfNotInit: {
+        this.readIfElse();
+        break;
+      }
+      case OpCode.Loop:
+      case OpCode.LoopFor:
+      case OpCode.LoopRange:
+      case OpCode.LoopRangeExclusive: {
+        this.identCounter++;
+        this.closureCounter++;
+        this.readBlockEnd(OpCode.LoopEnd);
+        break;
+      }
+      case OpCode.Record: {
+        this.readRecord(reg);
+        break;
+      }
+      case OpCode.Array: {
+        this.readArray(reg);
+        break;
+      }
+    }
+  }
+  /** 读取 chunk */
+  read() {
+    this.readConsts();
+    this.readCode();
+    if (this.globals.size > 0) {
+      let globalsInit = "";
+      for (const [val, lit, eager] of this.globals.values()) {
+        const expr = eager ? `${val} = global.get(${lit})` : val;
+        globalsInit += globalsInit ? `, ${expr}` : `var ${GLOBAL_HINT} ${expr}`;
+      }
+      this.codeLines[0] += globalsInit + ";";
+    }
+    this.addSourceMap();
+  }
+  /** 添加源映射 */
+  addSourceMap() {
+    if (!this.options.sourceMap) return;
+    let fileName = (this.options.fileName ?? "").trim();
+    const hasSchema = /^\w+:/.test(fileName);
+    if (!hasSchema) {
+      if (fileName.startsWith("/")) {
+        fileName = fileName.replace(/^\/+\s*/, "");
+      }
+      if (!fileName) {
+        fileName = `${sourceId++}.${this.options.input_mode === "Template" ? "miratpl" : "mira"}`;
+      }
+    }
+    const map = new SourceMapGenerator({
+      file: fileName + ".js"
+    });
+    if (typeof this.source === "string") {
+      map.setSourceContent(fileName, this.source);
+    }
+    let hasStartMap = false;
+    for (let i = 1; i < this.sourcemaps.length; i++) {
+      const range = this.sourcemaps[i];
+      if (!range) break;
+      if (!hasStartMap && range.startLineNumber === 1 && range.startColumn === 1) {
+        hasStartMap = true;
+      }
+      map.addMapping({
+        generated: {
+          // 前两行固定为：
+          // (function anonymous($Add,$Aeq, ...
+          // ) {
+          line: i + 3,
+          column: 0
+        },
+        original: {
+          line: range.startLineNumber,
+          column: range.startColumn - 1
+        },
+        source: fileName
+      });
+    }
+    if (!hasStartMap) {
+      map.addMapping({
+        generated: {
+          line: 3,
+          column: SCRIPT_PREFIX.length - "CpEnter();".length
+        },
+        original: {
+          line: 1,
+          column: 0
+        },
+        source: fileName
+      });
+    }
+    {
+      const line0 = this.codeLines[0];
+      const file = `${fileName} <globals>`;
+      let globals = `global;
+`;
+      map.addMapping({
+        generated: {
+          line: 3,
+          column: line0.indexOf(`global = `)
+        },
+        original: {
+          line: 1,
+          column: 0
+        },
+        source: file,
+        name: "global"
+      });
+      map.addMapping({
+        generated: {
+          line: 3,
+          column: SCRIPT_PREFIX.length
+        },
+        original: {
+          line: 1,
+          column: 7
+        },
+        source: file,
+        name: ""
+      });
+      let i = 1;
+      let pos = line0.indexOf(GLOBAL_HINT, SCRIPT_PREFIX.length) + GLOBAL_HINT.length;
+      for (const p of this.globals.values()) {
+        i++;
+        if (pos < 0) break;
+        const val = p[0];
+        pos = line0.indexOf(val, pos);
+        if (pos < 0) break;
+        const name = p[4];
+        map.addMapping({
+          generated: {
+            line: 3,
+            column: pos
+          },
+          original: {
+            line: i,
+            column: 0
+          },
+          source: file,
+          name
+        });
+        globals += `${name};
+`;
+      }
+      map.addMapping({
+        generated: {
+          line: 3,
+          column: pos
+        },
+        original: {
+          line: i,
+          column: 0
+        },
+        source: file,
+        name: ""
+      });
+      map.setSourceContent(file, globals);
+    }
+    const prefix = "//# ";
+    const sourceURL = hasSchema ? fileName : `${ORIGIN}${fileName}`;
+    this.codeLines.push(
+      // Prevent source map from being recognized as of this file
+      `${prefix}sourceURL=${sourceURL}.js`,
+      `${prefix}sourceMappingURL=data:application/json,${encodeURIComponent(map.toString())}`
+    );
+  }
+};
+
+// src/compiler/generate-bytecode.ts
+import { getModule as getModule2, loadModule } from "@mirascript/bindings";
+function generateBytecodeSync(script, options) {
+  const module = getModule2();
+  const result = module.compileSync(script, options);
+  return [result.chunk, result.diagnostics];
+}
+async function generateBytecode(script, options) {
+  if (options == null) {
+    throw new TypeError("options must be provided");
+  }
+  const module = await loadModule();
+  const result = "compile" in module ? await module.compile(script, options) : module.compileSync(script, options);
+  return [result.chunk, result.diagnostics];
+}
+
+export {
+  __export,
+  isArray,
+  isFinite,
+  isNaN,
+  isInteger,
+  isSafeInteger,
+  hasOwn,
+  keys,
+  values,
+  entries,
+  create,
+  fromEntries,
+  defineProperty,
+  VmError,
+  $Add,
+  $Sub,
+  $Mul,
+  $Div,
+  $Same,
+  $Call,
+  $Type,
+  $ToBoolean,
+  $ToString,
+  $ToNumber,
+  $Format,
+  operations_exports,
+  VmSharedContext,
+  defineVmContextValue,
+  DefaultVmContext,
+  createVmContext,
+  isVmContext,
+  Element,
+  Cp,
+  configCheckpoint,
+  GlobalFallback,
+  helpers_exports,
+  isVmFunction,
+  getVmFunctionInfo,
+  VmFunction,
+  isVmWrapper,
+  VmExtern,
+  isVmExtern,
+  toVmFunctionProxy,
+  fromVmFunctionProxy,
+  wrapToVmValue,
+  unwrapFromVmValue,
+  isVmScript,
+  isVmCallable,
+  VM_ARRAY_MAX_LENGTH,
+  isVmArray,
+  isVmRecord,
+  isVmArrayLikeRecordByEntires,
+  isVmArrayLikeRecordByKeys,
+  isVmArrayLikeRecord,
+  isVmPrimitive,
+  isVmConst,
+  VmModule,
+  isVmModule,
+  isVmImmutable,
+  isVmAny,
+  isVmValue,
+  DiagnosticCode,
+  getDiagnosticMessage,
+  parseDiagnostics,
+  formatDiagnostic,
+  emit,
+  generateBytecodeSync,
+  generateBytecode
+};
+//# sourceMappingURL=chunk-55FKP56O.js.map