@mirascript/mirascript 0.1.86 → 0.1.88

package/dist/{chunk-A425FGG3.js → chunk-Y7S6AHE7.js}

@@ -1,60 +1,35 @@
 import {
   DiagnosticCode,
+  NegativeInfinity,
   NotNumber,
   PositiveInfinity,
-  VM_ARRAY_MAX_LENGTH,
-  VM_FUNCTION_ANONYMOUS_NAME,
-  VM_SCRIPT_NAME,
-  VmError,
   __export,
+  __reExport,
   apply,
-  constants_exports,
   create,
   defineProperty,
-  display,
   emit,
   entries,
   formatDiagnostics,
   freeze,
   fromEntries,
+  generateBytecode,
   getOwnPropertyNames,
   getPrototypeOf,
   getRecord,
-  getVmType,
   hasOwn,
   hasOwnEnumerable,
-  innerToString,
   isArray,
   isFinite,
   isInteger,
   isNaN,
   isSafeInteger,
-  isVmArray,
-  isVmCallable,
-  isVmConst,
-  isVmExtern,
-  isVmFunction,
-  isVmModule,
-  isVmPrimitive,
-  isVmRecord,
-  isVmWrapper,
-  kVmContext,
-  kVmExtern,
-  kVmFunction,
-  kVmFunctionProxy,
-  kVmModule,
-  kVmScript,
-  kVmWrapper,
   keys,
   keysLength,
   parseDiagnostics,
   setRecord,
-  toBoolean,
-  toFormat,
-  toNumber,
-  toString,
   values
-} from "./chunk-LSPCAN32.js";
+} from "./chunk-HHKY7Y7L.js";
 
 // src/compiler/load-module.ts
 import { loadModule } from "@mirascript/bindings";
@@ -63,6 +38,605 @@ try {
 } catch (error) {
 }
 
