@mirascript/mirascript 0.1.0

package/dist/chunk-5FQWUJIY.js

@@ -0,0 +1,766 @@
+// src/compiler/emit.ts
+import { OpCode } from "@mirascript/wasm/types";
+import { encodeURL } from "js-base64";
+function emit(source, chunk, options) {
+  const gen = new Emitter(source, chunk, options);
+  gen.read();
+  const code = gen.codeLines.join("\n");
+  return code;
+}
+function readConst(reader, offset) {
+  const type = reader.getUint8(offset);
+  switch (type) {
+    /* c8 ignore next 2 */
+    case 0:
+      return [null, 1];
+    case 1:
+      return [true, 1];
+    case 2:
+      return [false, 1];
+    case 3: {
+      const ordinal = reader.getInt32(offset + 1, true);
+      return [ordinal, 5];
+    }
+    case 4: {
+      const num = reader.getFloat64(offset + 1, true);
+      return [num, 9];
+    }
+    case 5: {
+      const len = reader.getUint32(offset + 1, true);
+      const str = new TextDecoder().decode(new Uint8Array(reader.buffer, reader.byteOffset + offset + 5, len));
+      return [str, 5 + len];
+    }
+    /* c8 ignore next 2 */
+    default:
+      throw new Error(`Unknown constant type: ${type}`);
+  }
+}
+function toJavascript(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value == "object" || typeof value == "string") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+var ORIGIN = `mira://MiraScript`;
+var sourceId = 1;
+function createArray(length, fn) {
+  const result = [];
+  for (let i = 0; i < length; i++) {
+    result.push(fn(i));
+  }
+  return result;
+}
+var Emitter = class {
+  constructor(source, chunk, options) {
+    this.source = source;
+    this.chunk = chunk;
+    this.options = options;
+    this.constants = [];
+    this.codeOffset = 0;
+    this.closureCounter = 0;
+    this.identCounter = 0;
+    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.constants.push(toJavascript(constant));
+      i += size;
+    }
+  }
+  /** 制造缩进 */
+  ident(len = 0) {
+    if (!this.pretty) return "";
+    return "  ".repeat(this.identCounter + len);
+  }
+  /** 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.constants[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 script = 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(
+          ", "
+        );
+        if (script) {
+          args.unshift(`global = GlobalFallback()`);
+          code = `'use strict'; return (function script(${args.join(", ")}) { try { CpEnter(); var ${regs};`;
+        } else {
+          code = `${this.wv(reg)} = Function(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.constants[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(${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.constants[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 ? `global.get(${this.constants[func]})` : 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.constants[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.constants[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.constants[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();
+        const c = this.constants[i];
+        code = `${this.wv(reg)} = global.get(${c}) ?? null;`;
+        break;
+      }
+      case OpCode.GetGlobalDyn: {
+        reg = read();
+        const name = read();
+        code = `${this.wv(reg)} = global.get(${this.rv(name)}) ?? null;`;
+        break;
+      }
+      case OpCode.GetUpvalue: {
+        reg = read();
+        const level = read();
+        const up = read();
+        code = `${this.wv(reg)} = Upvalue(${this.rv(up, level)});`;
+        break;
+      }
+      case OpCode.SetUpvalue: {
+        reg = read();
+        const level = read();
+        const up = read();
+        code = `${this.wv(up, level)} = ${this.rv(reg)};`;
+        break;
+      }
+      case OpCode.Slice: {
+        reg = read();
+        const obj = read();
+        const start = readIndex();
+        const end = readIndex();
+        code = `${this.wv(reg)} = $Slice(${this.rv(obj)}, ${start}, ${end});`;
+        break;
+      }
+      case OpCode.SliceStart: {
+        reg = read();
+        const obj = read();
+        const end = readIndex();
+        code = `${this.wv(reg)} = $Slice(${this.rv(obj)}, null, ${end});`;
+        break;
+      }
+      case OpCode.SliceEnd: {
+        reg = read();
+        const obj = read();
+        const start = readIndex();
+        code = `${this.wv(reg)} = $Slice(${this.rv(obj)}, ${start}, null);`;
+        break;
+      }
+      case OpCode.SliceDyn: {
+        reg = read();
+        const obj = read();
+        const start = read();
+        const end = read();
+        code = `${this.wv(reg)} = $Slice(${this.rv(obj)}, ${this.rv(start)}, ${this.rv(end)});`;
+        break;
+      }
+      case OpCode.SliceExclusiveDyn: {
+        reg = read();
+        const obj = read();
+        const start = read();
+        const end = read();
+        code = `${this.wv(reg)} = $SliceExclusive(${this.rv(obj)}, ${this.rv(start)}, ${this.rv(end)});`;
+        break;
+      }
+      case OpCode.Record: {
+        reg = read();
+        code = `${this.wv(reg)} = ({`;
+        break;
+      }
+      case OpCode.Array: {
+        reg = read();
+        code = `${this.wv(reg)} = ([`;
+        break;
+      }
+      case OpCode.If: {
+        const cond = read();
+        code = `if (${this.rv(cond)} !== false && $ToBoolean(${this.rv(cond)}) !== false) {`;
+        break;
+      }
+      case OpCode.IfNot: {
+        const cond = read();
+        code = `if (${this.rv(cond)} !== true && $ToBoolean(${this.rv(cond)}) !== true) {`;
+        break;
+      }
+      case OpCode.IfInit: {
+        const cond = read();
+        code = `if (${this.rv(cond)} !== undefined) {`;
+        break;
+      }
+      case OpCode.IfNotInit: {
+        const cond = read();
+        code = `if (${this.rv(cond)} === undefined) {`;
+        break;
+      }
+      case OpCode.IfNil: {
+        const cond = read();
+        code = `if (${this.rv(cond)} === null) {`;
+        break;
+      }
+      case OpCode.IfNotNil: {
+        const cond = read();
+        code = `if (${this.rv(cond)} !== null) {`;
+        break;
+      }
+      case OpCode.LoopFor: {
+        const nreg = read();
+        const iterable = read();
+        const regs = createArray(nreg - 1, (i) => this.wv(i + 2, -1));
+        regs.unshift("_");
+        const ir = this.wv(1, -1);
+        code = `for (let ${ir} of $Iterable(${this.rv(iterable)})) { ${ir} ??= null; Cp(); let ${regs.join(", ")};`;
+        break;
+      }
+      case OpCode.LoopRange:
+      case OpCode.LoopRangeExclusive: {
+        const nreg = read();
+        const start = read();
+        const end = read();
+        const exclusive = opcode === OpCode.LoopRangeExclusive;
+        const regs = createArray(nreg - 1, (i2) => this.wv(i2 + 2, -1));
+        regs.unshift("_");
+        const i = this.wv(1, -1);
+        code = `for (let start = $ToNumber(${this.rv(start)}), end = $ToNumber(${this.rv(end)}), ${i} = start; ${i} ${exclusive ? "<" : "<="} end; ${i} += 1) { Cp(); let ${regs.join(", ")};`;
+        break;
+      }
+      case OpCode.Loop: {
+        const nreg = read();
+        const regs = createArray(nreg, (i) => this.wv(i + 1, -1));
+        regs.unshift("_");
+        code = `while (true) { Cp(); let ${regs.join(", ")};`;
+        break;
+      }
+      case OpCode.Break: {
+        code = `break;`;
+        break;
+      }
+      case OpCode.Continue: {
+        code = `continue;`;
+        break;
+      }
+      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();
+    this.addSourceMap();
+  }
+  /** 添加源映射 */
+  addSourceMap() {
+    if (!this.options.sourceMap) return;
+    let fileName = (this.options.fileName ?? "").trim();
+    const hasSchema = /^\w+:/.test(fileName);
+    if (!hasSchema) {
+      if (fileName.startsWith("/")) {
+        fileName = fileName.replace(/^\\+\s*/, "");
+      }
+      if (!fileName) {
+        fileName = `${sourceId++}.${this.options.input_mode === "Template" ? "miratpl" : "mira"}`;
+      }
+    }
+    const data = {
+      version: 3,
+      file: fileName,
+      sourceRoot: hasSchema ? "" : ORIGIN,
+      sources: [fileName],
+      sourcesContent: [ArrayBuffer.isView(this.source) ? null : this.source],
+      names: [],
+      mappings: ""
+    };
+    const prefix = "//# ";
+    const sourceURL = hasSchema ? fileName : `${ORIGIN}/${fileName}.js`;
+    this.codeLines.push(
+      // Prevent source map from being recognized as of this file
+      `${prefix}sourceURL=${sourceURL}`,
+      `${prefix}sourceMappingURL=data:application/json;base64,${encodeURL(JSON.stringify(data))}`
+    );
+  }
+};
+
+// src/compiler/compile-bytecode.ts
+import * as wasm from "@mirascript/wasm";
+var module;
+var loading;
+async function loadModule() {
+  if (module != null) return;
+  if (loading) return loading;
+  const p = (async () => {
+    let mod;
+    try {
+      mod = await import("#compiler-bundle");
+    } catch (ex) {
+      console.warn("Failed to load compiler bundle, falling back to @mirascript/wasm");
+      mod = wasm;
+    }
+    await wasm.ready;
+    module = mod;
+  })();
+  void p.finally(() => {
+    if (loading === p) {
+      loading = void 0;
+    }
+  });
+  loading = p;
+  return p;
+}
+function checkModule() {
+  if (module == null) {
+    throw new Error("MiraScript compiler module is not loaded.");
+  }
+}
+function compileBytecodeSync(script, options) {
+  checkModule();
+  const result = module.compileSync(script, options);
+  return [result.chunk, result.diagnostics];
+}
+async function compileBytecode(script, options) {
+  await loadModule();
+  const result = "compile" in module ? await module.compile(script, options) : module.compileSync(script, options);
+  return [result.chunk, result.diagnostics];
+}
+
+export {
+  emit,
+  loadModule,
+  compileBytecodeSync,
+  compileBytecode
+};
+//# sourceMappingURL=chunk-5FQWUJIY.js.map