@monaco-neovim-wasm/lib 0.1.6 → 0.1.8

package/dist/nvimWorkerAsyncify.js

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