@mirascript/mirascript 0.1.93-alpha.2 → 0.1.93

package/dist/chunk-7JTZW66P.js

@@ -0,0 +1,1075 @@
+import {
+  __export,
+  __reExport,
+  apply,
+  defineProperty,
+  entries,
+  freeze,
+  getOwnPropertyNames,
+  getPrototypeOf,
+  hasOwn,
+  isArray,
+  isNaN,
+  isPromiseLike,
+  keys,
+  values
+} from "./chunk-H2OHULLB.js";
+
+// src/helpers/serialize/simple.ts
+function serializeNil() {
+  return "nil";
+}
+function serializeBoolean(value) {
+  return value ? "true" : "false";
+}
+function numberToString(value, minusZero) {
+  if (isNaN(value)) return "nan";
+  if (value === Infinity) return "inf";
+  if (value === -Infinity) return "-inf";
+  if (minusZero && value === 0 && 1 / value < 0) return "-0";
+  return String(value);
+}
+function serializeNumber(value) {
+  return numberToString(value, true);
+}
+
+// src/helpers/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  VM_ARRAY_MAX_LENGTH: () => VM_ARRAY_MAX_LENGTH,
+  VM_FUNCTION_ANONYMOUS_NAME: () => VM_FUNCTION_ANONYMOUS_NAME,
+  VM_SCRIPT_NAME: () => VM_SCRIPT_NAME,
+  kVmContext: () => kVmContext,
+  kVmExtern: () => kVmExtern,
+  kVmFunction: () => kVmFunction,
+  kVmFunctionProxy: () => kVmFunctionProxy,
+  kVmModule: () => kVmModule,
+  kVmScript: () => kVmScript,
+  kVmWrapper: () => kVmWrapper
+});
+__reExport(constants_exports, constants_star);
+import * as constants_star from "@mirascript/constants";
+var VM_ARRAY_MAX_LENGTH = 16777216;
+var kVmScript = /* @__PURE__ */ Symbol.for("mirascript.vm.script");
+var kVmFunction = /* @__PURE__ */ Symbol.for("mirascript.vm.function");
+var kVmFunctionProxy = /* @__PURE__ */ Symbol.for("mirascript.vm.function.proxy");
+var kVmContext = /* @__PURE__ */ Symbol.for("mirascript.vm.context");
+var kVmExtern = /* @__PURE__ */ Symbol.for("mirascript.vm.extern");
+var kVmModule = /* @__PURE__ */ Symbol.for("mirascript.vm.module");
+var kVmWrapper = /* @__PURE__ */ Symbol.for("mirascript.vm.wrapper");
+var VM_SCRIPT_NAME = `<script_root>`;
+var VM_FUNCTION_ANONYMOUS_NAME = `<anonymous>`;
+
+// src/helpers/types/basic.ts
+function isVmScript(value) {
+  return typeof value === "function" && kVmScript in value;
+}
+function isVmContext(context) {
+  return context != null && typeof context == "object" && kVmContext in context;
+}
+function isVmFunction(value) {
+  return typeof value == "function" && kVmFunction in value;
+}
+function getVmFunctionInfo(value) {
+  if (typeof value != "function") return void 0;
+  return value[kVmFunction];
+}
+function isVmWrapper(value) {
+  return value != null && typeof value == "object" && kVmWrapper in value;
+}
+function isVmModule(value) {
+  return value != null && typeof value == "object" && kVmModule in value;
+}
+function isVmExtern(value) {
+  return value != null && typeof value == "object" && kVmExtern in value;
+}
+function isVmCallable(value) {
+  return isVmFunction(value) || isVmExtern(value) && typeof value.value == "function";
+}
+function isVmPrimitive(value) {
+  if (value === null || typeof value == "number" || typeof value == "string" || typeof value == "boolean") {
+    value;
+    value;
+    return true;
+  }
+  return false;
+}
+function isVmArray(value) {
+  if (!isArray(value)) return false;
+  value;
+  return true;
+}
+function isVmRecord(value) {
+  if (value == null || typeof value != "object") return false;
+  if (isVmWrapper(value) || isVmArray(value)) return false;
+  value;
+  return true;
+}
+
+// src/helpers/types/proto.ts
+function isPlainArray(value) {
+  const proto = getPrototypeOf(value);
+  return isArray(proto) && hasOwn(proto, "push");
+}
+function isPlainObject(value) {
+  const proto1 = getPrototypeOf(value);
+  if (proto1 == null) return true;
+  const proto2 = getPrototypeOf(proto1);
+  if (proto2 != null) return false;
+  return hasOwn(proto1, "hasOwnProperty");
+}
+
+// src/helpers/types/const.ts
+var MAX_DEPTH = 16;
+function isVmArrayDeep(value, depth) {
+  if (!isPlainArray(value)) return false;
+  if (depth <= 0) return true;
+  const inner_depth = depth - 1;
+  return value.every((item) => isVmConstInner(item, inner_depth));
+}
+function isVmRecordDeep(value, depth) {
+  if (!isPlainObject(value)) return false;
+  if (depth <= 0) return true;
+  const inner_depth = depth - 1;
+  return values(value).every((value2) => isVmConstInner(value2, inner_depth));
+}
+function isVmConstInner(value, depth) {
+  if (value == null) return true;
+  if (typeof value == "string" || typeof value == "number" || typeof value == "boolean") return true;
+  if (typeof value == "object") {
+    if (isVmWrapper(value)) return false;
+    if (isArray(value)) {
+      return isVmArrayDeep(value, depth);
+    } else {
+      return isVmRecordDeep(value, depth);
+    }
+  }
+  return false;
+}
+function isVmConst(value, checkDeep = false) {
+  if (value === void 0) return false;
+  return isVmConstInner(value, checkDeep ? MAX_DEPTH : 0);
+}
+
+// src/helpers/types/get-type.ts
+function getVmType(value) {
+  if (value === void 0) return "uninitialized";
+  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;
+}
+
+// src/helpers/types/array-like.ts
+function isVmArrayLikeRecordByEntries(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/helpers/types/composed.ts
+function isVmImmutable(value, checkDeep = false) {
+  return isVmModule(value) || isVmFunction(value) || isVmConst(value, checkDeep);
+}
+function isVmValue(value, checkDeep = false) {
+  return isVmWrapper(value) || isVmFunction(value) || isVmConst(value, checkDeep);
+}
+function isVmAny(value, checkDeep) {
+  if (value == null) return true;
+  return isVmValue(value, checkDeep);
+}
+
+// src/helpers/serialize/serialize.ts
+import { REG_IDENTIFIER_FULL, REG_ORDINAL_FULL } from "@mirascript/constants";
+
+// src/helpers/serialize/string.ts
+function serializeStringEscaped(escaped, options) {
+  return options.serializeStringEscape("\\" + escaped, options);
+}
+function serializeStringContent(value, options) {
+  return options.serializeStringContent(value, options);
+}
+var STRING_QUOTE = `'`;
+var STRING_REG = new RegExp(String.raw`[${STRING_QUOTE}\\\$\p{C}\u2028\u2029]`, "gu");
+var STRING_MARK = /^[\p{M}]$/u;
+function serializeSpecialChar(char, options) {
+  if (char === STRING_QUOTE) {
+    return serializeStringEscaped(STRING_QUOTE, options);
+  } else if (char === "\0") {
+    return serializeStringEscaped(`0`, options);
+  } else if (char === "\n") {
+    return serializeStringEscaped(`n`, options);
+  } else if (char === "\r") {
+    return serializeStringEscaped(`r`, options);
+  } else if (char === "	") {
+    return serializeStringEscaped(`t`, options);
+  } else if (char === "\b") {
+    return serializeStringEscaped(`b`, options);
+  } else if (char === "\f") {
+    return serializeStringEscaped(`f`, options);
+  } else if (char === "\v") {
+    return serializeStringEscaped(`v`, options);
+  } else if (char === "\\") {
+    return serializeStringEscaped(`\\`, options);
+  } else if (char === "$") {
+    return serializeStringEscaped(`$`, options);
+  } else {
+    const code = char.codePointAt(0);
+    if (code <= 127) {
+      return serializeStringEscaped(`x${code.toString(16).padStart(2, "0")}`, options);
+    } else if (code >= 55296 && code <= 57343) {
+      return serializeStringContent("�", options);
+    } else {
+      return serializeStringEscaped(`u{${code.toString(16)}}`, options);
+    }
+  }
+}
+function serializeStringImpl(value, options) {
+  const oq = options.serializeStringQuote(STRING_QUOTE, true, options);
+  const cq = options.serializeStringQuote(STRING_QUOTE, false, options);
+  if (value.length === 0) {
+    return oq + cq;
+  }
+  let ret = oq;
+  let lastIndex = 0;
+  while (value.length > lastIndex) {
+    const cp = value.codePointAt(lastIndex);
+    const ch = String.fromCodePoint(cp);
+    if (!STRING_MARK.test(ch)) break;
+    ret += serializeStringEscaped(`u{${cp.toString(16)}}`, options);
+    lastIndex += ch.length;
+  }
+  STRING_REG.lastIndex = lastIndex;
+  let match;
+  while ((match = STRING_REG.exec(value)) !== null) {
+    ret += serializeStringContent(value.slice(lastIndex, match.index), options);
+    lastIndex = STRING_REG.lastIndex;
+    ret += serializeSpecialChar(match[0], options);
+  }
+  ret += serializeStringContent(value.slice(lastIndex), options);
+  ret += cq;
+  return ret;
+}
+
+// src/helpers/serialize/serialize.ts
+function serializeString(value, options) {
+  return serializeStringImpl(value, getSerializeOptions(options));
+}
+function serializeRecordKeyDefault(key) {
+  if (REG_ORDINAL_FULL.test(key) || REG_IDENTIFIER_FULL.test(key)) {
+    return key;
+  }
+  return serializeStringImpl(key, DEFAULT_OPTIONS);
+}
+function serializeRecordKeyOpt(value, options) {
+  if (isDefaultOptions(options)) {
+    return serializeRecordKeyDefault(value);
+  }
+  if (REG_ORDINAL_FULL.test(value)) {
+    return options.serializePropName(Number(value), options);
+  }
+  if (REG_IDENTIFIER_FULL.test(value)) {
+    return options.serializePropName(value, options);
+  }
+  return options.serializeString(value, options);
+}
+function serializeRecordKey(key, options) {
+  if (isDefaultOptions(options)) {
+    return serializeRecordKeyDefault(key);
+  }
+  return serializeRecordKeyOpt(key, getSerializeOptions(options));
+}
+function serializeArray(value, depth, options) {
+  if (depth > options.maxDepth) return `[]`;
+  if (value.length === 0) return "[]";
+  let result = "[";
+  for (let i = 0; i < value.length; i++) {
+    if (i > 0) result += ", ";
+    result += serializeImpl(value[i], depth, options);
+  }
+  result += "]";
+  return result;
+}
+var { valueOf } = Object.prototype;
+function customValueOf(value) {
+  const thisValueOf = value.valueOf;
+  if (typeof thisValueOf !== "function" || thisValueOf === valueOf) {
+    return void 0;
+  }
+  const customValue = thisValueOf.call(value);
+  if (customValue === value) return void 0;
+  return customValue;
+}
+function serializeRecord(value, depth, options) {
+  const customValue = customValueOf(value);
+  if (customValue !== void 0) {
+    return serializeImpl(customValue, depth - 1, options);
+  }
+  if (depth > options.maxDepth) return `()`;
+  const e = entries(value);
+  if (e.length === 0) return "()";
+  if (e.length === 1) {
+    const [k, v] = e[0];
+    if (k === "0") {
+      return `(${serializeImpl(v, depth, options)},)`;
+    }
+    return `(${serializeRecordKeyOpt(k, options)}: ${serializeImpl(v, depth, options)})`;
+  }
+  const omitKey = isVmArrayLikeRecordByEntries(e);
+  let result = "(";
+  for (const [key, val] of e) {
+    if (result.length > 1) result += ", ";
+    if (omitKey) {
+      result += serializeImpl(val, depth, options);
+    } else {
+      result += `${serializeRecordKeyOpt(key, options)}: ${serializeImpl(val, depth, options)}`;
+    }
+  }
+  result += ")";
+  return result;
+}
+function serializeImpl(value, depth, options) {
+  if (value == null) {
+    return options.serializeNil(options);
+  }
+  if (typeof value == "boolean") {
+    return options.serializeBoolean(value, options);
+  }
+  if (typeof value == "number") {
+    return options.serializeNumber(value, options);
+  }
+  if (typeof value == "string") {
+    return options.serializeString(value, options);
+  }
+  if (isVmFunction(value)) {
+    return options.serializeFunction(value, options);
+  }
+  if (isVmModule(value)) {
+    return options.serializeModule(value, depth + 1, options);
+  }
+  if (isVmExtern(value)) {
+    return options.serializeExtern(value, depth + 1, options);
+  }
+  if (isVmArray(value)) {
+    return options.serializeArray(value, depth + 1, options);
+  }
+  if (isVmRecord(value)) {
+    return options.serializeRecord(value, depth + 1, options);
+  }
+  value;
+  return options.serializeNil(options);
+}
+function serialize(value, options) {
+  return serializeImpl(value, 0, getSerializeOptions(options));
+}
+function isDefaultOptions(options) {
+  return options == null || options === DEFAULT_OPTIONS;
+}
+function mergeOptions(base, options) {
+  if (options == null) return base;
+  let opt = null;
+  for (const key in options) {
+    if (!hasOwn(options, key) || !hasOwn(base, key)) continue;
+    const el = options[key];
+    if (el == null) continue;
+    opt ??= { ...base };
+    opt[key] = el;
+  }
+  return opt ? Object.freeze(opt) : base;
+}
+function getSerializeOptions(options) {
+  if (isDefaultOptions(options)) return DEFAULT_OPTIONS;
+  return mergeOptions(DEFAULT_OPTIONS, options);
+}
+var DEFAULT_OPTIONS = Object.freeze({
+  maxDepth: 128,
+  serializeNil,
+  serializeBoolean,
+  serializeNumber,
+  serializeString: serializeStringImpl,
+  serializeStringQuote: (value) => value,
+  serializeStringEscape: (value) => value,
+  serializeStringContent: (value) => value,
+  serializeArray,
+  serializeRecord,
+  serializePropName: String,
+  serializeFunction: serializeNil,
+  serializeModule: serializeNil,
+  serializeExtern: serializeNil
+});
+
+// src/vm/effects/state.ts
+var AsyncRequiredError = class extends Error {
+  constructor() {
+    super("An async VM function requires runInContext");
+    this.name = "AsyncRequiredError";
+  }
+};
+var ReplayMismatchError = class extends Error {
+  constructor() {
+    super("Host effect sequence changed during replay");
+    this.name = "ReplayMismatchError";
+  }
+};
+var ContextReentrancyError = class extends Error {
+  constructor() {
+    super("Nested execution contexts and host effects are not supported");
+    this.name = "ContextReentrancyError";
+  }
+};
+var SuspensionError = class extends Error {
+  constructor(slot) {
+    super("Host effect suspended");
+    this.slot = slot;
+    this.name = "SuspensionError";
+  }
+};
+var kEffectContext = /* @__PURE__ */ Symbol("EffectContext");
+function createContext() {
+  return {
+    __proto__: null,
+    __marker__: kEffectContext,
+    cursor: 0,
+    slots: [],
+    inHost: false
+  };
+}
+var currentContext;
+function setCurrentContext(context) {
+  const previous = currentContext;
+  currentContext = context;
+  return previous;
+}
+function resetContext(context) {
+  context.cursor = 0;
+  context.suspension = void 0;
+}
+function failContext(error) {
+  if (currentContext) currentContext.failure ??= error;
+  throw error;
+}
+function throwIfFailed(context) {
+  if (context.failure) throw context.failure;
+}
+function rethrowControl(error) {
+  if (error instanceof SuspensionError || error instanceof AsyncRequiredError || error instanceof ReplayMismatchError || error instanceof ContextReentrancyError) {
+    throw error;
+  }
+}
+
+// src/helpers/serialize/display.ts
+function displayFunction(value) {
+  try {
+    const name = getVmFunctionInfo(value)?.fullName;
+    return name ? `<function ${name}>` : `<function>`;
+  } catch (error) {
+    rethrowControl(error);
+    return `<function>`;
+  }
+}
+function displayModule(value) {
+  try {
+    return value.toString(true);
+  } catch (error) {
+    rethrowControl(error);
+    return `<module>`;
+  }
+}
+function displayExtern(value) {
+  try {
+    const tag = `<extern ${value.tag}>`;
+    const rep = value.toString(true);
+    if (rep === tag || rep.length > 50) {
+      return tag;
+    }
+    return `${tag} ${rep}`;
+  } catch (error) {
+    rethrowControl(error);
+    return `<extern>`;
+  }
+}
+var DISPLAY_OPTIONS = Object.freeze({
+  ...DEFAULT_OPTIONS,
+  maxDepth: 3,
+  serializeFunction: displayFunction,
+  serializeModule: displayModule,
+  serializeExtern: displayExtern
+});
+function display(value, options) {
+  const opt = mergeOptions(DISPLAY_OPTIONS, options);
+  return serializeImpl(value, 0, opt);
+}
+
+// src/helpers/error.ts
+var VmError = class _VmError extends Error {
+  constructor(message, recovered) {
+    super(message);
+    this.recovered = recovered;
+    this.name = "VmError";
+  }
+  /** 从其他错误构造 */
+  static from(prefix, error, recovered) {
+    rethrowControl(error);
+    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/helpers/convert/string.ts
+function innerToString(value, useBraces) {
+  if (value == null) return "nil";
+  if (typeof value == "number") return numberToString(value, false);
+  if (typeof value == "string" || typeof value == "boolean") return String(value);
+  if (typeof value == "function") return displayFunction(value);
+  if (isVmWrapper(value)) return value.toString(useBraces);
+  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}]`;
+  } else {
+    const entries2 = keys(value).map((key) => `${key}: ${innerToString(value[key], true)}`).join(", ");
+    if (!useBraces) return entries2;
+    return `(${entries2})`;
+  }
+}
+function toString(value, fallback) {
+  if (typeof value == "string") return value;
+  if (value == null) return "";
+  try {
+    return innerToString(value, false);
+  } catch (ex) {
+    rethrowControl(ex);
+    if (fallback === void 0) {
+      const e = new VmError(`Failed to convert value to string: ${display(value)}`, "");
+      e.cause = ex;
+      throw e;
+    }
+    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
+var $AssertInit = (value) => {
+  if (value === void 0) throw new VmError(`Uninitialized value`, null);
+};
+
+// src/vm/operations/call.ts
+function $Call(func, args) {
+  const argsLen = args.length;
+  for (let i = 0; i < argsLen; i++) {
+    $AssertInit(args[i]);
+  }
+  if (typeof func == "function") {
+    return func(...args) ?? null;
+  }
+  if (isVmExtern(func)) {
+    return func.call(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/tag.ts
+var ObjectPrototype = Object.prototype;
+function getJsObjectTag(value) {
+  return ObjectPrototype.toString.call(value).slice(8, -1);
+}
+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;
+}
+function getTag(value) {
+  const tag = getJsObjectTag(value);
+  if (tag === "Function") {
+    if ("prototype" in value && typeof value.prototype == "object") {
+      const className = classNameOf(value);
+      if (!className) return `class`;
+      return `class ${className}`;
+    }
+    return `function`;
+  }
+  if (tag === "AsyncFunction") {
+    return `async function`;
+  }
+  if (tag === "GeneratorFunction") {
+    return `function*`;
+  }
+  if (tag === "AsyncGeneratorFunction") {
+    return `async function*`;
+  }
+  if (tag === "Object") {
+    const proto = getPrototypeOf(value);
+    if (proto === ObjectPrototype) {
+      return "Object";
+    }
+    if (proto == null) {
+      return "Object: null prototype";
+    }
+    if (typeof proto.constructor === "function") {
+      return classNameOf(proto.constructor) ?? "Object";
+    }
+  }
+  return tag;
+}
+
+// src/vm/types/extern/utils.ts
+function isArrayLike(value) {
+  return isArray(value) || ArrayBuffer.isView(value) && "length" in value;
+}
+function getKeys(value, includeNonEnumerable) {
+  if (!includeNonEnumerable) {
+    const keys3 = [];
+    for (const key in value) {
+      keys3.push(key);
+    }
+    return keys3;
+  }
+  const keys2 = /* @__PURE__ */ new Set();
+  let e = value;
+  while (e != null && (typeof e == "object" || typeof e == "function")) {
+    for (const key of getOwnPropertyNames(e)) {
+      keys2.add(key);
+    }
+    e = getPrototypeOf(e);
+  }
+  return Array.from(keys2);
+}
+var ObjectToString = Object.prototype.toString;
+var FunctionToString = Function.prototype.toString;
+var ArrayToString = Array.prototype.toString;
+var TypedArrayToString = Uint8Array.prototype.toString;
+function hasCustomToString(value) {
+  const { toString: toString2 } = value;
+  if (typeof toString2 != "function") return false;
+  if (toString2 === ObjectToString || toString2 === FunctionToString || toString2 === ArrayToString || toString2 === TypedArrayToString)
+    return false;
+  return true;
+}
+
+// src/vm/types/extern/access.ts
+var pFunction = Function.prototype;
+var pArray = Array.prototype;
+var pObject = Object.prototype;
+function canAccessProperty(value, key, read) {
+  if (key.startsWith("_")) return false;
+  if (typeof value == "function" && (key === "prototype" || key === "arguments" || key === "caller")) return false;
+  if (hasOwn(value, key)) return true;
+  if (!read) return true;
+  if (!(key in value)) return false;
+  if (key === "constructor") return false;
+  const prop = value[key];
+  if (key in pFunction && prop === pFunction[key]) return false;
+  if (key in pArray && prop === pArray[key]) return false;
+  if (key in pObject && prop === pObject[key]) return false;
+  return true;
+}
+
+// src/vm/types/extern/index.ts
+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
+   * This method will be used in {@link get}, {@link set}, {@link has}, and {@link keys} methods
+   */
+  access(key, read) {
+    return canAccessProperty(this.value, key, read);
+  }
+  /** 决定是否对属性进行包装 */
+  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) {
+    const keys2 = getKeys(this.value, includeNonEnumerable);
+    return keys2.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 isArrayLike(this.value);
+  }
+  /** @inheritdoc */
+  toString(useBraces) {
+    if (hasCustomToString(this.value)) {
+      return String(this.value);
+    }
+    if (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 super.toString(useBraces);
+  }
+  /** @inheritdoc */
+  get type() {
+    return "extern";
+  }
+  /** @inheritdoc */
+  get tag() {
+    const tag = getTag(this.value);
+    if (this.isArrayLike()) {
+      return `${tag}(${this.value.length})`;
+    }
+    return tag;
+  }
+};
+Object.defineProperty(VmExtern.prototype, kVmExtern, { value: true });
+
+// 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,
+      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,
+    returns: opt.returns ?? void 0,
+    examples: opt.examples?.length ? opt.examples : void 0,
+    deprecated: opt.deprecated ?? void 0
+  };
+  const name = opt.name ?? fn.name;
+  defineProperty(fn, "name", { value: name, configurable: true });
+  defineProperty(fn, kVmFunction, { value: freeze(info) });
+  return fn;
+}
+
+// src/vm/effects/wrap.ts
+function wrapEffect(kind, fn) {
+  const token = /* @__PURE__ */ Symbol();
+  return function(...args) {
+    const context = currentContext;
+    if (!context) {
+      if (kind === "async") throw new AsyncRequiredError();
+      return apply(fn, this, args);
+    }
+    throwIfFailed(context);
+    if (context.inHost) failContext(new ContextReentrancyError());
+    if (context.suspension) throw context.suspension;
+    const index = context.cursor++;
+    let slot = context.slots[index];
+    if (slot) {
+      if (slot.token !== token || slot.kind !== kind) failContext(new ReplayMismatchError());
+    } else {
+      slot = { token, kind, state: "pending", value: void 0 };
+      context.slots.push(slot);
+      context.inHost = true;
+      try {
+        const value = apply(fn, this, args);
+        if (kind === "async" && isPromiseLike(value)) {
+          const pending = slot;
+          pending.ready = Promise.resolve(value).then(
+            (result) => {
+              pending.state = "resolved";
+              pending.value = result;
+            },
+            (error) => {
+              pending.state = "rejected";
+              pending.value = error;
+            }
+          );
+        } else {
+          slot.state = "resolved";
+          slot.value = value;
+        }
+      } catch (error) {
+        rethrowControl(error);
+        slot.state = "rejected";
+        slot.value = error;
+      } finally {
+        context.inHost = false;
+      }
+    }
+    throwIfFailed(context);
+    if (slot.state === "rejected") throw slot.value;
+    if (slot.state === "resolved") return slot.value;
+    context.suspension = new SuspensionError(slot);
+    throw context.suspension;
+  };
+}
+
+export {
+  serializeNil,
+  serializeBoolean,
+  serializeNumber,
+  VM_ARRAY_MAX_LENGTH,
+  kVmScript,
+  kVmContext,
+  kVmModule,
+  VM_SCRIPT_NAME,
+  VM_FUNCTION_ANONYMOUS_NAME,
+  constants_exports,
+  isVmScript,
+  isVmContext,
+  isVmFunction,
+  getVmFunctionInfo,
+  isVmWrapper,
+  isVmModule,
+  isVmExtern,
+  isVmCallable,
+  isVmPrimitive,
+  isVmArray,
+  isVmRecord,
+  isVmConst,
+  getVmType,
+  isVmArrayLikeRecordByEntries,
+  isVmArrayLikeRecordByKeys,
+  isVmArrayLikeRecord,
+  isVmImmutable,
+  isVmValue,
+  isVmAny,
+  serializeString,
+  serializeRecordKey,
+  serializeArray,
+  serializeRecord,
+  serialize,
+  AsyncRequiredError,
+  ReplayMismatchError,
+  ContextReentrancyError,
+  createContext,
+  currentContext,
+  setCurrentContext,
+  resetContext,
+  failContext,
+  rethrowControl,
+  display,
+  VmError,
+  $AssertInit,
+  toString,
+  $Call,
+  $VArgs,
+  VmWrapper,
+  VmExtern,
+  wrapToVmConst,
+  wrapToVmValue,
+  unwrapFromVmValue,
+  VmFunction,
+  wrapEffect
+};
+//# sourceMappingURL=chunk-7JTZW66P.js.map