@monaco-neovim-wasm/lib 0.1.6

package/dist/nvimWorkerAsyncify.js

@@ -0,0 +1,461 @@
+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;
+  try {
+    postMessage({ type: "start-error", message: n ? `${e}
+${n}` : e }), postMessage({ type: "exit", code: 1, lastStderr: W });
+  } 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;
+  try {
+    postMessage({ type: "start-error", message: s ? `${n}
+${s}` : n }), postMessage({ type: "exit", code: 1, lastStderr: W });
+  } catch {
+  }
+});
+self.onmessage = (t) => {
+  const { type: e } = t.data || {};
+  if (e === "start")
+    Dt(t.data).catch((n) => {
+      postMessage({ type: "start-error", message: n?.message || String(n) }), 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);
+  } else if (e === "stop") {
+    try {
+      f?.close();
+    } catch {
+    }
+    try {
+      _?.wasiImport?.proc_exit?.(0);
+    } catch {
+    }
+    f = null;
+  }
+};
+class Mt extends at {
+  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 };
+  }
+  fd_close() {
+    return this.close(), w;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = !0;
+    const e = this.waiters;
+    this.waiters = [];
+    for (const n of e) n();
+  }
+  push(e) {
+    if (this.closed || !e?.byteLength) return;
+    this.chunks.push(e), this.total += e.byteLength;
+    const n = this.waiters;
+    this.waiters = [];
+    for (const s of n) s();
+  }
+  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);
+    }
+    return this.total -= r, { ret: w, data: s };
+  }
+  fd_write() {
+    return { ret: T, nwritten: 0 };
+  }
+  fd_seek() {
+    return { ret: T, offset: 0n };
+  }
+  fd_tell() {
+    return { ret: T, offset: 0n };
+  }
+  fd_pread() {
+    return { ret: T, data: new Uint8Array() };
+  }
+  fd_pwrite() {
+    return { ret: T, nwritten: 0 };
+  }
+}
+class tt extends at {
+  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 };
+  }
+  fd_write(e) {
+    return this.onWrite(new Uint8Array(e)), { ret: w, nwritten: e.byteLength };
+  }
+  fd_close() {
+    return w;
+  }
+}
+async function Dt({ cols: t, rows: e, wasmPath: n, runtimePath: s, env: r, files: o }) {
+  let i = 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, () => {
+    });
+    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 = [
+      "VIMRUNTIME=/nvim/runtime",
+      "HOME=/nvim/home",
+      "PWD=/nvim",
+      "XDG_CONFIG_HOME=/nvim/home/.config",
+      "XDG_DATA_HOME=/nvim/home/.local/share",
+      "XDG_STATE_HOME=/nvim/home/.local/state",
+      "PATH=/usr/bin:/bin",
+      "TMPDIR=/nvim/tmp",
+      `COLUMNS=${t || 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,
+      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;
+    else {
+      const y = a?.message || String(a), c = a?.stack;
+      postMessage({ type: "start-error", message: c ? `${y}
+${c}` : y });
+    }
+  }
+  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 });
+        continue;
+      }
+      if (D === 0) {
+        !!(f && (f.total > 0 || f.closed)) ? h.push({ userdata: d, eventtype: p }) : E = !0;
+        continue;
+      }
+      h.push({ userdata: d, eventtype: p });
+      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 });
+      else {
+        const X = $ - U;
+        (b === null || X < b) && (b = X);
+      }
+      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 typeof s == "number" && m.setUint32(s, l, !0), w;
+  }
+  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))));
+  }
+  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));
+}
+function Rt() {
+  return !f || f.closed || f.total > 0 ? Promise.resolve() : (B || (B = f.waitForData().finally(() => {
+    B = null;
+  })), B);
+}
+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();
+    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();
+}
+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 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 et() {
+  !u?.asyncify_get_state || !u?.asyncify_stop_rewind || u.asyncify_get_state() === 2 && (u.asyncify_stop_rewind(), z());
+}
+async function Tt(t) {
+  for (; ; ) {
+    try {
+      t._start();
+    } catch (s) {
+      if (s instanceof rt) return s.code;
+      throw s;
+    }
+    const e = t.asyncify_get_state();
+    if (e === 0) return 0;
+    if (e === 2) {
+      t.asyncify_stop_rewind(), z();
+      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))
+    try {
+      n = gt(e);
+    } catch (r) {
+      throw new Error(`gunzip runtime failed: ${r?.message ?? r}`);
+    }
+  else
+    n = e;
+  let s;
+  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);
+    }
+    const y = i[i.length - 1];
+    a.contents.set(y, new ot(o, { 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);
+  try {
+    return new TextEncoder().encode(String(t));
+  } catch {
+    return null;
+  }
+}
+function Ft(t) {
+  F || (F = new Q(nt));
+  try {
+    F.push(t);
+  } catch {
+    F = new Q(nt);
+  }
+}
+function nt(t) {
+  if (!Array.isArray(t) || t.length < 1) return;
+  const e = t[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 });
+  } else if (e === 1) {
+    const [, n, s, r] = t;
+    postMessage({ type: "rpc-response", msgid: n, error: s, result: r });
+  } 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;
+  }
+  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 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);
+    }
+    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 }));
+  }
+  return P(n, "home"), P(n, "tmp"), P(n, "home/.config"), P(n, "home/.local/share"), P(n, "home/.local/state"), n;
+}
+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 xt(t) {
+  const e = WebAssembly, n = new e.Tag({ parameters: ["i32"], results: [] });
+  return {
+    flock: () => 0,
+    getpid: () => 1,
+    uv_random: () => -38,
+    uv_wtf8_to_utf16: () => {
+    },
+    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_setjmp: () => 0,
+    __wasm_setjmp_test: () => 0,
+    tmpfile: () => 0,
+    clock: () => 0,
+    system: () => -1,
+    tmpnam: () => 0,
+    __c_longjmp: n
+  };
+}
+class st extends Z {
+  #t(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_filestat_get(e, n) {
+    return super.path_filestat_get(e, this.#t(n));
+  }
+  path_create_directory(e) {
+    return super.path_create_directory(this.#t(e));
+  }
+  path_unlink_file(e) {
+    return super.path_unlink_file(this.#t(e));
+  }
+  path_remove_directory(e) {
+    return super.path_remove_directory(this.#t(e));
+  }
+  path_link(e, n, s) {
+    return super.path_link(this.#t(e), n, s);
+  }
+  path_readlink(e) {
+    return super.path_readlink(this.#t(e));
+  }
+  path_symlink(e, n) {
+    const s = Z.prototype.path_symlink;
+    return s ? s.call(this, this.#t(e), this.#t(n)) : it;
+  }
+}

package/dist/sharedInput.d.ts

@@ -0,0 +1,10 @@
+export declare class SharedInputRing {
+    readonly buffer: SharedArrayBuffer;
+    readonly ctrl: Int32Array;
+    readonly data: Uint8Array;
+    readonly capacity: number;
+    constructor(capacity?: number);
+    push(bytes: Uint8Array | ArrayBufferLike | ArrayLike<number>): boolean;
+}
+export declare const DEFAULT_SHARED_INPUT_BYTES = 262144;
+export declare function createSharedInputRing(capacity?: number): SharedInputRing;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@monaco-neovim-wasm/lib",
+  "version": "0.1.6",
+  "private": false,
+  "type": "module",
+  "description": "Core library for running Neovim (WASM) behind Monaco via msgpack-RPC.",
+  "scripts": {
+    "build": "vite build && vite build -c vite.worker.config.ts && npm run build:types",
+    "typecheck": "tsc --noEmit",
+    "build:types": "tsc -p tsconfig.build.json"
+  },
+  "dependencies": {
+    "@bjorn3/browser_wasi_shim": "^0.4.2",
+    "fflate": "^0.8.2"
+  },
+  "peerDependencies": {
+    "monaco-editor": "^0.44.0"
+  },
+  "main": "./dist/monaco-neovim-wasm.es.js",
+  "module": "./dist/monaco-neovim-wasm.es.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/monaco-neovim-wasm.es.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ]
+}
+