@monaco-neovim-wasm/lib 0.1.6

package/dist/msgpack.d.ts

@@ -0,0 +1,19 @@
+export type MsgpackExt = {
+    type: number;
+    data: Uint8Array;
+};
+type MsgpackPrimitive = null | boolean | number | bigint | string | Uint8Array | MsgpackExt;
+interface MsgpackValueArray extends Array<MsgpackValue> {
+}
+interface MsgpackValueMap {
+    [key: string]: MsgpackValue;
+}
+export type MsgpackValue = MsgpackPrimitive | MsgpackValueArray | MsgpackValueMap;
+export declare function encode(value: MsgpackValue): Uint8Array;
+export declare class Decoder {
+    private buffer;
+    private readonly onMessage;
+    constructor(onMessage: (value: MsgpackValue) => void);
+    push(chunk: Uint8Array): void;
+}
+export {};

package/dist/neovimWasmSession.d.ts

@@ -0,0 +1,69 @@
+export type NeovimWasmSessionHandlers = {
+    onNotify?: (method: string, params: unknown[]) => void;
+    onRequest?: (msgid: number, method: string, params: unknown[]) => void;
+    onClipboardCopy?: (lines: string[], regtype: string) => void;
+    onClipboardPaste?: (msgid: number) => void;
+    onStderr?: (message?: string) => void;
+    onStartError?: (message?: string) => void;
+    onExit?: (code: number, lastStderr?: string) => void;
+    onWarning?: (message: string) => void;
+};
+export type NeovimWasmInputMode = "shared" | "message";
+export type NeovimWasmSessionInit = {
+    worker?: Worker | null;
+    workerUrl?: URL;
+    createWorker?: (() => Worker) | null;
+    sharedInputBytes?: number;
+    inputMode?: NeovimWasmInputMode;
+    rpcTimeoutMs?: number;
+    maxQueuedBytes?: number;
+    reuseWorker?: boolean;
+    handlers?: NeovimWasmSessionHandlers;
+};
+export type NeovimWasmSessionStartOptions = {
+    cols: number;
+    rows: number;
+    wasmPath: string;
+    runtimePath: string;
+    env?: Record<string, string>;
+    files?: Array<{
+        path: string;
+        data: Uint8Array;
+    }>;
+    inputMode?: NeovimWasmInputMode;
+};
+export declare function isSharedArrayBufferAvailable(): boolean;
+export declare class NeovimWasmSession {
+    private readonly init;
+    private worker;
+    private sharedInput;
+    private inputMode;
+    private reqId;
+    private readonly pending;
+    private workerExited;
+    private workerExitCode;
+    private inputQueue;
+    private inputQueueHead;
+    private inputQueuedBytes;
+    private inputFlushTimer;
+    constructor(init?: NeovimWasmSessionInit);
+    setHandlers(handlers: NeovimWasmSessionHandlers): void;
+    isRunning(): boolean;
+    getExitCode(): number | null;
+    start(options: NeovimWasmSessionStartOptions): Promise<void>;
+    stop(opts?: {
+        terminate?: boolean;
+        silent?: boolean;
+    }): void;
+    dispose(): void;
+    notify(method: string, params?: unknown[]): void;
+    call<T = unknown>(method: string, params?: unknown[]): Promise<T>;
+    waitForApi(): Promise<void>;
+    respond(msgid: number, error: unknown, result: unknown): void;
+    private handleWorkerMessage;
+    private postInput;
+    private enqueueInput;
+    private scheduleFlushInput;
+    private flushInputQueue;
+    private postStdin;
+}

package/dist/nvimWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/nvimWorker.js

