@mirascript/mirascript 0.1.15 → 0.1.17

package/dist/chunk-JG3D67GF.js

@@ -0,0 +1,1625 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/helpers/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  REG_BIN: () => REG_BIN,
+  REG_HEX: () => REG_HEX,
+  REG_IDENTIFIER: () => REG_IDENTIFIER,
+  REG_NUMBER: () => REG_NUMBER,
+  REG_OCT: () => REG_OCT,
+  REG_ORDINAL: () => REG_ORDINAL,
+  REG_WHITESPACE: () => REG_WHITESPACE,
+  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
+});
+var REG_IDENTIFIER = /(?:_+|@+|\$+|\p{XID_Start})\p{XID_Continue}*/u;
+var REG_ORDINAL = /(?:214748364[0-7]|21474836[0-3]\d|2147483[0-5]\d{2}|214748[0-2]\d{3}|21474[0-7]\d{4}|2147[0-3]\d{5}|214[0-6]\d{6}|21[0-3]\d{7}|20\d{8}|1\d{9}|[1-9]\d{0,8}|0)/;
+var REG_WHITESPACE = /[ \t\v\f\r\n]/u;
+var REG_HEX = /0[xX][a-fA-F0-9_]*[a-fA-F0-9]/;
+var REG_OCT = /0[oO][0-7_]*[0-7]/;
+var REG_BIN = /0[bB][01_]*[01]/;
+var REG_NUMBER = /\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?[\d_]*\d)?/u;
+var VM_ARRAY_MAX_LENGTH = 2 ** 31 - 1;
+var kVmScript = Symbol.for("mirascript.vm.script");
+var kVmFunction = Symbol.for("mirascript.vm.function");
+var kVmFunctionProxy = Symbol.for("mirascript.vm.function.proxy");
+var kVmContext = Symbol.for("mirascript.vm.context");
+var kVmExtern = Symbol.for("mirascript.vm.extern");
+var kVmModule = Symbol.for("mirascript.vm.module");
+var kVmWrapper = Symbol.for("mirascript.vm.wrapper");
+var VM_SCRIPT_NAME = `<script_root>`;
+var VM_FUNCTION_ANONYMOUS_NAME = `<anonymous>`;
+
+// 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/helpers/types.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)) 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));
+}
+var MAX_DEPTH = 16;
+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_DEPTH) 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;
+  }
+}
+function isVmImmutable(value, checkDeep = false) {
+  return isVmModule(value) || isVmFunction(value) || isVmConst(value, checkDeep);
+}
+function isVmAny(value, checkDeep) {
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "undefined":
+      return true;
+    case "object":
+      if (value == null) return true;
+      if (isVmWrapper(value)) return true;
+      return isVmConst(value, checkDeep);
+    case "function":
+      return isVmFunction(value);
+    case "bigint":
+    case "symbol":
+    default:
+      return false;
+  }
+}
+function isVmValue(value, checkDeep = false) {
+  if (value === void 0) return false;
+  return isVmAny(value, checkDeep);
+}
+
+// src/helpers/serialize.ts
+var REG_IDENTIFIER_FULL = new RegExp(`^${REG_IDENTIFIER.source}$`, REG_IDENTIFIER.flags);
+var REG_ORDINAL_FULL = new RegExp(`^${REG_ORDINAL.source}$`, REG_ORDINAL.flags);
+var DEFAULT_OPTIONS = Object.freeze({
+  maxDepth: 128,
+  serializeNil,
+  serializeBoolean,
+  serializeNumber,
+  serializeString: serializeStringImpl,
+  serializeStringQuote: (value) => value,
+  serializeStringEscape: (value) => value,
+  serializeStringContent: (value) => value,
+  serializeArray,
+  serializeRecord,
+  serializePropName: String,
+  serializeFunction: serializeNil,
+  serializeModule: serializeNil,
+  serializeExtern: serializeNil
+});
+function 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);
+}
+function serializeStringImpl(value, options) {
+  if (!/[\p{C}'"`$\\]/u.test(value)) {
+    const oq = options.serializeStringQuote(`'`, true, options);
+    const cq = options.serializeStringQuote(`'`, false, options);
+    const c = options.serializeStringContent(value, options);
+    return oq + c + cq;
+  }
+  let ret = options.serializeStringQuote(`'`, true, options);
+  for (const char of value) {
+    if (char === "'") {
+      ret += options.serializeStringEscape(String.raw`\'`, options);
+    } else if (char === "\0") {
+      ret += options.serializeStringEscape(String.raw`\0`, options);
+    } else if (char === "\n") {
+      ret += options.serializeStringEscape(String.raw`\n`, options);
+    } else if (char === "\r") {
+      ret += options.serializeStringEscape(String.raw`\r`, options);
+    } else if (char === "	") {
+      ret += options.serializeStringEscape(String.raw`\t`, options);
+    } else if (char === "\b") {
+      ret += options.serializeStringEscape(String.raw`\b`, options);
+    } else if (char === "\f") {
+      ret += options.serializeStringEscape(String.raw`\f`, options);
+    } else if (char === "\v") {
+      ret += options.serializeStringEscape(String.raw`\v`, options);
+    } else if (char === "\\") {
+      ret += options.serializeStringEscape(String.raw`\\`, options);
+    } else if (char === "$") {
+      ret += options.serializeStringEscape(String.raw`\$`, options);
+    } else if (/\p{C}/u.test(char)) {
+      const code = char.codePointAt(0);
+      if (code <= 127) {
+        ret += options.serializeStringEscape(String.raw`\x${code.toString(16).padStart(2, "0")}`, options);
+      } else if (code >= 55296 && code <= 57343) {
+        ret += options.serializeStringContent("�", options);
+      } else {
+        ret += options.serializeStringEscape(String.raw`\u{${code.toString(16)}}`, options);
+      }
+    } else {
+      ret += options.serializeStringContent(char, options);
+    }
+  }
+  ret += options.serializeStringQuote(`'`, false, options);
+  return ret;
+}
+function serializeString(value, options) {
+  return serializeStringImpl(value, getSerializeOptions(options));
+}
+function 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 serializeNil() {
+  return "nil";
+}
+function serializeBoolean(value) {
+  return value ? "true" : "false";
+}
+function serializeNumber(value) {
+  if (isNaN(value)) return "nan";
+  if (!isFinite(value)) return value < 0 ? "-inf" : "inf";
+  if (value === 0) {
+    if (1 / value < 0) return "-0";
+    return "0";
+  }
+  return String(value);
+}
+function serializeArray(value, depth, options) {
+  if (depth > options.maxDepth) return `[]`;
+  if (value.length === 0) return "[]";
+  let str = "[";
+  for (let i = 0; i < value.length; i++) {
+    if (i > 0) str += ", ";
+    str += serializeImpl(value[i], depth, options);
+  }
+  str += "]";
+  return str;
+}
+var { valueOf } = Object.prototype;
+function customValueOf(value) {
+  const thisValueOf = value.valueOf;
+  if (typeof thisValueOf != "function" || thisValueOf === valueOf) {
+    return void 0;
+  }
+  const customValue = thisValueOf.call(value);
+  if (customValue === value) return void 0;
+  return customValue;
+}
+function serializeRecord(value, depth, options) {
+  const customValue = customValueOf(value);
+  if (customValue !== void 0) {
+    return serializeImpl(customValue, depth - 1, options);
+  }
+  if (depth > options.maxDepth) return `()`;
+  const e = entries(value);
+  if (e.length === 0) return "()";
+  if (e.length === 1) {
+    const [k, v] = e[0];
+    if (k === "0") {
+      return `(${serializeImpl(v, depth, options)},)`;
+    }
+    return `(${serializeRecordKeyOpt(k, options)}: ${serializeImpl(v, depth, options)})`;
+  }
+  const omitKey = isVmArrayLikeRecordByEntires(e);
+  let str = "(";
+  for (const [key, val] of e) {
+    if (str.length > 1) str += ", ";
+    if (omitKey) {
+      str += serializeImpl(val, depth, options);
+    } else {
+      str += `${serializeRecordKeyOpt(key, options)}: ${serializeImpl(val, depth, options)}`;
+    }
+  }
+  str += ")";
+  return str;
+}
+function serializeImpl(value, depth, options) {
+  if (value == null) {
+    return options.serializeNil(options);
+  }
+  if (typeof value == "boolean") {
+    return options.serializeBoolean(value, options);
+  }
+  if (typeof value == "number") {
+    return options.serializeNumber(value, options);
+  }
+  if (typeof value == "string") {
+    return options.serializeString(value, options);
+  }
+  if (isVmFunction(value)) {
+    return options.serializeFunction(value, options);
+  }
+  if (isVmModule(value)) {
+    return options.serializeModule(value, depth + 1, options);
+  }
+  if (isVmExtern(value)) {
+    return options.serializeExtern(value, depth + 1, options);
+  }
+  if (isVmArray(value)) {
+    return options.serializeArray(value, depth + 1, options);
+  }
+  if (isVmRecord(value)) {
+    return options.serializeRecord(value, depth + 1, options);
+  }
+  value;
+  return options.serializeNil(options);
+}
+function serialize(value, options) {
+  return serializeImpl(value, 0, getSerializeOptions(options));
+}
+function displayFunction(value) {
+  try {
+    const name = getVmFunctionInfo(value)?.fullName;
+    return name ? `<function ${name}>` : `<function>`;
+  } catch {
+    return `<function>`;
+  }
+}
+function displayWrapper(value, useBraces, fallback) {
+  try {
+    return value.toString(useBraces);
+  } catch {
+    return fallback;
+  }
+}
+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: (value) => displayWrapper(value, true, "<module>"),
+  serializeExtern: (value) => displayWrapper(value, true, "<extern>")
+});
+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) {
+    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/compiler/emit/index.ts
+import { OpCode } from "@mirascript/bindings";
+
+// src/helpers/convert/to-string.ts
+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 (typeof value == "number") return numberToString(value);
+  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) {
+    if (fallback === void 0) {
+      const e = new VmError(`Failed to convert value to string: ${display(value)}`, "");
+      e.cause = ex;
+      throw e;
+    }
+    return fallback;
+  }
+}
+
+// src/compiler/emit/consts.ts
+function toJsLiteral(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value == "string") {
+    return JSON.stringify(value);
+  }
+  if (value === 0) {
+    if (1 / value === -Infinity) return "-0";
+    return "0";
+  }
+  return String(value);
+}
+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}`);
+  }
+}
+
+// src/compiler/emit/globals.ts
+function readGlobal(emitter, constIdx) {
+  const { globals } = emitter;
+  const cached = globals.get(constIdx);
+  if (cached) return cached;
+  const constName = emitter.constVals[constIdx];
+  let name, lit;
+  if (typeof constName == "string") {
+    name = constName;
+    lit = emitter.constLits[constIdx];
+  } else {
+    name = toString(constName, void 0);
+    lit = toJsLiteral(name);
+  }
+  const val = `g${globals.size + 1}`;
+  const expr = `(${val} === undefined ? (${val} = global.get(${lit})) : ${val})`;
+  const desc = { v: val, l: lit, e: expr, n: name };
+  globals.set(constIdx, desc);
+  return desc;
+}
+
+// src/compiler/emit/sourcemap.ts
+import { SourceMapGenerator } from "source-map-js";
+
+// src/compiler/emit/constants.ts
+var SCRIPT_PREFIX = `'use strict'; return ((global = GlobalFallback()) => { try { CpEnter();`;
+var GLOBAL_HINT = `/* globals */`;
+
+// src/compiler/emit/sourcemap.ts
+var ORIGIN = `mira://MiraScript/`;
+var { SOURCE_URL, SOURCE_MAPPING_URL } = ((source, mapping, url) => {
+  const prefix = "//# ";
+  return {
+    SOURCE_URL: prefix.concat(source, url),
+    SOURCE_MAPPING_URL: prefix.concat(source, mapping, url)
+  };
+})(`source`, `Mapping`, `URL`);
+var SOURCE_OFFSET = 3;
+var toDataUrl = typeof Buffer == "function" && typeof Buffer.from == "function" ? (s) => `data:application/json;base64,${Buffer.from(s, "utf8").toString("base64")}` : (s) => `data:application/json;charset=utf-8,${encodeURIComponent(s)}`;
+function addGlobalMappings(globalLine, fileName, map, globals) {
+  let globalFile = `global;
+`;
+  map.addMapping({
+    generated: {
+      line: 3,
+      column: globalLine.indexOf(`global = `)
+    },
+    original: {
+      line: 1,
+      column: 0
+    },
+    source: fileName,
+    name: "global"
+  });
+  map.addMapping({
+    generated: {
+      line: 3,
+      column: SCRIPT_PREFIX.length
+    },
+    original: {
+      line: 1,
+      column: 7
+    },
+    source: fileName,
+    name: ""
+  });
+  let i = 1;
+  let pos = globalLine.indexOf(GLOBAL_HINT, SCRIPT_PREFIX.length) + GLOBAL_HINT.length;
+  for (const p of globals.values()) {
+    i++;
+    if (pos < 0) break;
+    const { v, n } = p;
+    pos = globalLine.indexOf(v, pos);
+    if (pos < 0) break;
+    map.addMapping({
+      generated: {
+        line: 3,
+        column: pos
+      },
+      original: {
+        line: i,
+        column: 0
+      },
+      source: fileName,
+      name: n
+    });
+    globalFile += `${n};
+`;
+  }
+  map.addMapping({
+    generated: {
+      line: 3,
+      column: pos
+    },
+    original: {
+      line: i,
+      column: 0
+    },
+    source: fileName,
+    name: ""
+  });
+  map.setSourceContent(fileName, globalFile);
+}
+var sourceId = 1;
+function createSourceMap(source, sourcemaps, codeLines, globals, options) {
+  let fileName = (options.fileName ?? "").trim();
+  const hasSchema = /^\w+:/.test(fileName);
+  if (!hasSchema) {
+    if (fileName.startsWith("/")) {
+      fileName = fileName.replace(/^\/+\s*/, "");
+    }
+    if (!fileName) {
+      fileName = `${sourceId++}.${options.input_mode === "Template" ? "miratpl" : "mira"}`;
+    }
+  }
+  const map = new SourceMapGenerator({
+    file: fileName + ".js"
+  });
+  if (typeof source === "string") {
+    map.setSourceContent(fileName, source);
+  }
+  let hasStartMap = false;
+  for (let i = 1; i < sourcemaps.length; i++) {
+    const range = sourcemaps[i];
+    if (!range) break;
+    if (!hasStartMap && range.startLineNumber === 1 && range.startColumn === 1) {
+      hasStartMap = true;
+    }
+    map.addMapping({
+      generated: {
+        line: i + SOURCE_OFFSET,
+        column: 0
+      },
+      original: {
+        line: range.startLineNumber,
+        column: range.startColumn - 1
+      },
+      source: fileName
+    });
+  }
+  if (!hasStartMap) {
+    map.addMapping({
+      generated: {
+        line: SOURCE_OFFSET,
+        column: SCRIPT_PREFIX.length - "CpEnter();".length
+      },
+      original: {
+        line: 1,
+        column: 0
+      },
+      source: fileName
+    });
+  }
+  const globalLine = codeLines[0];
+  if (globalLine?.includes(GLOBAL_HINT)) {
+    addGlobalMappings(globalLine, `${fileName} <globals>`, map, globals);
+  }
+  const sourceURL = hasSchema ? fileName : `${ORIGIN}${fileName}`;
+  const dataUrl = toDataUrl(map.toString());
+  return [
+    // Prevent source map from being recognized as of this file
+    `${SOURCE_URL}=${sourceURL}.js`,
+    `${SOURCE_MAPPING_URL}=${dataUrl}`
+  ];
+}
+
+// src/compiler/emit/index.ts
+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 createArray(length, fn) {
+  const result = [];
+  for (let i = 0; i < length; i++) {
+    result.push(fn(i));
+  }
+  return result;
+}
+var SCRIPT_PREFIX2 = `'use strict'; return ((global = GlobalFallback()) => { try { CpEnter();`;
+var GLOBAL_HINT2 = `/* 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(toJsLiteral(constant));
+      i += size;
+    }
+  }
+  /** 制造缩进 */
+  ident(len = 0) {
+    if (!this.pretty) return "";
+    return "  ".repeat(this.identCounter + len);
+  }
+  /** 读取全局变量 */
+  rg(constIdx, eager) {
+    return readGlobal(this, constIdx).e;
+  }
+  /** 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_PREFIX2} 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, false) : 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, false)};`;
+        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 ($ToBoolean(${this.rv(cond)})) {`;
+        break;
+      }
+      case OpCode.IfNot: {
+        const cond = read();
+        code = `if (!$ToBoolean(${this.rv(cond)})) {`;
+        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 { v } of this.globals.values()) {
+        globalsInit += globalsInit ? `, ${v}` : `var ${GLOBAL_HINT2} ${v}`;
+      }
+      this.codeLines[0] += globalsInit + ";";
+    }
+    this.addSourceMap();
+  }
+  /** 添加源映射 */
+  addSourceMap() {
+    if (!this.options.sourceMap) return;
+    const mapLines = createSourceMap(this.source, this.sourcemaps, this.codeLines, this.globals, this.options);
+    this.codeLines.push(...mapLines);
+  }
+};
+
+// 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 formatDiagnostics(diagnostics, source, fileName) {
+  const rangePrefix = fileName ? `${fileName}:` : "";
+  const messages = [];
+  for (const diagnostic of diagnostics) {
+    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)}`;
+    }
+    messages.push(`  ${codeName}(${rangePrefix}${range}): ${message}`);
+  }
+  return messages;
+}
+
+// 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,
+  VM_ARRAY_MAX_LENGTH,
+  kVmScript,
+  kVmFunction,
+  kVmFunctionProxy,
+  kVmContext,
+  kVmExtern,
+  kVmModule,
+  kVmWrapper,
+  VM_SCRIPT_NAME,
+  VM_FUNCTION_ANONYMOUS_NAME,
+  constants_exports,
+  isArray,
+  isFinite,
+  isNaN,
+  isInteger,
+  isSafeInteger,
+  hasOwn,
+  keys,
+  values,
+  entries,
+  create,
+  getPrototypeOf,
+  fromEntries,
+  defineProperty,
+  apply,
+  hasOwnEnumerable,
+  isVmScript,
+  isVmContext,
+  isVmFunction,
+  getVmFunctionInfo,
+  isVmWrapper,
+  isVmModule,
+  isVmExtern,
+  isVmCallable,
+  isVmPrimitive,
+  isVmArray,
+  isVmRecord,
+  isVmArrayLikeRecordByEntires,
+  isVmArrayLikeRecordByKeys,
+  isVmArrayLikeRecord,
+  isVmConst,
+  isVmImmutable,
+  isVmAny,
+  isVmValue,
+  serializeString,
+  serializeRecordKey,
+  serializeNil,
+  serializeBoolean,
+  serializeNumber,
+  serializeArray,
+  serializeRecord,
+  serialize,
+  display,
+  VmError,
+  innerToString,
+  toString,
+  emit,
+  DiagnosticCode,
+  getDiagnosticMessage,
+  parseDiagnostics,
+  formatDiagnostics,
+  generateBytecodeSync,
+  generateBytecode
+};
+//# sourceMappingURL=chunk-JG3D67GF.js.map