+// 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(entries3) {
+  const { length } = entries3;
+  if (length === 0) return true;
+  if (length > VM_ARRAY_MAX_LENGTH) return false;
+  const firstKey = entries3[0][0];
+  if (firstKey !== "0") return false;
+  const lastKey = entries3[length - 1][0];
+  if (lastKey !== String(length - 1)) return false;
+  return true;
+}
+function isVmArrayLikeRecordByKeys(keys4) {
+  const { length } = keys4;
+  if (length === 0) return true;
+  if (length > VM_ARRAY_MAX_LENGTH) return false;
+  const firstKey = keys4[0];
+  if (firstKey !== "0") return false;
+  const lastKey = keys4[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/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/helpers/serialize.ts
+import { REG_IDENTIFIER_FULL, REG_ORDINAL_FULL } from "@mirascript/constants";
+
+// src/helpers/convert/string.ts
+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 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 entries3 = keys(value).map((key) => `${key}: ${innerToString(value[key], true)}`).join(", ");
+    if (!useBraces) return entries3;
+    return `(${entries3})`;
+  }
+}
+function toString(value, fallback) {
+  if (typeof value == "string") return value;
+  if (value == null) return "";
+  try {
+    return innerToString(value, false);
+  } catch (ex) {
+    if (fallback === void 0) {
+      const e2 = new VmError(`Failed to convert value to string: ${display(value)}`, "");
+      e2.cause = ex;
+      throw e2;
+    }
+    return fallback;
+  }
+}
+
+// src/helpers/serialize.ts
+function serializeNil() {
+  return "nil";
+}
+function serializeBoolean(value) {
+  return value ? "true" : "false";
+}
+function serializeNumber(value) {
+  return numberToString(value, true);
+}
+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 cp2 = value.codePointAt(lastIndex);
+    const ch = String.fromCodePoint(cp2);
+    if (!STRING_MARK.test(ch)) break;
+    ret += serializeStringEscaped(`u{${cp2.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;
+}
+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 e2 = entries(value);
+  if (e2.length === 0) return "()";
+  if (e2.length === 1) {
+    const [k, v] = e2[0];
+    if (k === "0") {
+      return `(${serializeImpl(v, depth, options)},)`;
+    }
+    return `(${serializeRecordKeyOpt(k, options)}: ${serializeImpl(v, depth, options)})`;
+  }
+  const omitKey = isVmArrayLikeRecordByEntries(e2);
+  let result = "(";
+  for (const [key, val] of e2) {
+    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 displayFunction(value) {
+  try {
+    const name = getVmFunctionInfo(value)?.fullName;
+    return name ? `<function ${name}>` : `<function>`;
+  } catch {
+    return `<function>`;
+  }
+}
+function displayModule(value) {
+  try {
+    return value.toString(true);
+  } catch {
+    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 {
+    return `<extern>`;
+  }
+}
+function display(value, options) {
+  const opt = mergeOptions(DISPLAY_OPTIONS, options);
+  return serializeImpl(value, 0, opt);
+}
+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
+});
+var DISPLAY_OPTIONS = Object.freeze({
+  maxDepth: 3,
+  serializeNil,
+  serializeBoolean,
+  serializeNumber,
+  serializeString: serializeStringImpl,
+  serializeStringQuote: (value) => value,
+  serializeStringEscape: (value) => value,
+  serializeStringContent: (value) => value,
+  serializeArray,
+  serializeRecord,
+  serializePropName: String,
+  serializeFunction: displayFunction,
+  serializeModule: displayModule,
+  serializeExtern: displayExtern
+});
+
+// src/helpers/convert/index.ts
+var convert_exports = {};
+__export(convert_exports, {
+  toBoolean: () => toBoolean,
+  toFormat: () => toFormat,
+  toNumber: () => toNumber,
+  toString: () => toString
+});
+
+// src/helpers/convert/number.ts
+var parseInt = (value, radix) => Number.parseInt(value.slice(2), radix);
+function parseNumericLiteral(value) {
+  const ch0 = value.charAt(0);
+  if (ch0 < "0" || ch0 > "9") return null;
+  if (/^0[bB][01]+$/.test(value)) return parseInt(value, 2);
+  if (/^0[oO][0-7]+$/.test(value)) return parseInt(value, 8);
+  if (/^0[xX][0-9a-fA-F]+$/.test(value)) return parseInt(value, 16);
+  if (/^[0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?$/.test(value)) return Number.parseFloat(value);
+  return null;
+}
+function stringToNumber(value) {
+  value = value.trim();
+  if (value === "") return null;
+  if (value === "inf" || value === "+inf" || value === "Infinity" || value === "+Infinity") return PositiveInfinity;
+  if (value === "-inf" || value === "-Infinity") return NegativeInfinity;
+  if (value === "nan" || value === "NaN") return NotNumber;
+  if (value.startsWith("-")) {
+    const num2 = parseNumericLiteral(value.slice(1));
+    if (num2 != null) return -num2;
+    return null;
+  } else if (value.startsWith("+")) {
+    return parseNumericLiteral(value.slice(1));
+  } else {
+    return parseNumericLiteral(value);
+  }
+}
+function toNumber(value, fallback) {
+  if (typeof value == "number") return value;
+  if (typeof value == "boolean") return value ? 1 : 0;
+  if (typeof value == "string") {
+    const num2 = stringToNumber(value);
+    if (num2 !== null) return num2;
+  }
+  if (fallback === void 0) {
+    throw new VmError(`Failed to convert value to number: ${display(value)}`, NotNumber);
+  }
+  return fallback;
+}
+
+// src/helpers/convert/format.ts
+function formatNumber(finite) {
+  if (finite === 0) return "0";
+  const s2 = finite.toString();
+  let ps;
+  const abs3 = Math.abs(finite);
+  if (abs3 >= 1e3 || abs3 < 1e-3) {
+    const ps1 = finite.toExponential();
+    const ps2 = finite.toExponential(5);
+    ps = ps1.length < ps2.length ? ps1 : ps2;
+  } else {
+    ps = finite.toPrecision(6);
+  }
+  return ps.length < s2.length ? ps : s2;
+}
+function toFormat(value, format2) {
+  const f = format2 == null ? "" : format2.trim();
+  if (typeof value == "number") {
+    if (!isFinite(value)) {
+      return toString(value, void 0);
+    }
+    if (/^\.\d+$/.test(f)) {
+      let digits = Math.trunc(Number(f.slice(1)));
+      if (!(digits <= 100)) digits = 100;
+      return value.toFixed(digits);
+    } else {
+      return formatNumber(value);
+    }
+  }
+  return toString(value, void 0);
+}
+
+// src/helpers/convert/boolean.ts
+function toBoolean(value, fallback) {
+  if (typeof value == "boolean") return value;
+  if (fallback === void 0) {
+    throw new VmError(`Failed to convert value to boolean: ${display(value)}`, false);
+  }
+  return fallback;
+}
+
 // src/vm/types/wrapper.ts
 var VmWrapper = class {
   constructor(value) {
@@ -642,7 +1216,7 @@ var { now } = Date;
 var TIME_ORIGIN = now() - 1e3 * 3600 * 12;
 var timestamp = () => now() - TIME_ORIGIN | 0;
 var CP_DEFAULT_INTERVAL = 100;
-var MAX_DEPTH = 128;
+var MAX_DEPTH2 = 128;
 var CP_UNSET = -1;
 var CP_DEFAULT_TIMEOUT = 100;
 var cpTimeout = CP_DEFAULT_TIMEOUT | 0;
@@ -667,7 +1241,7 @@ var CpEnter = () => {
     cp = CP_UNSET | 0;
     cpCounter = 0;
     cpDepth = 1;
-  } else if ((cpDepth | 0) > MAX_DEPTH) {
+  } else if ((cpDepth | 0) > MAX_DEPTH2) {
     throw new RangeError("Maximum call depth exceeded");
   } else {
     Cp();
@@ -1276,6 +1850,56 @@ function emitScript(source, [code, diagnostics], options) {
   return createScript(source, options.input_mode ?? "Script", target);
 }
 
+// src/compiler/worker-manager.ts
+import { WorkerPool } from "@cloudpss/worker/pool";
+var pool = /* @__PURE__ */ new WorkerPool(
+  () => {
+    return new Worker(new URL("#compiler/worker", import.meta.url), {
+      type: "module",
+      name: "@mirascript/compiler"
+    });
+  },
+  {
+    name: "@mirascript/compiler"
+  }
+);
+async function compileWorker(...args) {
+  return await pool.call("compile", args);
+}
+
+// src/compiler/options.ts
+var WORKER_MIN_LEN = typeof Worker != "function" ? Number.MAX_VALUE : 1024;
+function normalizeTranspileOptions(options) {
+  options ??= {};
+  if (options.sourceMap) {
+    options.diagnostic_sourcemap = true;
+    options.diagnostic_position_encoding ??= "Utf16";
+  }
+  options.input_mode ??= "Script";
+  return options;
+}
+
+// src/compiler/verbose.ts
+async function compileVerbose(source, options) {
+  options = normalizeTranspileOptions(options);
+  if (source.length < WORKER_MIN_LEN) {
+    const bc = await generateBytecode(source, options);
+    const script2 = emitScript(source, bc, options);
+    return {
+      script: script2,
+      bytecode: bc[0],
+      // Will throw if bytecode is undefined, but that should be handled by emitScript
+      diagnostics: bc[1]
+    };
+  }
+  const [bytecode, target, diagnostics] = await compileWorker(source, options);
+  if (target == null) {
+    throw new CompileError(source, diagnostics, options.fileName);
+  }
+  const script = createScript(source, options.input_mode ?? "Script", target);
+  return { script, bytecode, diagnostics };
+}
+
 // src/vm/lib/global/index.ts
 var global_exports = {};
 __export(global_exports, {
@@ -3979,6 +4603,37 @@ for (const [name, value] of entries(mod_exports)) {
 var lib = Object.freeze(Object.assign(create(null), global_exports, mod_exports));
 
 export {
+  constants_exports,
+  isVmScript,
+  isVmContext,
+  isVmFunction,
+  getVmFunctionInfo,
+  isVmWrapper,
+  isVmModule,
+  isVmExtern,
+  isVmCallable,
+  isVmPrimitive,
+  isVmArray,
+  isVmRecord,
+  isVmConst,
+  getVmType,
+  isVmArrayLikeRecordByEntries,
+  isVmArrayLikeRecordByKeys,
+  isVmArrayLikeRecord,
+  isVmImmutable,
+  isVmValue,
+  isVmAny,
+  VmError,
+  serializeNil,
+  serializeBoolean,
+  serializeNumber,
+  serializeString,
+  serializeRecordKey,
+  serializeArray,
+  serializeRecord,
+  serialize,
+  display,
+  convert_exports,
   VmExtern,
   wrapToVmValue,
   unwrapFromVmValue,
@@ -3994,6 +4649,8 @@ export {
   createScript,
   CompileError,
   emitScript,
+  normalizeTranspileOptions,
+  compileVerbose,
   lib
 };
-//# sourceMappingURL=chunk-A425FGG3.js.map
+//# sourceMappingURL=chunk-Y7S6AHE7.js.map