@monaco-neovim-wasm/lib 0.1.6 → 0.1.8

package/dist/nvimWorker.js

@@ -1,114 +1,1433 @@
-import { W as Y, g as J, D as M, F as P, a as $, P as N, E as K, b as C, c as j, R as Q, d as G, e as m, f as L, h as w, i as H } from "./msgpack-BSNDwQ9a.js";
-let v = null, f = null, U = null;
-const Z = new TextDecoder();
-let E = "", R = !1, g = null, A = null;
-self.addEventListener("error", (n) => {
-  if (R) return;
-  R = !0;
-  const t = n.message || String(n.error || "worker error"), e = n.error?.stack;
+class Z {
+  static read_bytes(e, t) {
+    const i = new Z();
+    return i.buf = e.getUint32(t, !0), i.buf_len = e.getUint32(t + 4, !0), i;
+  }
+  static read_bytes_array(e, t, i) {
+    const o = [];
+    for (let n = 0; n < i; n++)
+      o.push(Z.read_bytes(e, t + 8 * n));
+    return o;
+  }
+}
+class ee {
+  static read_bytes(e, t) {
+    const i = new ee();
+    return i.buf = e.getUint32(t, !0), i.buf_len = e.getUint32(t + 4, !0), i;
+  }
+  static read_bytes_array(e, t, i) {
+    const o = [];
+    for (let n = 0; n < i; n++)
+      o.push(ee.read_bytes(e, t + 8 * n));
+    return o;
+  }
+}
+const ct = 0, ut = 1, Ye = 2, U = 3, j = 4;
+class Re {
+  head_length() {
+    return 24;
+  }
+  name_length() {
+    return this.dir_name.byteLength;
+  }
+  write_head_bytes(e, t) {
+    e.setBigUint64(t, this.d_next, !0), e.setBigUint64(t + 8, this.d_ino, !0), e.setUint32(t + 16, this.dir_name.length, !0), e.setUint8(t + 20, this.d_type);
+  }
+  write_name_bytes(e, t, i) {
+    e.set(this.dir_name.slice(0, Math.min(this.dir_name.byteLength, i)), t);
+  }
+  constructor(e, t, i, o) {
+    const n = new TextEncoder().encode(i);
+    this.d_next = e, this.d_ino = t, this.d_namlen = n.byteLength, this.d_type = o, this.dir_name = n;
+  }
+}
+const _t = 1;
+class ce {
+  write_bytes(e, t) {
+    e.setUint8(t, this.fs_filetype), e.setUint16(t + 2, this.fs_flags, !0), e.setBigUint64(t + 8, this.fs_rights_base, !0), e.setBigUint64(t + 16, this.fs_rights_inherited, !0);
+  }
+  constructor(e, t) {
+    this.fs_rights_base = 0n, this.fs_rights_inherited = 0n, this.fs_filetype = e, this.fs_flags = t;
+  }
+}
+const ge = 1, G = 2, Ve = 4, je = 8;
+class Xe {
+  write_bytes(e, t) {
+    e.setBigUint64(t, this.dev, !0), e.setBigUint64(t + 8, this.ino, !0), e.setUint8(t + 16, this.filetype), e.setBigUint64(t + 24, this.nlink, !0), e.setBigUint64(t + 32, this.size, !0), e.setBigUint64(t + 38, this.atim, !0), e.setBigUint64(t + 46, this.mtim, !0), e.setBigUint64(t + 52, this.ctim, !0);
+  }
+  constructor(e, t, i) {
+    this.dev = 0n, this.nlink = 0n, this.atim = 0n, this.mtim = 0n, this.ctim = 0n, this.ino = e, this.filetype = t, this.size = i;
+  }
+}
+const dt = 0, ht = 1;
+class ve {
+  static read_bytes(e, t) {
+    return new ve(e.getBigUint64(t, !0), e.getUint8(t + 8), e.getUint32(t + 16, !0), e.getBigUint64(t + 24, !0), e.getUint16(t + 36, !0));
+  }
+  constructor(e, t, i, o, n) {
+    this.userdata = e, this.eventtype = t, this.clockid = i, this.timeout = o, this.flags = n;
+  }
+}
+class pt {
+  write_bytes(e, t) {
+    e.setBigUint64(t, this.userdata, !0), e.setUint16(t + 8, this.error, !0), e.setUint8(t + 10, this.eventtype);
+  }
+  constructor(e, t, i) {
+    this.userdata = e, this.error = t, this.eventtype = i;
+  }
+}
+const Rt = 0;
+class gt {
+  write_bytes(e, t) {
+    e.setUint32(t, this.pr_name.byteLength, !0);
+  }
+  constructor(e) {
+    this.pr_name = new TextEncoder().encode(e);
+  }
+}
+class De {
+  static dir(e) {
+    const t = new De();
+    return t.tag = Rt, t.inner = new gt(e), t;
+  }
+  write_bytes(e, t) {
+    e.setUint32(t, this.tag, !0), this.inner.write_bytes(e, t + 4);
+  }
+}
+let yt = class {
+  enable(e) {
+    this.log = wt(e === void 0 ? !0 : e, this.prefix);
+  }
+  get enabled() {
+    return this.isEnabled;
+  }
+  constructor(e) {
+    this.isEnabled = e, this.prefix = "wasi:", this.enable(e);
+  }
+};
+function wt(r, e) {
+  return r ? console.log.bind(console, "%c%s", "color: #265BA0", e) : () => {
+  };
+}
+const w = new yt(!1);
+class ze extends Error {
+  constructor(e) {
+    super("exit with exit code " + e), this.code = e;
+  }
+}
+let mt = class {
+  start(e) {
+    this.inst = e;
+    try {
+      return e.exports._start(), 0;
+    } catch (t) {
+      if (t instanceof ze)
+        return t.code;
+      throw t;
+    }
+  }
+  initialize(e) {
+    this.inst = e, e.exports._initialize && e.exports._initialize();
+  }
+  constructor(e, t, i, o = {}) {
+    this.args = [], this.env = [], this.fds = [], w.enable(o.debug), this.args = e, this.env = t, this.fds = i;
+    const n = this;
+    this.wasiImport = { args_sizes_get(s, a) {
+      const f = new DataView(n.inst.exports.memory.buffer);
+      f.setUint32(s, n.args.length, !0);
+      let l = 0;
+      for (const u of n.args)
+        l += u.length + 1;
+      return f.setUint32(a, l, !0), w.log(f.getUint32(s, !0), f.getUint32(a, !0)), 0;
+    }, args_get(s, a) {
+      const f = new DataView(n.inst.exports.memory.buffer), l = new Uint8Array(n.inst.exports.memory.buffer), u = a;
+      for (let c = 0; c < n.args.length; c++) {
+        f.setUint32(s, a, !0), s += 4;
+        const _ = new TextEncoder().encode(n.args[c]);
+        l.set(_, a), f.setUint8(a + _.length, 0), a += _.length + 1;
+      }
+      return w.enabled && w.log(new TextDecoder("utf-8").decode(l.slice(u, a))), 0;
+    }, environ_sizes_get(s, a) {
+      const f = new DataView(n.inst.exports.memory.buffer);
+      f.setUint32(s, n.env.length, !0);
+      let l = 0;
+      for (const u of n.env)
+        l += new TextEncoder().encode(u).length + 1;
+      return f.setUint32(a, l, !0), w.log(f.getUint32(s, !0), f.getUint32(a, !0)), 0;
+    }, environ_get(s, a) {
+      const f = new DataView(n.inst.exports.memory.buffer), l = new Uint8Array(n.inst.exports.memory.buffer), u = a;
+      for (let c = 0; c < n.env.length; c++) {
+        f.setUint32(s, a, !0), s += 4;
+        const _ = new TextEncoder().encode(n.env[c]);
+        l.set(_, a), f.setUint8(a + _.length, 0), a += _.length + 1;
+      }
+      return w.enabled && w.log(new TextDecoder("utf-8").decode(l.slice(u, a))), 0;
+    }, clock_res_get(s, a) {
+      let f;
+      switch (s) {
+        case 1: {
+          f = 5000n;
+          break;
+        }
+        case 0: {
+          f = 1000000n;
+          break;
+        }
+        default:
+          return 52;
+      }
+      return new DataView(n.inst.exports.memory.buffer).setBigUint64(a, f, !0), 0;
+    }, clock_time_get(s, a, f) {
+      const l = new DataView(n.inst.exports.memory.buffer);
+      if (s === 0)
+        l.setBigUint64(f, BigInt((/* @__PURE__ */ new Date()).getTime()) * 1000000n, !0);
+      else if (s == 1) {
+        let u;
+        try {
+          u = BigInt(Math.round(performance.now() * 1e6));
+        } catch {
+          u = 0n;
+        }
+        l.setBigUint64(f, u, !0);
+      } else
+        l.setBigUint64(f, 0n, !0);
+      return 0;
+    }, fd_advise(s, a, f, l) {
+      return n.fds[s] != null ? 0 : 8;
+    }, fd_allocate(s, a, f) {
+      return n.fds[s] != null ? n.fds[s].fd_allocate(a, f) : 8;
+    }, fd_close(s) {
+      if (n.fds[s] != null) {
+        const a = n.fds[s].fd_close();
+        return n.fds[s] = void 0, a;
+      } else
+        return 8;
+    }, fd_datasync(s) {
+      return n.fds[s] != null ? n.fds[s].fd_sync() : 8;
+    }, fd_fdstat_get(s, a) {
+      if (n.fds[s] != null) {
+        const { ret: f, fdstat: l } = n.fds[s].fd_fdstat_get();
+        return l?.write_bytes(new DataView(n.inst.exports.memory.buffer), a), f;
+      } else
+        return 8;
+    }, fd_fdstat_set_flags(s, a) {
+      return n.fds[s] != null ? n.fds[s].fd_fdstat_set_flags(a) : 8;
+    }, fd_fdstat_set_rights(s, a, f) {
+      return n.fds[s] != null ? n.fds[s].fd_fdstat_set_rights(a, f) : 8;
+    }, fd_filestat_get(s, a) {
+      if (n.fds[s] != null) {
+        const { ret: f, filestat: l } = n.fds[s].fd_filestat_get();
+        return l?.write_bytes(new DataView(n.inst.exports.memory.buffer), a), f;
+      } else
+        return 8;
+    }, fd_filestat_set_size(s, a) {
+      return n.fds[s] != null ? n.fds[s].fd_filestat_set_size(a) : 8;
+    }, fd_filestat_set_times(s, a, f, l) {
+      return n.fds[s] != null ? n.fds[s].fd_filestat_set_times(a, f, l) : 8;
+    }, fd_pread(s, a, f, l, u) {
+      const c = new DataView(n.inst.exports.memory.buffer), _ = new Uint8Array(n.inst.exports.memory.buffer);
+      if (n.fds[s] != null) {
+        const d = Z.read_bytes_array(c, a, f);
+        let p = 0;
+        for (const h of d) {
+          const { ret: R, data: g } = n.fds[s].fd_pread(h.buf_len, l);
+          if (R != 0)
+            return c.setUint32(u, p, !0), R;
+          if (_.set(g, h.buf), p += g.length, l += BigInt(g.length), g.length != h.buf_len)
+            break;
+        }
+        return c.setUint32(u, p, !0), 0;
+      } else
+        return 8;
+    }, fd_prestat_get(s, a) {
+      const f = new DataView(n.inst.exports.memory.buffer);
+      if (n.fds[s] != null) {
+        const { ret: l, prestat: u } = n.fds[s].fd_prestat_get();
+        return u?.write_bytes(f, a), l;
+      } else
+        return 8;
+    }, fd_prestat_dir_name(s, a, f) {
+      if (n.fds[s] != null) {
+        const { ret: l, prestat: u } = n.fds[s].fd_prestat_get();
+        if (u == null)
+          return l;
+        const c = u.inner.pr_name;
+        return new Uint8Array(n.inst.exports.memory.buffer).set(c.slice(0, f), a), c.byteLength > f ? 37 : 0;
+      } else
+        return 8;
+    }, fd_pwrite(s, a, f, l, u) {
+      const c = new DataView(n.inst.exports.memory.buffer), _ = new Uint8Array(n.inst.exports.memory.buffer);
+      if (n.fds[s] != null) {
+        const d = ee.read_bytes_array(c, a, f);
+        let p = 0;
+        for (const h of d) {
+          const R = _.slice(h.buf, h.buf + h.buf_len), { ret: g, nwritten: N } = n.fds[s].fd_pwrite(R, l);
+          if (g != 0)
+            return c.setUint32(u, p, !0), g;
+          if (p += N, l += BigInt(N), N != R.byteLength)
+            break;
+        }
+        return c.setUint32(u, p, !0), 0;
+      } else
+        return 8;
+    }, fd_read(s, a, f, l) {
+      const u = new DataView(n.inst.exports.memory.buffer), c = new Uint8Array(n.inst.exports.memory.buffer);
+      if (n.fds[s] != null) {
+        const _ = Z.read_bytes_array(u, a, f);
+        let d = 0;
+        for (const p of _) {
+          const { ret: h, data: R } = n.fds[s].fd_read(p.buf_len);
+          if (h != 0)
+            return u.setUint32(l, d, !0), h;
+          if (c.set(R, p.buf), d += R.length, R.length != p.buf_len)
+            break;
+        }
+        return u.setUint32(l, d, !0), 0;
+      } else
+        return 8;
+    }, fd_readdir(s, a, f, l, u) {
+      const c = new DataView(n.inst.exports.memory.buffer), _ = new Uint8Array(n.inst.exports.memory.buffer);
+      if (n.fds[s] != null) {
+        let d = 0;
+        for (; ; ) {
+          const { ret: p, dirent: h } = n.fds[s].fd_readdir_single(l);
+          if (p != 0)
+            return c.setUint32(u, d, !0), p;
+          if (h == null)
+            break;
+          if (f - d < h.head_length()) {
+            d = f;
+            break;
+          }
+          const R = new ArrayBuffer(h.head_length());
+          if (h.write_head_bytes(new DataView(R), 0), _.set(new Uint8Array(R).slice(0, Math.min(R.byteLength, f - d)), a), a += h.head_length(), d += h.head_length(), f - d < h.name_length()) {
+            d = f;
+            break;
+          }
+          h.write_name_bytes(_, a, f - d), a += h.name_length(), d += h.name_length(), l = h.d_next;
+        }
+        return c.setUint32(u, d, !0), 0;
+      } else
+        return 8;
+    }, fd_renumber(s, a) {
+      if (n.fds[s] != null && n.fds[a] != null) {
+        const f = n.fds[a].fd_close();
+        return f != 0 ? f : (n.fds[a] = n.fds[s], n.fds[s] = void 0, 0);
+      } else
+        return 8;
+    }, fd_seek(s, a, f, l) {
+      const u = new DataView(n.inst.exports.memory.buffer);
+      if (n.fds[s] != null) {
+        const { ret: c, offset: _ } = n.fds[s].fd_seek(a, f);
+        return u.setBigInt64(l, _, !0), c;
+      } else
+        return 8;
+    }, fd_sync(s) {
+      return n.fds[s] != null ? n.fds[s].fd_sync() : 8;
+    }, fd_tell(s, a) {
+      const f = new DataView(n.inst.exports.memory.buffer);
+      if (n.fds[s] != null) {
+        const { ret: l, offset: u } = n.fds[s].fd_tell();
+        return f.setBigUint64(a, u, !0), l;
+      } else
+        return 8;
+    }, fd_write(s, a, f, l) {
+      const u = new DataView(n.inst.exports.memory.buffer), c = new Uint8Array(n.inst.exports.memory.buffer);
+      if (n.fds[s] != null) {
+        const _ = ee.read_bytes_array(u, a, f);
+        let d = 0;
+        for (const p of _) {
+          const h = c.slice(p.buf, p.buf + p.buf_len), { ret: R, nwritten: g } = n.fds[s].fd_write(h);
+          if (R != 0)
+            return u.setUint32(l, d, !0), R;
+          if (d += g, g != h.byteLength)
+            break;
+        }
+        return u.setUint32(l, d, !0), 0;
+      } else
+        return 8;
+    }, path_create_directory(s, a, f) {
+      const l = new Uint8Array(n.inst.exports.memory.buffer);
+      if (n.fds[s] != null) {
+        const u = new TextDecoder("utf-8").decode(l.slice(a, a + f));
+        return n.fds[s].path_create_directory(u);
+      } else
+        return 8;
+    }, path_filestat_get(s, a, f, l, u) {
+      const c = new DataView(n.inst.exports.memory.buffer), _ = new Uint8Array(n.inst.exports.memory.buffer);
+      if (n.fds[s] != null) {
+        const d = new TextDecoder("utf-8").decode(_.slice(f, f + l)), { ret: p, filestat: h } = n.fds[s].path_filestat_get(a, d);
+        return h?.write_bytes(c, u), p;
+      } else
+        return 8;
+    }, path_filestat_set_times(s, a, f, l, u, c, _) {
+      const d = new Uint8Array(n.inst.exports.memory.buffer);
+      if (n.fds[s] != null) {
+        const p = new TextDecoder("utf-8").decode(d.slice(f, f + l));
+        return n.fds[s].path_filestat_set_times(a, p, u, c, _);
+      } else
+        return 8;
+    }, path_link(s, a, f, l, u, c, _) {
+      const d = new Uint8Array(n.inst.exports.memory.buffer);
+      if (n.fds[s] != null && n.fds[u] != null) {
+        const p = new TextDecoder("utf-8").decode(d.slice(f, f + l)), h = new TextDecoder("utf-8").decode(d.slice(c, c + _)), { ret: R, inode_obj: g } = n.fds[s].path_lookup(p, a);
+        return g == null ? R : n.fds[u].path_link(h, g, !1);
+      } else
+        return 8;
+    }, path_open(s, a, f, l, u, c, _, d, p) {
+      const h = new DataView(n.inst.exports.memory.buffer), R = new Uint8Array(n.inst.exports.memory.buffer);
+      if (n.fds[s] != null) {
+        const g = new TextDecoder("utf-8").decode(R.slice(f, f + l));
+        w.log(g);
+        const { ret: N, fd_obj: m } = n.fds[s].path_open(a, g, u, c, _, d);
+        if (N != 0)
+          return N;
+        n.fds.push(m);
+        const I = n.fds.length - 1;
+        return h.setUint32(p, I, !0), 0;
+      } else
+        return 8;
+    }, path_readlink(s, a, f, l, u, c) {
+      const _ = new DataView(n.inst.exports.memory.buffer), d = new Uint8Array(n.inst.exports.memory.buffer);
+      if (n.fds[s] != null) {
+        const p = new TextDecoder("utf-8").decode(d.slice(a, a + f));
+        w.log(p);
+        const { ret: h, data: R } = n.fds[s].path_readlink(p);
+        if (R != null) {
+          const g = new TextEncoder().encode(R);
+          if (g.length > u)
+            return _.setUint32(c, 0, !0), 8;
+          d.set(g, l), _.setUint32(c, g.length, !0);
+        }
+        return h;
+      } else
+        return 8;
+    }, path_remove_directory(s, a, f) {
+      const l = new Uint8Array(n.inst.exports.memory.buffer);
+      if (n.fds[s] != null) {
+        const u = new TextDecoder("utf-8").decode(l.slice(a, a + f));
+        return n.fds[s].path_remove_directory(u);
+      } else
+        return 8;
+    }, path_rename(s, a, f, l, u, c) {
+      const _ = new Uint8Array(n.inst.exports.memory.buffer);
+      if (n.fds[s] != null && n.fds[l] != null) {
+        const d = new TextDecoder("utf-8").decode(_.slice(a, a + f)), p = new TextDecoder("utf-8").decode(_.slice(u, u + c));
+        let { ret: h, inode_obj: R } = n.fds[s].path_unlink(d);
+        if (R == null)
+          return h;
+        if (h = n.fds[l].path_link(p, R, !0), h != 0 && n.fds[s].path_link(d, R, !0) != 0)
+          throw "path_link should always return success when relinking an inode back to the original place";
+        return h;
+      } else
+        return 8;
+    }, path_symlink(s, a, f, l, u) {
+      const c = new Uint8Array(n.inst.exports.memory.buffer);
+      return n.fds[f] != null ? (new TextDecoder("utf-8").decode(c.slice(s, s + a)), new TextDecoder("utf-8").decode(c.slice(l, l + u)), 58) : 8;
+    }, path_unlink_file(s, a, f) {
+      const l = new Uint8Array(n.inst.exports.memory.buffer);
+      if (n.fds[s] != null) {
+        const u = new TextDecoder("utf-8").decode(l.slice(a, a + f));
+        return n.fds[s].path_unlink_file(u);
+      } else
+        return 8;
+    }, poll_oneoff(s, a, f) {
+      if (f === 0)
+        return 28;
+      if (f > 1)
+        return w.log("poll_oneoff: only a single subscription is supported"), 58;
+      const l = new DataView(n.inst.exports.memory.buffer), u = ve.read_bytes(l, s), c = u.eventtype, _ = u.clockid, d = u.timeout;
+      if (c !== dt)
+        return w.log("poll_oneoff: only clock subscriptions are supported"), 58;
+      let p;
+      if (_ === 1)
+        p = () => BigInt(Math.round(performance.now() * 1e6));
+      else if (_ === 0)
+        p = () => BigInt((/* @__PURE__ */ new Date()).getTime()) * 1000000n;
+      else
+        return 28;
+      const h = u.flags & ht ? d : p() + d;
+      for (; h > p(); )
+        ;
+      return new pt(u.userdata, 0, c).write_bytes(l, a), 0;
+    }, proc_exit(s) {
+      throw new ze(s);
+    }, proc_raise(s) {
+      throw "raised signal " + s;
+    }, sched_yield() {
+    }, random_get(s, a) {
+      const f = new Uint8Array(n.inst.exports.memory.buffer).subarray(s, s + a);
+      if ("crypto" in globalThis && (typeof SharedArrayBuffer > "u" || !(n.inst.exports.memory.buffer instanceof SharedArrayBuffer)))
+        for (let l = 0; l < a; l += 65536)
+          crypto.getRandomValues(f.subarray(l, l + 65536));
+      else
+        for (let l = 0; l < a; l++)
+          f[l] = Math.random() * 256 | 0;
+    }, sock_recv(s, a, f) {
+      throw "sockets not supported";
+    }, sock_send(s, a, f) {
+      throw "sockets not supported";
+    }, sock_shutdown(s, a) {
+      throw "sockets not supported";
+    }, sock_accept(s, a) {
+      throw "sockets not supported";
+    } };
+  }
+};
+class ue {
+  fd_allocate(e, t) {
+    return 58;
+  }
+  fd_close() {
+    return 0;
+  }
+  fd_fdstat_get() {
+    return { ret: 58, fdstat: null };
+  }
+  fd_fdstat_set_flags(e) {
+    return 58;
+  }
+  fd_fdstat_set_rights(e, t) {
+    return 58;
+  }
+  fd_filestat_get() {
+    return { ret: 58, filestat: null };
+  }
+  fd_filestat_set_size(e) {
+    return 58;
+  }
+  fd_filestat_set_times(e, t, i) {
+    return 58;
+  }
+  fd_pread(e, t) {
+    return { ret: 58, data: new Uint8Array() };
+  }
+  fd_prestat_get() {
+    return { ret: 58, prestat: null };
+  }
+  fd_pwrite(e, t) {
+    return { ret: 58, nwritten: 0 };
+  }
+  fd_read(e) {
+    return { ret: 58, data: new Uint8Array() };
+  }
+  fd_readdir_single(e) {
+    return { ret: 58, dirent: null };
+  }
+  fd_seek(e, t) {
+    return { ret: 58, offset: 0n };
+  }
+  fd_sync() {
+    return 0;
+  }
+  fd_tell() {
+    return { ret: 58, offset: 0n };
+  }
+  fd_write(e) {
+    return { ret: 58, nwritten: 0 };
+  }
+  path_create_directory(e) {
+    return 58;
+  }
+  path_filestat_get(e, t) {
+    return { ret: 58, filestat: null };
+  }
+  path_filestat_set_times(e, t, i, o, n) {
+    return 58;
+  }
+  path_link(e, t, i) {
+    return 58;
+  }
+  path_unlink(e) {
+    return { ret: 58, inode_obj: null };
+  }
+  path_lookup(e, t) {
+    return { ret: 58, inode_obj: null };
+  }
+  path_open(e, t, i, o, n, s) {
+    return { ret: 54, fd_obj: null };
+  }
+  path_readlink(e) {
+    return { ret: 58, data: null };
+  }
+  path_remove_directory(e) {
+    return 58;
+  }
+  path_rename(e, t, i) {
+    return 58;
+  }
+  path_unlink_file(e) {
+    return 58;
+  }
+}
+class F {
+  static issue_ino() {
+    return F.next_ino++;
+  }
+  static root_ino() {
+    return 0n;
+  }
+  constructor() {
+    this.ino = F.issue_ino();
+  }
+}
+F.next_ino = 1n;
+class Et extends ue {
+  fd_allocate(e, t) {
+    if (!(this.file.size > e + t)) {
+      const i = new Uint8Array(Number(e + t));
+      i.set(this.file.data, 0), this.file.data = i;
+    }
+    return 0;
+  }
+  fd_fdstat_get() {
+    return { ret: 0, fdstat: new ce(j, 0) };
+  }
+  fd_filestat_set_size(e) {
+    if (this.file.size > e)
+      this.file.data = new Uint8Array(this.file.data.buffer.slice(0, Number(e)));
+    else {
+      const t = new Uint8Array(Number(e));
+      t.set(this.file.data, 0), this.file.data = t;
+    }
+    return 0;
+  }
+  fd_read(e) {
+    const t = this.file.data.slice(Number(this.file_pos), Number(this.file_pos + BigInt(e)));
+    return this.file_pos += BigInt(t.length), { ret: 0, data: t };
+  }
+  fd_pread(e, t) {
+    return { ret: 0, data: this.file.data.slice(Number(t), Number(t + BigInt(e))) };
+  }
+  fd_seek(e, t) {
+    let i;
+    switch (t) {
+      case ct:
+        i = e;
+        break;
+      case ut:
+        i = this.file_pos + e;
+        break;
+      case Ye:
+        i = BigInt(this.file.data.byteLength) + e;
+        break;
+      default:
+        return { ret: 28, offset: 0n };
+    }
+    return i < 0 ? { ret: 28, offset: 0n } : (this.file_pos = i, { ret: 0, offset: this.file_pos });
+  }
+  fd_tell() {
+    return { ret: 0, offset: this.file_pos };
+  }
+  fd_write(e) {
+    if (this.file.readonly) return { ret: 8, nwritten: 0 };
+    if (this.file_pos + BigInt(e.byteLength) > this.file.size) {
+      const t = this.file.data;
+      this.file.data = new Uint8Array(Number(this.file_pos + BigInt(e.byteLength))), this.file.data.set(t);
+    }
+    return this.file.data.set(e, Number(this.file_pos)), this.file_pos += BigInt(e.byteLength), { ret: 0, nwritten: e.byteLength };
+  }
+  fd_pwrite(e, t) {
+    if (this.file.readonly) return { ret: 8, nwritten: 0 };
+    if (t + BigInt(e.byteLength) > this.file.size) {
+      const i = this.file.data;
+      this.file.data = new Uint8Array(Number(t + BigInt(e.byteLength))), this.file.data.set(i);
+    }
+    return this.file.data.set(e, Number(t)), { ret: 0, nwritten: e.byteLength };
+  }
+  fd_filestat_get() {
+    return { ret: 0, filestat: this.file.stat() };
+  }
+  constructor(e) {
+    super(), this.file_pos = 0n, this.file = e;
+  }
+}
+class qe extends ue {
+  fd_seek(e, t) {
+    return { ret: 8, offset: 0n };
+  }
+  fd_tell() {
+    return { ret: 8, offset: 0n };
+  }
+  fd_allocate(e, t) {
+    return 8;
+  }
+  fd_fdstat_get() {
+    return { ret: 0, fdstat: new ce(U, 0) };
+  }
+  fd_readdir_single(e) {
+    if (w.enabled && (w.log("readdir_single", e), w.log(e, this.dir.contents.keys())), e == 0n)
+      return { ret: 0, dirent: new Re(1n, this.dir.ino, ".", U) };
+    if (e == 1n)
+      return { ret: 0, dirent: new Re(2n, this.dir.parent_ino(), "..", U) };
+    if (e >= BigInt(this.dir.contents.size) + 2n)
+      return { ret: 0, dirent: null };
+    const [t, i] = Array.from(this.dir.contents.entries())[Number(e - 2n)];
+    return { ret: 0, dirent: new Re(e + 1n, i.ino, t, i.stat().filetype) };
+  }
+  path_filestat_get(e, t) {
+    const { ret: i, path: o } = B.from(t);
+    if (o == null)
+      return { ret: i, filestat: null };
+    const { ret: n, entry: s } = this.dir.get_entry_for_path(o);
+    return s == null ? { ret: n, filestat: null } : { ret: 0, filestat: s.stat() };
+  }
+  path_lookup(e, t) {
+    const { ret: i, path: o } = B.from(e);
+    if (o == null)
+      return { ret: i, inode_obj: null };
+    const { ret: n, entry: s } = this.dir.get_entry_for_path(o);
+    return s == null ? { ret: n, inode_obj: null } : { ret: 0, inode_obj: s };
+  }
+  path_open(e, t, i, o, n, s) {
+    const { ret: a, path: f } = B.from(t);
+    if (f == null)
+      return { ret: a, fd_obj: null };
+    let { ret: l, entry: u } = this.dir.get_entry_for_path(f);
+    if (u == null) {
+      if (l != 44)
+        return { ret: l, fd_obj: null };
+      if ((i & ge) == ge) {
+        const { ret: c, entry: _ } = this.dir.create_entry_for_path(t, (i & G) == G);
+        if (_ == null)
+          return { ret: c, fd_obj: null };
+        u = _;
+      } else
+        return { ret: 44, fd_obj: null };
+    } else if ((i & Ve) == Ve)
+      return { ret: 20, fd_obj: null };
+    return (i & G) == G && u.stat().filetype !== U ? { ret: 54, fd_obj: null } : u.path_open(i, o, s);
+  }
+  path_create_directory(e) {
+    return this.path_open(0, e, ge | G, 0n, 0n, 0).ret;
+  }
+  path_link(e, t, i) {
+    const { ret: o, path: n } = B.from(e);
+    if (n == null)
+      return o;
+    if (n.is_dir)
+      return 44;
+    const { ret: s, parent_entry: a, filename: f, entry: l } = this.dir.get_parent_dir_and_entry_for_path(n, !0);
+    if (a == null || f == null)
+      return s;
+    if (l != null) {
+      const u = t.stat().filetype == U, c = l.stat().filetype == U;
+      if (u && c)
+        if (i && l instanceof O) {
+          if (l.contents.size != 0) return 55;
+        } else
+          return 20;
+      else {
+        if (u && !c)
+          return 54;
+        if (!u && c)
+          return 31;
+        if (!(t.stat().filetype == j && l.stat().filetype == j)) return 20;
+      }
+    }
+    return !i && t.stat().filetype == U ? 63 : (a.contents.set(f, t), 0);
+  }
+  path_unlink(e) {
+    const { ret: t, path: i } = B.from(e);
+    if (i == null)
+      return { ret: t, inode_obj: null };
+    const { ret: o, parent_entry: n, filename: s, entry: a } = this.dir.get_parent_dir_and_entry_for_path(i, !0);
+    return n == null || s == null ? { ret: o, inode_obj: null } : a == null ? { ret: 44, inode_obj: null } : (n.contents.delete(s), { ret: 0, inode_obj: a });
+  }
+  path_unlink_file(e) {
+    const { ret: t, path: i } = B.from(e);
+    if (i == null)
+      return t;
+    const { ret: o, parent_entry: n, filename: s, entry: a } = this.dir.get_parent_dir_and_entry_for_path(i, !1);
+    return n == null || s == null || a == null ? o : a.stat().filetype === U ? 31 : (n.contents.delete(s), 0);
+  }
+  path_remove_directory(e) {
+    const { ret: t, path: i } = B.from(e);
+    if (i == null)
+      return t;
+    const { ret: o, parent_entry: n, filename: s, entry: a } = this.dir.get_parent_dir_and_entry_for_path(i, !1);
+    return n == null || s == null || a == null ? o : !(a instanceof O) || a.stat().filetype !== U ? 54 : a.contents.size !== 0 ? 55 : n.contents.delete(s) ? 0 : 44;
+  }
+  fd_filestat_get() {
+    return { ret: 0, filestat: this.dir.stat() };
+  }
+  fd_filestat_set_size(e) {
+    return 8;
+  }
+  fd_read(e) {
+    return { ret: 8, data: new Uint8Array() };
+  }
+  fd_pread(e, t) {
+    return { ret: 8, data: new Uint8Array() };
+  }
+  fd_write(e) {
+    return { ret: 8, nwritten: 0 };
+  }
+  fd_pwrite(e, t) {
+    return { ret: 8, nwritten: 0 };
+  }
+  constructor(e) {
+    super(), this.dir = e;
+  }
+}
+class Ge extends qe {
+  fd_prestat_get() {
+    return { ret: 0, prestat: De.dir(this.prestat_name) };
+  }
+  constructor(e, t) {
+    super(new O(t)), this.prestat_name = e;
+  }
+}
+class Te extends F {
+  path_open(e, t, i) {
+    if (this.readonly && (t & BigInt(64)) == BigInt(64))
+      return { ret: 63, fd_obj: null };
+    if ((e & je) == je) {
+      if (this.readonly) return { ret: 63, fd_obj: null };
+      this.data = new Uint8Array([]);
+    }
+    const o = new Et(this);
+    return i & _t && o.fd_seek(0n, Ye), { ret: 0, fd_obj: o };
+  }
+  get size() {
+    return BigInt(this.data.byteLength);
+  }
+  stat() {
+    return new Xe(this.ino, j, this.size);
+  }
+  constructor(e, t) {
+    super(), this.data = new Uint8Array(e), this.readonly = !!t?.readonly;
+  }
+}
+let B = class Je {
+  static from(e) {
+    const t = new Je();
+    if (t.is_dir = e.endsWith("/"), e.startsWith("/"))
+      return { ret: 76, path: null };
+    if (e.includes("\0"))
+      return { ret: 28, path: null };
+    for (const i of e.split("/"))
+      if (!(i === "" || i === ".")) {
+        if (i === "..") {
+          if (t.parts.pop() == null)
+            return { ret: 76, path: null };
+          continue;
+        }
+        t.parts.push(i);
+      }
+    return { ret: 0, path: t };
+  }
+  to_path_string() {
+    let e = this.parts.join("/");
+    return this.is_dir && (e += "/"), e;
+  }
+  constructor() {
+    this.parts = [], this.is_dir = !1;
+  }
+};
+class O extends F {
+  parent_ino() {
+    return this.parent == null ? F.root_ino() : this.parent.ino;
+  }
+  path_open(e, t, i) {
+    return { ret: 0, fd_obj: new qe(this) };
+  }
+  stat() {
+    return new Xe(this.ino, U, 0n);
+  }
+  get_entry_for_path(e) {
+    let t = this;
+    for (const i of e.parts) {
+      if (!(t instanceof O))
+        return { ret: 54, entry: null };
+      const o = t.contents.get(i);
+      if (o !== void 0)
+        t = o;
+      else
+        return w.log(i), { ret: 44, entry: null };
+    }
+    return e.is_dir && t.stat().filetype != U ? { ret: 54, entry: null } : { ret: 0, entry: t };
+  }
+  get_parent_dir_and_entry_for_path(e, t) {
+    const i = e.parts.pop();
+    if (i === void 0)
+      return { ret: 28, parent_entry: null, filename: null, entry: null };
+    const { ret: o, entry: n } = this.get_entry_for_path(e);
+    if (n == null)
+      return { ret: o, parent_entry: null, filename: null, entry: null };
+    if (!(n instanceof O))
+      return { ret: 54, parent_entry: null, filename: null, entry: null };
+    const s = n.contents.get(i);
+    return s === void 0 ? t ? { ret: 0, parent_entry: n, filename: i, entry: null } : { ret: 44, parent_entry: null, filename: null, entry: null } : e.is_dir && s.stat().filetype != U ? { ret: 54, parent_entry: null, filename: null, entry: null } : { ret: 0, parent_entry: n, filename: i, entry: s };
+  }
+  create_entry_for_path(e, t) {
+    const { ret: i, path: o } = B.from(e);
+    if (o == null)
+      return { ret: i, entry: null };
+    let { ret: n, parent_entry: s, filename: a, entry: f } = this.get_parent_dir_and_entry_for_path(o, !0);
+    if (s == null || a == null)
+      return { ret: n, entry: null };
+    if (f != null)
+      return { ret: 20, entry: null };
+    w.log("create", o);
+    let l;
+    return t ? l = new O(/* @__PURE__ */ new Map()) : l = new Te(new ArrayBuffer(0)), s.contents.set(a, l), f = l, { ret: 0, entry: f };
+  }
+  constructor(e) {
+    super(), this.parent = null, e instanceof Array ? this.contents = new Map(e) : this.contents = e;
+    for (const t of this.contents.values())
+      t instanceof O && (t.parent = this);
+  }
+}
+var E = Uint8Array, V = Uint16Array, Ot = Int32Array, Qe = new E([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0,
+  /* unused */
+  0,
+  0,
+  /* impossible */
+  0
+]), Ze = new E([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13,
+  /* unused */
+  0,
+  0
+]), Nt = new E([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]), et = function(r, e) {
+  for (var t = new V(31), i = 0; i < 31; ++i)
+    t[i] = e += 1 << r[i - 1];
+  for (var o = new Ot(t[30]), i = 1; i < 30; ++i)
+    for (var n = t[i]; n < t[i + 1]; ++n)
+      o[n] = n - t[i] << 5 | i;
+  return { b: t, r: o };
+}, tt = et(Qe, 2), rt = tt.b, St = tt.r;
+rt[28] = 258, St[258] = 28;
+var Ut = et(Ze, 0), bt = Ut.b, be = new V(32768);
+for (var y = 0; y < 32768; ++y) {
+  var C = (y & 43690) >> 1 | (y & 21845) << 1;
+  C = (C & 52428) >> 2 | (C & 13107) << 2, C = (C & 61680) >> 4 | (C & 3855) << 4, be[y] = ((C & 65280) >> 8 | (C & 255) << 8) >> 1;
+}
+var J = function(r, e, t) {
+  for (var i = r.length, o = 0, n = new V(e); o < i; ++o)
+    r[o] && ++n[r[o] - 1];
+  var s = new V(e);
+  for (o = 1; o < e; ++o)
+    s[o] = s[o - 1] + n[o - 1] << 1;
+  var a;
+  if (t) {
+    a = new V(1 << e);
+    var f = 15 - e;
+    for (o = 0; o < i; ++o)
+      if (r[o])
+        for (var l = o << 4 | r[o], u = e - r[o], c = s[r[o] - 1]++ << u, _ = c | (1 << u) - 1; c <= _; ++c)
+          a[be[c] >> f] = l;
+  } else
+    for (a = new V(i), o = 0; o < i; ++o)
+      r[o] && (a[o] = be[s[r[o] - 1]++] >> 15 - r[o]);
+  return a;
+}, te = new E(288);
+for (var y = 0; y < 144; ++y)
+  te[y] = 8;
+for (var y = 144; y < 256; ++y)
+  te[y] = 9;
+for (var y = 256; y < 280; ++y)
+  te[y] = 7;
+for (var y = 280; y < 288; ++y)
+  te[y] = 8;
+var nt = new E(32);
+for (var y = 0; y < 32; ++y)
+  nt[y] = 5;
+var At = /* @__PURE__ */ J(te, 9, 1), vt = /* @__PURE__ */ J(nt, 5, 1), ye = function(r) {
+  for (var e = r[0], t = 1; t < r.length; ++t)
+    r[t] > e && (e = r[t]);
+  return e;
+}, A = function(r, e, t) {
+  var i = e / 8 | 0;
+  return (r[i] | r[i + 1] << 8) >> (e & 7) & t;
+}, we = function(r, e) {
+  var t = e / 8 | 0;
+  return (r[t] | r[t + 1] << 8 | r[t + 2] << 16) >> (e & 7);
+}, Dt = function(r) {
+  return (r + 7) / 8 | 0;
+}, Tt = function(r, e, t) {
+  return (t == null || t > r.length) && (t = r.length), new E(r.subarray(e, t));
+}, xt = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+  // determined by unknown compression method
+], D = function(r, e, t) {
+  var i = new Error(e || xt[r]);
+  if (i.code = r, Error.captureStackTrace && Error.captureStackTrace(i, D), !t)
+    throw i;
+  return i;
+}, Ct = function(r, e, t, i) {
+  var o = r.length, n = 0;
+  if (!o || e.f && !e.l)
+    return t || new E(0);
+  var s = !t, a = s || e.i != 2, f = e.i;
+  s && (t = new E(o * 3));
+  var l = function(Me) {
+    var Le = t.length;
+    if (Me > Le) {
+      var Pe = new E(Math.max(Le * 2, Me));
+      Pe.set(t), t = Pe;
+    }
+  }, u = e.f || 0, c = e.p || 0, _ = e.b || 0, d = e.l, p = e.d, h = e.m, R = e.n, g = o * 8;
+  do {
+    if (!d) {
+      u = A(r, c, 1);
+      var N = A(r, c + 1, 3);
+      if (c += 3, N)
+        if (N == 1)
+          d = At, p = vt, h = 9, R = 5;
+        else if (N == 2) {
+          var re = A(r, c, 31) + 257, ne = A(r, c + 10, 15) + 4, k = re + A(r, c + 5, 31) + 1;
+          c += 14;
+          for (var b = new E(k), _e = new E(19), S = 0; S < ne; ++S)
+            _e[Nt[S]] = A(r, c + S * 3, 7);
+          c += ne * 3;
+          for (var xe = ye(_e), it = (1 << xe) - 1, at = J(_e, xe, 1), S = 0; S < k; ) {
+            var Ce = at[A(r, c, it)];
+            c += Ce & 15;
+            var m = Ce >> 4;
+            if (m < 16)
+              b[S++] = m;
+            else {
+              var L = 0, se = 0;
+              for (m == 16 ? (se = 3 + A(r, c, 3), c += 2, L = b[S - 1]) : m == 17 ? (se = 3 + A(r, c, 7), c += 3) : m == 18 && (se = 11 + A(r, c, 127), c += 7); se--; )
+                b[S++] = L;
+            }
+          }
+          var Be = b.subarray(0, re), x = b.subarray(re);
+          h = ye(Be), R = ye(x), d = J(Be, h, 1), p = J(x, R, 1);
+        } else
+          D(1);
+      else {
+        var m = Dt(c) + 4, I = r[m - 4] | r[m - 3] << 8, M = m + I;
+        if (M > o) {
+          f && D(0);
+          break;
+        }
+        a && l(_ + I), t.set(r.subarray(m, M), _), e.b = _ += I, e.p = c = M * 8, e.f = u;
+        continue;
+      }
+      if (c > g) {
+        f && D(0);
+        break;
+      }
+    }
+    a && l(_ + 131072);
+    for (var ot = (1 << h) - 1, ft = (1 << R) - 1, de = c; ; de = c) {
+      var L = d[we(r, c) & ot], P = L >> 4;
+      if (c += L & 15, c > g) {
+        f && D(0);
+        break;
+      }
+      if (L || D(2), P < 256)
+        t[_++] = P;
+      else if (P == 256) {
+        de = c, d = null;
+        break;
+      } else {
+        var Ie = P - 254;
+        if (P > 264) {
+          var S = P - 257, z = Qe[S];
+          Ie = A(r, c, (1 << z) - 1) + rt[S], c += z;
+        }
+        var he = p[we(r, c) & ft], pe = he >> 4;
+        he || D(3), c += he & 15;
+        var x = bt[pe];
+        if (pe > 3) {
+          var z = Ze[pe];
+          x += we(r, c) & (1 << z) - 1, c += z;
+        }
+        if (c > g) {
+          f && D(0);
+          break;
+        }
+        a && l(_ + 131072);
+        var ke = _ + Ie;
+        if (_ < x) {
+          var Fe = n - x, lt = Math.min(x, ke);
+          for (Fe + _ < 0 && D(3); _ < lt; ++_)
+            t[_] = i[Fe + _];
+        }
+        for (; _ < ke; ++_)
+          t[_] = t[_ - x];
+      }
+    }
+    e.l = d, e.p = de, e.b = _, e.f = u, d && (u = 1, e.m = h, e.d = p, e.n = R);
+  } while (!u);
+  return _ != t.length && s ? Tt(t, 0, _) : t.subarray(0, _);
+}, Bt = /* @__PURE__ */ new E(0), It = function(r) {
+  (r[0] != 31 || r[1] != 139 || r[2] != 8) && D(6, "invalid gzip data");
+  var e = r[3], t = 10;
+  e & 4 && (t += (r[10] | r[11] << 8) + 2);
+  for (var i = (e >> 3 & 1) + (e >> 4 & 1); i > 0; i -= !r[t++])
+    ;
+  return t + (e & 2);
+}, kt = function(r) {
+  var e = r.length;
+  return (r[e - 4] | r[e - 3] << 8 | r[e - 2] << 16 | r[e - 1] << 24) >>> 0;
+};
+function Ft(r, e) {
+  var t = It(r);
+  return t + 8 > r.length && D(6, "invalid gzip data"), Ct(r.subarray(t, -8), { i: 2 }, new E(kt(r)), e);
+}
+var Mt = typeof TextDecoder < "u" && /* @__PURE__ */ new TextDecoder(), Lt = 0;
+try {
+  Mt.decode(Bt, { stream: !0 }), Lt = 1;
+} catch {
+}
+class We {
+  buffer;
+  onMessage;
+  constructor(e) {
+    this.onMessage = e, this.buffer = new Uint8Array();
+  }
+  push(e) {
+    this.buffer = Pt(this.buffer, e);
+    let t = 0;
+    for (; t < this.buffer.length; )
+      try {
+        const { value: i, nextOffset: o } = fe(this.buffer, t);
+        t = o, this.onMessage(i);
+      } catch (i) {
+        if (i.incomplete) break;
+        throw i;
+      }
+    t > 0 && (this.buffer = this.buffer.slice(t));
+  }
+}
+function Pt(r, e) {
+  const t = new Uint8Array(r.length + e.length);
+  return t.set(r, 0), t.set(e, r.length), t;
+}
+function T() {
+  const r = new Error("incomplete msgpack buffer");
+  return r.incomplete = !0, r;
+}
+function fe(r, e) {
+  if (e >= r.length) throw T();
+  const t = r[e];
+  if (t <= 127) return { value: t, nextOffset: e + 1 };
+  if (t >= 128 && t <= 143) return Oe(r, e, t & 15, 1);
+  if (t >= 144 && t <= 159) return Ee(r, e, t & 15, 1);
+  if (t >= 160 && t <= 191) return ie(r, e, t & 31, 1);
+  if (t >= 224) return { value: t - 256, nextOffset: e + 1 };
+  switch (t) {
+    case 192:
+      return { value: null, nextOffset: e + 1 };
+    case 194:
+      return { value: !1, nextOffset: e + 1 };
+    case 195:
+      return { value: !0, nextOffset: e + 1 };
+    case 199:
+      return Ne(r, e, Se(r, e + 1, 1), 3);
+    case 200:
+      return Ne(r, e, Se(r, e + 1, 2), 4);
+    case 201:
+      return Ne(r, e, Se(r, e + 1, 4), 6);
+    case 204:
+      return ae(r, e, 1, !1);
+    case 205:
+      return ae(r, e, 2, !1);
+    case 206:
+      return ae(r, e, 4, !1);
+    case 207:
+      return ae(r, e, 8, !0);
+    case 208:
+      return oe(r, e, 1);
+    case 209:
+      return oe(r, e, 2);
+    case 210:
+      return oe(r, e, 4);
+    case 211:
+      return oe(r, e, 8);
+    case 212:
+      return W(r, e, 1);
+    case 213:
+      return W(r, e, 2);
+    case 214:
+      return W(r, e, 4);
+    case 215:
+      return W(r, e, 8);
+    case 216:
+      return W(r, e, 16);
+    case 217:
+      return ie(r, e, r[e + 1], 2);
+    case 218:
+      return ie(r, e, Y(r, e + 1), 3);
+    case 219:
+      return ie(r, e, X(r, e + 1), 5);
+    case 220:
+      return Ee(r, e, Y(r, e + 1), 3);
+    case 221:
+      return Ee(r, e, X(r, e + 1), 5);
+    case 222:
+      return Oe(r, e, Y(r, e + 1), 3);
+    case 223:
+      return Oe(r, e, X(r, e + 1), 5);
+    case 196:
+      return me(r, e, r[e + 1], 2);
+    case 197:
+      return me(r, e, Y(r, e + 1), 3);
+    case 198:
+      return me(r, e, X(r, e + 1), 5);
+    case 203:
+      return Vt(r, e, 8);
+    default:
+      throw new Error(`Unsupported msgpack type: 0x${t.toString(16)}`);
+  }
+}
+function me(r, e, t, i) {
+  const o = e + i, n = o + t;
+  if (n > r.length) throw T();
+  return { value: r.slice(o, n), nextOffset: n };
+}
+function ie(r, e, t, i) {
+  const o = e + i, n = o + t;
+  if (n > r.length) throw T();
+  return { value: new TextDecoder().decode(r.slice(o, n)), nextOffset: n };
+}
+function Ee(r, e, t, i) {
+  let o = e + i;
+  const n = [];
+  for (let s = 0; s < t; s += 1) {
+    const { value: a, nextOffset: f } = fe(r, o);
+    n.push(a), o = f;
+  }
+  return { value: n, nextOffset: o };
+}
+function Oe(r, e, t, i) {
+  let o = e + i;
+  const n = {};
+  for (let s = 0; s < t; s += 1) {
+    const a = fe(r, o), f = fe(r, a.nextOffset);
+    n[String(a.value)] = f.value, o = f.nextOffset;
+  }
+  return { value: n, nextOffset: o };
+}
+function W(r, e, t) {
+  const i = e + 2, o = i + t;
+  if (o > r.length) throw T();
+  const n = r.slice(i, o);
+  return { value: { type: r[e + 1], data: n }, nextOffset: o };
+}
+function Ne(r, e, t, i) {
+  const o = r[e + i - 1], n = e + i, s = n + t;
+  if (s > r.length) throw T();
+  const a = r.slice(n, s);
+  return { value: { type: o, data: a }, nextOffset: s };
+}
+function ae(r, e, t, i) {
+  const o = e + 1, n = o + t;
+  if (n > r.length) throw T();
+  const s = new DataView(r.slice(o, n).buffer);
+  let a;
+  return t === 1 ? a = s.getUint8(0) : t === 2 ? a = s.getUint16(0) : t === 4 ? a = s.getUint32(0) : a = s.getBigUint64(0), { value: i ? a : Number(a), nextOffset: n };
+}
+function oe(r, e, t) {
+  const i = e + 1, o = i + t;
+  if (o > r.length) throw T();
+  const n = new DataView(r.slice(i, o).buffer);
+  let s;
+  return t === 1 ? s = n.getInt8(0) : t === 2 ? s = n.getInt16(0) : t === 4 ? s = n.getInt32(0) : s = n.getBigInt64(0), { value: Number(s), nextOffset: o };
+}
+function Vt(r, e, t) {
+  const i = e + 1, o = i + t;
+  if (o > r.length) throw T();
+  const n = new DataView(r.slice(i, o).buffer);
+  return { value: t === 4 ? n.getFloat32(0) : n.getFloat64(0), nextOffset: o };
+}
+function Se(r, e, t) {
+  const i = e;
+  if (i + t > r.length) throw T();
+  return t === 1 ? r[i] : t === 2 ? Y(r, i) : X(r, i);
+}
+function Y(r, e) {
+  return r[e] << 8 | r[e + 1];
+}
+function X(r, e) {
+  return r[e] * 16777216 + (r[e + 1] << 16 | r[e + 2] << 8 | r[e + 3]);
+}
+let q = null, v = null, Ae = null;
+const jt = new TextDecoder();
+let Q = "", le = !1, $ = null, H = null;
+self.addEventListener("error", (r) => {
+  if (le) return;
+  le = !0;
+  const e = r.message || String(r.error || "worker error"), t = r.error?.stack;
   try {
-    postMessage({ type: "start-error", message: e ? `${t}
-${e}` : t }), postMessage({ type: "exit", code: 1, lastStderr: E });
+    postMessage({ type: "start-error", message: t ? `${e}
+${t}` : e }), postMessage({ type: "exit", code: 1, lastStderr: Q });
   } catch {
   }
 });
-self.addEventListener("unhandledrejection", (n) => {
-  if (R) return;
-  R = !0;
-  const t = n.reason, e = t && (t.message || String(t)) || "unhandled rejection", r = t?.stack;
+self.addEventListener("unhandledrejection", (r) => {
+  if (le) return;
+  le = !0;
+  const e = r.reason, t = e && (e.message || String(e)) || "unhandled rejection", i = e?.stack;
   try {
-    postMessage({ type: "start-error", message: r ? `${e}
-${r}` : e }), postMessage({ type: "exit", code: 1, lastStderr: E });
+    postMessage({ type: "start-error", message: i ? `${t}
+${i}` : t }), postMessage({ type: "exit", code: 1, lastStderr: Q });
   } catch {
   }
 });
-self.onmessage = (n) => {
-  const { type: t } = n.data || {};
-  if (t === "start")
-    et(n.data).catch((e) => {
-      postMessage({ type: "start-error", message: e?.message || String(e) }), postMessage({ type: "exit", code: 1 });
+self.onmessage = (r) => {
+  const { type: e } = r.data || {};
+  if (e === "start")
+    Gt(r.data).catch((t) => {
+      postMessage({ type: "start-error", message: t?.message || String(t) }), postMessage({ type: "exit", code: 1 });
     });
-  else if (t === "stop") {
+  else if (e === "stop") {
     try {
-      f?.wasiImport?.proc_exit?.(0);
+      v?.wasiImport?.proc_exit?.(0);
     } catch {
     }
-    U = null;
+    Ae = null;
   }
 };
-class tt extends C {
+class zt extends ue {
   ctrl;
   data;
   capacity;
-  constructor(t) {
-    super(), this.ctrl = new Int32Array(t, 0, 2), this.data = new Uint8Array(t, 8), this.capacity = this.data.length;
+  constructor(e) {
+    super(), this.ctrl = new Int32Array(e, 0, 2), this.data = new Uint8Array(e, 8), this.capacity = this.data.length;
   }
   fd_fdstat_get() {
-    const t = new j(H, 0);
-    return t.fs_rights_base = BigInt(Q | G), { ret: m, fdstat: t };
+    const e = new ce(j, 0);
+    return e.fs_rights_base = BigInt(66), { ret: 0, fdstat: e };
   }
   fd_close() {
-    return m;
-  }
-  fd_read(t) {
-    const e = Math.min(Math.max(0, Number(t) || 0), this.capacity);
-    if (e === 0) return { ret: L, data: new Uint8Array() };
-    let r = Atomics.load(this.ctrl, 0);
-    const s = Atomics.load(this.ctrl, 1);
-    if (r === s) return { ret: L, data: new Uint8Array() };
-    const a = new Uint8Array(e);
-    let o = 0;
-    for (; r !== s && o < e; )
-      a[o++] = this.data[r], r = (r + 1) % this.capacity;
-    return Atomics.store(this.ctrl, 0, r), { ret: m, data: a.slice(0, o) };
+    return 0;
+  }
+  fd_read(e) {
+    const t = Math.min(Math.max(0, Number(e) || 0), this.capacity);
+    if (t === 0) return { ret: 6, data: new Uint8Array() };
+    let i = Atomics.load(this.ctrl, 0);
+    const o = Atomics.load(this.ctrl, 1);
+    if (i === o) return { ret: 6, data: new Uint8Array() };
+    const n = new Uint8Array(t);
+    let s = 0;
+    for (; i !== o && s < t; )
+      n[s++] = this.data[i], i = (i + 1) % this.capacity;
+    return Atomics.store(this.ctrl, 0, i), { ret: 0, data: n.slice(0, s) };
   }
   fd_write() {
-    return { ret: w, nwritten: 0 };
+    return { ret: 8, nwritten: 0 };
   }
   fd_seek() {
-    return { ret: w, offset: 0n };
+    return { ret: 8, offset: 0n };
   }
   fd_tell() {
-    return { ret: w, offset: 0n };
+    return { ret: 8, offset: 0n };
   }
   fd_pread() {
-    return { ret: w, data: new Uint8Array() };
+    return { ret: 8, data: new Uint8Array() };
   }
   fd_pwrite() {
-    return { ret: w, nwritten: 0 };
+    return { ret: 8, nwritten: 0 };
   }
 }
-class O extends C {
+class $e extends ue {
   onWrite;
-  constructor(t) {
-    super(), this.onWrite = t;
+  constructor(e) {
+    super(), this.onWrite = e;
   }
   fd_fdstat_get() {
-    const t = new j(H, 0);
-    return t.fs_rights_base = BigInt(G), { ret: m, fdstat: t };
+    const e = new ce(j, 0);
+    return e.fs_rights_base = BigInt(64), { ret: 0, fdstat: e };
   }
-  fd_write(t) {
-    return this.onWrite(new Uint8Array(t)), { ret: m, nwritten: t.byteLength };
+  fd_write(e) {
+    return this.onWrite(new Uint8Array(e)), { ret: 0, nwritten: e.byteLength };
   }
   fd_close() {
-    return m;
+    return 0;
   }
 }
-async function et({ cols: n, rows: t, wasmPath: e, runtimePath: r, inputBuffer: s, env: a, files: o }) {
-  let c = 1;
+async function Gt({ cols: r, rows: e, wasmPath: t, runtimePath: i, inputBuffer: o, env: n, files: s }) {
+  let a = 1;
   try {
-    if (!s) {
+    if (!o) {
       postMessage({ type: "start-error", message: "input buffer missing" }), postMessage({ type: "exit", code: 1 });
       return;
     }
-    v = null, U = new tt(s);
-    const l = await nt(e), i = await rt(r), p = lt(i, () => {
+    q = null, Ae = new zt(o);
+    const f = await Wt(t), l = await $t(i), u = Jt(l, () => {
     });
-    o && Array.isArray(o) && o.length && st(p, o);
-    const u = U, k = new O(at), d = new O((S) => {
-      const y = Z.decode(S);
-      y && (E = (E + y).slice(-8192)), postMessage({ type: "stderr", message: y });
-    }), _ = new W("nvim", p.contents), D = p.contents.get("tmp")?.contents || /* @__PURE__ */ new Map(), h = new W("tmp", D), X = ["nvim", "--headless", "--embed", "-u", "NORC", "--noplugin", "-i", "NONE", "-n"], F = [
+    s && Array.isArray(s) && s.length && Ht(u, s);
+    const c = Ae, _ = new $e(Yt), d = new $e((k) => {
+      const b = jt.decode(k);
+      b && (Q = (Q + b).slice(-8192)), postMessage({ type: "stderr", message: b });
+    }), p = new Ke("nvim", u.contents), R = u.contents.get("tmp")?.contents || /* @__PURE__ */ new Map(), g = new Ke("tmp", R), N = ["nvim", "--headless", "--embed", "-u", "NORC", "--noplugin", "-i", "NONE", "-n"], m = [
       "VIMRUNTIME=/nvim/runtime",
       "HOME=/nvim/home",
       "PWD=/nvim",
@@ -117,166 +1436,166 @@ async function et({ cols: n, rows: t, wasmPath: e, runtimePath: r, inputBuffer:
       "XDG_STATE_HOME=/nvim/home/.local/state",
       "PATH=/usr/bin:/bin",
       "TMPDIR=/nvim/tmp",
-      `COLUMNS=${n || 120}`,
-      `LINES=${t || 40}`
+      `COLUMNS=${r || 120}`,
+      `LINES=${e || 40}`
     ];
-    if (a && typeof a == "object")
-      for (const [S, y] of Object.entries(a))
-        S && F.push(`${S}=${String(y ?? "")}`);
-    f = new Y(X, F, [u, k, d, _, h], { debug: !1 }), f.fds[0] = u, f.fds[1] = k, f.fds[2] = d, f.fds[3] = _, f.fds[4] = h, f.preopens = { "/nvim": _, "/tmp": h };
-    const q = pt(() => f?.wasiImport?.proc_exit?.(1)), T = await WebAssembly.instantiate(l, {
-      wasi_snapshot_preview1: f.wasiImport,
-      env: q
-    }), V = T.instance ?? T.instance;
-    c = f.start(V);
-  } catch (l) {
-    const i = l?.message || String(l), p = l?.stack;
-    postMessage({ type: "start-error", message: p ? `${i}
-${p}` : i });
-  }
-  postMessage({ type: "exit", code: c, lastStderr: E });
-}
-async function nt(n) {
-  if (g && g.url === n && g.bytes?.byteLength) return g.bytes;
-  const t = await z(n);
-  return g = { url: n, bytes: t }, t;
-}
-async function rt(n) {
-  if (A && A.url === n && A.entries?.length) return A.entries;
-  const t = await z(n);
-  let e;
-  if (it(t))
+    if (n && typeof n == "object")
+      for (const [k, b] of Object.entries(n))
+        k && m.push(`${k}=${String(b ?? "")}`);
+    v = new mt(N, m, [c, _, d, p, g], { debug: !1 }), v.fds[0] = c, v.fds[1] = _, v.fds[2] = d, v.fds[3] = p, v.fds[4] = g, v.preopens = { "/nvim": p, "/tmp": g };
+    const I = Qt(() => v?.wasiImport?.proc_exit?.(1)), M = await WebAssembly.instantiate(f, {
+      wasi_snapshot_preview1: v.wasiImport,
+      env: I
+    }), ne = M.instance ?? M.instance;
+    a = v.start(ne);
+  } catch (f) {
+    const l = f?.message || String(f), u = f?.stack;
+    postMessage({ type: "start-error", message: u ? `${l}
+${u}` : l });
+  }
+  postMessage({ type: "exit", code: a, lastStderr: Q });
+}
+async function Wt(r) {
+  if ($ && $.url === r && $.bytes?.byteLength) return $.bytes;
+  const e = await st(r);
+  return $ = { url: r, bytes: e }, e;
+}
+async function $t(r) {
+  if (H && H.url === r && H.entries?.length) return H.entries;
+  const e = await st(r);
+  let t;
+  if (Xt(e))
     try {
-      e = J(t);
-    } catch (s) {
-      throw new Error(`gunzip runtime failed: ${s?.message ?? s}`);
+      t = Ft(e);
+    } catch (o) {
+      throw new Error(`gunzip runtime failed: ${o?.message ?? o}`);
     }
   else
-    e = t;
-  let r;
+    t = e;
+  let i;
   try {
-    r = ct(e);
-  } catch (s) {
-    throw new Error(`untar runtime failed: ${s?.message ?? s}`);
-  }
-  return A = { url: n, entries: r }, r;
-}
-function st(n, t) {
-  for (const e of t) {
-    const s = String(e?.path ?? "").replace(/^\/+/, "").replace(/^\.\/+/, "");
-    if (!s || s.endsWith("/")) continue;
-    const a = ot(e?.data);
-    if (!a) continue;
-    const o = s.split("/").filter(Boolean);
-    if (!o.length) continue;
-    let c = n;
-    for (let i = 0; i < o.length - 1; i += 1) {
-      const p = o[i];
-      c.contents.has(p) || c.contents.set(p, new M(/* @__PURE__ */ new Map())), c = c.contents.get(p);
+    i = qt(t);
+  } catch (o) {
+    throw new Error(`untar runtime failed: ${o?.message ?? o}`);
+  }
+  return H = { url: r, entries: i }, i;
+}
+function Ht(r, e) {
+  for (const t of e) {
+    const o = String(t?.path ?? "").replace(/^\/+/, "").replace(/^\.\/+/, "");
+    if (!o || o.endsWith("/")) continue;
+    const n = Kt(t?.data);
+    if (!n) continue;
+    const s = o.split("/").filter(Boolean);
+    if (!s.length) continue;
+    let a = r;
+    for (let l = 0; l < s.length - 1; l += 1) {
+      const u = s[l];
+      a.contents.has(u) || a.contents.set(u, new O(/* @__PURE__ */ new Map())), a = a.contents.get(u);
     }
-    const l = o[o.length - 1];
-    c.contents.set(l, new P(a, { readonly: !1 }));
+    const f = s[s.length - 1];
+    a.contents.set(f, new Te(n, { readonly: !1 }));
   }
 }
-function ot(n) {
-  if (!n) return new Uint8Array();
-  if (n instanceof Uint8Array) return n;
-  if (n instanceof ArrayBuffer) return new Uint8Array(n);
-  if (n instanceof SharedArrayBuffer) return new Uint8Array(n);
-  if (Array.isArray(n)) return new Uint8Array(n);
-  if (n && n.type === "Buffer" && Array.isArray(n.data)) return new Uint8Array(n.data);
+function Kt(r) {
+  if (!r) return new Uint8Array();
+  if (r instanceof Uint8Array) return r;
+  if (r instanceof ArrayBuffer) return new Uint8Array(r);
+  if (r instanceof SharedArrayBuffer) return new Uint8Array(r);
+  if (Array.isArray(r)) return new Uint8Array(r);
+  if (r && r.type === "Buffer" && Array.isArray(r.data)) return new Uint8Array(r.data);
   try {
-    return new TextEncoder().encode(String(n));
+    return new TextEncoder().encode(String(r));
   } catch {
     return null;
   }
 }
-function at(n) {
-  v || (v = new $(B));
+function Yt(r) {
+  q || (q = new We(He));
   try {
-    v.push(n);
+    q.push(r);
   } catch {
-    v = new $(B);
-  }
-}
-function B(n) {
-  if (!Array.isArray(n) || n.length < 1) return;
-  const t = n[0];
-  if (t === 0) {
-    const [, e, r, s] = n;
-    postMessage(r === "wasm-clipboard-paste" ? { type: "clipboard-paste", msgid: e } : { type: "rpc-request", msgid: e, method: r, params: s });
-  } else if (t === 1) {
-    const [, e, r, s] = n;
-    postMessage({ type: "rpc-response", msgid: e, error: r, result: s });
-  } else if (t === 2) {
-    const [, e, r] = n;
-    if (e === "wasm-clipboard-copy") {
-      const s = Array.isArray(r?.[0]) ? r[0] : [], a = typeof r?.[1] == "string" ? r[1] : "v";
-      postMessage({ type: "clipboard-copy", lines: s, regtype: a });
-    } else (e === "nvim_buf_lines_event" || e === "nvim_buf_detach_event" || e === "redraw" || e === "monaco_cursor" || e === "monaco_mode" || e === "monaco_cursorMove" || e === "monaco_scroll" || e === "monaco_reveal" || e === "monaco_moveCursor" || e === "monaco_scrolloff" || e === "monaco_host_command" || e === "monaco_buf_enter" || e === "monaco_buf_delete") && postMessage({ type: "rpc-notify", method: e, params: r });
-  }
-}
-async function z(n) {
-  const t = await fetch(n);
-  if (!t.ok) throw new Error(`fetch ${n} failed (${t.status})`);
-  if ((t.headers.get("content-type") || "").toLowerCase().includes("text/html")) throw new Error(`fetch ${n} returned HTML (likely wrong path or dev server fallback)`);
-  const r = new Uint8Array(await t.arrayBuffer());
-  if (!r.byteLength) throw new Error(`fetch ${n} returned empty body`);
-  return r;
-}
-function it(n) {
-  return n && n.length >= 2 && n[0] === 31 && n[1] === 139;
-}
-function ct(n) {
-  const t = [], e = n instanceof Uint8Array ? n : new Uint8Array(n);
-  let r = 0;
-  const s = new TextDecoder();
-  let a = 0;
-  for (; r + 512 <= e.length; ) {
-    if (a++ > 1e5) throw new Error("untar safety break");
-    const o = I(s, e, r, 100), c = I(s, e, r + 124, 12), l = e[r + 156], i = I(s, e, r + 345, 155);
-    if (!o && !i) break;
-    const p = c.trim() || "0", u = parseInt(p, 8);
-    if (!Number.isFinite(u) || u < 0) throw new Error(`invalid tar size: ${p}`);
-    const k = i ? `${i}/${o}` : o, d = r + 512, _ = d + u, x = e.slice(d, _);
-    t.push({ name: k, type: l === 53 ? "dir" : "file", data: x });
-    const D = Math.ceil(u / 512), h = d + D * 512;
-    if (h <= r) throw new Error("tar parse did not advance");
-    r = h;
-  }
-  return t;
-}
-function I(n, t, e, r) {
-  let s = e;
-  const a = e + r;
-  for (; s < a && t[s] !== 0; ) s += 1;
-  return n.decode(t.subarray(e, s)).trim();
-}
-function lt(n, t) {
-  const e = new M(/* @__PURE__ */ new Map());
-  for (const r of n) {
-    const s = r.name.replace(/^\.\/?/, "");
-    if (!s) continue;
-    const a = s.split("/").filter(Boolean);
-    if (!a.length) continue;
-    let o = e;
-    for (let l = 0; l < a.length - 1; l += 1) {
-      const i = a[l];
-      o.contents.has(i) || o.contents.set(i, new M(/* @__PURE__ */ new Map())), o = o.contents.get(i);
+    q = new We(He);
+  }
+}
+function He(r) {
+  if (!Array.isArray(r) || r.length < 1) return;
+  const e = r[0];
+  if (e === 0) {
+    const [, t, i, o] = r;
+    postMessage(i === "wasm-clipboard-paste" ? { type: "clipboard-paste", msgid: t } : { type: "rpc-request", msgid: t, method: i, params: o });
+  } else if (e === 1) {
+    const [, t, i, o] = r;
+    postMessage({ type: "rpc-response", msgid: t, error: i, result: o });
+  } else if (e === 2) {
+    const [, t, i] = r;
+    if (t === "wasm-clipboard-copy") {
+      const o = Array.isArray(i?.[0]) ? i[0] : [], n = typeof i?.[1] == "string" ? i[1] : "v";
+      postMessage({ type: "clipboard-copy", lines: o, regtype: n });
+    } else (t === "nvim_buf_lines_event" || t === "nvim_buf_detach_event" || t === "redraw" || t === "monaco_cursor" || t === "monaco_mode" || t === "monaco_cursorMove" || t === "monaco_scroll" || t === "monaco_reveal" || t === "monaco_moveCursor" || t === "monaco_scrolloff" || t === "monaco_host_command" || t === "monaco_buf_enter" || t === "monaco_buf_delete") && postMessage({ type: "rpc-notify", method: t, params: i });
+  }
+}
+async function st(r) {
+  const e = await fetch(r);
+  if (!e.ok) throw new Error(`fetch ${r} failed (${e.status})`);
+  if ((e.headers.get("content-type") || "").toLowerCase().includes("text/html")) throw new Error(`fetch ${r} returned HTML (likely wrong path or dev server fallback)`);
+  const i = new Uint8Array(await e.arrayBuffer());
+  if (!i.byteLength) throw new Error(`fetch ${r} returned empty body`);
+  return i;
+}
+function Xt(r) {
+  return r && r.length >= 2 && r[0] === 31 && r[1] === 139;
+}
+function qt(r) {
+  const e = [], t = r instanceof Uint8Array ? r : new Uint8Array(r);
+  let i = 0;
+  const o = new TextDecoder();
+  let n = 0;
+  for (; i + 512 <= t.length; ) {
+    if (n++ > 1e5) throw new Error("untar safety break");
+    const s = Ue(o, t, i, 100), a = Ue(o, t, i + 124, 12), f = t[i + 156], l = Ue(o, t, i + 345, 155);
+    if (!s && !l) break;
+    const u = a.trim() || "0", c = parseInt(u, 8);
+    if (!Number.isFinite(c) || c < 0) throw new Error(`invalid tar size: ${u}`);
+    const _ = l ? `${l}/${s}` : s, d = i + 512, p = d + c, h = t.slice(d, p);
+    e.push({ name: _, type: f === 53 ? "dir" : "file", data: h });
+    const R = Math.ceil(c / 512), g = d + R * 512;
+    if (g <= i) throw new Error("tar parse did not advance");
+    i = g;
+  }
+  return e;
+}
+function Ue(r, e, t, i) {
+  let o = t;
+  const n = t + i;
+  for (; o < n && e[o] !== 0; ) o += 1;
+  return r.decode(e.subarray(t, o)).trim();
+}
+function Jt(r, e) {
+  const t = new O(/* @__PURE__ */ new Map());
+  for (const i of r) {
+    const o = i.name.replace(/^\.\/?/, "");
+    if (!o) continue;
+    const n = o.split("/").filter(Boolean);
+    if (!n.length) continue;
+    let s = t;
+    for (let f = 0; f < n.length - 1; f += 1) {
+      const l = n[f];
+      s.contents.has(l) || s.contents.set(l, new O(/* @__PURE__ */ new Map())), s = s.contents.get(l);
     }
-    const c = a[a.length - 1];
-    r.type === "dir" ? o.contents.has(c) || o.contents.set(c, new M(/* @__PURE__ */ new Map())) : o.contents.set(c, new P(r.data, { readonly: !0 }));
+    const a = n[n.length - 1];
+    i.type === "dir" ? s.contents.has(a) || s.contents.set(a, new O(/* @__PURE__ */ new Map())) : s.contents.set(a, new Te(i.data, { readonly: !0 }));
   }
-  return b(e, "home"), b(e, "tmp"), b(e, "home/.config"), b(e, "home/.local/share"), b(e, "home/.local/state"), e;
+  return K(t, "home"), K(t, "tmp"), K(t, "home/.config"), K(t, "home/.local/share"), K(t, "home/.local/state"), t;
 }
-function b(n, t) {
-  const e = t.split("/").filter(Boolean);
-  let r = n;
-  for (const s of e)
-    r.contents.has(s) || r.contents.set(s, new M(/* @__PURE__ */ new Map())), r = r.contents.get(s);
+function K(r, e) {
+  const t = e.split("/").filter(Boolean);
+  let i = r;
+  for (const o of t)
+    i.contents.has(o) || i.contents.set(o, new O(/* @__PURE__ */ new Map())), i = i.contents.get(o);
 }
-function pt(n) {
-  const t = WebAssembly, e = new t.Tag({ parameters: ["i32"], results: [] });
+function Qt(r) {
+  const e = WebAssembly, t = new e.Tag({ parameters: ["i32"], results: [] });
   return {
     flock: () => 0,
     getpid: () => 1,
@@ -286,8 +1605,8 @@ function pt(n) {
     uv_utf16_length_as_wtf8: () => 0,
     uv_utf16_to_wtf8: () => -38,
     uv_wtf8_length_as_utf16: () => 0,
-    __wasm_longjmp: (r) => {
-      throw n && n(1), new t.Exception(e, [r ?? 0]);
+    __wasm_longjmp: (i) => {
+      throw r && r(1), new e.Exception(t, [i ?? 0]);
     },
     __wasm_setjmp: () => 0,
     __wasm_setjmp_test: () => 0,
@@ -295,36 +1614,36 @@ function pt(n) {
     clock: () => 0,
     system: () => -1,
     tmpnam: () => 0,
-    __c_longjmp: e
+    __c_longjmp: t
   };
 }
-class W extends N {
-  #t(t) {
-    return t.replace(/^\/+/, "");
+class Ke extends Ge {
+  #e(e) {
+    return e.replace(/^\/+/, "");
   }
-  path_open(t, e, r, s, a, o) {
-    return super.path_open(t, this.#t(e), r, s, a, o);
+  path_open(e, t, i, o, n, s) {
+    return super.path_open(e, this.#e(t), i, o, n, s);
   }
-  path_filestat_get(t, e) {
-    return super.path_filestat_get(t, this.#t(e));
+  path_filestat_get(e, t) {
+    return super.path_filestat_get(e, this.#e(t));
   }
-  path_create_directory(t) {
-    return super.path_create_directory(this.#t(t));
+  path_create_directory(e) {
+    return super.path_create_directory(this.#e(e));
   }
-  path_unlink_file(t) {
-    return super.path_unlink_file(this.#t(t));
+  path_unlink_file(e) {
+    return super.path_unlink_file(this.#e(e));
   }
-  path_remove_directory(t) {
-    return super.path_remove_directory(this.#t(t));
+  path_remove_directory(e) {
+    return super.path_remove_directory(this.#e(e));
   }
-  path_link(t, e, r) {
-    return super.path_link(this.#t(t), e, r);
+  path_link(e, t, i) {
+    return super.path_link(this.#e(e), t, i);
   }
-  path_readlink(t) {
-    return super.path_readlink(this.#t(t));
+  path_readlink(e) {
+    return super.path_readlink(this.#e(e));
   }
-  path_symlink(t, e) {
-    const r = N.prototype.path_symlink;
-    return r ? r.call(this, this.#t(t), this.#t(e)) : K;
+  path_symlink(e, t) {
+    const i = Ge.prototype.path_symlink;
+    return i ? i.call(this, this.#e(e), this.#e(t)) : 58;
   }
 }