@@ -0,0 +1,330 @@
+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;
+  try {
+    postMessage({ type: "start-error", message: e ? `${t}
+${e}` : t }), postMessage({ type: "exit", code: 1, lastStderr: E });
+  } 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;
+  try {
+    postMessage({ type: "start-error", message: r ? `${e}
+${r}` : e }), postMessage({ type: "exit", code: 1, lastStderr: E });
+  } 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 });
+    });
+  else if (t === "stop") {
+    try {
+      f?.wasiImport?.proc_exit?.(0);
+    } catch {
+    }
+    U = null;
+  }
+};
+class tt extends C {
+  ctrl;
+  data;
+  capacity;
+  constructor(t) {
+    super(), this.ctrl = new Int32Array(t, 0, 2), this.data = new Uint8Array(t, 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 };
+  }
+  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) };
+  }
+  fd_write() {
+    return { ret: w, nwritten: 0 };
+  }
+  fd_seek() {
+    return { ret: w, offset: 0n };
+  }
+  fd_tell() {
+    return { ret: w, offset: 0n };
+  }
+  fd_pread() {
+    return { ret: w, data: new Uint8Array() };
+  }
+  fd_pwrite() {
+    return { ret: w, nwritten: 0 };
+  }
+}
+class O extends C {
+  onWrite;
+  constructor(t) {
+    super(), this.onWrite = t;
+  }
+  fd_fdstat_get() {
+    const t = new j(H, 0);
+    return t.fs_rights_base = BigInt(G), { ret: m, fdstat: t };
+  }
+  fd_write(t) {
+    return this.onWrite(new Uint8Array(t)), { ret: m, nwritten: t.byteLength };
+  }
+  fd_close() {
+    return m;
+  }
+}
+async function et({ cols: n, rows: t, wasmPath: e, runtimePath: r, inputBuffer: s, env: a, files: o }) {
+  let c = 1;
+  try {
+    if (!s) {
+      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, () => {
+    });
+    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 = [
+      "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=${n || 120}`,
+      `LINES=${t || 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))
+    try {
+      e = J(t);
+    } catch (s) {
+      throw new Error(`gunzip runtime failed: ${s?.message ?? s}`);
+    }
+  else
+    e = t;
+  let r;
+  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);
+    }
+    const l = o[o.length - 1];
+    c.contents.set(l, new P(a, { 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);
+  try {
+    return new TextEncoder().encode(String(n));
+  } catch {
+    return null;
+  }
+}
+function at(n) {
+  v || (v = new $(B));
+  try {
+    v.push(n);
+  } 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);
+    }
+    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 }));
+  }
+  return b(e, "home"), b(e, "tmp"), b(e, "home/.config"), b(e, "home/.local/share"), b(e, "home/.local/state"), e;
+}
+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 pt(n) {
+  const t = WebAssembly, e = new t.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: (r) => {
+      throw n && n(1), new t.Exception(e, [r ?? 0]);
+    },
+    __wasm_setjmp: () => 0,
+    __wasm_setjmp_test: () => 0,
+    tmpfile: () => 0,
+    clock: () => 0,
+    system: () => -1,
+    tmpnam: () => 0,
+    __c_longjmp: e
+  };
+}
+class W extends N {
+  #t(t) {
+    return t.replace(/^\/+/, "");
+  }
+  path_open(t, e, r, s, a, o) {
+    return super.path_open(t, this.#t(e), r, s, a, o);
+  }
+  path_filestat_get(t, e) {
+    return super.path_filestat_get(t, this.#t(e));
+  }
+  path_create_directory(t) {
+    return super.path_create_directory(this.#t(t));
+  }
+  path_unlink_file(t) {
+    return super.path_unlink_file(this.#t(t));
+  }
+  path_remove_directory(t) {
+    return super.path_remove_directory(this.#t(t));
+  }
+  path_link(t, e, r) {
+    return super.path_link(this.#t(t), e, r);
+  }
+  path_readlink(t) {
+    return super.path_readlink(this.#t(t));
+  }
+  path_symlink(t, e) {
+    const r = N.prototype.path_symlink;
+    return r ? r.call(this, this.#t(t), this.#t(e)) : K;
+  }
+}

package/dist/nvimWorkerAsyncify.d.ts

@@ -0,0 +1 @@
+export {};