@yowasp/yosys 0.0.0-experimental1

package/gen/bundle-browser.js

@@ -0,0 +1,4554 @@
+// node_modules/@yowasp/runtime/lib/wasi-virt.js
+var Exit = class extends Error {
+  constructor(code = 0) {
+    super(`Exited with status ${code}`);
+    this.code = code;
+  }
+};
+function monotonicNow() {
+  return BigInt(Math.floor(performance.now() * 1e6));
+}
+function wallClockNow() {
+  let now = Date.now();
+  const seconds = BigInt(Math.floor(now / 1e3));
+  const nanoseconds = now % 1e3 * 1e6;
+  return { seconds, nanoseconds };
+}
+var IoError = class extends Error {
+};
+var InputStream = class {
+  read(_len) {
+    throw { tag: "closed" };
+  }
+  blockingRead(len) {
+    return this.read(len);
+  }
+};
+var OutputStream = class {
+  checkWrite() {
+    throw { tag: "closed" };
+  }
+  write(_contents) {
+    this.checkWrite();
+  }
+  flush() {
+  }
+  blockingFlush() {
+    this.flush();
+  }
+  blockingWriteAndFlush(contents) {
+    this.write(contents);
+    this.blockingFlush();
+  }
+};
+var TerminalInput = class {
+};
+var TerminalOutput = class {
+};
+var TerminalOutputStream = class extends OutputStream {
+  buffer = "";
+  constructor(printLine = console.log) {
+    super();
+    this.printLine = printLine;
+  }
+  checkWrite() {
+    return 4096;
+  }
+  write(contents) {
+    this.buffer += new TextDecoder().decode(contents);
+    let newlineAt = -1;
+    while (true) {
+      const nextNewlineAt = this.buffer.indexOf("\n", newlineAt + 1);
+      if (nextNewlineAt === -1) {
+        break;
+      }
+      this.printLine(this.buffer.substring(0, nextNewlineAt));
+      newlineAt = nextNewlineAt;
+    }
+    this.buffer = this.buffer.substring(newlineAt + 1);
+  }
+};
+var File = class {
+  constructor(data = "") {
+    if (data instanceof Uint8Array) {
+      this.data = data;
+    } else if (typeof data === "string") {
+      this.data = new TextEncoder().encode(data);
+    } else {
+      throw new Error(`Cannot construct a file from ${typeof data}`);
+    }
+  }
+  get size() {
+    return this.data.length;
+  }
+};
+var ReadStream = class extends InputStream {
+  constructor(file, offset) {
+    super();
+    this.file = file;
+    this.offset = offset;
+  }
+  read(len) {
+    const data = this.file.data.subarray(Number(this.offset), Number(this.offset + len));
+    this.offset += len;
+    return data;
+  }
+};
+var WriteStream = class extends OutputStream {
+  constructor(file, offset) {
+    super();
+    this.file = file;
+    this.offset = offset;
+  }
+  write(contents) {
+    const newData = new Uint8Array(this.file.data.length + contents.length);
+    newData.set(this.file.data);
+    newData.subarray(Number(this.offset)).set(contents);
+    this.file.data = newData;
+    this.offset += BigInt(contents.length);
+  }
+};
+var Directory = class _Directory {
+  constructor(files = {}) {
+    this.files = files;
+  }
+  get size() {
+    return Object.keys(this.files).length;
+  }
+  traverse(path, flags = { create: false, remove: false }) {
+    let entry = this;
+    let separatorAt = -1;
+    do {
+      if (entry instanceof File)
+        throw "not-directory";
+      const files = entry.files;
+      separatorAt = path.indexOf("/");
+      const segment = separatorAt === -1 ? path : path.substring(0, separatorAt);
+      if (separatorAt === -1 && flags.remove)
+        delete files[segment];
+      else if (segment === "" || segment === ".")
+        ;
+      else if (segment === "..")
+        ;
+      else if (Object.hasOwn(files, segment))
+        entry = files[segment];
+      else if (flags.create === "directory" || flags.create === "file" && separatorAt !== -1)
+        entry = files[segment] = new _Directory({});
+      else if (flags.create === "file")
+        entry = files[segment] = new File(new Uint8Array());
+      else
+        throw "no-entry";
+      path = path.substring(separatorAt + 1);
+    } while (separatorAt !== -1);
+    return entry;
+  }
+};
+var Descriptor = class _Descriptor {
+  constructor(entry) {
+    this.entry = entry;
+  }
+  getType() {
+    if (this.entry instanceof Directory)
+      return "directory";
+    if (this.entry instanceof File)
+      return "regular-file";
+  }
+  getFlags() {
+    return {};
+  }
+  metadataHash() {
+    return { upper: 0, lower: 0 };
+  }
+  metadataHashAt(_pathFlags, path) {
+    if (!(this.entry instanceof Directory))
+      throw "invalid";
+    const pathEntry = this.entry.traverse(path);
+    return new _Descriptor(pathEntry).metadataHash();
+  }
+  stat() {
+    let type;
+    if (this.entry instanceof Directory)
+      type = "directory";
+    if (this.entry instanceof File)
+      type = "regular-file";
+    return {
+      type,
+      linkCount: 1,
+      size: this.entry.size,
+      dataAccessTimestamp: null,
+      dataModificationTimestamp: null,
+      statusChangeTimestamp: null
+    };
+  }
+  statAt(_pathFlags, path) {
+    if (!(this.entry instanceof Directory))
+      throw "invalid";
+    const pathEntry = this.entry.traverse(path);
+    return new _Descriptor(pathEntry).stat();
+  }
+  openAt(_pathFlags, path, openFlags, _descriptorFlags) {
+    if (!(this.entry instanceof Directory))
+      throw "invalid";
+    const openEntry = this.entry.traverse(path, { create: openFlags.create ? "file" : false });
+    if (openFlags.directory) {
+      if (!(openEntry instanceof Directory))
+        throw "not-directory";
+    } else {
+      if (openEntry instanceof Directory)
+        throw "is-directory";
+      if (openFlags.truncate)
+        openEntry.data = new Uint8Array();
+    }
+    return new _Descriptor(openEntry);
+  }
+  readViaStream(offset) {
+    return new ReadStream(this.entry, offset);
+  }
+  writeViaStream(offset) {
+    return new WriteStream(this.entry, offset);
+  }
+  readDirectory() {
+    return new DirectoryEntryStream(this.entry);
+  }
+  createDirectoryAt(path) {
+    this.entry.traverse(path, { create: "directory" });
+  }
+  unlinkFileAt(path) {
+    const pathEntry = this.entry.traverse(path);
+    if (pathEntry instanceof Directory)
+      return "is-directory";
+    this.entry.traverse(path, { remove: true });
+  }
+  removeDirectoryAt(path) {
+    const pathEntry = this.entry.traverse(path);
+    if (!(pathEntry instanceof Directory))
+      return "not-directory";
+    this.entry.traverse(path, { remove: true });
+  }
+};
+var DirectoryEntryStream = class {
+  constructor(directory) {
+    this.entries = Object.entries(directory.files);
+    this.index = 0;
+  }
+  readDirectoryEntry() {
+    if (this.index === this.entries.length)
+      return null;
+    const [name, entry] = this.entries[this.index++];
+    let type;
+    if (entry instanceof Directory)
+      type = "directory";
+    if (entry instanceof File)
+      type = "regular-file";
+    return { name, type };
+  }
+};
+function directoryFromTree(tree) {
+  const files = {};
+  for (const [filename, data] of Object.entries(tree)) {
+    if (typeof data === "string" || data instanceof Uint8Array)
+      files[filename] = new File(tree[filename]);
+    else
+      files[filename] = directoryFromTree(tree[filename]);
+  }
+  return new Directory(files);
+}
+function directoryIntoTree(directory) {
+  const tree = {};
+  for (const [filename, entry] of Object.entries(directory.files)) {
+    if (entry instanceof File)
+      tree[filename] = new TextDecoder().decode(entry.data);
+    if (entry instanceof Directory)
+      tree[filename] = directoryIntoTree(entry);
+  }
+  return tree;
+}
+var Environment = class {
+  vars = {};
+  args = [];
+  root = new Directory({});
+  constructor() {
+    this.terminalInputStream = new InputStream();
+    this.terminalOutputStream = new TerminalOutputStream();
+    this.terminalInput = new TerminalInput();
+    this.terminalOutput = new TerminalOutput();
+    const $this = this;
+    this.exports = {
+      monotonicClock: {
+        now: monotonicNow
+      },
+      wallClock: {
+        now: wallClockNow
+      },
+      io: {
+        Error: IoError,
+        InputStream,
+        OutputStream
+      },
+      cli: {
+        exit(status) {
+          throw new Exit(status.tag === "ok" ? 0 : 1);
+        },
+        getEnvironment() {
+          return $this.vars;
+        },
+        getArguments() {
+          return $this.args;
+        },
+        getStdin() {
+          return $this.terminalInputStream;
+        },
+        getStdout() {
+          return $this.terminalOutputStream;
+        },
+        getStderr() {
+          return $this.terminalOutputStream;
+        },
+        getTerminalStdin() {
+          return $this.terminalInput;
+        },
+        getTerminalStdout() {
+          return $this.terminalOutput;
+        },
+        getTerminalStderr() {
+          return $this.terminalOutput;
+        },
+        TerminalInput,
+        TerminalOutput
+      },
+      fs: {
+        Descriptor,
+        DirectoryEntryStream,
+        filesystemErrorCode() {
+        },
+        getDirectories() {
+          if ($this.root === null)
+            return [];
+          return [[new Descriptor($this.root), "/"]];
+        }
+      }
+    };
+  }
+  get printLine() {
+    return this.terminalOutputStream.printLine;
+  }
+  set printLine(fn) {
+    this.terminalOutputStream.printLine = fn;
+  }
+};
+
+// node_modules/@yowasp/runtime/lib/api-base.js
+var BaseApplication = class {
+  constructor(getResources, wasmModules, instantiate2, argv0) {
+    this._resources = null;
+    this.getResources = getResources;
+    this.wasmModules = wasmModules;
+    this.instantiate = instantiate2;
+    this.argv0 = argv0;
+  }
+  async run(args, files = {}, printLine = console.log) {
+    if (this._resources === null)
+      this._resources = await this.getResources();
+    const environment = new Environment();
+    environment.args = [this.argv0].concat(args);
+    environment.root = directoryFromTree(files);
+    for (const [dirName, resourceFiles] of Object.entries(this._resources))
+      environment.root.files[dirName] = directoryFromTree(resourceFiles);
+    environment.printLine = printLine;
+    const wasmCommand = await this.instantiate(
+      (filename) => this.wasmModules[filename],
+      { runtime: environment.exports }
+    );
+    try {
+      wasmCommand.run.run();
+    } catch (e) {
+      if (!(e instanceof Exit && e.code === 0))
+        throw e;
+    }
+    for (const dirName of Object.keys(this._resources))
+      delete environment.root[dirName];
+    return directoryIntoTree(environment.root);
+  }
+};
+
+// node_modules/@yowasp/runtime/lib/api-browser.js
+var Application = class extends BaseApplication {
+  constructor(baseURL2, resourceFilenames, wasmFilenames, instantiate2, argv0) {
+    async function getResources() {
+      const resources = {};
+      for (const [dirName, jsonFilename] of Object.entries(resourceFilenames))
+        resources[dirName] = await fetch(new URL(jsonFilename, baseURL2)).then((resp) => resp.json());
+      return resources;
+    }
+    const wasmModules = {};
+    for (const [modName, wasmFilename] of Object.entries(wasmFilenames))
+      wasmModules[modName] = fetch(new URL(wasmFilename, baseURL2)).then(WebAssembly.compileStreaming);
+    super(getResources, wasmModules, instantiate2, argv0);
+  }
+};
+
+// gen/yosys.js
+var ComponentError = class extends Error {
+  constructor(value) {
+    const enumerable = typeof value !== "string";
+    super(enumerable ? `${String(value)} (see error.payload)` : value);
+    Object.defineProperty(this, "payload", { value, enumerable });
+  }
+};
+var dv = new DataView(new ArrayBuffer());
+var dataView = (mem) => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
+function getErrorPayload(e) {
+  if (e && hasOwnProperty.call(e, "payload"))
+    return e.payload;
+  return e;
+}
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var resourceHandleSymbol = Symbol("resource");
+var symbolDispose = Symbol.dispose || Symbol.for("dispose");
+var toUint64 = (val) => BigInt.asUintN(64, BigInt(val));
+function toUint32(val) {
+  return val >>> 0;
+}
+var utf8Decoder = new TextDecoder();
+var utf8Encoder = new TextEncoder();
+var utf8EncodedLen = 0;
+function utf8Encode(s, realloc, memory) {
+  if (typeof s !== "string")
+    throw new TypeError("expected a string");
+  if (s.length === 0) {
+    utf8EncodedLen = 0;
+    return 1;
+  }
+  let allocLen = 0;
+  let ptr = 0;
+  let writtenTotal = 0;
+  while (s.length > 0) {
+    ptr = realloc(ptr, allocLen, 1, allocLen += s.length * 2);
+    const { read, written } = utf8Encoder.encodeInto(
+      s,
+      new Uint8Array(memory.buffer, ptr + writtenTotal, allocLen - writtenTotal)
+    );
+    writtenTotal += written;
+    s = s.slice(read);
+  }
+  utf8EncodedLen = writtenTotal;
+  return ptr;
+}
+async function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.instantiate) {
+  const module0 = getCoreModule("yosys.core.wasm");
+  const module1 = getCoreModule("yosys.core2.wasm");
+  const module2 = getCoreModule("yosys.core3.wasm");
+  const module3 = getCoreModule("yosys.core4.wasm");
+  const { cli, fs, io, monotonicClock, wallClock } = imports.runtime;
+  const {
+    TerminalInput: TerminalInput2,
+    TerminalOutput: TerminalOutput2,
+    exit,
+    getArguments,
+    getEnvironment,
+    getStderr,
+    getStdin,
+    getStdout,
+    getTerminalStderr,
+    getTerminalStdin,
+    getTerminalStdout
+  } = cli;
+  const {
+    Descriptor: Descriptor2,
+    DirectoryEntryStream: DirectoryEntryStream2,
+    filesystemErrorCode,
+    getDirectories
+  } = fs;
+  const {
+    Error: Error$1,
+    InputStream: InputStream2,
+    OutputStream: OutputStream2
+  } = io;
+  const { now } = monotonicClock;
+  const { now: now$1 } = wallClock;
+  let exports0;
+  let exports1;
+  function trampoline0() {
+    const ret = now();
+    return toUint64(ret);
+  }
+  function trampoline9() {
+    const ret = getStderr();
+    if (!(ret instanceof OutputStream2)) {
+      throw new Error('Resource error: Not a valid "OutputStream" resource.');
+    }
+    var handle0 = handleCnt2++;
+    handleTable2.set(handle0, { rep: ret, own: true });
+    return handle0;
+  }
+  function trampoline10(arg0) {
+    let variant0;
+    switch (arg0) {
+      case 0: {
+        variant0 = {
+          tag: "ok",
+          val: void 0
+        };
+        break;
+      }
+      case 1: {
+        variant0 = {
+          tag: "err",
+          val: void 0
+        };
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant discriminant for expected");
+      }
+    }
+    exit(variant0);
+  }
+  function trampoline11() {
+    const ret = getStdin();
+    if (!(ret instanceof InputStream2)) {
+      throw new Error('Resource error: Not a valid "InputStream" resource.');
+    }
+    var handle0 = handleCnt1++;
+    handleTable1.set(handle0, { rep: ret, own: true });
+    return handle0;
+  }
+  function trampoline12() {
+    const ret = getStdout();
+    if (!(ret instanceof OutputStream2)) {
+      throw new Error('Resource error: Not a valid "OutputStream" resource.');
+    }
+    var handle0 = handleCnt2++;
+    handleTable2.set(handle0, { rep: ret, own: true });
+    return handle0;
+  }
+  let exports2;
+  function trampoline13(arg0) {
+    const ret = getDirectories();
+    var vec3 = ret;
+    var len3 = vec3.length;
+    var result3 = realloc0(0, 0, 4, len3 * 12);
+    for (let i = 0; i < vec3.length; i++) {
+      const e = vec3[i];
+      const base = result3 + i * 12;
+      var [tuple0_0, tuple0_1] = e;
+      if (!(tuple0_0 instanceof Descriptor2)) {
+        throw new Error('Resource error: Not a valid "Descriptor" resource.');
+      }
+      var handle1 = handleCnt3++;
+      handleTable3.set(handle1, { rep: tuple0_0, own: true });
+      dataView(memory0).setInt32(base + 0, handle1, true);
+      var ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
+      var len2 = utf8EncodedLen;
+      dataView(memory0).setInt32(base + 8, len2, true);
+      dataView(memory0).setInt32(base + 4, ptr2, true);
+    }
+    dataView(memory0).setInt32(arg0 + 4, len3, true);
+    dataView(memory0).setInt32(arg0 + 0, result3, true);
+  }
+  let memory0;
+  let realloc0;
+  function trampoline14(arg0) {
+    const ret = now$1();
+    var { seconds: v0_0, nanoseconds: v0_1 } = ret;
+    dataView(memory0).setBigInt64(arg0 + 0, toUint64(v0_0), true);
+    dataView(memory0).setInt32(arg0 + 8, toUint32(v0_1), true);
+  }
+  function trampoline15(arg0, arg1, arg2) {
+    var handle1 = arg0;
+    var rsc0 = handleTable3.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.readViaStream.call(rsc0, BigInt.asUintN(64, arg1)) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg2 + 0, 0, true);
+        if (!(e instanceof InputStream2)) {
+          throw new Error('Resource error: Not a valid "InputStream" resource.');
+        }
+        var handle2 = handleCnt1++;
+        handleTable1.set(handle2, { rep: e, own: true });
+        dataView(memory0).setInt32(arg2 + 4, handle2, true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg2 + 0, 1, true);
+        var val3 = e;
+        let enum3;
+        switch (val3) {
+          case "access": {
+            enum3 = 0;
+            break;
+          }
+          case "would-block": {
+            enum3 = 1;
+            break;
+          }
+          case "already": {
+            enum3 = 2;
+            break;
+          }
+          case "bad-descriptor": {
+            enum3 = 3;
+            break;
+          }
+          case "busy": {
+            enum3 = 4;
+            break;
+          }
+          case "deadlock": {
+            enum3 = 5;
+            break;
+          }
+          case "quota": {
+            enum3 = 6;
+            break;
+          }
+          case "exist": {
+            enum3 = 7;
+            break;
+          }
+          case "file-too-large": {
+            enum3 = 8;
+            break;
+          }
+          case "illegal-byte-sequence": {
+            enum3 = 9;
+            break;
+          }
+          case "in-progress": {
+            enum3 = 10;
+            break;
+          }
+          case "interrupted": {
+            enum3 = 11;
+            break;
+          }
+          case "invalid": {
+            enum3 = 12;
+            break;
+          }
+          case "io": {
+            enum3 = 13;
+            break;
+          }
+          case "is-directory": {
+            enum3 = 14;
+            break;
+          }
+          case "loop": {
+            enum3 = 15;
+            break;
+          }
+          case "too-many-links": {
+            enum3 = 16;
+            break;
+          }
+          case "message-size": {
+            enum3 = 17;
+            break;
+          }
+          case "name-too-long": {
+            enum3 = 18;
+            break;
+          }
+          case "no-device": {
+            enum3 = 19;
+            break;
+          }
+          case "no-entry": {
+            enum3 = 20;
+            break;
+          }
+          case "no-lock": {
+            enum3 = 21;
+            break;
+          }
+          case "insufficient-memory": {
+            enum3 = 22;
+            break;
+          }
+          case "insufficient-space": {
+            enum3 = 23;
+            break;
+          }
+          case "not-directory": {
+            enum3 = 24;
+            break;
+          }
+          case "not-empty": {
+            enum3 = 25;
+            break;
+          }
+          case "not-recoverable": {
+            enum3 = 26;
+            break;
+          }
+          case "unsupported": {
+            enum3 = 27;
+            break;
+          }
+          case "no-tty": {
+            enum3 = 28;
+            break;
+          }
+          case "no-such-device": {
+            enum3 = 29;
+            break;
+          }
+          case "overflow": {
+            enum3 = 30;
+            break;
+          }
+          case "not-permitted": {
+            enum3 = 31;
+            break;
+          }
+          case "pipe": {
+            enum3 = 32;
+            break;
+          }
+          case "read-only": {
+            enum3 = 33;
+            break;
+          }
+          case "invalid-seek": {
+            enum3 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum3 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum3 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg2 + 4, enum3, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline16(arg0, arg1, arg2) {
+    var handle1 = arg0;
+    var rsc0 = handleTable3.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.writeViaStream.call(rsc0, BigInt.asUintN(64, arg1)) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg2 + 0, 0, true);
+        if (!(e instanceof OutputStream2)) {
+          throw new Error('Resource error: Not a valid "OutputStream" resource.');
+        }
+        var handle2 = handleCnt2++;
+        handleTable2.set(handle2, { rep: e, own: true });
+        dataView(memory0).setInt32(arg2 + 4, handle2, true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg2 + 0, 1, true);
+        var val3 = e;
+        let enum3;
+        switch (val3) {
+          case "access": {
+            enum3 = 0;
+            break;
+          }
+          case "would-block": {
+            enum3 = 1;
+            break;
+          }
+          case "already": {
+            enum3 = 2;
+            break;
+          }
+          case "bad-descriptor": {
+            enum3 = 3;
+            break;
+          }
+          case "busy": {
+            enum3 = 4;
+            break;
+          }
+          case "deadlock": {
+            enum3 = 5;
+            break;
+          }
+          case "quota": {
+            enum3 = 6;
+            break;
+          }
+          case "exist": {
+            enum3 = 7;
+            break;
+          }
+          case "file-too-large": {
+            enum3 = 8;
+            break;
+          }
+          case "illegal-byte-sequence": {
+            enum3 = 9;
+            break;
+          }
+          case "in-progress": {
+            enum3 = 10;
+            break;
+          }
+          case "interrupted": {
+            enum3 = 11;
+            break;
+          }
+          case "invalid": {
+            enum3 = 12;
+            break;
+          }
+          case "io": {
+            enum3 = 13;
+            break;
+          }
+          case "is-directory": {
+            enum3 = 14;
+            break;
+          }
+          case "loop": {
+            enum3 = 15;
+            break;
+          }
+          case "too-many-links": {
+            enum3 = 16;
+            break;
+          }
+          case "message-size": {
+            enum3 = 17;
+            break;
+          }
+          case "name-too-long": {
+            enum3 = 18;
+            break;
+          }
+          case "no-device": {
+            enum3 = 19;
+            break;
+          }
+          case "no-entry": {
+            enum3 = 20;
+            break;
+          }
+          case "no-lock": {
+            enum3 = 21;
+            break;
+          }
+          case "insufficient-memory": {
+            enum3 = 22;
+            break;
+          }
+          case "insufficient-space": {
+            enum3 = 23;
+            break;
+          }
+          case "not-directory": {
+            enum3 = 24;
+            break;
+          }
+          case "not-empty": {
+            enum3 = 25;
+            break;
+          }
+          case "not-recoverable": {
+            enum3 = 26;
+            break;
+          }
+          case "unsupported": {
+            enum3 = 27;
+            break;
+          }
+          case "no-tty": {
+            enum3 = 28;
+            break;
+          }
+          case "no-such-device": {
+            enum3 = 29;
+            break;
+          }
+          case "overflow": {
+            enum3 = 30;
+            break;
+          }
+          case "not-permitted": {
+            enum3 = 31;
+            break;
+          }
+          case "pipe": {
+            enum3 = 32;
+            break;
+          }
+          case "read-only": {
+            enum3 = 33;
+            break;
+          }
+          case "invalid-seek": {
+            enum3 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum3 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum3 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg2 + 4, enum3, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline17(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable3.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.appendViaStream.call(rsc0) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        if (!(e instanceof OutputStream2)) {
+          throw new Error('Resource error: Not a valid "OutputStream" resource.');
+        }
+        var handle2 = handleCnt2++;
+        handleTable2.set(handle2, { rep: e, own: true });
+        dataView(memory0).setInt32(arg1 + 4, handle2, true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var val3 = e;
+        let enum3;
+        switch (val3) {
+          case "access": {
+            enum3 = 0;
+            break;
+          }
+          case "would-block": {
+            enum3 = 1;
+            break;
+          }
+          case "already": {
+            enum3 = 2;
+            break;
+          }
+          case "bad-descriptor": {
+            enum3 = 3;
+            break;
+          }
+          case "busy": {
+            enum3 = 4;
+            break;
+          }
+          case "deadlock": {
+            enum3 = 5;
+            break;
+          }
+          case "quota": {
+            enum3 = 6;
+            break;
+          }
+          case "exist": {
+            enum3 = 7;
+            break;
+          }
+          case "file-too-large": {
+            enum3 = 8;
+            break;
+          }
+          case "illegal-byte-sequence": {
+            enum3 = 9;
+            break;
+          }
+          case "in-progress": {
+            enum3 = 10;
+            break;
+          }
+          case "interrupted": {
+            enum3 = 11;
+            break;
+          }
+          case "invalid": {
+            enum3 = 12;
+            break;
+          }
+          case "io": {
+            enum3 = 13;
+            break;
+          }
+          case "is-directory": {
+            enum3 = 14;
+            break;
+          }
+          case "loop": {
+            enum3 = 15;
+            break;
+          }
+          case "too-many-links": {
+            enum3 = 16;
+            break;
+          }
+          case "message-size": {
+            enum3 = 17;
+            break;
+          }
+          case "name-too-long": {
+            enum3 = 18;
+            break;
+          }
+          case "no-device": {
+            enum3 = 19;
+            break;
+          }
+          case "no-entry": {
+            enum3 = 20;
+            break;
+          }
+          case "no-lock": {
+            enum3 = 21;
+            break;
+          }
+          case "insufficient-memory": {
+            enum3 = 22;
+            break;
+          }
+          case "insufficient-space": {
+            enum3 = 23;
+            break;
+          }
+          case "not-directory": {
+            enum3 = 24;
+            break;
+          }
+          case "not-empty": {
+            enum3 = 25;
+            break;
+          }
+          case "not-recoverable": {
+            enum3 = 26;
+            break;
+          }
+          case "unsupported": {
+            enum3 = 27;
+            break;
+          }
+          case "no-tty": {
+            enum3 = 28;
+            break;
+          }
+          case "no-such-device": {
+            enum3 = 29;
+            break;
+          }
+          case "overflow": {
+            enum3 = 30;
+            break;
+          }
+          case "not-permitted": {
+            enum3 = 31;
+            break;
+          }
+          case "pipe": {
+            enum3 = 32;
+            break;
+          }
+          case "read-only": {
+            enum3 = 33;
+            break;
+          }
+          case "invalid-seek": {
+            enum3 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum3 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum3 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 4, enum3, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline18(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable3.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.getFlags.call(rsc0) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        let flags2 = 0;
+        if (typeof e === "object" && e !== null) {
+          flags2 = Boolean(e.read) << 0 | Boolean(e.write) << 1 | Boolean(e.fileIntegritySync) << 2 | Boolean(e.dataIntegritySync) << 3 | Boolean(e.requestedWriteSync) << 4 | Boolean(e.mutateDirectory) << 5;
+        } else if (e !== null && e !== void 0) {
+          throw new TypeError("only an object, undefined or null can be converted to flags");
+        }
+        dataView(memory0).setInt8(arg1 + 1, flags2, true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var val3 = e;
+        let enum3;
+        switch (val3) {
+          case "access": {
+            enum3 = 0;
+            break;
+          }
+          case "would-block": {
+            enum3 = 1;
+            break;
+          }
+          case "already": {
+            enum3 = 2;
+            break;
+          }
+          case "bad-descriptor": {
+            enum3 = 3;
+            break;
+          }
+          case "busy": {
+            enum3 = 4;
+            break;
+          }
+          case "deadlock": {
+            enum3 = 5;
+            break;
+          }
+          case "quota": {
+            enum3 = 6;
+            break;
+          }
+          case "exist": {
+            enum3 = 7;
+            break;
+          }
+          case "file-too-large": {
+            enum3 = 8;
+            break;
+          }
+          case "illegal-byte-sequence": {
+            enum3 = 9;
+            break;
+          }
+          case "in-progress": {
+            enum3 = 10;
+            break;
+          }
+          case "interrupted": {
+            enum3 = 11;
+            break;
+          }
+          case "invalid": {
+            enum3 = 12;
+            break;
+          }
+          case "io": {
+            enum3 = 13;
+            break;
+          }
+          case "is-directory": {
+            enum3 = 14;
+            break;
+          }
+          case "loop": {
+            enum3 = 15;
+            break;
+          }
+          case "too-many-links": {
+            enum3 = 16;
+            break;
+          }
+          case "message-size": {
+            enum3 = 17;
+            break;
+          }
+          case "name-too-long": {
+            enum3 = 18;
+            break;
+          }
+          case "no-device": {
+            enum3 = 19;
+            break;
+          }
+          case "no-entry": {
+            enum3 = 20;
+            break;
+          }
+          case "no-lock": {
+            enum3 = 21;
+            break;
+          }
+          case "insufficient-memory": {
+            enum3 = 22;
+            break;
+          }
+          case "insufficient-space": {
+            enum3 = 23;
+            break;
+          }
+          case "not-directory": {
+            enum3 = 24;
+            break;
+          }
+          case "not-empty": {
+            enum3 = 25;
+            break;
+          }
+          case "not-recoverable": {
+            enum3 = 26;
+            break;
+          }
+          case "unsupported": {
+            enum3 = 27;
+            break;
+          }
+          case "no-tty": {
+            enum3 = 28;
+            break;
+          }
+          case "no-such-device": {
+            enum3 = 29;
+            break;
+          }
+          case "overflow": {
+            enum3 = 30;
+            break;
+          }
+          case "not-permitted": {
+            enum3 = 31;
+            break;
+          }
+          case "pipe": {
+            enum3 = 32;
+            break;
+          }
+          case "read-only": {
+            enum3 = 33;
+            break;
+          }
+          case "invalid-seek": {
+            enum3 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum3 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum3 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 1, enum3, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline19(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable3.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.getType.call(rsc0) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        var val2 = e;
+        let enum2;
+        switch (val2) {
+          case "unknown": {
+            enum2 = 0;
+            break;
+          }
+          case "block-device": {
+            enum2 = 1;
+            break;
+          }
+          case "character-device": {
+            enum2 = 2;
+            break;
+          }
+          case "directory": {
+            enum2 = 3;
+            break;
+          }
+          case "fifo": {
+            enum2 = 4;
+            break;
+          }
+          case "symbolic-link": {
+            enum2 = 5;
+            break;
+          }
+          case "regular-file": {
+            enum2 = 6;
+            break;
+          }
+          case "socket": {
+            enum2 = 7;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val2}" is not one of the cases of descriptor-type`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 1, enum2, true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var val3 = e;
+        let enum3;
+        switch (val3) {
+          case "access": {
+            enum3 = 0;
+            break;
+          }
+          case "would-block": {
+            enum3 = 1;
+            break;
+          }
+          case "already": {
+            enum3 = 2;
+            break;
+          }
+          case "bad-descriptor": {
+            enum3 = 3;
+            break;
+          }
+          case "busy": {
+            enum3 = 4;
+            break;
+          }
+          case "deadlock": {
+            enum3 = 5;
+            break;
+          }
+          case "quota": {
+            enum3 = 6;
+            break;
+          }
+          case "exist": {
+            enum3 = 7;
+            break;
+          }
+          case "file-too-large": {
+            enum3 = 8;
+            break;
+          }
+          case "illegal-byte-sequence": {
+            enum3 = 9;
+            break;
+          }
+          case "in-progress": {
+            enum3 = 10;
+            break;
+          }
+          case "interrupted": {
+            enum3 = 11;
+            break;
+          }
+          case "invalid": {
+            enum3 = 12;
+            break;
+          }
+          case "io": {
+            enum3 = 13;
+            break;
+          }
+          case "is-directory": {
+            enum3 = 14;
+            break;
+          }
+          case "loop": {
+            enum3 = 15;
+            break;
+          }
+          case "too-many-links": {
+            enum3 = 16;
+            break;
+          }
+          case "message-size": {
+            enum3 = 17;
+            break;
+          }
+          case "name-too-long": {
+            enum3 = 18;
+            break;
+          }
+          case "no-device": {
+            enum3 = 19;
+            break;
+          }
+          case "no-entry": {
+            enum3 = 20;
+            break;
+          }
+          case "no-lock": {
+            enum3 = 21;
+            break;
+          }
+          case "insufficient-memory": {
+            enum3 = 22;
+            break;
+          }
+          case "insufficient-space": {
+            enum3 = 23;
+            break;
+          }
+          case "not-directory": {
+            enum3 = 24;
+            break;
+          }
+          case "not-empty": {
+            enum3 = 25;
+            break;
+          }
+          case "not-recoverable": {
+            enum3 = 26;
+            break;
+          }
+          case "unsupported": {
+            enum3 = 27;
+            break;
+          }
+          case "no-tty": {
+            enum3 = 28;
+            break;
+          }
+          case "no-such-device": {
+            enum3 = 29;
+            break;
+          }
+          case "overflow": {
+            enum3 = 30;
+            break;
+          }
+          case "not-permitted": {
+            enum3 = 31;
+            break;
+          }
+          case "pipe": {
+            enum3 = 32;
+            break;
+          }
+          case "read-only": {
+            enum3 = 33;
+            break;
+          }
+          case "invalid-seek": {
+            enum3 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum3 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum3 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 1, enum3, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline20(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable3.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.readDirectory.call(rsc0) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        if (!(e instanceof DirectoryEntryStream2)) {
+          throw new Error('Resource error: Not a valid "DirectoryEntryStream" resource.');
+        }
+        var handle2 = handleCnt4++;
+        handleTable4.set(handle2, { rep: e, own: true });
+        dataView(memory0).setInt32(arg1 + 4, handle2, true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var val3 = e;
+        let enum3;
+        switch (val3) {
+          case "access": {
+            enum3 = 0;
+            break;
+          }
+          case "would-block": {
+            enum3 = 1;
+            break;
+          }
+          case "already": {
+            enum3 = 2;
+            break;
+          }
+          case "bad-descriptor": {
+            enum3 = 3;
+            break;
+          }
+          case "busy": {
+            enum3 = 4;
+            break;
+          }
+          case "deadlock": {
+            enum3 = 5;
+            break;
+          }
+          case "quota": {
+            enum3 = 6;
+            break;
+          }
+          case "exist": {
+            enum3 = 7;
+            break;
+          }
+          case "file-too-large": {
+            enum3 = 8;
+            break;
+          }
+          case "illegal-byte-sequence": {
+            enum3 = 9;
+            break;
+          }
+          case "in-progress": {
+            enum3 = 10;
+            break;
+          }
+          case "interrupted": {
+            enum3 = 11;
+            break;
+          }
+          case "invalid": {
+            enum3 = 12;
+            break;
+          }
+          case "io": {
+            enum3 = 13;
+            break;
+          }
+          case "is-directory": {
+            enum3 = 14;
+            break;
+          }
+          case "loop": {
+            enum3 = 15;
+            break;
+          }
+          case "too-many-links": {
+            enum3 = 16;
+            break;
+          }
+          case "message-size": {
+            enum3 = 17;
+            break;
+          }
+          case "name-too-long": {
+            enum3 = 18;
+            break;
+          }
+          case "no-device": {
+            enum3 = 19;
+            break;
+          }
+          case "no-entry": {
+            enum3 = 20;
+            break;
+          }
+          case "no-lock": {
+            enum3 = 21;
+            break;
+          }
+          case "insufficient-memory": {
+            enum3 = 22;
+            break;
+          }
+          case "insufficient-space": {
+            enum3 = 23;
+            break;
+          }
+          case "not-directory": {
+            enum3 = 24;
+            break;
+          }
+          case "not-empty": {
+            enum3 = 25;
+            break;
+          }
+          case "not-recoverable": {
+            enum3 = 26;
+            break;
+          }
+          case "unsupported": {
+            enum3 = 27;
+            break;
+          }
+          case "no-tty": {
+            enum3 = 28;
+            break;
+          }
+          case "no-such-device": {
+            enum3 = 29;
+            break;
+          }
+          case "overflow": {
+            enum3 = 30;
+            break;
+          }
+          case "not-permitted": {
+            enum3 = 31;
+            break;
+          }
+          case "pipe": {
+            enum3 = 32;
+            break;
+          }
+          case "read-only": {
+            enum3 = 33;
+            break;
+          }
+          case "invalid-seek": {
+            enum3 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum3 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum3 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 4, enum3, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline21(arg0, arg1, arg2, arg3) {
+    var handle1 = arg0;
+    var rsc0 = handleTable3.get(handle1).rep;
+    var ptr2 = arg1;
+    var len2 = arg2;
+    var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.createDirectoryAt.call(rsc0, result2) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg3 + 0, 0, true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg3 + 0, 1, true);
+        var val3 = e;
+        let enum3;
+        switch (val3) {
+          case "access": {
+            enum3 = 0;
+            break;
+          }
+          case "would-block": {
+            enum3 = 1;
+            break;
+          }
+          case "already": {
+            enum3 = 2;
+            break;
+          }
+          case "bad-descriptor": {
+            enum3 = 3;
+            break;
+          }
+          case "busy": {
+            enum3 = 4;
+            break;
+          }
+          case "deadlock": {
+            enum3 = 5;
+            break;
+          }
+          case "quota": {
+            enum3 = 6;
+            break;
+          }
+          case "exist": {
+            enum3 = 7;
+            break;
+          }
+          case "file-too-large": {
+            enum3 = 8;
+            break;
+          }
+          case "illegal-byte-sequence": {
+            enum3 = 9;
+            break;
+          }
+          case "in-progress": {
+            enum3 = 10;
+            break;
+          }
+          case "interrupted": {
+            enum3 = 11;
+            break;
+          }
+          case "invalid": {
+            enum3 = 12;
+            break;
+          }
+          case "io": {
+            enum3 = 13;
+            break;
+          }
+          case "is-directory": {
+            enum3 = 14;
+            break;
+          }
+          case "loop": {
+            enum3 = 15;
+            break;
+          }
+          case "too-many-links": {
+            enum3 = 16;
+            break;
+          }
+          case "message-size": {
+            enum3 = 17;
+            break;
+          }
+          case "name-too-long": {
+            enum3 = 18;
+            break;
+          }
+          case "no-device": {
+            enum3 = 19;
+            break;
+          }
+          case "no-entry": {
+            enum3 = 20;
+            break;
+          }
+          case "no-lock": {
+            enum3 = 21;
+            break;
+          }
+          case "insufficient-memory": {
+            enum3 = 22;
+            break;
+          }
+          case "insufficient-space": {
+            enum3 = 23;
+            break;
+          }
+          case "not-directory": {
+            enum3 = 24;
+            break;
+          }
+          case "not-empty": {
+            enum3 = 25;
+            break;
+          }
+          case "not-recoverable": {
+            enum3 = 26;
+            break;
+          }
+          case "unsupported": {
+            enum3 = 27;
+            break;
+          }
+          case "no-tty": {
+            enum3 = 28;
+            break;
+          }
+          case "no-such-device": {
+            enum3 = 29;
+            break;
+          }
+          case "overflow": {
+            enum3 = 30;
+            break;
+          }
+          case "not-permitted": {
+            enum3 = 31;
+            break;
+          }
+          case "pipe": {
+            enum3 = 32;
+            break;
+          }
+          case "read-only": {
+            enum3 = 33;
+            break;
+          }
+          case "invalid-seek": {
+            enum3 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum3 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum3 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg3 + 1, enum3, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline22(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable3.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.stat.call(rsc0) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant11 = ret;
+    switch (variant11.tag) {
+      case "ok": {
+        const e = variant11.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        var { type: v2_0, linkCount: v2_1, size: v2_2, dataAccessTimestamp: v2_3, dataModificationTimestamp: v2_4, statusChangeTimestamp: v2_5 } = e;
+        var val3 = v2_0;
+        let enum3;
+        switch (val3) {
+          case "unknown": {
+            enum3 = 0;
+            break;
+          }
+          case "block-device": {
+            enum3 = 1;
+            break;
+          }
+          case "character-device": {
+            enum3 = 2;
+            break;
+          }
+          case "directory": {
+            enum3 = 3;
+            break;
+          }
+          case "fifo": {
+            enum3 = 4;
+            break;
+          }
+          case "symbolic-link": {
+            enum3 = 5;
+            break;
+          }
+          case "regular-file": {
+            enum3 = 6;
+            break;
+          }
+          case "socket": {
+            enum3 = 7;
+            break;
+          }
+          default: {
+            if (v2_0 instanceof Error) {
+              console.error(v2_0);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of descriptor-type`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 8, enum3, true);
+        dataView(memory0).setBigInt64(arg1 + 16, toUint64(v2_1), true);
+        dataView(memory0).setBigInt64(arg1 + 24, toUint64(v2_2), true);
+        var variant5 = v2_3;
+        if (variant5 === null || variant5 === void 0) {
+          dataView(memory0).setInt8(arg1 + 32, 0, true);
+        } else {
+          const e2 = variant5;
+          dataView(memory0).setInt8(arg1 + 32, 1, true);
+          var { seconds: v4_0, nanoseconds: v4_1 } = e2;
+          dataView(memory0).setBigInt64(arg1 + 40, toUint64(v4_0), true);
+          dataView(memory0).setInt32(arg1 + 48, toUint32(v4_1), true);
+        }
+        var variant7 = v2_4;
+        if (variant7 === null || variant7 === void 0) {
+          dataView(memory0).setInt8(arg1 + 56, 0, true);
+        } else {
+          const e2 = variant7;
+          dataView(memory0).setInt8(arg1 + 56, 1, true);
+          var { seconds: v6_0, nanoseconds: v6_1 } = e2;
+          dataView(memory0).setBigInt64(arg1 + 64, toUint64(v6_0), true);
+          dataView(memory0).setInt32(arg1 + 72, toUint32(v6_1), true);
+        }
+        var variant9 = v2_5;
+        if (variant9 === null || variant9 === void 0) {
+          dataView(memory0).setInt8(arg1 + 80, 0, true);
+        } else {
+          const e2 = variant9;
+          dataView(memory0).setInt8(arg1 + 80, 1, true);
+          var { seconds: v8_0, nanoseconds: v8_1 } = e2;
+          dataView(memory0).setBigInt64(arg1 + 88, toUint64(v8_0), true);
+          dataView(memory0).setInt32(arg1 + 96, toUint32(v8_1), true);
+        }
+        break;
+      }
+      case "err": {
+        const e = variant11.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var val10 = e;
+        let enum10;
+        switch (val10) {
+          case "access": {
+            enum10 = 0;
+            break;
+          }
+          case "would-block": {
+            enum10 = 1;
+            break;
+          }
+          case "already": {
+            enum10 = 2;
+            break;
+          }
+          case "bad-descriptor": {
+            enum10 = 3;
+            break;
+          }
+          case "busy": {
+            enum10 = 4;
+            break;
+          }
+          case "deadlock": {
+            enum10 = 5;
+            break;
+          }
+          case "quota": {
+            enum10 = 6;
+            break;
+          }
+          case "exist": {
+            enum10 = 7;
+            break;
+          }
+          case "file-too-large": {
+            enum10 = 8;
+            break;
+          }
+          case "illegal-byte-sequence": {
+            enum10 = 9;
+            break;
+          }
+          case "in-progress": {
+            enum10 = 10;
+            break;
+          }
+          case "interrupted": {
+            enum10 = 11;
+            break;
+          }
+          case "invalid": {
+            enum10 = 12;
+            break;
+          }
+          case "io": {
+            enum10 = 13;
+            break;
+          }
+          case "is-directory": {
+            enum10 = 14;
+            break;
+          }
+          case "loop": {
+            enum10 = 15;
+            break;
+          }
+          case "too-many-links": {
+            enum10 = 16;
+            break;
+          }
+          case "message-size": {
+            enum10 = 17;
+            break;
+          }
+          case "name-too-long": {
+            enum10 = 18;
+            break;
+          }
+          case "no-device": {
+            enum10 = 19;
+            break;
+          }
+          case "no-entry": {
+            enum10 = 20;
+            break;
+          }
+          case "no-lock": {
+            enum10 = 21;
+            break;
+          }
+          case "insufficient-memory": {
+            enum10 = 22;
+            break;
+          }
+          case "insufficient-space": {
+            enum10 = 23;
+            break;
+          }
+          case "not-directory": {
+            enum10 = 24;
+            break;
+          }
+          case "not-empty": {
+            enum10 = 25;
+            break;
+          }
+          case "not-recoverable": {
+            enum10 = 26;
+            break;
+          }
+          case "unsupported": {
+            enum10 = 27;
+            break;
+          }
+          case "no-tty": {
+            enum10 = 28;
+            break;
+          }
+          case "no-such-device": {
+            enum10 = 29;
+            break;
+          }
+          case "overflow": {
+            enum10 = 30;
+            break;
+          }
+          case "not-permitted": {
+            enum10 = 31;
+            break;
+          }
+          case "pipe": {
+            enum10 = 32;
+            break;
+          }
+          case "read-only": {
+            enum10 = 33;
+            break;
+          }
+          case "invalid-seek": {
+            enum10 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum10 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum10 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val10}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 8, enum10, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline23(arg0, arg1, arg2, arg3, arg4) {
+    var handle1 = arg0;
+    var rsc0 = handleTable3.get(handle1).rep;
+    if ((arg1 & 4294967294) !== 0) {
+      throw new TypeError("flags have extraneous bits set");
+    }
+    var flags2 = {
+      symlinkFollow: Boolean(arg1 & 1)
+    };
+    var ptr3 = arg2;
+    var len3 = arg3;
+    var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.statAt.call(rsc0, flags2, result3) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant13 = ret;
+    switch (variant13.tag) {
+      case "ok": {
+        const e = variant13.val;
+        dataView(memory0).setInt8(arg4 + 0, 0, true);
+        var { type: v4_0, linkCount: v4_1, size: v4_2, dataAccessTimestamp: v4_3, dataModificationTimestamp: v4_4, statusChangeTimestamp: v4_5 } = e;
+        var val5 = v4_0;
+        let enum5;
+        switch (val5) {
+          case "unknown": {
+            enum5 = 0;
+            break;
+          }
+          case "block-device": {
+            enum5 = 1;
+            break;
+          }
+          case "character-device": {
+            enum5 = 2;
+            break;
+          }
+          case "directory": {
+            enum5 = 3;
+            break;
+          }
+          case "fifo": {
+            enum5 = 4;
+            break;
+          }
+          case "symbolic-link": {
+            enum5 = 5;
+            break;
+          }
+          case "regular-file": {
+            enum5 = 6;
+            break;
+          }
+          case "socket": {
+            enum5 = 7;
+            break;
+          }
+          default: {
+            if (v4_0 instanceof Error) {
+              console.error(v4_0);
+            }
+            throw new TypeError(`"${val5}" is not one of the cases of descriptor-type`);
+          }
+        }
+        dataView(memory0).setInt8(arg4 + 8, enum5, true);
+        dataView(memory0).setBigInt64(arg4 + 16, toUint64(v4_1), true);
+        dataView(memory0).setBigInt64(arg4 + 24, toUint64(v4_2), true);
+        var variant7 = v4_3;
+        if (variant7 === null || variant7 === void 0) {
+          dataView(memory0).setInt8(arg4 + 32, 0, true);
+        } else {
+          const e2 = variant7;
+          dataView(memory0).setInt8(arg4 + 32, 1, true);
+          var { seconds: v6_0, nanoseconds: v6_1 } = e2;
+          dataView(memory0).setBigInt64(arg4 + 40, toUint64(v6_0), true);
+          dataView(memory0).setInt32(arg4 + 48, toUint32(v6_1), true);
+        }
+        var variant9 = v4_4;
+        if (variant9 === null || variant9 === void 0) {
+          dataView(memory0).setInt8(arg4 + 56, 0, true);
+        } else {
+          const e2 = variant9;
+          dataView(memory0).setInt8(arg4 + 56, 1, true);
+          var { seconds: v8_0, nanoseconds: v8_1 } = e2;
+          dataView(memory0).setBigInt64(arg4 + 64, toUint64(v8_0), true);
+          dataView(memory0).setInt32(arg4 + 72, toUint32(v8_1), true);
+        }
+        var variant11 = v4_5;
+        if (variant11 === null || variant11 === void 0) {
+          dataView(memory0).setInt8(arg4 + 80, 0, true);
+        } else {
+          const e2 = variant11;
+          dataView(memory0).setInt8(arg4 + 80, 1, true);
+          var { seconds: v10_0, nanoseconds: v10_1 } = e2;
+          dataView(memory0).setBigInt64(arg4 + 88, toUint64(v10_0), true);
+          dataView(memory0).setInt32(arg4 + 96, toUint32(v10_1), true);
+        }
+        break;
+      }
+      case "err": {
+        const e = variant13.val;
+        dataView(memory0).setInt8(arg4 + 0, 1, true);
+        var val12 = e;
+        let enum12;
+        switch (val12) {
+          case "access": {
+            enum12 = 0;
+            break;
+          }
+          case "would-block": {
+            enum12 = 1;
+            break;
+          }
+          case "already": {
+            enum12 = 2;
+            break;
+          }
+          case "bad-descriptor": {
+            enum12 = 3;
+            break;
+          }
+          case "busy": {
+            enum12 = 4;
+            break;
+          }
+          case "deadlock": {
+            enum12 = 5;
+            break;
+          }
+          case "quota": {
+            enum12 = 6;
+            break;
+          }
+          case "exist": {
+            enum12 = 7;
+            break;
+          }
+          case "file-too-large": {
+            enum12 = 8;
+            break;
+          }
+          case "illegal-byte-sequence": {
+            enum12 = 9;
+            break;
+          }
+          case "in-progress": {
+            enum12 = 10;
+            break;
+          }
+          case "interrupted": {
+            enum12 = 11;
+            break;
+          }
+          case "invalid": {
+            enum12 = 12;
+            break;
+          }
+          case "io": {
+            enum12 = 13;
+            break;
+          }
+          case "is-directory": {
+            enum12 = 14;
+            break;
+          }
+          case "loop": {
+            enum12 = 15;
+            break;
+          }
+          case "too-many-links": {
+            enum12 = 16;
+            break;
+          }
+          case "message-size": {
+            enum12 = 17;
+            break;
+          }
+          case "name-too-long": {
+            enum12 = 18;
+            break;
+          }
+          case "no-device": {
+            enum12 = 19;
+            break;
+          }
+          case "no-entry": {
+            enum12 = 20;
+            break;
+          }
+          case "no-lock": {
+            enum12 = 21;
+            break;
+          }
+          case "insufficient-memory": {
+            enum12 = 22;
+            break;
+          }
+          case "insufficient-space": {
+            enum12 = 23;
+            break;
+          }
+          case "not-directory": {
+            enum12 = 24;
+            break;
+          }
+          case "not-empty": {
+            enum12 = 25;
+            break;
+          }
+          case "not-recoverable": {
+            enum12 = 26;
+            break;
+          }
+          case "unsupported": {
+            enum12 = 27;
+            break;
+          }
+          case "no-tty": {
+            enum12 = 28;
+            break;
+          }
+          case "no-such-device": {
+            enum12 = 29;
+            break;
+          }
+          case "overflow": {
+            enum12 = 30;
+            break;
+          }
+          case "not-permitted": {
+            enum12 = 31;
+            break;
+          }
+          case "pipe": {
+            enum12 = 32;
+            break;
+          }
+          case "read-only": {
+            enum12 = 33;
+            break;
+          }
+          case "invalid-seek": {
+            enum12 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum12 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum12 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val12}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg4 + 8, enum12, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline24(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+    var handle1 = arg0;
+    var rsc0 = handleTable3.get(handle1).rep;
+    if ((arg1 & 4294967294) !== 0) {
+      throw new TypeError("flags have extraneous bits set");
+    }
+    var flags2 = {
+      symlinkFollow: Boolean(arg1 & 1)
+    };
+    var ptr3 = arg2;
+    var len3 = arg3;
+    var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
+    if ((arg4 & 4294967280) !== 0) {
+      throw new TypeError("flags have extraneous bits set");
+    }
+    var flags4 = {
+      create: Boolean(arg4 & 1),
+      directory: Boolean(arg4 & 2),
+      exclusive: Boolean(arg4 & 4),
+      truncate: Boolean(arg4 & 8)
+    };
+    if ((arg5 & 4294967232) !== 0) {
+      throw new TypeError("flags have extraneous bits set");
+    }
+    var flags5 = {
+      read: Boolean(arg5 & 1),
+      write: Boolean(arg5 & 2),
+      fileIntegritySync: Boolean(arg5 & 4),
+      dataIntegritySync: Boolean(arg5 & 8),
+      requestedWriteSync: Boolean(arg5 & 16),
+      mutateDirectory: Boolean(arg5 & 32)
+    };
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.openAt.call(rsc0, flags2, result3, flags4, flags5) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant8 = ret;
+    switch (variant8.tag) {
+      case "ok": {
+        const e = variant8.val;
+        dataView(memory0).setInt8(arg6 + 0, 0, true);
+        if (!(e instanceof Descriptor2)) {
+          throw new Error('Resource error: Not a valid "Descriptor" resource.');
+        }
+        var handle6 = handleCnt3++;
+        handleTable3.set(handle6, { rep: e, own: true });
+        dataView(memory0).setInt32(arg6 + 4, handle6, true);
+        break;
+      }
+      case "err": {
+        const e = variant8.val;
+        dataView(memory0).setInt8(arg6 + 0, 1, true);
+        var val7 = e;
+        let enum7;
+        switch (val7) {
+          case "access": {
+            enum7 = 0;
+            break;
+          }
+          case "would-block": {
+            enum7 = 1;
+            break;
+          }
+          case "already": {
+            enum7 = 2;
+            break;
+          }
+          case "bad-descriptor": {
+            enum7 = 3;
+            break;
+          }
+          case "busy": {
+            enum7 = 4;
+            break;
+          }
+          case "deadlock": {
+            enum7 = 5;
+            break;
+          }
+          case "quota": {
+            enum7 = 6;
+            break;
+          }
+          case "exist": {
+            enum7 = 7;
+            break;
+          }
+          case "file-too-large": {
+            enum7 = 8;
+            break;
+          }
+          case "illegal-byte-sequence": {
+            enum7 = 9;
+            break;
+          }
+          case "in-progress": {
+            enum7 = 10;
+            break;
+          }
+          case "interrupted": {
+            enum7 = 11;
+            break;
+          }
+          case "invalid": {
+            enum7 = 12;
+            break;
+          }
+          case "io": {
+            enum7 = 13;
+            break;
+          }
+          case "is-directory": {
+            enum7 = 14;
+            break;
+          }
+          case "loop": {
+            enum7 = 15;
+            break;
+          }
+          case "too-many-links": {
+            enum7 = 16;
+            break;
+          }
+          case "message-size": {
+            enum7 = 17;
+            break;
+          }
+          case "name-too-long": {
+            enum7 = 18;
+            break;
+          }
+          case "no-device": {
+            enum7 = 19;
+            break;
+          }
+          case "no-entry": {
+            enum7 = 20;
+            break;
+          }
+          case "no-lock": {
+            enum7 = 21;
+            break;
+          }
+          case "insufficient-memory": {
+            enum7 = 22;
+            break;
+          }
+          case "insufficient-space": {
+            enum7 = 23;
+            break;
+          }
+          case "not-directory": {
+            enum7 = 24;
+            break;
+          }
+          case "not-empty": {
+            enum7 = 25;
+            break;
+          }
+          case "not-recoverable": {
+            enum7 = 26;
+            break;
+          }
+          case "unsupported": {
+            enum7 = 27;
+            break;
+          }
+          case "no-tty": {
+            enum7 = 28;
+            break;
+          }
+          case "no-such-device": {
+            enum7 = 29;
+            break;
+          }
+          case "overflow": {
+            enum7 = 30;
+            break;
+          }
+          case "not-permitted": {
+            enum7 = 31;
+            break;
+          }
+          case "pipe": {
+            enum7 = 32;
+            break;
+          }
+          case "read-only": {
+            enum7 = 33;
+            break;
+          }
+          case "invalid-seek": {
+            enum7 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum7 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum7 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val7}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg6 + 4, enum7, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline25(arg0, arg1, arg2, arg3) {
+    var handle1 = arg0;
+    var rsc0 = handleTable3.get(handle1).rep;
+    var ptr2 = arg1;
+    var len2 = arg2;
+    var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.removeDirectoryAt.call(rsc0, result2) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg3 + 0, 0, true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg3 + 0, 1, true);
+        var val3 = e;
+        let enum3;
+        switch (val3) {
+          case "access": {
+            enum3 = 0;
+            break;
+          }
+          case "would-block": {
+            enum3 = 1;
+            break;
+          }
+          case "already": {
+            enum3 = 2;
+            break;
+          }
+          case "bad-descriptor": {
+            enum3 = 3;
+            break;
+          }
+          case "busy": {
+            enum3 = 4;
+            break;
+          }
+          case "deadlock": {
+            enum3 = 5;
+            break;
+          }
+          case "quota": {
+            enum3 = 6;
+            break;
+          }
+          case "exist": {
+            enum3 = 7;
+            break;
+          }
+          case "file-too-large": {
+            enum3 = 8;
+            break;
+          }
+          case "illegal-byte-sequence": {
+            enum3 = 9;
+            break;
+          }
+          case "in-progress": {
+            enum3 = 10;
+            break;
+          }
+          case "interrupted": {
+            enum3 = 11;
+            break;
+          }
+          case "invalid": {
+            enum3 = 12;
+            break;
+          }
+          case "io": {
+            enum3 = 13;
+            break;
+          }
+          case "is-directory": {
+            enum3 = 14;
+            break;
+          }
+          case "loop": {
+            enum3 = 15;
+            break;
+          }
+          case "too-many-links": {
+            enum3 = 16;
+            break;
+          }
+          case "message-size": {
+            enum3 = 17;
+            break;
+          }
+          case "name-too-long": {
+            enum3 = 18;
+            break;
+          }
+          case "no-device": {
+            enum3 = 19;
+            break;
+          }
+          case "no-entry": {
+            enum3 = 20;
+            break;
+          }
+          case "no-lock": {
+            enum3 = 21;
+            break;
+          }
+          case "insufficient-memory": {
+            enum3 = 22;
+            break;
+          }
+          case "insufficient-space": {
+            enum3 = 23;
+            break;
+          }
+          case "not-directory": {
+            enum3 = 24;
+            break;
+          }
+          case "not-empty": {
+            enum3 = 25;
+            break;
+          }
+          case "not-recoverable": {
+            enum3 = 26;
+            break;
+          }
+          case "unsupported": {
+            enum3 = 27;
+            break;
+          }
+          case "no-tty": {
+            enum3 = 28;
+            break;
+          }
+          case "no-such-device": {
+            enum3 = 29;
+            break;
+          }
+          case "overflow": {
+            enum3 = 30;
+            break;
+          }
+          case "not-permitted": {
+            enum3 = 31;
+            break;
+          }
+          case "pipe": {
+            enum3 = 32;
+            break;
+          }
+          case "read-only": {
+            enum3 = 33;
+            break;
+          }
+          case "invalid-seek": {
+            enum3 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum3 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum3 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg3 + 1, enum3, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline26(arg0, arg1, arg2, arg3) {
+    var handle1 = arg0;
+    var rsc0 = handleTable3.get(handle1).rep;
+    var ptr2 = arg1;
+    var len2 = arg2;
+    var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.unlinkFileAt.call(rsc0, result2) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg3 + 0, 0, true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg3 + 0, 1, true);
+        var val3 = e;
+        let enum3;
+        switch (val3) {
+          case "access": {
+            enum3 = 0;
+            break;
+          }
+          case "would-block": {
+            enum3 = 1;
+            break;
+          }
+          case "already": {
+            enum3 = 2;
+            break;
+          }
+          case "bad-descriptor": {
+            enum3 = 3;
+            break;
+          }
+          case "busy": {
+            enum3 = 4;
+            break;
+          }
+          case "deadlock": {
+            enum3 = 5;
+            break;
+          }
+          case "quota": {
+            enum3 = 6;
+            break;
+          }
+          case "exist": {
+            enum3 = 7;
+            break;
+          }
+          case "file-too-large": {
+            enum3 = 8;
+            break;
+          }
+          case "illegal-byte-sequence": {
+            enum3 = 9;
+            break;
+          }
+          case "in-progress": {
+            enum3 = 10;
+            break;
+          }
+          case "interrupted": {
+            enum3 = 11;
+            break;
+          }
+          case "invalid": {
+            enum3 = 12;
+            break;
+          }
+          case "io": {
+            enum3 = 13;
+            break;
+          }
+          case "is-directory": {
+            enum3 = 14;
+            break;
+          }
+          case "loop": {
+            enum3 = 15;
+            break;
+          }
+          case "too-many-links": {
+            enum3 = 16;
+            break;
+          }
+          case "message-size": {
+            enum3 = 17;
+            break;
+          }
+          case "name-too-long": {
+            enum3 = 18;
+            break;
+          }
+          case "no-device": {
+            enum3 = 19;
+            break;
+          }
+          case "no-entry": {
+            enum3 = 20;
+            break;
+          }
+          case "no-lock": {
+            enum3 = 21;
+            break;
+          }
+          case "insufficient-memory": {
+            enum3 = 22;
+            break;
+          }
+          case "insufficient-space": {
+            enum3 = 23;
+            break;
+          }
+          case "not-directory": {
+            enum3 = 24;
+            break;
+          }
+          case "not-empty": {
+            enum3 = 25;
+            break;
+          }
+          case "not-recoverable": {
+            enum3 = 26;
+            break;
+          }
+          case "unsupported": {
+            enum3 = 27;
+            break;
+          }
+          case "no-tty": {
+            enum3 = 28;
+            break;
+          }
+          case "no-such-device": {
+            enum3 = 29;
+            break;
+          }
+          case "overflow": {
+            enum3 = 30;
+            break;
+          }
+          case "not-permitted": {
+            enum3 = 31;
+            break;
+          }
+          case "pipe": {
+            enum3 = 32;
+            break;
+          }
+          case "read-only": {
+            enum3 = 33;
+            break;
+          }
+          case "invalid-seek": {
+            enum3 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum3 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum3 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg3 + 1, enum3, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline27(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable3.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.metadataHash.call(rsc0) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        var { lower: v2_0, upper: v2_1 } = e;
+        dataView(memory0).setBigInt64(arg1 + 8, toUint64(v2_0), true);
+        dataView(memory0).setBigInt64(arg1 + 16, toUint64(v2_1), true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var val3 = e;
+        let enum3;
+        switch (val3) {
+          case "access": {
+            enum3 = 0;
+            break;
+          }
+          case "would-block": {
+            enum3 = 1;
+            break;
+          }
+          case "already": {
+            enum3 = 2;
+            break;
+          }
+          case "bad-descriptor": {
+            enum3 = 3;
+            break;
+          }
+          case "busy": {
+            enum3 = 4;
+            break;
+          }
+          case "deadlock": {
+            enum3 = 5;
+            break;
+          }
+          case "quota": {
+            enum3 = 6;
+            break;
+          }
+          case "exist": {
+            enum3 = 7;
+            break;
+          }
+          case "file-too-large": {
+            enum3 = 8;
+            break;
+          }
+          case "illegal-byte-sequence": {
+            enum3 = 9;
+            break;
+          }
+          case "in-progress": {
+            enum3 = 10;
+            break;
+          }
+          case "interrupted": {
+            enum3 = 11;
+            break;
+          }
+          case "invalid": {
+            enum3 = 12;
+            break;
+          }
+          case "io": {
+            enum3 = 13;
+            break;
+          }
+          case "is-directory": {
+            enum3 = 14;
+            break;
+          }
+          case "loop": {
+            enum3 = 15;
+            break;
+          }
+          case "too-many-links": {
+            enum3 = 16;
+            break;
+          }
+          case "message-size": {
+            enum3 = 17;
+            break;
+          }
+          case "name-too-long": {
+            enum3 = 18;
+            break;
+          }
+          case "no-device": {
+            enum3 = 19;
+            break;
+          }
+          case "no-entry": {
+            enum3 = 20;
+            break;
+          }
+          case "no-lock": {
+            enum3 = 21;
+            break;
+          }
+          case "insufficient-memory": {
+            enum3 = 22;
+            break;
+          }
+          case "insufficient-space": {
+            enum3 = 23;
+            break;
+          }
+          case "not-directory": {
+            enum3 = 24;
+            break;
+          }
+          case "not-empty": {
+            enum3 = 25;
+            break;
+          }
+          case "not-recoverable": {
+            enum3 = 26;
+            break;
+          }
+          case "unsupported": {
+            enum3 = 27;
+            break;
+          }
+          case "no-tty": {
+            enum3 = 28;
+            break;
+          }
+          case "no-such-device": {
+            enum3 = 29;
+            break;
+          }
+          case "overflow": {
+            enum3 = 30;
+            break;
+          }
+          case "not-permitted": {
+            enum3 = 31;
+            break;
+          }
+          case "pipe": {
+            enum3 = 32;
+            break;
+          }
+          case "read-only": {
+            enum3 = 33;
+            break;
+          }
+          case "invalid-seek": {
+            enum3 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum3 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum3 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val3}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 8, enum3, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline28(arg0, arg1, arg2, arg3, arg4) {
+    var handle1 = arg0;
+    var rsc0 = handleTable3.get(handle1).rep;
+    if ((arg1 & 4294967294) !== 0) {
+      throw new TypeError("flags have extraneous bits set");
+    }
+    var flags2 = {
+      symlinkFollow: Boolean(arg1 & 1)
+    };
+    var ptr3 = arg2;
+    var len3 = arg3;
+    var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
+    let ret;
+    try {
+      ret = { tag: "ok", val: Descriptor2.prototype.metadataHashAt.call(rsc0, flags2, result3) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant6 = ret;
+    switch (variant6.tag) {
+      case "ok": {
+        const e = variant6.val;
+        dataView(memory0).setInt8(arg4 + 0, 0, true);
+        var { lower: v4_0, upper: v4_1 } = e;
+        dataView(memory0).setBigInt64(arg4 + 8, toUint64(v4_0), true);
+        dataView(memory0).setBigInt64(arg4 + 16, toUint64(v4_1), true);
+        break;
+      }
+      case "err": {
+        const e = variant6.val;
+        dataView(memory0).setInt8(arg4 + 0, 1, true);
+        var val5 = e;
+        let enum5;
+        switch (val5) {
+          case "access": {
+            enum5 = 0;
+            break;
+          }
+          case "would-block": {
+            enum5 = 1;
+            break;
+          }
+          case "already": {
+            enum5 = 2;
+            break;
+          }
+          case "bad-descriptor": {
+            enum5 = 3;
+            break;
+          }
+          case "busy": {
+            enum5 = 4;
+            break;
+          }
+          case "deadlock": {
+            enum5 = 5;
+            break;
+          }
+          case "quota": {
+            enum5 = 6;
+            break;
+          }
+          case "exist": {
+            enum5 = 7;
+            break;
+          }
+          case "file-too-large": {
+            enum5 = 8;
+            break;
+          }
+          case "illegal-byte-sequence": {
+            enum5 = 9;
+            break;
+          }
+          case "in-progress": {
+            enum5 = 10;
+            break;
+          }
+          case "interrupted": {
+            enum5 = 11;
+            break;
+          }
+          case "invalid": {
+            enum5 = 12;
+            break;
+          }
+          case "io": {
+            enum5 = 13;
+            break;
+          }
+          case "is-directory": {
+            enum5 = 14;
+            break;
+          }
+          case "loop": {
+            enum5 = 15;
+            break;
+          }
+          case "too-many-links": {
+            enum5 = 16;
+            break;
+          }
+          case "message-size": {
+            enum5 = 17;
+            break;
+          }
+          case "name-too-long": {
+            enum5 = 18;
+            break;
+          }
+          case "no-device": {
+            enum5 = 19;
+            break;
+          }
+          case "no-entry": {
+            enum5 = 20;
+            break;
+          }
+          case "no-lock": {
+            enum5 = 21;
+            break;
+          }
+          case "insufficient-memory": {
+            enum5 = 22;
+            break;
+          }
+          case "insufficient-space": {
+            enum5 = 23;
+            break;
+          }
+          case "not-directory": {
+            enum5 = 24;
+            break;
+          }
+          case "not-empty": {
+            enum5 = 25;
+            break;
+          }
+          case "not-recoverable": {
+            enum5 = 26;
+            break;
+          }
+          case "unsupported": {
+            enum5 = 27;
+            break;
+          }
+          case "no-tty": {
+            enum5 = 28;
+            break;
+          }
+          case "no-such-device": {
+            enum5 = 29;
+            break;
+          }
+          case "overflow": {
+            enum5 = 30;
+            break;
+          }
+          case "not-permitted": {
+            enum5 = 31;
+            break;
+          }
+          case "pipe": {
+            enum5 = 32;
+            break;
+          }
+          case "read-only": {
+            enum5 = 33;
+            break;
+          }
+          case "invalid-seek": {
+            enum5 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum5 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum5 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val5}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg4 + 8, enum5, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline29(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable4.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: DirectoryEntryStream2.prototype.readDirectoryEntry.call(rsc0) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant7 = ret;
+    switch (variant7.tag) {
+      case "ok": {
+        const e = variant7.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        var variant5 = e;
+        if (variant5 === null || variant5 === void 0) {
+          dataView(memory0).setInt8(arg1 + 4, 0, true);
+        } else {
+          const e2 = variant5;
+          dataView(memory0).setInt8(arg1 + 4, 1, true);
+          var { type: v2_0, name: v2_1 } = e2;
+          var val3 = v2_0;
+          let enum3;
+          switch (val3) {
+            case "unknown": {
+              enum3 = 0;
+              break;
+            }
+            case "block-device": {
+              enum3 = 1;
+              break;
+            }
+            case "character-device": {
+              enum3 = 2;
+              break;
+            }
+            case "directory": {
+              enum3 = 3;
+              break;
+            }
+            case "fifo": {
+              enum3 = 4;
+              break;
+            }
+            case "symbolic-link": {
+              enum3 = 5;
+              break;
+            }
+            case "regular-file": {
+              enum3 = 6;
+              break;
+            }
+            case "socket": {
+              enum3 = 7;
+              break;
+            }
+            default: {
+              if (v2_0 instanceof Error) {
+                console.error(v2_0);
+              }
+              throw new TypeError(`"${val3}" is not one of the cases of descriptor-type`);
+            }
+          }
+          dataView(memory0).setInt8(arg1 + 8, enum3, true);
+          var ptr4 = utf8Encode(v2_1, realloc0, memory0);
+          var len4 = utf8EncodedLen;
+          dataView(memory0).setInt32(arg1 + 16, len4, true);
+          dataView(memory0).setInt32(arg1 + 12, ptr4, true);
+        }
+        break;
+      }
+      case "err": {
+        const e = variant7.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var val6 = e;
+        let enum6;
+        switch (val6) {
+          case "access": {
+            enum6 = 0;
+            break;
+          }
+          case "would-block": {
+            enum6 = 1;
+            break;
+          }
+          case "already": {
+            enum6 = 2;
+            break;
+          }
+          case "bad-descriptor": {
+            enum6 = 3;
+            break;
+          }
+          case "busy": {
+            enum6 = 4;
+            break;
+          }
+          case "deadlock": {
+            enum6 = 5;
+            break;
+          }
+          case "quota": {
+            enum6 = 6;
+            break;
+          }
+          case "exist": {
+            enum6 = 7;
+            break;
+          }
+          case "file-too-large": {
+            enum6 = 8;
+            break;
+          }
+          case "illegal-byte-sequence": {
+            enum6 = 9;
+            break;
+          }
+          case "in-progress": {
+            enum6 = 10;
+            break;
+          }
+          case "interrupted": {
+            enum6 = 11;
+            break;
+          }
+          case "invalid": {
+            enum6 = 12;
+            break;
+          }
+          case "io": {
+            enum6 = 13;
+            break;
+          }
+          case "is-directory": {
+            enum6 = 14;
+            break;
+          }
+          case "loop": {
+            enum6 = 15;
+            break;
+          }
+          case "too-many-links": {
+            enum6 = 16;
+            break;
+          }
+          case "message-size": {
+            enum6 = 17;
+            break;
+          }
+          case "name-too-long": {
+            enum6 = 18;
+            break;
+          }
+          case "no-device": {
+            enum6 = 19;
+            break;
+          }
+          case "no-entry": {
+            enum6 = 20;
+            break;
+          }
+          case "no-lock": {
+            enum6 = 21;
+            break;
+          }
+          case "insufficient-memory": {
+            enum6 = 22;
+            break;
+          }
+          case "insufficient-space": {
+            enum6 = 23;
+            break;
+          }
+          case "not-directory": {
+            enum6 = 24;
+            break;
+          }
+          case "not-empty": {
+            enum6 = 25;
+            break;
+          }
+          case "not-recoverable": {
+            enum6 = 26;
+            break;
+          }
+          case "unsupported": {
+            enum6 = 27;
+            break;
+          }
+          case "no-tty": {
+            enum6 = 28;
+            break;
+          }
+          case "no-such-device": {
+            enum6 = 29;
+            break;
+          }
+          case "overflow": {
+            enum6 = 30;
+            break;
+          }
+          case "not-permitted": {
+            enum6 = 31;
+            break;
+          }
+          case "pipe": {
+            enum6 = 32;
+            break;
+          }
+          case "read-only": {
+            enum6 = 33;
+            break;
+          }
+          case "invalid-seek": {
+            enum6 = 34;
+            break;
+          }
+          case "text-file-busy": {
+            enum6 = 35;
+            break;
+          }
+          case "cross-device": {
+            enum6 = 36;
+            break;
+          }
+          default: {
+            if (e instanceof Error) {
+              console.error(e);
+            }
+            throw new TypeError(`"${val6}" is not one of the cases of error-code`);
+          }
+        }
+        dataView(memory0).setInt8(arg1 + 4, enum6, true);
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline30(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable0.get(handle1).rep;
+    const ret = filesystemErrorCode(rsc0);
+    var variant3 = ret;
+    if (variant3 === null || variant3 === void 0) {
+      dataView(memory0).setInt8(arg1 + 0, 0, true);
+    } else {
+      const e = variant3;
+      dataView(memory0).setInt8(arg1 + 0, 1, true);
+      var val2 = e;
+      let enum2;
+      switch (val2) {
+        case "access": {
+          enum2 = 0;
+          break;
+        }
+        case "would-block": {
+          enum2 = 1;
+          break;
+        }
+        case "already": {
+          enum2 = 2;
+          break;
+        }
+        case "bad-descriptor": {
+          enum2 = 3;
+          break;
+        }
+        case "busy": {
+          enum2 = 4;
+          break;
+        }
+        case "deadlock": {
+          enum2 = 5;
+          break;
+        }
+        case "quota": {
+          enum2 = 6;
+          break;
+        }
+        case "exist": {
+          enum2 = 7;
+          break;
+        }
+        case "file-too-large": {
+          enum2 = 8;
+          break;
+        }
+        case "illegal-byte-sequence": {
+          enum2 = 9;
+          break;
+        }
+        case "in-progress": {
+          enum2 = 10;
+          break;
+        }
+        case "interrupted": {
+          enum2 = 11;
+          break;
+        }
+        case "invalid": {
+          enum2 = 12;
+          break;
+        }
+        case "io": {
+          enum2 = 13;
+          break;
+        }
+        case "is-directory": {
+          enum2 = 14;
+          break;
+        }
+        case "loop": {
+          enum2 = 15;
+          break;
+        }
+        case "too-many-links": {
+          enum2 = 16;
+          break;
+        }
+        case "message-size": {
+          enum2 = 17;
+          break;
+        }
+        case "name-too-long": {
+          enum2 = 18;
+          break;
+        }
+        case "no-device": {
+          enum2 = 19;
+          break;
+        }
+        case "no-entry": {
+          enum2 = 20;
+          break;
+        }
+        case "no-lock": {
+          enum2 = 21;
+          break;
+        }
+        case "insufficient-memory": {
+          enum2 = 22;
+          break;
+        }
+        case "insufficient-space": {
+          enum2 = 23;
+          break;
+        }
+        case "not-directory": {
+          enum2 = 24;
+          break;
+        }
+        case "not-empty": {
+          enum2 = 25;
+          break;
+        }
+        case "not-recoverable": {
+          enum2 = 26;
+          break;
+        }
+        case "unsupported": {
+          enum2 = 27;
+          break;
+        }
+        case "no-tty": {
+          enum2 = 28;
+          break;
+        }
+        case "no-such-device": {
+          enum2 = 29;
+          break;
+        }
+        case "overflow": {
+          enum2 = 30;
+          break;
+        }
+        case "not-permitted": {
+          enum2 = 31;
+          break;
+        }
+        case "pipe": {
+          enum2 = 32;
+          break;
+        }
+        case "read-only": {
+          enum2 = 33;
+          break;
+        }
+        case "invalid-seek": {
+          enum2 = 34;
+          break;
+        }
+        case "text-file-busy": {
+          enum2 = 35;
+          break;
+        }
+        case "cross-device": {
+          enum2 = 36;
+          break;
+        }
+        default: {
+          if (e instanceof Error) {
+            console.error(e);
+          }
+          throw new TypeError(`"${val2}" is not one of the cases of error-code`);
+        }
+      }
+      dataView(memory0).setInt8(arg1 + 1, enum2, true);
+    }
+  }
+  function trampoline31(arg0, arg1, arg2) {
+    var handle1 = arg0;
+    var rsc0 = handleTable1.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: InputStream2.prototype.read.call(rsc0, BigInt.asUintN(64, arg1)) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case "ok": {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg2 + 0, 0, true);
+        var val2 = e;
+        var len2 = val2.byteLength;
+        var ptr2 = realloc0(0, 0, 1, len2 * 1);
+        var src2 = new Uint8Array(val2.buffer || val2, val2.byteOffset, len2 * 1);
+        new Uint8Array(memory0.buffer, ptr2, len2 * 1).set(src2);
+        dataView(memory0).setInt32(arg2 + 8, len2, true);
+        dataView(memory0).setInt32(arg2 + 4, ptr2, true);
+        break;
+      }
+      case "err": {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg2 + 0, 1, true);
+        var variant4 = e;
+        switch (variant4.tag) {
+          case "last-operation-failed": {
+            const e2 = variant4.val;
+            dataView(memory0).setInt8(arg2 + 4, 0, true);
+            if (!(e2 instanceof Error$1)) {
+              throw new Error('Resource error: Not a valid "Error" resource.');
+            }
+            var handle3 = handleCnt0++;
+            handleTable0.set(handle3, { rep: e2, own: true });
+            dataView(memory0).setInt32(arg2 + 8, handle3, true);
+            break;
+          }
+          case "closed": {
+            dataView(memory0).setInt8(arg2 + 4, 1, true);
+            break;
+          }
+          default: {
+            throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
+          }
+        }
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline32(arg0, arg1, arg2) {
+    var handle1 = arg0;
+    var rsc0 = handleTable1.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: InputStream2.prototype.blockingRead.call(rsc0, BigInt.asUintN(64, arg1)) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case "ok": {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg2 + 0, 0, true);
+        var val2 = e;
+        var len2 = val2.byteLength;
+        var ptr2 = realloc0(0, 0, 1, len2 * 1);
+        var src2 = new Uint8Array(val2.buffer || val2, val2.byteOffset, len2 * 1);
+        new Uint8Array(memory0.buffer, ptr2, len2 * 1).set(src2);
+        dataView(memory0).setInt32(arg2 + 8, len2, true);
+        dataView(memory0).setInt32(arg2 + 4, ptr2, true);
+        break;
+      }
+      case "err": {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg2 + 0, 1, true);
+        var variant4 = e;
+        switch (variant4.tag) {
+          case "last-operation-failed": {
+            const e2 = variant4.val;
+            dataView(memory0).setInt8(arg2 + 4, 0, true);
+            if (!(e2 instanceof Error$1)) {
+              throw new Error('Resource error: Not a valid "Error" resource.');
+            }
+            var handle3 = handleCnt0++;
+            handleTable0.set(handle3, { rep: e2, own: true });
+            dataView(memory0).setInt32(arg2 + 8, handle3, true);
+            break;
+          }
+          case "closed": {
+            dataView(memory0).setInt8(arg2 + 4, 1, true);
+            break;
+          }
+          default: {
+            throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
+          }
+        }
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline33(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable2.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: OutputStream2.prototype.checkWrite.call(rsc0) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        dataView(memory0).setBigInt64(arg1 + 8, toUint64(e), true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var variant3 = e;
+        switch (variant3.tag) {
+          case "last-operation-failed": {
+            const e2 = variant3.val;
+            dataView(memory0).setInt8(arg1 + 8, 0, true);
+            if (!(e2 instanceof Error$1)) {
+              throw new Error('Resource error: Not a valid "Error" resource.');
+            }
+            var handle2 = handleCnt0++;
+            handleTable0.set(handle2, { rep: e2, own: true });
+            dataView(memory0).setInt32(arg1 + 12, handle2, true);
+            break;
+          }
+          case "closed": {
+            dataView(memory0).setInt8(arg1 + 8, 1, true);
+            break;
+          }
+          default: {
+            throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant3.tag)}\` (received \`${variant3}\`) specified for \`StreamError\``);
+          }
+        }
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline34(arg0, arg1, arg2, arg3) {
+    var handle1 = arg0;
+    var rsc0 = handleTable2.get(handle1).rep;
+    var ptr2 = arg1;
+    var len2 = arg2;
+    var result2 = new Uint8Array(memory0.buffer.slice(ptr2, ptr2 + len2 * 1));
+    let ret;
+    try {
+      ret = { tag: "ok", val: OutputStream2.prototype.write.call(rsc0, result2) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case "ok": {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg3 + 0, 0, true);
+        break;
+      }
+      case "err": {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg3 + 0, 1, true);
+        var variant4 = e;
+        switch (variant4.tag) {
+          case "last-operation-failed": {
+            const e2 = variant4.val;
+            dataView(memory0).setInt8(arg3 + 4, 0, true);
+            if (!(e2 instanceof Error$1)) {
+              throw new Error('Resource error: Not a valid "Error" resource.');
+            }
+            var handle3 = handleCnt0++;
+            handleTable0.set(handle3, { rep: e2, own: true });
+            dataView(memory0).setInt32(arg3 + 8, handle3, true);
+            break;
+          }
+          case "closed": {
+            dataView(memory0).setInt8(arg3 + 4, 1, true);
+            break;
+          }
+          default: {
+            throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
+          }
+        }
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline35(arg0, arg1, arg2, arg3) {
+    var handle1 = arg0;
+    var rsc0 = handleTable2.get(handle1).rep;
+    var ptr2 = arg1;
+    var len2 = arg2;
+    var result2 = new Uint8Array(memory0.buffer.slice(ptr2, ptr2 + len2 * 1));
+    let ret;
+    try {
+      ret = { tag: "ok", val: OutputStream2.prototype.blockingWriteAndFlush.call(rsc0, result2) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant5 = ret;
+    switch (variant5.tag) {
+      case "ok": {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg3 + 0, 0, true);
+        break;
+      }
+      case "err": {
+        const e = variant5.val;
+        dataView(memory0).setInt8(arg3 + 0, 1, true);
+        var variant4 = e;
+        switch (variant4.tag) {
+          case "last-operation-failed": {
+            const e2 = variant4.val;
+            dataView(memory0).setInt8(arg3 + 4, 0, true);
+            if (!(e2 instanceof Error$1)) {
+              throw new Error('Resource error: Not a valid "Error" resource.');
+            }
+            var handle3 = handleCnt0++;
+            handleTable0.set(handle3, { rep: e2, own: true });
+            dataView(memory0).setInt32(arg3 + 8, handle3, true);
+            break;
+          }
+          case "closed": {
+            dataView(memory0).setInt8(arg3 + 4, 1, true);
+            break;
+          }
+          default: {
+            throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
+          }
+        }
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline36(arg0, arg1) {
+    var handle1 = arg0;
+    var rsc0 = handleTable2.get(handle1).rep;
+    let ret;
+    try {
+      ret = { tag: "ok", val: OutputStream2.prototype.blockingFlush.call(rsc0) };
+    } catch (e) {
+      ret = { tag: "err", val: getErrorPayload(e) };
+    }
+    var variant4 = ret;
+    switch (variant4.tag) {
+      case "ok": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 0, true);
+        break;
+      }
+      case "err": {
+        const e = variant4.val;
+        dataView(memory0).setInt8(arg1 + 0, 1, true);
+        var variant3 = e;
+        switch (variant3.tag) {
+          case "last-operation-failed": {
+            const e2 = variant3.val;
+            dataView(memory0).setInt8(arg1 + 4, 0, true);
+            if (!(e2 instanceof Error$1)) {
+              throw new Error('Resource error: Not a valid "Error" resource.');
+            }
+            var handle2 = handleCnt0++;
+            handleTable0.set(handle2, { rep: e2, own: true });
+            dataView(memory0).setInt32(arg1 + 8, handle2, true);
+            break;
+          }
+          case "closed": {
+            dataView(memory0).setInt8(arg1 + 4, 1, true);
+            break;
+          }
+          default: {
+            throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant3.tag)}\` (received \`${variant3}\`) specified for \`StreamError\``);
+          }
+        }
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant specified for result");
+      }
+    }
+  }
+  function trampoline37(arg0) {
+    const ret = getEnvironment();
+    var vec3 = ret;
+    var len3 = vec3.length;
+    var result3 = realloc0(0, 0, 4, len3 * 16);
+    for (let i = 0; i < vec3.length; i++) {
+      const e = vec3[i];
+      const base = result3 + i * 16;
+      var [tuple0_0, tuple0_1] = e;
+      var ptr1 = utf8Encode(tuple0_0, realloc0, memory0);
+      var len1 = utf8EncodedLen;
+      dataView(memory0).setInt32(base + 4, len1, true);
+      dataView(memory0).setInt32(base + 0, ptr1, true);
+      var ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
+      var len2 = utf8EncodedLen;
+      dataView(memory0).setInt32(base + 12, len2, true);
+      dataView(memory0).setInt32(base + 8, ptr2, true);
+    }
+    dataView(memory0).setInt32(arg0 + 4, len3, true);
+    dataView(memory0).setInt32(arg0 + 0, result3, true);
+  }
+  function trampoline38(arg0) {
+    const ret = getArguments();
+    var vec1 = ret;
+    var len1 = vec1.length;
+    var result1 = realloc0(0, 0, 4, len1 * 8);
+    for (let i = 0; i < vec1.length; i++) {
+      const e = vec1[i];
+      const base = result1 + i * 8;
+      var ptr0 = utf8Encode(e, realloc0, memory0);
+      var len0 = utf8EncodedLen;
+      dataView(memory0).setInt32(base + 4, len0, true);
+      dataView(memory0).setInt32(base + 0, ptr0, true);
+    }
+    dataView(memory0).setInt32(arg0 + 4, len1, true);
+    dataView(memory0).setInt32(arg0 + 0, result1, true);
+  }
+  function trampoline39(arg0) {
+    const ret = getTerminalStdin();
+    var variant1 = ret;
+    if (variant1 === null || variant1 === void 0) {
+      dataView(memory0).setInt8(arg0 + 0, 0, true);
+    } else {
+      const e = variant1;
+      dataView(memory0).setInt8(arg0 + 0, 1, true);
+      if (!(e instanceof TerminalInput2)) {
+        throw new Error('Resource error: Not a valid "TerminalInput" resource.');
+      }
+      var handle0 = handleCnt6++;
+      handleTable6.set(handle0, { rep: e, own: true });
+      dataView(memory0).setInt32(arg0 + 4, handle0, true);
+    }
+  }
+  function trampoline40(arg0) {
+    const ret = getTerminalStdout();
+    var variant1 = ret;
+    if (variant1 === null || variant1 === void 0) {
+      dataView(memory0).setInt8(arg0 + 0, 0, true);
+    } else {
+      const e = variant1;
+      dataView(memory0).setInt8(arg0 + 0, 1, true);
+      if (!(e instanceof TerminalOutput2)) {
+        throw new Error('Resource error: Not a valid "TerminalOutput" resource.');
+      }
+      var handle0 = handleCnt7++;
+      handleTable7.set(handle0, { rep: e, own: true });
+      dataView(memory0).setInt32(arg0 + 4, handle0, true);
+    }
+  }
+  function trampoline41(arg0) {
+    const ret = getTerminalStderr();
+    var variant1 = ret;
+    if (variant1 === null || variant1 === void 0) {
+      dataView(memory0).setInt8(arg0 + 0, 0, true);
+    } else {
+      const e = variant1;
+      dataView(memory0).setInt8(arg0 + 0, 1, true);
+      if (!(e instanceof TerminalOutput2)) {
+        throw new Error('Resource error: Not a valid "TerminalOutput" resource.');
+      }
+      var handle0 = handleCnt7++;
+      handleTable7.set(handle0, { rep: e, own: true });
+      dataView(memory0).setInt32(arg0 + 4, handle0, true);
+    }
+  }
+  let exports3;
+  function trampoline1(handle) {
+    const handleEntry = handleTable4.get(handle);
+    if (!handleEntry) {
+      throw new Error(`Resource error: Invalid handle ${handle}`);
+    }
+    handleTable4.delete(handle);
+    if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+      handleEntry.rep[symbolDispose]();
+    }
+  }
+  function trampoline2(handle) {
+    const handleEntry = handleTable0.get(handle);
+    if (!handleEntry) {
+      throw new Error(`Resource error: Invalid handle ${handle}`);
+    }
+    handleTable0.delete(handle);
+    if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+      handleEntry.rep[symbolDispose]();
+    }
+  }
+  function trampoline3(handle) {
+    const handleEntry = handleTable1.get(handle);
+    if (!handleEntry) {
+      throw new Error(`Resource error: Invalid handle ${handle}`);
+    }
+    handleTable1.delete(handle);
+    if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+      handleEntry.rep[symbolDispose]();
+    }
+  }
+  function trampoline4(handle) {
+    const handleEntry = handleTable2.get(handle);
+    if (!handleEntry) {
+      throw new Error(`Resource error: Invalid handle ${handle}`);
+    }
+    handleTable2.delete(handle);
+    if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+      handleEntry.rep[symbolDispose]();
+    }
+  }
+  function trampoline5(handle) {
+    const handleEntry = handleTable3.get(handle);
+    if (!handleEntry) {
+      throw new Error(`Resource error: Invalid handle ${handle}`);
+    }
+    handleTable3.delete(handle);
+    if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+      handleEntry.rep[symbolDispose]();
+    }
+  }
+  function trampoline6(handle) {
+    const handleEntry = handleTable5.get(handle);
+    if (!handleEntry) {
+      throw new Error(`Resource error: Invalid handle ${handle}`);
+    }
+    handleTable5.delete(handle);
+    if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+      handleEntry.rep[symbolDispose]();
+    }
+  }
+  function trampoline7(handle) {
+    const handleEntry = handleTable7.get(handle);
+    if (!handleEntry) {
+      throw new Error(`Resource error: Invalid handle ${handle}`);
+    }
+    handleTable7.delete(handle);
+    if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+      handleEntry.rep[symbolDispose]();
+    }
+  }
+  function trampoline8(handle) {
+    const handleEntry = handleTable6.get(handle);
+    if (!handleEntry) {
+      throw new Error(`Resource error: Invalid handle ${handle}`);
+    }
+    handleTable6.delete(handle);
+    if (handleEntry.own && handleEntry.rep[symbolDispose]) {
+      handleEntry.rep[symbolDispose]();
+    }
+  }
+  Promise.all([module0, module1, module2, module3]).catch(() => {
+  });
+  ({ exports: exports0 } = await instantiateCore(await module2));
+  ({ exports: exports1 } = await instantiateCore(await module0, {
+    wasi_snapshot_preview1: {
+      args_get: exports0["29"],
+      args_sizes_get: exports0["30"],
+      clock_time_get: exports0["33"],
+      environ_get: exports0["31"],
+      environ_sizes_get: exports0["32"],
+      fd_close: exports0["34"],
+      fd_fdstat_get: exports0["35"],
+      fd_fdstat_set_flags: exports0["36"],
+      fd_prestat_dir_name: exports0["38"],
+      fd_prestat_get: exports0["37"],
+      fd_read: exports0["39"],
+      fd_readdir: exports0["40"],
+      fd_renumber: exports0["41"],
+      fd_seek: exports0["42"],
+      fd_write: exports0["43"],
+      path_create_directory: exports0["44"],
+      path_filestat_get: exports0["45"],
+      path_open: exports0["46"],
+      path_remove_directory: exports0["47"],
+      path_unlink_file: exports0["48"],
+      proc_exit: exports0["49"]
+    }
+  }));
+  ({ exports: exports2 } = await instantiateCore(await module1, {
+    __main_module__: {
+      _start: exports1._start
+    },
+    env: {
+      memory: exports1.memory
+    },
+    "wasi:cli/environment@0.2.0-rc-2023-11-10": {
+      "get-arguments": exports0["25"],
+      "get-environment": exports0["24"]
+    },
+    "wasi:cli/exit@0.2.0-rc-2023-11-10": {
+      exit: trampoline10
+    },
+    "wasi:cli/stderr@0.2.0-rc-2023-11-10": {
+      "get-stderr": trampoline9
+    },
+    "wasi:cli/stdin@0.2.0-rc-2023-11-10": {
+      "get-stdin": trampoline11
+    },
+    "wasi:cli/stdout@0.2.0-rc-2023-11-10": {
+      "get-stdout": trampoline12
+    },
+    "wasi:cli/terminal-input@0.2.0-rc-2023-11-10": {
+      "[resource-drop]terminal-input": trampoline8
+    },
+    "wasi:cli/terminal-output@0.2.0-rc-2023-11-10": {
+      "[resource-drop]terminal-output": trampoline7
+    },
+    "wasi:cli/terminal-stderr@0.2.0-rc-2023-11-10": {
+      "get-terminal-stderr": exports0["28"]
+    },
+    "wasi:cli/terminal-stdin@0.2.0-rc-2023-11-10": {
+      "get-terminal-stdin": exports0["26"]
+    },
+    "wasi:cli/terminal-stdout@0.2.0-rc-2023-11-10": {
+      "get-terminal-stdout": exports0["27"]
+    },
+    "wasi:clocks/monotonic-clock@0.2.0-rc-2023-11-10": {
+      now: trampoline0
+    },
+    "wasi:clocks/wall-clock@0.2.0-rc-2023-11-10": {
+      now: exports0["1"]
+    },
+    "wasi:filesystem/preopens@0.2.0-rc-2023-11-10": {
+      "get-directories": exports0["0"]
+    },
+    "wasi:filesystem/types@0.2.0-rc-2023-11-10": {
+      "[method]descriptor.append-via-stream": exports0["4"],
+      "[method]descriptor.create-directory-at": exports0["8"],
+      "[method]descriptor.get-flags": exports0["5"],
+      "[method]descriptor.get-type": exports0["6"],
+      "[method]descriptor.metadata-hash": exports0["14"],
+      "[method]descriptor.metadata-hash-at": exports0["15"],
+      "[method]descriptor.open-at": exports0["11"],
+      "[method]descriptor.read-directory": exports0["7"],
+      "[method]descriptor.read-via-stream": exports0["2"],
+      "[method]descriptor.remove-directory-at": exports0["12"],
+      "[method]descriptor.stat": exports0["9"],
+      "[method]descriptor.stat-at": exports0["10"],
+      "[method]descriptor.unlink-file-at": exports0["13"],
+      "[method]descriptor.write-via-stream": exports0["3"],
+      "[method]directory-entry-stream.read-directory-entry": exports0["16"],
+      "[resource-drop]descriptor": trampoline5,
+      "[resource-drop]directory-entry-stream": trampoline1,
+      "filesystem-error-code": exports0["17"]
+    },
+    "wasi:io/error@0.2.0-rc-2023-11-10": {
+      "[resource-drop]error": trampoline2
+    },
+    "wasi:io/streams@0.2.0-rc-2023-11-10": {
+      "[method]input-stream.blocking-read": exports0["19"],
+      "[method]input-stream.read": exports0["18"],
+      "[method]output-stream.blocking-flush": exports0["23"],
+      "[method]output-stream.blocking-write-and-flush": exports0["22"],
+      "[method]output-stream.check-write": exports0["20"],
+      "[method]output-stream.write": exports0["21"],
+      "[resource-drop]input-stream": trampoline3,
+      "[resource-drop]output-stream": trampoline4
+    },
+    "wasi:sockets/tcp@0.2.0-rc-2023-11-10": {
+      "[resource-drop]tcp-socket": trampoline6
+    }
+  }));
+  memory0 = exports1.memory;
+  realloc0 = exports2.cabi_import_realloc;
+  ({ exports: exports3 } = await instantiateCore(await module3, {
+    "": {
+      $imports: exports0.$imports,
+      "0": trampoline13,
+      "1": trampoline14,
+      "10": trampoline23,
+      "11": trampoline24,
+      "12": trampoline25,
+      "13": trampoline26,
+      "14": trampoline27,
+      "15": trampoline28,
+      "16": trampoline29,
+      "17": trampoline30,
+      "18": trampoline31,
+      "19": trampoline32,
+      "2": trampoline15,
+      "20": trampoline33,
+      "21": trampoline34,
+      "22": trampoline35,
+      "23": trampoline36,
+      "24": trampoline37,
+      "25": trampoline38,
+      "26": trampoline39,
+      "27": trampoline40,
+      "28": trampoline41,
+      "29": exports2.args_get,
+      "3": trampoline16,
+      "30": exports2.args_sizes_get,
+      "31": exports2.environ_get,
+      "32": exports2.environ_sizes_get,
+      "33": exports2.clock_time_get,
+      "34": exports2.fd_close,
+      "35": exports2.fd_fdstat_get,
+      "36": exports2.fd_fdstat_set_flags,
+      "37": exports2.fd_prestat_get,
+      "38": exports2.fd_prestat_dir_name,
+      "39": exports2.fd_read,
+      "4": trampoline17,
+      "40": exports2.fd_readdir,
+      "41": exports2.fd_renumber,
+      "42": exports2.fd_seek,
+      "43": exports2.fd_write,
+      "44": exports2.path_create_directory,
+      "45": exports2.path_filestat_get,
+      "46": exports2.path_open,
+      "47": exports2.path_remove_directory,
+      "48": exports2.path_unlink_file,
+      "49": exports2.proc_exit,
+      "5": trampoline18,
+      "6": trampoline19,
+      "7": trampoline20,
+      "8": trampoline21,
+      "9": trampoline22
+    }
+  }));
+  function run() {
+    const ret = exports2["wasi:cli/run@0.2.0-rc-2023-11-10#run"]();
+    let variant0;
+    switch (ret) {
+      case 0: {
+        variant0 = {
+          tag: "ok",
+          val: void 0
+        };
+        break;
+      }
+      case 1: {
+        variant0 = {
+          tag: "err",
+          val: void 0
+        };
+        break;
+      }
+      default: {
+        throw new TypeError("invalid variant discriminant for expected");
+      }
+    }
+    if (variant0.tag === "err") {
+      throw new ComponentError(variant0.val);
+    }
+    return variant0.val;
+  }
+  const handleTable0 = /* @__PURE__ */ new Map();
+  let handleCnt0 = 0;
+  const handleTable1 = /* @__PURE__ */ new Map();
+  let handleCnt1 = 0;
+  const handleTable2 = /* @__PURE__ */ new Map();
+  let handleCnt2 = 0;
+  const handleTable3 = /* @__PURE__ */ new Map();
+  let handleCnt3 = 0;
+  const handleTable4 = /* @__PURE__ */ new Map();
+  let handleCnt4 = 0;
+  const handleTable5 = /* @__PURE__ */ new Map();
+  let handleCnt5 = 0;
+  const handleTable6 = /* @__PURE__ */ new Map();
+  let handleCnt6 = 0;
+  const handleTable7 = /* @__PURE__ */ new Map();
+  let handleCnt7 = 0;
+  const run0_2_0Rc20231110 = {
+    run
+  };
+  return { run: run0_2_0Rc20231110, "wasi:cli/run@0.2.0-rc-2023-11-10": run0_2_0Rc20231110 };
+}
+
+// lib/api.js
+var baseURL = "http://127.0.0.1:8000/gen/bundle-browser.js";
+console.log("baseURL", baseURL);
+var yosys = new Application(baseURL, {
+  "share": "./yosys-share.json"
+}, {
+  "yosys.core.wasm": "./yosys.core.wasm",
+  "yosys.core2.wasm": "./yosys.core2.wasm",
+  "yosys.core3.wasm": "./yosys.core3.wasm",
+  "yosys.core4.wasm": "./yosys.core4.wasm"
+}, instantiate, "yowasp-yosys");
+var runYosys = yosys.run.bind(yosys);
+export {
+  Exit,
+  runYosys
+};