@monaco-neovim-wasm/lib 0.1.6

package/dist/monaco-neovim-wasm.es.js

@@ -0,0 +1,2901 @@
+import * as m from "monaco-editor";
+class W {
+  buffer;
+  ctrl;
+  data;
+  capacity;
+  constructor(t = I) {
+    this.capacity = Math.max(8 * 1024, t | 0), this.buffer = new SharedArrayBuffer(8 + this.capacity), this.ctrl = new Int32Array(this.buffer, 0, 2), this.data = new Uint8Array(this.buffer, 8), Atomics.store(this.ctrl, 0, 0), Atomics.store(this.ctrl, 1, 0);
+  }
+  push(t) {
+    let e;
+    if (t instanceof Uint8Array ? e = t : t instanceof ArrayBuffer || t instanceof SharedArrayBuffer ? e = new Uint8Array(t) : e = new Uint8Array(t), !e.byteLength) return !0;
+    const i = Atomics.load(this.ctrl, 0), s = Atomics.load(this.ctrl, 1), n = s >= i ? s - i : this.capacity - (i - s), o = this.capacity - n - 1;
+    if (e.byteLength > o) return !1;
+    const l = this.capacity - s;
+    return e.byteLength <= l ? (this.data.set(e, s), Atomics.store(this.ctrl, 1, (s + e.byteLength) % this.capacity)) : (this.data.set(e.subarray(0, l), s), this.data.set(e.subarray(l), 0), Atomics.store(this.ctrl, 1, e.byteLength - l)), Atomics.notify(this.ctrl, 1), !0;
+  }
+}
+const I = 262144;
+function z(r = I) {
+  return new W(r);
+}
+function N(r) {
+  const t = [];
+  return x(r, t), new Uint8Array(t);
+}
+function x(r, t) {
+  if (r == null) {
+    t.push(192);
+    return;
+  }
+  if (typeof r == "boolean") {
+    t.push(r ? 195 : 194);
+    return;
+  }
+  if (typeof r == "number") {
+    O(r, t);
+    return;
+  }
+  if (typeof r == "string") {
+    $(r, t);
+    return;
+  }
+  if (typeof r == "bigint") {
+    H(r, t);
+    return;
+  }
+  if (Array.isArray(r)) {
+    V(r, t);
+    return;
+  }
+  if (r instanceof Uint8Array) {
+    U(r, t);
+    return;
+  }
+  if (j(r)) {
+    q(r, t);
+    return;
+  }
+  if (typeof r == "object") {
+    Q(r, t);
+    return;
+  }
+  throw new Error("Unsupported type in msgpack encode");
+}
+function O(r, t) {
+  if (!Number.isFinite(r)) throw new Error("Cannot encode non-finite number");
+  if (Number.isInteger(r)) {
+    if (r >= 0 && r <= 127) {
+      t.push(r);
+      return;
+    }
+    if (r < 0 && r >= -32) {
+      t.push(224 | r + 32);
+      return;
+    }
+    if (r >= -128 && r <= 127) {
+      t.push(208, r + 256 & 255);
+      return;
+    }
+    if (r >= -32768 && r <= 32767) {
+      t.push(209, r >> 8 & 255, r & 255);
+      return;
+    }
+    if (r >= -2147483648 && r <= 2147483647) {
+      t.push(210, r >> 24 & 255, r >> 16 & 255, r >> 8 & 255, r & 255);
+      return;
+    }
+    H(BigInt(r), t);
+    return;
+  }
+  const e = new ArrayBuffer(8);
+  new DataView(e).setFloat64(0, r), t.push(203, ...new Uint8Array(e));
+}
+function H(r, t) {
+  const e = new ArrayBuffer(8);
+  new DataView(e).setBigInt64(0, BigInt(r)), t.push(211, ...new Uint8Array(e));
+}
+function $(r, t) {
+  const i = new TextEncoder().encode(r), s = i.length;
+  s <= 31 ? t.push(160 | s) : s <= 255 ? t.push(217, s) : s <= 65535 ? t.push(218, s >> 8 & 255, s & 255) : t.push(219, s >> 24 & 255, s >> 16 & 255, s >> 8 & 255, s & 255), t.push(...i);
+}
+function U(r, t) {
+  const e = r.length;
+  e <= 255 ? t.push(196, e) : e <= 65535 ? t.push(197, e >> 8 & 255, e & 255) : t.push(198, e >> 24 & 255, e >> 16 & 255, e >> 8 & 255, e & 255), t.push(...r);
+}
+function V(r, t) {
+  const e = r.length;
+  e <= 15 ? t.push(144 | e) : e <= 65535 ? t.push(220, e >> 8 & 255, e & 255) : t.push(221, e >> 24 & 255, e >> 16 & 255, e >> 8 & 255, e & 255);
+  for (const i of r)
+    x(i, t);
+}
+function Q(r, t) {
+  const e = Object.keys(r), i = e.length;
+  i <= 15 ? t.push(128 | i) : i <= 65535 ? t.push(222, i >> 8 & 255, i & 255) : t.push(223, i >> 24 & 255, i >> 16 & 255, i >> 8 & 255, i & 255);
+  for (const s of e)
+    x(s, t), x(r[s], t);
+}
+function q(r, t) {
+  const e = r.data.length;
+  e === 1 ? t.push(212, r.type) : e === 2 ? t.push(213, r.type) : e === 4 ? t.push(214, r.type) : e === 8 ? t.push(215, r.type) : e === 16 ? t.push(216, r.type) : t.push(199, e, r.type);
+  for (let i = 0; i < e; i += 1)
+    t.push(r.data[i]);
+}
+function j(r) {
+  return !!(r && typeof r == "object" && typeof r.type == "number" && r.data instanceof Uint8Array);
+}
+function G() {
+  return typeof SharedArrayBuffer < "u" && typeof crossOriginIsolated < "u" && crossOriginIsolated;
+}
+function Z(r) {
+  return r.byteOffset === 0 && r.byteLength === r.buffer.byteLength ? r : r.slice();
+}
+class Y {
+  init;
+  worker = null;
+  sharedInput = null;
+  inputMode = "shared";
+  reqId = 1;
+  pending = /* @__PURE__ */ new Map();
+  workerExited = !1;
+  workerExitCode = null;
+  inputQueue = [];
+  inputQueueHead = 0;
+  inputQueuedBytes = 0;
+  inputFlushTimer = null;
+  constructor(t = {}) {
+    this.init = {
+      worker: t.worker ?? null,
+      workerUrl: t.workerUrl ?? null,
+      createWorker: t.createWorker ?? null,
+      sharedInputBytes: t.sharedInputBytes ?? I,
+      inputMode: t.inputMode ?? "shared",
+      rpcTimeoutMs: t.rpcTimeoutMs ?? 8e3,
+      maxQueuedBytes: t.maxQueuedBytes ?? 4 * 1024 * 1024,
+      reuseWorker: t.reuseWorker ?? !1,
+      handlers: t.handlers ?? {}
+    };
+  }
+  setHandlers(t) {
+    this.init.handlers = t;
+  }
+  isRunning() {
+    return !!(this.worker && !this.workerExited);
+  }
+  getExitCode() {
+    return this.workerExitCode;
+  }
+  async start(t) {
+    const { cols: e, rows: i, wasmPath: s, runtimePath: n, env: o, files: l } = t;
+    if (this.inputMode = t.inputMode ?? this.init.inputMode, this.inputMode === "shared" && !G())
+      throw new Error('SharedArrayBuffer is required for inputMode="shared"; serve with COOP/COEP so crossOriginIsolated is true, or use inputMode="message" with the asyncify worker.');
+    const a = this.worker;
+    if (this.stop({ terminate: !this.init.reuseWorker, silent: !0 }), this.sharedInput = this.inputMode === "shared" ? z(this.init.sharedInputBytes) : null, this.workerExited = !1, this.workerExitCode = null, this.reqId = 1, this.pending.clear(), this.init.worker ? this.worker = this.init.worker : this.init.createWorker ? this.worker = this.init.createWorker() : this.init.reuseWorker && a ? this.worker = a : this.worker = this.init.workerUrl ? new Worker(this.init.workerUrl, { type: "module" }) : null, !this.worker) throw new Error("worker/workerUrl is required");
+    this.worker.onmessage = (h) => this.handleWorkerMessage(h.data);
+    const u = {
+      type: "start",
+      cols: Number(e) || 80,
+      rows: Number(i) || 24,
+      wasmPath: String(s ?? ""),
+      runtimePath: String(n ?? ""),
+      inputBuffer: this.sharedInput?.buffer ?? null,
+      env: o ?? void 0,
+      files: l ?? void 0
+    };
+    try {
+      this.worker.postMessage(u, []);
+    } catch {
+      this.worker.postMessage(u);
+    }
+  }
+  stop(t = {}) {
+    const e = t.terminate ?? !0;
+    if (this.inputFlushTimer && (clearTimeout(this.inputFlushTimer), this.inputFlushTimer = null), this.sharedInput = null, this.inputQueue = [], this.inputQueueHead = 0, this.inputQueuedBytes = 0, this.pending.size) {
+      const i = new Error("session stopped");
+      this.pending.forEach((s) => s.reject(i)), this.pending.clear();
+    }
+    if (this.workerExited = !1, this.workerExitCode = null, !!this.worker) {
+      if (e) {
+        this.worker.terminate(), this.worker = null;
+        return;
+      }
+      try {
+        this.worker.postMessage({ type: "stop" });
+      } catch {
+      }
+    }
+  }
+  dispose() {
+    this.stop({ terminate: !0, silent: !0 });
+  }
+  notify(t, e = []) {
+    if (!this.worker || this.workerExited) return;
+    const i = N([2, t, e]);
+    this.postInput(i);
+  }
+  call(t, e = []) {
+    return new Promise((i, s) => {
+      if (!this.worker) {
+        s(new Error("session not started"));
+        return;
+      }
+      if (this.workerExited) {
+        const l = this.workerExitCode;
+        s(new Error(l != null ? `nvim exited (${l})` : "nvim exited"));
+        return;
+      }
+      const n = this.reqId++;
+      this.pending.set(n, { resolve: i, reject: s, ts: Date.now(), method: t });
+      const o = N([0, n, t, e]);
+      this.postInput(o), setTimeout(() => {
+        this.pending.has(n) && (this.pending.delete(n), s(new Error(this.workerExited ? this.workerExitCode != null ? `nvim exited (${this.workerExitCode})` : "nvim exited" : `rpc timeout: ${t}`)));
+      }, this.init.rpcTimeoutMs);
+    });
+  }
+  async waitForApi() {
+    const e = Math.min(Math.max(this.init.rpcTimeoutMs * 2, 1e4), 15e3), i = Math.ceil(e / 300);
+    for (let s = 0; s < i; s += 1)
+      try {
+        await this.call("nvim_get_api_info", []);
+        return;
+      } catch {
+        await new Promise((o) => setTimeout(o, 300));
+      }
+    throw new Error("nvim_get_api_info timed out");
+  }
+  respond(t, e, i) {
+    if (!this.worker || this.workerExited) return;
+    const s = N([1, t, e, i]);
+    this.postInput(s);
+  }
+  handleWorkerMessage(t) {
+    const e = t?.type;
+    if (e === "rpc-response") {
+      const { msgid: i, error: s, result: n } = t, o = this.pending.get(i);
+      if (!o) return;
+      this.pending.delete(i), s ? o.reject(new Error(String(s))) : o.resolve(n);
+      return;
+    }
+    if (e === "rpc-notify") {
+      const { method: i, params: s } = t;
+      try {
+        this.init.handlers.onNotify?.(i, s ?? []);
+      } catch {
+      }
+      return;
+    }
+    if (e === "rpc-request") {
+      const { msgid: i, method: s, params: n } = t;
+      try {
+        this.init.handlers.onRequest?.(i, s, n ?? []);
+      } catch {
+      }
+      return;
+    }
+    if (e === "clipboard-copy") {
+      const i = t;
+      try {
+        this.init.handlers.onClipboardCopy?.(i.lines ?? [], i.regtype ?? "v");
+      } catch {
+      }
+      return;
+    }
+    if (e === "clipboard-paste") {
+      const i = t;
+      try {
+        this.init.handlers.onClipboardPaste?.(i.msgid);
+      } catch {
+      }
+      return;
+    }
+    if (e === "stderr") {
+      const i = t;
+      try {
+        this.init.handlers.onStderr?.(i?.message);
+      } catch {
+      }
+      return;
+    }
+    if (e === "start-error") {
+      const i = t;
+      try {
+        this.init.handlers.onStartError?.(i?.message);
+      } catch {
+      }
+      return;
+    }
+    if (e === "exit") {
+      const i = t, s = i.code, n = i.lastStderr;
+      if (this.workerExited = !0, this.workerExitCode = s, this.pending.size) {
+        const o = n ? `: ${n.trim()}` : "", l = new Error(`nvim exited (${s})${o}`);
+        this.pending.forEach((a) => a.reject(l)), this.pending.clear();
+      }
+      try {
+        this.init.handlers.onExit?.(s, n);
+      } catch {
+      }
+    }
+  }
+  postInput(t) {
+    if (!t || !t.buffer) return;
+    const e = Z(t);
+    if (!(!this.worker || this.workerExited)) {
+      if (this.inputMode === "shared") {
+        if (!this.sharedInput || this.inputQueueHead >= this.inputQueue.length && this.sharedInput.push(e))
+          return;
+        this.enqueueInput(e);
+        return;
+      }
+      this.enqueueInput(e);
+    }
+  }
+  enqueueInput(t) {
+    if (!(!this.worker || this.workerExited)) {
+      if (this.inputQueue.push(t), this.inputQueuedBytes += t.byteLength, this.inputQueuedBytes > this.init.maxQueuedBytes) {
+        try {
+          this.init.handlers.onWarning?.("input queue overflow; dropping queued input");
+        } catch {
+        }
+        this.inputQueue = [], this.inputQueueHead = 0, this.inputQueuedBytes = 0;
+        return;
+      }
+      this.scheduleFlushInput();
+    }
+  }
+  scheduleFlushInput() {
+    this.inputFlushTimer || (this.inputFlushTimer = window.setTimeout(() => {
+      this.inputFlushTimer = null, this.flushInputQueue();
+    }, 0));
+  }
+  flushInputQueue() {
+    if (!(this.inputQueueHead >= this.inputQueue.length) && !(!this.worker || this.workerExited)) {
+      if (this.inputMode === "shared") {
+        if (!this.sharedInput) return;
+        for (; this.inputQueueHead < this.inputQueue.length; ) {
+          const t = this.inputQueue[this.inputQueueHead];
+          if (!this.sharedInput.push(t)) break;
+          this.inputQueueHead += 1, this.inputQueuedBytes -= t.byteLength;
+        }
+      } else {
+        let e = 0, i = 0;
+        for (let o = this.inputQueueHead; o < this.inputQueue.length; o += 1) {
+          const l = this.inputQueue[o];
+          if (l?.byteLength) {
+            if (i > 0 && e + l.byteLength > 262144) break;
+            e += l.byteLength, i += 1;
+          }
+        }
+        if (i <= 0 || e <= 0) return;
+        const s = new Uint8Array(e);
+        let n = 0;
+        for (let o = 0; o < i; o += 1) {
+          const l = this.inputQueue[this.inputQueueHead + o];
+          s.set(l, n), n += l.byteLength;
+        }
+        this.inputQueueHead += i, this.inputQueuedBytes -= e, this.postStdin(s);
+      }
+      this.inputQueueHead > 64 && this.inputQueueHead > this.inputQueue.length / 2 && (this.inputQueue = this.inputQueue.slice(this.inputQueueHead), this.inputQueueHead = 0), this.inputQueueHead < this.inputQueue.length ? this.inputFlushTimer = window.setTimeout(() => {
+        this.inputFlushTimer = null, this.flushInputQueue();
+      }, this.inputMode === "shared" ? 2 : 0) : (this.inputQueue = [], this.inputQueueHead = 0);
+    }
+  }
+  postStdin(t) {
+    if (!(!this.worker || this.workerExited))
+      try {
+        this.worker.postMessage({ type: "stdin", chunk: t }, [t.buffer]);
+      } catch {
+        this.worker.postMessage({ type: "stdin", chunk: t });
+      }
+  }
+}
+const J = `if !exists('g:monaco_neovim_wasm_chan')
+  finish
+endif
+
+function! s:notify_cursor_move(payload) abort
+  call rpcnotify(g:monaco_neovim_wasm_chan, 'monaco_cursorMove', a:payload)
+endfunction
+
+function! s:in_macro() abort
+  return reg_recording() !=# '' || reg_executing() !=# ''
+endfunction
+
+function! s:native(keys) abort
+  execute 'normal! ' . a:keys
+endfunction
+
+function! s:to_first_char_of_screen_line() abort
+  if s:in_macro()
+    call s:native('g0')
+    return
+  endif
+  call s:notify_cursor_move({ 'to': 'wrappedLineFirstNonWhitespaceCharacter' })
+endfunction
+
+function! s:to_last_char_of_screen_line() abort
+  if s:in_macro()
+    call s:native('g$')
+    return
+  endif
+  call s:notify_cursor_move({ 'to': 'wrappedLineLastNonWhitespaceCharacter' })
+endfunction
+
+nnoremap <silent> g0 <Cmd>call <SID>to_first_char_of_screen_line()<CR>
+xnoremap <silent> g0 <Cmd>call <SID>to_first_char_of_screen_line()<CR>
+onoremap <silent> g0 <Cmd>call <SID>to_first_char_of_screen_line()<CR>
+nnoremap <silent> g<Home> <Cmd>call <SID>to_first_char_of_screen_line()<CR>
+xnoremap <silent> g<Home> <Cmd>call <SID>to_first_char_of_screen_line()<CR>
+onoremap <silent> g<Home> <Cmd>call <SID>to_first_char_of_screen_line()<CR>
+nnoremap <silent> g^ <Cmd>call <SID>to_first_char_of_screen_line()<CR>
+xnoremap <silent> g^ <Cmd>call <SID>to_first_char_of_screen_line()<CR>
+onoremap <silent> g^ <Cmd>call <SID>to_first_char_of_screen_line()<CR>
+nnoremap <silent> g$ <Cmd>call <SID>to_last_char_of_screen_line()<CR>
+xnoremap <silent> g$ <Cmd>call <SID>to_last_char_of_screen_line()<CR>
+onoremap <silent> g$ <Cmd>call <SID>to_last_char_of_screen_line()<CR>
+nnoremap <silent> g<End> <Cmd>call <SID>to_last_char_of_screen_line()<CR>
+xnoremap <silent> g<End> <Cmd>call <SID>to_last_char_of_screen_line()<CR>
+onoremap <silent> g<End> <Cmd>call <SID>to_last_char_of_screen_line()<CR>
+
+" Note: Using these in macros can be problematic.
+function! s:up_down(to) abort
+  if s:in_macro()
+    execute 'normal! ' . v:count1 . (a:to ==# 'up' ? 'gk' : 'gj')
+    return
+  endif
+  call s:notify_cursor_move({ 'to': a:to, 'by': 'wrappedLine', 'value': v:count1 })
+endfunction
+
+nnoremap <silent> gk <Cmd>call <SID>up_down('up')<CR>
+xnoremap <silent> gk <Cmd>call <SID>up_down('up')<CR>
+onoremap <silent> gk <Cmd>call <SID>up_down('up')<CR>
+nnoremap <silent> gj <Cmd>call <SID>up_down('down')<CR>
+xnoremap <silent> gj <Cmd>call <SID>up_down('down')<CR>
+onoremap <silent> gj <Cmd>call <SID>up_down('down')<CR>
+`, X = `if !exists('g:monaco_neovim_wasm_chan')
+  finish
+endif
+
+function! s:reveal(direction, resetCursor) abort
+  if reg_recording() !=# '' || reg_executing() !=# ''
+    execute 'normal! z' . (a:direction ==# 'top' ? 't' : (a:direction ==# 'bottom' ? 'b' : 'z'))
+    if a:resetCursor
+      execute 'normal! z' . (a:direction ==# 'top' ? "\\<CR>" : (a:direction ==# 'bottom' ? '-' : '.'))
+    endif
+    return
+  endif
+  call rpcnotify(g:monaco_neovim_wasm_chan, 'monaco_reveal', { 'direction': a:direction, 'resetCursor': a:resetCursor })
+endfunction
+
+nnoremap <silent> z<CR> <Cmd>call <SID>reveal('top', v:true)<CR>
+xnoremap <silent> z<CR> <Cmd>call <SID>reveal('top', v:true)<CR>
+onoremap <silent> z<CR> <Cmd>call <SID>reveal('top', v:true)<CR>
+nnoremap <silent> zt <Cmd>call <SID>reveal('top', v:false)<CR>
+xnoremap <silent> zt <Cmd>call <SID>reveal('top', v:false)<CR>
+onoremap <silent> zt <Cmd>call <SID>reveal('top', v:false)<CR>
+
+nnoremap <silent> z. <Cmd>call <SID>reveal('center', v:true)<CR>
+xnoremap <silent> z. <Cmd>call <SID>reveal('center', v:true)<CR>
+onoremap <silent> z. <Cmd>call <SID>reveal('center', v:true)<CR>
+nnoremap <silent> zz <Cmd>call <SID>reveal('center', v:false)<CR>
+xnoremap <silent> zz <Cmd>call <SID>reveal('center', v:false)<CR>
+onoremap <silent> zz <Cmd>call <SID>reveal('center', v:false)<CR>
+
+nnoremap <silent> z- <Cmd>call <SID>reveal('bottom', v:true)<CR>
+xnoremap <silent> z- <Cmd>call <SID>reveal('bottom', v:true)<CR>
+onoremap <silent> z- <Cmd>call <SID>reveal('bottom', v:true)<CR>
+nnoremap <silent> zb <Cmd>call <SID>reveal('bottom', v:false)<CR>
+xnoremap <silent> zb <Cmd>call <SID>reveal('bottom', v:false)<CR>
+onoremap <silent> zb <Cmd>call <SID>reveal('bottom', v:false)<CR>
+
+function! s:move_cursor(to) abort
+  " Native host commands don't register jumplist; record it explicitly.
+  if reg_recording() !=# '' || reg_executing() !=# ''
+    execute 'normal! ' . v:count1 . (a:to ==# 'top' ? 'H' : (a:to ==# 'bottom' ? 'L' : 'M'))
+    return
+  endif
+  normal! m'
+  if a:to ==# 'top' || a:to ==# 'bottom'
+    call rpcnotify(g:monaco_neovim_wasm_chan, 'monaco_moveCursor', { 'to': a:to, 'value': v:count1 })
+  else
+    call rpcnotify(g:monaco_neovim_wasm_chan, 'monaco_moveCursor', { 'to': a:to })
+  endif
+endfunction
+
+nnoremap <silent> H <Cmd>call <SID>move_cursor('top')<CR>
+xnoremap <silent> H <Cmd>call <SID>move_cursor('top')<CR>
+onoremap <silent> H <Cmd>call <SID>move_cursor('top')<CR>
+nnoremap <silent> M <Cmd>call <SID>move_cursor('middle')<CR>
+xnoremap <silent> M <Cmd>call <SID>move_cursor('middle')<CR>
+onoremap <silent> M <Cmd>call <SID>move_cursor('middle')<CR>
+nnoremap <silent> L <Cmd>call <SID>move_cursor('bottom')<CR>
+xnoremap <silent> L <Cmd>call <SID>move_cursor('bottom')<CR>
+onoremap <silent> L <Cmd>call <SID>move_cursor('bottom')<CR>
+
+function! s:scroll(direction, by) abort
+  if reg_recording() !=# '' || reg_executing() !=# ''
+    if a:by ==# 'line'
+      execute 'normal! ' . v:count1 . (a:direction ==# 'up' ? "\\<C-y>" : "\\<C-e>")
+    elseif a:by ==# 'halfPage'
+      execute 'normal! ' . v:count1 . (a:direction ==# 'up' ? "\\<C-u>" : "\\<C-d>")
+    else
+      execute 'normal! ' . v:count1 . (a:direction ==# 'up' ? "\\<C-b>" : "\\<C-f>")
+    endif
+    return
+  endif
+  let payload = { 'direction': a:direction, 'by': a:by, 'value': v:count1 }
+  if a:by ==# 'line'
+    let payload.moveCursor = v:false
+  else
+    let payload.moveCursor = v:true
+    let payload.cursorBy = 'wrappedLine'
+  endif
+  call rpcnotify(g:monaco_neovim_wasm_chan, 'monaco_scroll', payload)
+endfunction
+
+nnoremap <silent> <C-e> <Cmd>call <SID>scroll('down', 'line')<CR>
+xnoremap <silent> <C-e> <Cmd>call <SID>scroll('down', 'line')<CR>
+onoremap <silent> <C-e> <Cmd>call <SID>scroll('down', 'line')<CR>
+nnoremap <silent> <C-y> <Cmd>call <SID>scroll('up', 'line')<CR>
+xnoremap <silent> <C-y> <Cmd>call <SID>scroll('up', 'line')<CR>
+onoremap <silent> <C-y> <Cmd>call <SID>scroll('up', 'line')<CR>
+
+nnoremap <silent> <C-d> <Cmd>call <SID>scroll('down', 'halfPage')<CR>
+xnoremap <silent> <C-d> <Cmd>call <SID>scroll('down', 'halfPage')<CR>
+onoremap <silent> <C-d> <Cmd>call <SID>scroll('down', 'halfPage')<CR>
+nnoremap <silent> <C-u> <Cmd>call <SID>scroll('up', 'halfPage')<CR>
+xnoremap <silent> <C-u> <Cmd>call <SID>scroll('up', 'halfPage')<CR>
+onoremap <silent> <C-u> <Cmd>call <SID>scroll('up', 'halfPage')<CR>
+
+nnoremap <silent> <C-f> <Cmd>call <SID>scroll('down', 'page')<CR>
+xnoremap <silent> <C-f> <Cmd>call <SID>scroll('down', 'page')<CR>
+onoremap <silent> <C-f> <Cmd>call <SID>scroll('down', 'page')<CR>
+nnoremap <silent> <C-b> <Cmd>call <SID>scroll('up', 'page')<CR>
+xnoremap <silent> <C-b> <Cmd>call <SID>scroll('up', 'page')<CR>
+onoremap <silent> <C-b> <Cmd>call <SID>scroll('up', 'page')<CR>
+`, ee = `if !exists('g:monaco_neovim_wasm_chan')
+  finish
+endif
+
+function! s:notify(action, payload) abort
+  let obj = a:payload
+  let obj.action = a:action
+  call rpcnotify(g:monaco_neovim_wasm_chan, 'monaco_host_command', obj)
+endfunction
+
+function! s:edit(file, bang) abort
+  call s:notify('edit', { 'path': a:file, 'bang': a:bang ==# '!' })
+endfunction
+
+function! s:write(file, bang) abort
+  call s:notify('write', { 'path': a:file, 'bang': a:bang ==# '!' })
+endfunction
+
+function! s:quit(bang) abort
+  call s:notify('quit', { 'bang': a:bang ==# '!' })
+endfunction
+
+function! s:wq(bang) abort
+  call s:notify('wq', { 'bang': a:bang ==# '!' })
+endfunction
+
+command! -complete=file -bang -nargs=? MonacoEdit call <SID>edit(<q-args>, <q-bang>)
+command! -complete=file -bang -nargs=? MonacoWrite call <SID>write(<q-args>, <q-bang>)
+command! -bang -nargs=0 MonacoQuit call <SID>quit(<q-bang>)
+command! -bang -nargs=0 MonacoWq call <SID>wq(<q-bang>)
+
+function! s:abbr(cmd, target) abort
+  if getcmdtype() !=# ':'
+    return a:cmd
+  endif
+  let l = getcmdline()
+  " Only expand at the start of the command line (possibly after spaces).
+  if l !~# '^\\s*' . a:cmd . '\\>'
+    return a:cmd
+  endif
+  return substitute(l, '^\\s*' . a:cmd . '\\>', a:target, '')
+endfunction
+
+cnoreabbrev <expr> e <SID>abbr('e', 'MonacoEdit')
+cnoreabbrev <expr> edit <SID>abbr('edit', 'MonacoEdit')
+cnoreabbrev <expr> w <SID>abbr('w', 'MonacoWrite')
+cnoreabbrev <expr> write <SID>abbr('write', 'MonacoWrite')
+cnoreabbrev <expr> q <SID>abbr('q', 'MonacoQuit')
+cnoreabbrev <expr> quit <SID>abbr('quit', 'MonacoQuit')
+cnoreabbrev <expr> wq <SID>abbr('wq', 'MonacoWq')
+cnoreabbrev <expr> x <SID>abbr('x', 'MonacoWq')
+`, te = [
+  "-- Monaco + Neovim (WASM)",
+  "-- Click into the editor, press i, and start typing.",
+  "",
+  "local function greet(name)",
+  "  return 'hello ' .. name",
+  "end",
+  "",
+  "print(greet('monaco'))"
+], ie = `
+local api, fn = vim.api, vim.fn
+
+local function virtcol2byte(winid, lnum, virtcol)
+  local byte_idx = fn.virtcol2col(winid, lnum, virtcol) - 1
+  if fn.has("nvim-0.10.0") == 0 then
+    return byte_idx
+  end
+  local buf = api.nvim_win_get_buf(winid)
+  local line = api.nvim_buf_get_lines(buf, lnum - 1, lnum, false)[1] or ""
+  local char_idx = fn.charidx(line, byte_idx)
+  local prefix = fn.strcharpart(line, 0, char_idx + 1)
+  return #prefix
+end
+
+local function get_selections(win)
+  win = win or api.nvim_get_current_win()
+  local buf = api.nvim_win_get_buf(win)
+  local full_mode = api.nvim_get_mode().mode or ""
+  local mode = full_mode:sub(-1)
+  local is_visual = mode:match("[vV\\22sS\\19]")
+
+  if not is_visual then
+    local cur = api.nvim_win_get_cursor(win)
+    local line0 = (cur[1] or 1) - 1
+    local col0 = cur[2] or 0
+    return { { start = { line = line0, col = col0 }, ["end"] = { line = line0, col = col0 }, inclusive = false } }
+  end
+
+  local sline = fn.line('v') - 1
+  local scol = fn.col('v') - 1
+  local eline = fn.line('.') - 1
+  local ecol = fn.col('.') - 1
+
+  if mode == "v" or mode == "V" then
+    local start_left = true
+    if sline > eline or (sline == eline and scol > ecol) then
+      start_left = false
+      sline, eline = eline, sline
+      scol, ecol = ecol, scol
+    end
+    if mode == "V" then
+      scol = 0
+      local line = api.nvim_buf_get_lines(buf, eline, eline + 1, false)[1] or ""
+      ecol = #line
+    end
+    local range = {
+      start = { line = sline, col = scol },
+      ["end"] = { line = eline, col = ecol },
+      inclusive = (vim.o.selection or "inclusive") == "inclusive",
+    }
+    if not start_left then
+      range = { start = range["end"], ["end"] = range.start, inclusive = range.inclusive }
+    end
+    return { range }
+  end
+
+  local ranges = {}
+  local start_vcol, end_vcol = fn.virtcol("v"), fn.virtcol(".")
+  local top, bot = math.min(sline, eline), math.max(sline, eline)
+  for lnum = top, bot do
+    local line = api.nvim_buf_get_lines(buf, lnum, lnum + 1, false)[1] or ""
+    local disp = fn.strdisplaywidth(line)
+    if start_vcol > disp and end_vcol > disp then
+      local chars = ({ vim.str_utfindex(line) })[2]
+      table.insert(ranges, { start = { line = lnum, col = chars }, ["end"] = { line = lnum, col = chars }, inclusive = true })
+    else
+      local col_a = virtcol2byte(win, lnum + 1, math.min(start_vcol, end_vcol))
+      local col_b = virtcol2byte(win, lnum + 1, math.max(start_vcol, end_vcol))
+      table.insert(ranges, { start = { line = lnum, col = col_a }, ["end"] = { line = lnum, col = col_b }, inclusive = true })
+    end
+  end
+
+  if #ranges == 0 then
+    local cur = api.nvim_win_get_cursor(win)
+    local line0 = (cur[1] or 1) - 1
+    local col0 = cur[2] or 0
+    return { { start = { line = line0, col = col0 }, ["end"] = { line = line0, col = col0 }, inclusive = false } }
+  end
+
+  return ranges
+end
+
+return get_selections(...)
+`, ne = `
+local api, fn = vim.api, vim.fn
+
+local function get_visible_range(s, e)
+  s = tonumber(s) or 1
+  e = tonumber(e) or s
+  if e < s then s, e = e, s end
+  if s < 1 then s = 1 end
+  if e < 1 then e = 1 end
+  return s, e
+end
+
+local function to_matches(buf, s, e, pat)
+  local ok, re = pcall(vim.regex, pat)
+  if not ok or not re then
+    return {}, nil
+  end
+  local lines = api.nvim_buf_get_lines(buf, s - 1, e, false)
+  local matches = {}
+  local cur = api.nvim_win_get_cursor(0)
+  local cur_lnum = cur[1] or 1
+  local cur_col0 = cur[2] or 0
+  local current = nil
+
+  local max_total = 3000
+  local max_per_line = 200
+
+  for idx, line in ipairs(lines) do
+    if #matches >= max_total then break end
+    local lnum = (s + idx - 1)
+    local start = 0
+    local safety = 0
+    while start <= #line and safety < max_per_line do
+      safety = safety + 1
+      local ms, me = re:match_str(line, start)
+      if ms == nil or me == nil then break end
+      if me <= ms then
+        start = ms + 1
+      else
+        table.insert(matches, { l = lnum - 1, s = ms, e = me })
+        if current == nil and lnum == cur_lnum and cur_col0 >= ms and cur_col0 < me then
+          current = { l = lnum - 1, s = ms, e = me }
+        end
+        start = me
+      end
+    end
+  end
+
+  if current == nil then
+    local pos = fn.searchpos(pat, "nW")
+    local lnum = tonumber(pos[1] or 0) or 0
+    local col = tonumber(pos[2] or 0) or 0
+    if lnum > 0 and col > 0 then
+      local line = api.nvim_buf_get_lines(buf, lnum - 1, lnum, false)[1] or ""
+      local ms, me = re:match_str(line, col - 1)
+      if ms ~= nil and me ~= nil and me > ms then
+        current = { l = lnum - 1, s = ms, e = me }
+      end
+    end
+  end
+
+  return matches, current
+end
+
+local function run(...)
+  local cmdtype = fn.getcmdtype() or ""
+  local pat = ""
+  if cmdtype == "/" or cmdtype == "?" then
+    pat = fn.getcmdline() or ""
+    if pat == "" then
+      return { enabled = false, matches = {}, current = nil }
+    end
+  else
+    if vim.v.hlsearch ~= 1 then
+      return { enabled = false, matches = {}, current = nil }
+    end
+    pat = fn.getreg("/") or ""
+    if pat == "" then
+      return { enabled = false, matches = {}, current = nil }
+    end
+  end
+  local s, e = get_visible_range(select(1, ...), select(2, ...))
+  local buf = api.nvim_get_current_buf()
+  local matches, current = to_matches(buf, s, e, pat)
+  return { enabled = true, matches = matches, current = current, start = s, finish = e }
+end
+
+return run(...)
+`;
+class se {
+  editor;
+  opts;
+  session = null;
+  bufHandle = null;
+  uiCols = 0;
+  uiRows = 0;
+  resizeTimer = null;
+  wrapColumnApplied = null;
+  wrapStrategyApplied = null;
+  primeSent = !1;
+  lastCursorPos = null;
+  suppressCursorSync = !1;
+  lastMode = "";
+  visualSelectionToken = 0;
+  visualSelectionActive = !1;
+  visualDecorationIds = [];
+  visualStyleEl = null;
+  visualBgCss = "rgba(62, 68, 81, 0.45)";
+  cursorRefreshTimer = null;
+  cursorRefreshInFlight = !1;
+  cursorRefreshPending = !1;
+  disposables = [];
+  notifyChain = Promise.resolve();
+  nvimChannelId = null;
+  hostAutocmdInstalled = !1;
+  nvimScrolloff = 0;
+  ctrlKeysNormal = null;
+  ctrlKeysInsert = null;
+  altKeysNormal = null;
+  altKeysInsert = null;
+  metaKeysNormal = null;
+  metaKeysInsert = null;
+  searchDecorationIds = [];
+  searchStyleEl = null;
+  searchRefreshTimer = null;
+  searchRefreshInFlight = !1;
+  searchRefreshPending = !1;
+  execLuaAvailable = null;
+  visualSelectionRefreshTimer = null;
+  lastCursorStyle = null;
+  lastCursorBlink = null;
+  lastCursorWidth = null;
+  initialCursorWidth = 0;
+  typicalFullWidth = 2;
+  nextSeedLines = null;
+  cmdlineEl = null;
+  cmdlineVisible = !1;
+  messageEl = null;
+  messageTimer = null;
+  popupEl = null;
+  popupItems = [];
+  popupSelected = -1;
+  preeditEl = null;
+  preeditVisible = !1;
+  compositionActive = !1;
+  pendingResyncAfterComposition = !1;
+  ignoreNextInputEvent = !1;
+  ignoreTextKeydownUntil = 0;
+  optimisticCursorUntil = 0;
+  optimisticCursorPos = null;
+  optimisticCursorPrevPos = null;
+  delegateInsertToMonaco = !1;
+  applyingFromNvim = !1;
+  buffers = /* @__PURE__ */ new Map();
+  buffersByName = /* @__PURE__ */ new Map();
+  cursorSyncTimer = null;
+  modelContentDisposable = null;
+  originalOptions = null;
+  resyncTimer = null;
+  constructor(t, e = {}) {
+    this.editor = t, this.opts = {
+      worker: e.worker ?? null,
+      workerUrl: e.workerUrl ?? new URL("./nvimWorker.js", import.meta.url),
+      reuseWorker: e.reuseWorker ?? !1,
+      wasmPath: e.wasmPath ?? "",
+      runtimePath: e.runtimePath ?? "",
+      inputMode: e.inputMode ?? "shared",
+      env: e.env,
+      files: e.files,
+      sharedInputBytes: e.sharedInputBytes ?? I,
+      cols: e.cols ?? 120,
+      rows: e.rows ?? 40,
+      minCols: e.minCols ?? 20,
+      minRows: e.minRows ?? 5,
+      autoResize: e.autoResize ?? !0,
+      resizeDebounceMs: e.resizeDebounceMs ?? 50,
+      syncWrap: e.syncWrap ?? !1,
+      wrapStrategy: e.wrapStrategy ?? "simple",
+      syncTabstop: e.syncTabstop ?? !0,
+      wrappedLineMotions: e.wrappedLineMotions ?? e.syncWrap ?? !1,
+      scrollMotions: e.scrollMotions ?? !1,
+      scrolloff: Number.isFinite(e.scrolloff) ? Math.max(0, Number(e.scrolloff)) : void 0,
+      syncScrolloff: e.syncScrolloff ?? e.scrollMotions ?? !1,
+      ctrlKeysForNormalMode: e.ctrlKeysForNormalMode,
+      ctrlKeysForInsertMode: e.ctrlKeysForInsertMode,
+      altKeysForNormalMode: e.altKeysForNormalMode,
+      altKeysForInsertMode: e.altKeysForInsertMode,
+      metaKeysForNormalMode: e.metaKeysForNormalMode,
+      metaKeysForInsertMode: e.metaKeysForInsertMode,
+      searchHighlights: e.searchHighlights ?? !1,
+      hostCommands: e.hostCommands ?? !1,
+      fileSystem: e.fileSystem,
+      onHostCommand: e.onHostCommand,
+      status: e.status ?? (() => {
+      }),
+      seedLines: e.seedLines ?? te,
+      seedName: e.seedName ?? "monaco-demo.lua",
+      seedFiletype: e.seedFiletype ?? "lua",
+      uiAttach: e.uiAttach ?? !0,
+      uiAttachOptions: {
+        ext_cmdline: e.uiAttachOptions?.ext_cmdline ?? !0,
+        ext_messages: e.uiAttachOptions?.ext_messages ?? !0,
+        ext_popupmenu: e.uiAttachOptions?.ext_popupmenu ?? !0,
+        rgb: e.uiAttachOptions?.rgb ?? !0
+      },
+      startupCommands: e.startupCommands ?? [
+        "set noswapfile signcolumn=no number norelativenumber",
+        "set nowrap laststatus=0 cmdheight=1",
+        "set shortmess+=F",
+        "set clipboard=unnamedplus"
+      ],
+      startupLua: e.startupLua ?? "",
+      visualThemeName: e.visualThemeName ?? "nvim-visual",
+      rpcTimeoutMs: e.rpcTimeoutMs ?? 8e3,
+      clipboard: e.clipboard,
+      onStderr: e.onStderr,
+      onStartError: e.onStartError,
+      onExit: e.onExit,
+      onWarning: e.onWarning,
+      onModeChange: e.onModeChange,
+      onCmdline: e.onCmdline,
+      onMessage: e.onMessage,
+      onPopupmenu: e.onPopupmenu,
+      cmdlineContainer: e.cmdlineContainer,
+      shouldHandleKey: e.shouldHandleKey ?? (() => !0),
+      translateKey: e.translateKey ?? oe
+    }, this.ctrlKeysNormal = this.opts.ctrlKeysForNormalMode ? new Set(this.opts.ctrlKeysForNormalMode.map((i) => String(i).toLowerCase())) : null, this.ctrlKeysInsert = this.opts.ctrlKeysForInsertMode ? new Set(this.opts.ctrlKeysForInsertMode.map((i) => String(i).toLowerCase())) : null, this.altKeysNormal = this.opts.altKeysForNormalMode ? new Set(this.opts.altKeysForNormalMode.map((i) => String(i).toLowerCase())) : null, this.altKeysInsert = this.opts.altKeysForInsertMode ? new Set(this.opts.altKeysForInsertMode.map((i) => String(i).toLowerCase())) : null, this.metaKeysNormal = this.opts.metaKeysForNormalMode ? new Set(this.opts.metaKeysForNormalMode.map((i) => String(i).toLowerCase())) : null, this.metaKeysInsert = this.opts.metaKeysForInsertMode ? new Set(this.opts.metaKeysForInsertMode.map((i) => String(i).toLowerCase())) : null;
+  }
+  async start(t) {
+    this.stop(!0), this.nextSeedLines = t ?? null;
+    try {
+      const e = this.opts.autoResize ? this.computeGridSize() : { cols: this.opts.cols, rows: this.opts.rows };
+      this.uiCols = e.cols, this.uiRows = e.rows, this.attachEditorListeners();
+      const i = {
+        onNotify: (s, n) => {
+          this.notifyChain = this.notifyChain.then(() => this.handleNotify(s, n)).catch(() => {
+          });
+        },
+        onRequest: (s, n, o) => {
+          this.handleRequest(s, n, o);
+        },
+        onClipboardCopy: (s, n) => {
+          this.handleClipboardCopy(s);
+        },
+        onClipboardPaste: (s) => {
+          this.doClipboardPaste(s);
+        },
+        onStderr: (s) => {
+          const n = s == null ? "" : String(s);
+          try {
+            this.opts.onStderr?.(n);
+          } catch {
+          }
+        },
+        onStartError: (s) => {
+          try {
+            this.opts.onStartError?.(s);
+          } catch {
+          }
+          this.opts.status(`start failed: ${s ?? "unknown"}`, !0);
+        },
+        onExit: (s, n) => {
+          const o = n ? `: ${n.trim()}` : "";
+          this.opts.status(`nvim exited (${s})${o}`, s !== 0);
+          try {
+            this.opts.onExit?.(s, n);
+          } catch {
+          }
+        },
+        onWarning: (s) => {
+          try {
+            this.opts.onWarning?.(s);
+          } catch {
+          }
+          this.opts.status(s, !0);
+        }
+      };
+      if (!this.session || !this.opts.reuseWorker ? this.session = new Y({
+        worker: this.opts.worker,
+        workerUrl: this.opts.workerUrl,
+        inputMode: this.opts.inputMode,
+        sharedInputBytes: this.opts.sharedInputBytes,
+        rpcTimeoutMs: this.opts.rpcTimeoutMs,
+        reuseWorker: this.opts.reuseWorker,
+        handlers: i
+      }) : this.session.setHandlers(i), !this.opts.wasmPath || !this.opts.runtimePath)
+        throw new Error("wasmPath/runtimePath is required (use @monaco-neovim-wasm/wasm or @monaco-neovim-wasm/wasm-async for defaults).");
+      await this.session.start({
+        cols: this.uiCols,
+        rows: this.uiRows,
+        wasmPath: this.opts.wasmPath,
+        runtimePath: this.opts.runtimePath,
+        inputMode: this.opts.inputMode,
+        env: this.opts.env,
+        files: ce(ue(
+          this.opts.files,
+          this.opts.wrappedLineMotions || this.opts.scrollMotions || this.opts.hostCommands ? [
+            { path: "home/.config/nvim/monaco-neovim-wasm/motion.vim", data: J },
+            { path: "home/.config/nvim/monaco-neovim-wasm/scrolling.vim", data: X },
+            { path: "home/.config/nvim/monaco-neovim-wasm/host-commands.vim", data: ee }
+          ] : []
+        ))
+      }), this.opts.status("starting..."), this.primeSent = !1, setTimeout(() => {
+        this.primeSent || this.primeSession();
+      }, 300), await this.session.waitForApi(), await this.primeSession();
+    } catch (e) {
+      const i = e?.message || String(e);
+      throw this.opts.status(`start failed: ${i}`, !0), this.stop(!0), e;
+    }
+  }
+  stop(t = !1) {
+    this.session && (this.opts.reuseWorker ? this.session.stop({ terminate: !1, silent: !0 }) : (this.session.dispose(), this.session = null)), this.bufHandle = null, this.primeSent = !1, this.visualSelectionActive = !1, this.delegateInsertToMonaco = !1, this.applyingFromNvim = !1, this.clearBufferStates(), this.cursorSyncTimer && (clearTimeout(this.cursorSyncTimer), this.cursorSyncTimer = null), this.nvimChannelId = null, this.hostAutocmdInstalled = !1, this.notifyChain = Promise.resolve(), this.visualSelectionRefreshTimer && (clearTimeout(this.visualSelectionRefreshTimer), this.visualSelectionRefreshTimer = null), this.cursorRefreshTimer && (clearTimeout(this.cursorRefreshTimer), this.cursorRefreshTimer = null), this.cursorRefreshPending = !1, this.cursorRefreshInFlight = !1, this.setCmdline(null), this.setMessage(null), this.setPopupmenu(null, -1), this.resyncTimer && (clearTimeout(this.resyncTimer), this.resyncTimer = null), this.resizeTimer && (clearTimeout(this.resizeTimer), this.resizeTimer = null), t || this.opts.status("stopped", !0), this.disposeEditorListeners();
+  }
+  dispose() {
+    this.session && (this.session.dispose(), this.session = null), this.stop(!0);
+  }
+  notify(t, e = []) {
+    this.sendNotify(t, e);
+  }
+  call(t, e = []) {
+    return this.rpcCall(t, e);
+  }
+  command(t) {
+    this.sendNotify("nvim_command", [String(t ?? "")]);
+  }
+  input(t) {
+    this.sendNotify("nvim_input", [String(t ?? "")]);
+  }
+  paste(t) {
+    this.pasteText(t);
+  }
+  async execLua(t, e = []) {
+    const i = String(t ?? ""), s = Array.isArray(e) ? e : [];
+    if (this.execLuaAvailable !== !1)
+      try {
+        const o = await this.rpcCall("nvim_exec_lua", [i, s]);
+        return this.execLuaAvailable = !0, o;
+      } catch (o) {
+        const l = o?.message || String(o);
+        if (l.includes("Invalid method") && l.includes("nvim_exec_lua"))
+          this.execLuaAvailable = !1;
+        else
+          throw o;
+      }
+    const n = `(function(...)
+${i}
+end)(unpack(_A))`;
+    return this.rpcCall("nvim_call_function", ["luaeval", [n, s]]);
+  }
+  getSession() {
+    return this.session;
+  }
+  resize(t, e) {
+    const i = Math.max(this.opts.minCols, Number(t) || 0), s = Math.max(this.opts.minRows, Number(e) || 0);
+    !Number.isFinite(i) || !Number.isFinite(s) || i <= 0 || s <= 0 || (this.opts.syncWrap && this.applyMonacoWrap(i), this.uiCols = i, this.uiRows = s, !(!this.session || !this.session.isRunning()) && this.primeSent && this.rpcCall("nvim_ui_try_resize", [i, s]).catch(() => {
+    }));
+  }
+  resizeToEditor() {
+    const { cols: t, rows: e } = this.computeGridSize();
+    this.resize(t, e);
+  }
+  attachEditorListeners() {
+    this.disposeEditorListeners();
+    const t = m.editor.EditorOption;
+    try {
+      const e = this.editor.getOption(t.fontInfo);
+      this.initialCursorWidth = this.editor.getOption(t.cursorWidth) || 0, this.typicalFullWidth = e?.typicalFullwidthCharacterWidth || 2;
+    } catch {
+      this.initialCursorWidth = 0, this.typicalFullWidth = 2;
+    }
+    if (this.originalOptions == null)
+      try {
+        this.originalOptions = {
+          readOnly: this.editor.getOption(t.readOnly),
+          domReadOnly: this.editor.getOption(t.domReadOnly),
+          contextmenu: this.editor.getOption(t.contextmenu),
+          minimap: this.editor.getOption(t.minimap),
+          scrollBeyondLastLine: this.editor.getOption(t.scrollBeyondLastLine),
+          smoothScrolling: this.editor.getOption(t.smoothScrolling),
+          padding: this.editor.getOption(t.padding),
+          cursorSmoothCaretAnimation: this.editor.getOption(t.cursorSmoothCaretAnimation),
+          cursorStyle: this.editor.getOption(t.cursorStyle),
+          cursorBlinking: this.editor.getOption(t.cursorBlinking),
+          cursorWidth: this.editor.getOption(t.cursorWidth),
+          wordWrap: this.editor.getOption(t.wordWrap),
+          wordWrapColumn: this.editor.getOption(t.wordWrapColumn),
+          wrappingStrategy: this.editor.getOption(t.wrappingStrategy)
+        };
+      } catch {
+        this.originalOptions = null;
+      }
+    if (this.editor.updateOptions({ readOnly: !1, domReadOnly: !1 }), this.opts.syncWrap) {
+      const e = this.uiCols || this.opts.cols;
+      e > 0 && this.applyMonacoWrap(e);
+    }
+    this.attachActiveModelListener(), this.disposables.push(
+      this.editor.onDidChangeModel(() => this.attachActiveModelListener()),
+      this.editor.onKeyDown((e) => this.handleKey(e)),
+      this.editor.onMouseDown((e) => this.handleMouse(e)),
+      this.editor.onDidChangeCursorPosition((e) => {
+        const i = this.editor.getPosition();
+        if (i && (this.lastCursorPos = i), this.delegateInsertToMonaco) {
+          this.compositionActive && this.positionPreedit(), this.scheduleCursorSyncToNvim();
+          return;
+        }
+        if (this.compositionActive) {
+          this.positionPreedit();
+          return;
+        }
+        this.suppressCursorSync || !this.lastCursorPos || e.source === "keyboard" && (this.suppressCursorSync = !0, this.editor.setPosition(this.lastCursorPos), this.suppressCursorSync = !1);
+      }),
+      this.editor.onDidScrollChange(() => {
+        this.compositionActive && this.positionPreedit();
+      })
+    ), this.disposables.push(
+      this.editor.onDidScrollChange(() => {
+        this.opts.searchHighlights && (this.compositionActive || this.scheduleSearchHighlightRefresh());
+      })
+    ), this.opts.autoResize && this.disposables.push(
+      this.editor.onDidLayoutChange(() => this.scheduleResizeToEditor()),
+      this.editor.onDidChangeConfiguration((e) => {
+        (e.hasChanged(t.fontInfo) || e.hasChanged(t.lineHeight) || e.hasChanged(t.fontSize) || e.hasChanged(t.fontFamily)) && this.scheduleResizeToEditor();
+      })
+    ), this.initCmdlineUi(), this.initTextInputListeners();
+  }
+  computeGridSize() {
+    try {
+      const t = this.editor.getLayoutInfo(), e = Math.max(0, Number(t?.contentWidth ?? t?.width ?? 0) || 0), i = Math.max(0, Number(t?.contentHeight ?? t?.height ?? 0) || 0), s = this.editor.getOption(m.editor.EditorOption.fontInfo), n = Math.max(1, Number(s?.typicalHalfwidthCharacterWidth ?? s?.maxDigitWidth ?? 0) || 0), o = Math.max(1, Number(s?.lineHeight ?? 0) || 0), l = Math.max(this.opts.minCols, Math.floor(e / n)), a = Math.max(this.opts.minRows, Math.floor(i / o));
+      if (Number.isFinite(l) && Number.isFinite(a) && l > 0 && a > 0) return { cols: l, rows: a };
+    } catch {
+    }
+    return { cols: this.opts.cols, rows: this.opts.rows };
+  }
+  scheduleResizeToEditor() {
+    if (!this.opts.autoResize || this.resizeTimer) return;
+    const t = Math.max(0, Number(this.opts.resizeDebounceMs) || 0);
+    this.resizeTimer = window.setTimeout(() => {
+      this.resizeTimer = null, this.resizeToEditor();
+    }, t);
+  }
+  ensurePreeditUi() {
+    if (this.preeditEl) return;
+    const t = this.opts.cmdlineContainer ?? this.editor.getDomNode();
+    if (!t) return;
+    try {
+      window.getComputedStyle(t).position === "static" && (t.style.position = "relative");
+    } catch {
+    }
+    const e = document.createElement("div");
+    e.style.position = "absolute", e.style.display = "none", e.style.pointerEvents = "none", e.style.zIndex = "40", e.style.whiteSpace = "pre", e.style.padding = "0 1px", e.style.background = "rgba(0, 0, 0, 0.15)", e.style.borderBottom = "1px solid rgba(255, 255, 255, 0.6)", e.style.borderRadius = "2px";
+    try {
+      const i = this.editor.getOption(m.editor.EditorOption.fontInfo);
+      i?.fontFamily && (e.style.fontFamily = i.fontFamily), i?.fontSize && (e.style.fontSize = `${i.fontSize}px`), i?.lineHeight && (e.style.lineHeight = `${i.lineHeight}px`);
+    } catch {
+    }
+    t.appendChild(e), this.preeditEl = e;
+  }
+  setPreedit(t) {
+    if (this.ensurePreeditUi(), !this.preeditEl) return;
+    const e = t == null ? "" : String(t);
+    if (!(e.length > 0)) {
+      this.preeditVisible && (this.preeditEl.style.display = "none", this.preeditVisible = !1), this.preeditEl.textContent = "";
+      return;
+    }
+    this.preeditEl.textContent = e, this.preeditVisible || (this.preeditEl.style.display = "block", this.preeditVisible = !0), this.positionPreedit();
+  }
+  applyOptimisticInsert(t) {
+    if (!t || this.cmdlineVisible) return;
+    const e = this.editor.getModel();
+    if (!e) return;
+    const i = this.editor.getSelection(), n = (i && !i.isEmpty() ? i.getStartPosition() : null) ?? this.editor.getPosition() ?? this.lastCursorPos ?? new m.Position(1, 1), o = String(t).split(/\r?\n/);
+    let l = n.lineNumber, a = n.column;
+    o.length <= 1 ? a += Array.from(o[0] ?? "").length : (l += o.length - 1, a = 1 + Array.from(o[o.length - 1] ?? "").length);
+    const u = e.validatePosition(new m.Position(l, a)), h = this.editor.getPosition() ?? this.lastCursorPos ?? n;
+    this.optimisticCursorPrevPos = h, this.optimisticCursorPos = u, this.optimisticCursorUntil = (typeof performance < "u" && performance.now ? performance.now() : Date.now()) + 120, this.lastCursorPos = u, !this.compositionActive && (this.suppressCursorSync = !0, this.editor.setPosition(u), this.suppressCursorSync = !1);
+  }
+  positionPreedit() {
+    if (!this.preeditEl || !this.preeditVisible) return;
+    const t = this.editor.getPosition();
+    if (!t) return;
+    const e = this.editor.getScrolledVisiblePosition(t);
+    e && (this.preeditEl.style.left = `${Math.max(0, e.left)}px`, this.preeditEl.style.top = `${Math.max(0, e.top)}px`, this.preeditEl.style.height = `${Math.max(0, e.height)}px`);
+  }
+  disposeEditorListeners() {
+    if (this.disposables.forEach((t) => t.dispose()), this.disposables = [], this.modelContentDisposable) {
+      try {
+        this.modelContentDisposable.dispose();
+      } catch {
+      }
+      this.modelContentDisposable = null;
+    }
+    if (this.clearVisualDecorations(), this.clearSearchHighlights(), this.searchStyleEl) {
+      try {
+        this.searchStyleEl.remove();
+      } catch {
+      }
+      this.searchStyleEl = null;
+    }
+    if (this.visualStyleEl) {
+      try {
+        this.visualStyleEl.remove();
+      } catch {
+      }
+      this.visualStyleEl = null;
+    }
+    if (this.cmdlineEl) {
+      try {
+        this.cmdlineEl.remove();
+      } catch {
+      }
+      this.cmdlineEl = null;
+    }
+    if (this.messageEl) {
+      try {
+        this.messageEl.remove();
+      } catch {
+      }
+      this.messageEl = null;
+    }
+    if (this.popupEl) {
+      try {
+        this.popupEl.remove();
+      } catch {
+      }
+      this.popupEl = null;
+    }
+    if (this.preeditEl) {
+      try {
+        this.preeditEl.remove();
+      } catch {
+      }
+      this.preeditEl = null, this.preeditVisible = !1;
+    }
+    if (this.messageTimer && (clearTimeout(this.messageTimer), this.messageTimer = null), this.resyncTimer && (clearTimeout(this.resyncTimer), this.resyncTimer = null), this.searchRefreshTimer && (clearTimeout(this.searchRefreshTimer), this.searchRefreshTimer = null), this.searchRefreshInFlight = !1, this.searchRefreshPending = !1, this.resizeTimer && (clearTimeout(this.resizeTimer), this.resizeTimer = null), this.compositionActive = !1, this.pendingResyncAfterComposition = !1, this.delegateInsertToMonaco = !1, this.applyingFromNvim = !1, this.cursorSyncTimer && (clearTimeout(this.cursorSyncTimer), this.cursorSyncTimer = null), this.nvimChannelId = null, this.hostAutocmdInstalled = !1, this.visualSelectionRefreshTimer && (clearTimeout(this.visualSelectionRefreshTimer), this.visualSelectionRefreshTimer = null), this.originalOptions) {
+      try {
+        this.editor.updateOptions(this.originalOptions);
+      } catch {
+      }
+      this.originalOptions = null;
+    }
+  }
+  attachActiveModelListener() {
+    if (this.modelContentDisposable) {
+      try {
+        this.modelContentDisposable.dispose();
+      } catch {
+      }
+      this.modelContentDisposable = null;
+    }
+    const t = this.editor.getModel();
+    t && (this.modelContentDisposable = t.onDidChangeContent((e) => this.handleMonacoModelChange(e)));
+  }
+  getActiveState() {
+    return this.bufHandle ? this.buffers.get(this.bufHandle) ?? null : null;
+  }
+  ensureActiveState() {
+    if (!this.bufHandle) return null;
+    const t = this.editor.getModel();
+    if (!t) return null;
+    const e = this.buffers.get(this.bufHandle);
+    if (e)
+      return e.model !== t && (e.model = t, e.createdModel = !1), e;
+    const i = {
+      id: this.bufHandle,
+      name: "",
+      filetype: "",
+      model: t,
+      createdModel: !1,
+      shadowLines: null,
+      pendingBufEdits: [],
+      pendingFullSync: !1,
+      pendingCursorSync: !1
+    };
+    return this.buffers.set(i.id, i), i;
+  }
+  clearBufferStates() {
+    for (const t of this.buffers.values())
+      if (t.createdModel)
+        try {
+          t.model.dispose();
+        } catch {
+        }
+    this.buffers.clear(), this.buffersByName.clear();
+  }
+  async primeSession() {
+    if (!this.bufHandle) {
+      this.primeSent = !0;
+      try {
+        if (this.opts.uiAttach)
+          try {
+            await this.rpcCall("nvim_ui_attach", [this.uiCols || this.opts.cols, this.uiRows || this.opts.rows, this.opts.uiAttachOptions]);
+          } catch {
+          }
+        for (const o of this.opts.startupCommands)
+          o && this.sendNotify("nvim_command", [o]);
+        if (this.opts.startupLua)
+          try {
+            await this.execLua(this.opts.startupLua, []);
+          } catch {
+          }
+        const t = await this.rpcCall("nvim_get_current_buf", []), e = _(t) ?? 1;
+        if (this.bufHandle = e, await this.rpcCall("nvim_buf_attach", [e, !0, {}]) !== !0) throw new Error("nvim_buf_attach failed");
+        this.ensureActiveState(), this.opts.syncTabstop && this.syncTabstopFromMonaco();
+        const s = await this.rpcCall("nvim_buf_get_lines", [e, 0, -1, !1]);
+        this.applyBuffer(Array.isArray(s) ? s : [""]);
+        const n = await this.seedBuffer(e, this.nextSeedLines);
+        this.nextSeedLines = null, n && n.length && this.applyBuffer(n);
+        try {
+          const o = this.ensureActiveState();
+          if (o) {
+            const l = await this.rpcCall("nvim_buf_get_name", [e]);
+            o.name = typeof l == "string" ? l : "", o.name && this.buffersByName.set(o.name, e);
+            try {
+              const a = await this.rpcCall("nvim_buf_get_option", [e, "filetype"]);
+              o.filetype = typeof a == "string" ? a : "";
+            } catch {
+            }
+          }
+        } catch {
+        }
+        await this.installHostAutocmds(), await this.syncVisualSelectionColor(), this.lastMode || (this.lastMode = "n"), this.opts.status("ready"), this.editor.focus(), this.opts.autoResize && this.scheduleResizeToEditor(), this.opts.onModeChange && this.opts.onModeChange(this.lastMode);
+      } catch (t) {
+        this.opts.status(`failed to attach: ${t?.message ?? t}`, !0);
+      }
+    }
+  }
+  handleClipboardCopy(t) {
+    const e = (t ?? []).join(`
+`), i = this.opts.clipboard;
+    if (i !== null) {
+      if (i?.writeText) {
+        i.writeText(e).catch(() => {
+        });
+        return;
+      }
+      navigator.clipboard?.writeText && navigator.clipboard.writeText(e).catch(() => {
+      });
+    }
+  }
+  handleRequest(t, e, i) {
+    e === "wasm-clipboard-paste" ? this.doClipboardPaste(t) : this.sendRpcResponse(t, null, null);
+  }
+  async handleNotify(t, e) {
+    if (t === "monaco_cursorMove") {
+      const i = e?.[0];
+      i && typeof i == "object" && (this.applyMonacoCursorMove(i), this.syncCursorToNvimNow());
+      return;
+    }
+    if (t === "monaco_scroll") {
+      const i = e?.[0];
+      i && typeof i == "object" && this.applyMonacoScroll(i) && this.syncCursorToNvimNow();
+      return;
+    }
+    if (t === "monaco_reveal") {
+      const i = e?.[0];
+      i && typeof i == "object" && this.applyMonacoReveal(i) && this.syncCursorToNvimNow();
+      return;
+    }
+    if (t === "monaco_moveCursor") {
+      const i = e?.[0];
+      i && typeof i == "object" && (this.applyMonacoMoveCursor(i), this.syncCursorToNvimNow());
+      return;
+    }
+    if (t === "monaco_scrolloff") {
+      const i = Number(e?.[0]);
+      Number.isFinite(i) && (this.nvimScrolloff = Math.max(0, Math.floor(i)), this.applyScrolloff());
+      return;
+    }
+    if (t === "monaco_host_command") {
+      const i = e?.[0];
+      i && typeof i == "object" && await this.handleHostCommand(i);
+      return;
+    }
+    if (t === "monaco_buf_enter") {
+      const i = e?.[0];
+      i && typeof i == "object" && await this.handleBufEnter(i);
+      return;
+    }
+    if (t === "monaco_buf_delete") {
+      const i = e?.[0];
+      i && typeof i == "object" && this.handleBufDelete(i);
+      return;
+    }
+    if (t === "monaco_cursor") {
+      const [i, s] = e, n = L(this.editor, Number(i), Number(s));
+      if (this.delegateInsertToMonaco) {
+        const o = this.editor.getModel(), l = o ? o.validatePosition(new m.Position(n.line, n.col)) : new m.Position(n.line, n.col);
+        this.lastCursorPos = l;
+        return;
+      }
+      this.updateCursor(n.line, n.col), E(this.lastMode) && this.scheduleVisualSelectionRefresh();
+      return;
+    }
+    if (t === "monaco_mode") {
+      const i = typeof e?.[0] == "string" ? String(e[0]) : "";
+      this.applyNvimMode(i);
+      return;
+    }
+    if (t === "nvim_buf_lines_event") {
+      const [i, s, n, o, l] = e, a = _(i);
+      if (!a || this.delegateInsertToMonaco && this.bufHandle != null && a === this.bufHandle) return;
+      const u = this.bufHandle != null && a === this.bufHandle ? this.ensureActiveState() : this.buffers.get(a) ?? null;
+      if (!u) return;
+      if (this.bufHandle != null && a === this.bufHandle && this.compositionActive) {
+        this.pendingResyncAfterComposition = !0;
+        return;
+      }
+      const h = u.model, f = Number(n), c = Number(o), d = Array.isArray(l) ? l.map((g) => String(g ?? "")) : null;
+      if (h && Number.isInteger(f) && Number.isInteger(c) && f >= 0 && c >= f && d)
+        try {
+          this.bufHandle != null && a === this.bufHandle && this.editor.getModel() === h ? this.applyLinePatch(h, f, c, d) : this.applyLinePatchToModel(h, f, c, d);
+        } catch {
+        }
+      else
+        try {
+          const g = await this.rpcCall("nvim_buf_get_lines", [a, 0, -1, !1]), y = Array.isArray(g) ? g : [""];
+          this.bufHandle != null && a === this.bufHandle && this.editor.getModel() === h ? this.applyBuffer(y) : this.setModelText(h, y);
+        } catch {
+        }
+      this.bufHandle != null && a === this.bufHandle && E(this.lastMode) && this.scheduleVisualSelectionRefresh();
+    } else if (t === "nvim_buf_detach_event") {
+      const i = _(e?.[0]);
+      if (i && this.buffers.has(i)) {
+        const s = this.buffers.get(i);
+        if (s.name && this.buffersByName.delete(s.name), s.createdModel)
+          try {
+            s.model.dispose();
+          } catch {
+          }
+        this.buffers.delete(i);
+      }
+      i && this.bufHandle === i && (this.bufHandle = null);
+    } else t === "redraw" && this.handleRedraw(e);
+  }
+  applyLinePatch(t, e, i, s) {
+    const n = t.getLineCount(), o = Math.min(e, n), l = Math.min(i, n), a = this.lastCursorPos ?? this.editor.getPosition() ?? new m.Position(1, 1), u = new m.Position(n, t.getLineMaxColumn(n)), h = o < n ? new m.Position(o + 1, 1) : u, f = l < n ? new m.Position(l + 1, 1) : u;
+    let c = s.join(`
+`);
+    e >= n && i >= n && s.length > 0 && (c = `
+${c}`), i < n && s.length > 0 && (c += `
+`);
+    const g = new m.Range(h.lineNumber, h.column, f.lineNumber, f.column);
+    try {
+      if (t.getValueInRange(g) === c) return;
+    } catch {
+    }
+    if (this.suppressCursorSync = !0, this.applyingFromNvim = !0, t.applyEdits([{ range: g, text: c }]), this.applyingFromNvim = !1, a && this.editor.setPosition(a), this.suppressCursorSync = !1, this.delegateInsertToMonaco) {
+      const y = this.getActiveState();
+      if (y && y.model === t)
+        try {
+          y.shadowLines = t.getLinesContent();
+        } catch {
+        }
+    }
+  }
+  applyLinePatchToModel(t, e, i, s) {
+    const n = t.getLineCount(), o = Math.min(e, n), l = Math.min(i, n), a = new m.Position(n, t.getLineMaxColumn(n)), u = o < n ? new m.Position(o + 1, 1) : a, h = l < n ? new m.Position(l + 1, 1) : a;
+    let f = s.join(`
+`);
+    e >= n && i >= n && s.length > 0 && (f = `
+${f}`), i < n && s.length > 0 && (f += `
+`);
+    const p = new m.Range(u.lineNumber, u.column, h.lineNumber, h.column);
+    try {
+      if (t.getValueInRange(p) === f) return;
+    } catch {
+    }
+    this.applyingFromNvim = !0;
+    try {
+      t.applyEdits([{ range: p, text: f }]);
+    } catch {
+    }
+    this.applyingFromNvim = !1;
+  }
+  setModelText(t, e) {
+    const i = (e && e.length ? e : [""]).join(`
+`);
+    try {
+      if (t.getValue() === i) return;
+    } catch {
+    }
+    this.applyingFromNvim = !0;
+    try {
+      t.setValue(i);
+    } catch {
+    }
+    this.applyingFromNvim = !1;
+  }
+  initCmdlineUi() {
+    if (this.opts.cmdlineContainer === null || this.cmdlineEl || this.messageEl || this.popupEl) return;
+    const t = this.opts.cmdlineContainer ?? this.editor.getDomNode();
+    if (!t) return;
+    try {
+      window.getComputedStyle(t).position === "static" && (t.style.position = "relative");
+    } catch {
+    }
+    const e = "ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace", i = "12px", s = "1.4";
+    if (!this.opts.onCmdline) {
+      const n = document.createElement("div");
+      n.style.position = "absolute", n.style.left = "0", n.style.right = "0", n.style.bottom = "0", n.style.padding = "6px 10px", n.style.fontFamily = e, n.style.fontSize = i, n.style.lineHeight = s, n.style.background = "rgba(0, 0, 0, 0.72)", n.style.color = "#ddd", n.style.borderTop = "1px solid rgba(255, 255, 255, 0.08)", n.style.whiteSpace = "pre", n.style.display = "none", n.style.pointerEvents = "none", n.style.zIndex = "20", t.appendChild(n), this.cmdlineEl = n;
+    }
+    if (!this.opts.onMessage) {
+      const n = document.createElement("div");
+      n.style.position = "absolute", n.style.left = "0", n.style.right = "0", n.style.bottom = "34px", n.style.padding = "6px 10px", n.style.fontFamily = e, n.style.fontSize = i, n.style.lineHeight = s, n.style.background = "rgba(0, 0, 0, 0.55)", n.style.color = "#ddd", n.style.whiteSpace = "pre-wrap", n.style.display = "none", n.style.pointerEvents = "none", n.style.zIndex = "19", t.appendChild(n), this.messageEl = n;
+    }
+    if (!this.opts.onPopupmenu) {
+      const n = document.createElement("div");
+      n.style.position = "absolute", n.style.left = "12px", n.style.bottom = "34px", n.style.maxHeight = "40%", n.style.overflow = "auto", n.style.minWidth = "240px", n.style.padding = "4px 0", n.style.fontFamily = e, n.style.fontSize = i, n.style.lineHeight = s, n.style.background = "rgba(0, 0, 0, 0.88)", n.style.border = "1px solid rgba(255, 255, 255, 0.12)", n.style.borderRadius = "6px", n.style.color = "#ddd", n.style.whiteSpace = "pre", n.style.display = "none", n.style.pointerEvents = "none", n.style.zIndex = "21", t.appendChild(n), this.popupEl = n;
+    }
+  }
+  setCmdline(t) {
+    if (this.opts.onCmdline)
+      try {
+        this.opts.onCmdline(t);
+      } catch {
+      }
+    if (this.cmdlineEl) {
+      if (t == null || t === "") {
+        this.cmdlineEl.textContent = "", this.cmdlineEl.style.display = "none", this.cmdlineVisible = !1;
+        return;
+      }
+      this.cmdlineEl.textContent = t, this.cmdlineEl.style.display = "block", this.cmdlineVisible = !0;
+    }
+  }
+  setMessage(t) {
+    if (this.opts.onMessage)
+      try {
+        this.opts.onMessage(t);
+      } catch {
+      }
+    if (this.messageEl) {
+      if (this.messageTimer && (clearTimeout(this.messageTimer), this.messageTimer = null), t == null || t === "") {
+        this.messageEl.textContent = "", this.messageEl.style.display = "none";
+        return;
+      }
+      this.messageEl.textContent = t, this.messageEl.style.display = "block", this.messageTimer = window.setTimeout(() => {
+        this.messageTimer = null, this.setMessage(null);
+      }, 4e3);
+    }
+  }
+  setPopupmenu(t, e) {
+    if (this.popupItems = t ?? [], this.popupSelected = e, this.opts.onPopupmenu)
+      try {
+        this.opts.onPopupmenu(t, e);
+      } catch {
+      }
+    if (this.popupEl) {
+      if (!t || !t.length) {
+        this.popupEl.textContent = "", this.popupEl.style.display = "none";
+        return;
+      }
+      this.popupEl.innerHTML = "";
+      for (let i = 0; i < t.length; i += 1) {
+        const s = t[i], n = document.createElement("div");
+        n.style.padding = "2px 10px", n.style.display = "flex", n.style.gap = "10px", n.style.justifyContent = "space-between", n.style.background = i === e ? "rgba(255,255,255,0.12)" : "transparent";
+        const o = document.createElement("span");
+        o.textContent = s.word ?? "";
+        const l = document.createElement("span");
+        l.style.opacity = "0.7", l.textContent = s.menu ?? s.kind ?? "", n.appendChild(o), n.appendChild(l), this.popupEl.appendChild(n);
+      }
+      this.popupEl.style.display = "block";
+    }
+  }
+  applyMonacoWrap(t) {
+    const e = Math.max(this.opts.minCols, Number(t) || 0);
+    if (!Number.isFinite(e) || e <= 0) return;
+    const i = this.opts.wrapStrategy;
+    if (!(this.wrapColumnApplied === e && this.wrapStrategyApplied === i))
+      try {
+        this.editor.updateOptions({
+          wordWrap: "wordWrapColumn",
+          wordWrapColumn: e,
+          wrappingStrategy: i
+        }), this.wrapColumnApplied = e, this.wrapStrategyApplied = i;
+      } catch {
+      }
+  }
+  applyMonacoCursorMove(t) {
+    const e = typeof t.to == "string" ? t.to : "", i = typeof t.by == "string" ? t.by : "", s = Math.max(1, Number(t.value ?? 1) || 1);
+    if (!e) return;
+    const n = () => {
+      try {
+        return this.editor.trigger("monaco-neovim-wasm", "cursorMove", { to: e, by: i, value: s }), !0;
+      } catch {
+      }
+      if (i === "wrappedLine" && (e === "down" || e === "up")) {
+        const l = e === "down" ? "cursorDown" : "cursorUp";
+        for (let a = 0; a < s; a += 1)
+          try {
+            this.editor.trigger("monaco-neovim-wasm", l, null);
+          } catch {
+          }
+        return !0;
+      }
+      return !1;
+    };
+    this.suppressCursorSync = !0, n();
+    const o = this.editor.getPosition();
+    o && (this.lastCursorPos = o, this.applyScrolloff(o)), this.suppressCursorSync = !1, this.scheduleSearchHighlightRefresh();
+  }
+  getScrolloffLines() {
+    return this.opts.scrolloff != null ? Math.max(0, Math.floor(this.opts.scrolloff)) : this.opts.syncScrolloff ? Math.max(0, Math.floor(this.nvimScrolloff)) : 0;
+  }
+  applyScrolloff(t) {
+    if (this.compositionActive || this.delegateInsertToMonaco) return !1;
+    const e = this.getScrolloffLines();
+    if (e <= 0) return !1;
+    const i = t ?? this.editor.getPosition();
+    if (!i) return !1;
+    const s = Math.max(1, Number(this.editor.getOption(m.editor.EditorOption.lineHeight)) || 0), n = e * s;
+    if (n <= 0) return !1;
+    let o = 0;
+    try {
+      const p = this.editor.getLayoutInfo();
+      o = Math.max(0, Number(p?.contentHeight ?? p?.height ?? 0) || 0);
+    } catch {
+    }
+    if (o <= 0) return !1;
+    const l = () => {
+      try {
+        this.editor.revealPositionInCenterIfOutsideViewport(i);
+      } catch {
+      }
+    };
+    let a = null;
+    try {
+      a = this.editor.getScrolledVisiblePosition(i);
+    } catch {
+    }
+    if (!a) {
+      l();
+      try {
+        a = this.editor.getScrolledVisiblePosition(i);
+      } catch {
+      }
+    }
+    if (!a || !Number.isFinite(a.top) || !Number.isFinite(a.height)) return !1;
+    const u = this.editor.getScrollTop(), h = a.top, f = a.top + a.height, c = Math.max(0, o - n);
+    let d = 0;
+    if (h < n ? d = h - n : f > c && (d = f - c), !d) return !1;
+    try {
+      this.editor.setScrollTop(Math.max(0, u + d));
+    } catch {
+    }
+    return !0;
+  }
+  applyMonacoScroll(t) {
+    const e = typeof t.by == "string" ? t.by : "", i = typeof t.direction == "string" ? t.direction : "", s = Math.max(1, Number(t.value ?? 1) || 1), n = !!t.moveCursor, o = typeof t.cursorBy == "string" ? t.cursorBy : "wrappedLine", l = Math.max(3, this.uiRows || this.opts.rows), a = this.editor.getOption(m.editor.EditorOption.fontInfo), u = Math.max(1, Number(a?.lineHeight ?? 0) || 0), h = Math.max(1, l - 2), f = Math.max(1, Math.floor(h / 2));
+    let c = s;
+    if (e === "page") c = h * s;
+    else if (e === "halfPage") c = f * s;
+    else if (e === "line") c = s;
+    else return !1;
+    const d = i === "up" ? -1 : i === "down" ? 1 : 0;
+    if (!d) return !1;
+    this.suppressCursorSync = !0;
+    try {
+      const g = this.editor.getScrollTop(), y = Math.max(0, g + d * c * u);
+      this.editor.setScrollTop(y);
+    } catch {
+    }
+    let p = !1;
+    if (n)
+      try {
+        this.applyMonacoCursorMove({
+          to: d > 0 ? "down" : "up",
+          by: o,
+          value: c
+        }), p = !0;
+      } catch {
+      }
+    return this.suppressCursorSync = !1, p;
+  }
+  applyMonacoReveal(t) {
+    const e = typeof t.direction == "string" ? t.direction : "", i = !!t.resetCursor, s = this.editor.getPosition();
+    if (!s) return !1;
+    const n = s.lineNumber, o = Math.max(1, this.uiRows || this.opts.rows), l = this.editor.getOption(m.editor.EditorOption.fontInfo), a = Math.max(1, Number(l?.lineHeight ?? 0) || 0);
+    this.suppressCursorSync = !0;
+    try {
+      if (e === "top") {
+        const u = this.editor.getTopForLineNumber(n);
+        this.editor.setScrollTop(u);
+      } else if (e === "center")
+        this.editor.revealLineInCenter(n);
+      else if (e === "bottom") {
+        const u = this.editor.getTopForLineNumber(n), h = Math.max(0, u - (o - 1) * a);
+        this.editor.setScrollTop(h);
+      }
+      if (i) {
+        const u = this.editor.getModel();
+        if (u) {
+          const h = u.getLineContent(n) ?? "", f = /\S/.exec(h), c = f ? f.index + 1 : 1, d = u.validatePosition(new m.Position(n, c));
+          this.editor.setPosition(d), this.lastCursorPos = d;
+        }
+      }
+    } catch {
+    }
+    return this.suppressCursorSync = !1, i;
+  }
+  applyMonacoMoveCursor(t) {
+    const e = typeof t.to == "string" ? t.to : "";
+    if (!e) return;
+    const i = this.editor.getModel();
+    if (!i) return;
+    const s = Math.max(1, Number(t.value ?? 1) || 1);
+    let n = 1, o = i.getLineCount();
+    try {
+      const c = this.editor.getVisibleRanges();
+      c && c.length && (n = Math.min(...c.map((d) => d.startLineNumber)), o = Math.max(...c.map((d) => d.endLineNumber)));
+    } catch {
+    }
+    n = Math.max(1, Math.min(n, i.getLineCount())), o = Math.max(1, Math.min(o, i.getLineCount())), o < n && (o = n);
+    let l = n;
+    if (e === "top")
+      l = n + (s - 1);
+    else if (e === "middle")
+      l = Math.floor((n + o) / 2);
+    else if (e === "bottom")
+      l = o - (s - 1);
+    else
+      return;
+    l = Math.max(n, Math.min(o, l));
+    const a = i.getLineContent(l) ?? "", u = /\S/.exec(a), h = u ? u.index + 1 : 1, f = i.validatePosition(new m.Position(l, h));
+    this.suppressCursorSync = !0;
+    try {
+      this.editor.setPosition(f);
+    } catch {
+    }
+    this.lastCursorPos = f, this.suppressCursorSync = !1;
+  }
+  syncTabstopFromMonaco() {
+    const t = this.editor.getModel();
+    if (!t) return;
+    const i = Math.max(1, Number(t.getOptions?.().tabSize ?? 4) || 4);
+    this.sendNotify("nvim_command", [`set tabstop=${i} shiftwidth=${i} softtabstop=${i}`]);
+  }
+  updatePopupmenuSelection(t) {
+    if (this.popupSelected === t) return;
+    if (this.popupSelected = t, this.opts.onPopupmenu) {
+      try {
+        this.opts.onPopupmenu(this.popupItems, t);
+      } catch {
+      }
+      return;
+    }
+    if (!this.popupEl) return;
+    const e = Array.from(this.popupEl.children);
+    for (let i = 0; i < e.length; i += 1)
+      e[i].style.background = i === t ? "rgba(255,255,255,0.12)" : "transparent";
+  }
+  handleRedraw(t) {
+    if (Array.isArray(t))
+      for (const e of t) {
+        if (!Array.isArray(e) || e.length === 0) continue;
+        const i = e[0];
+        if (typeof i != "string") continue;
+        const s = e.slice(1), n = s.length === 1 && Array.isArray(s[0]) ? s[0] : s;
+        if (i === "cmdline_hide") {
+          this.setCmdline(null), this.scheduleSearchHighlightRefresh();
+          continue;
+        }
+        if (i === "cmdline_show") {
+          const o = n[0], l = typeof n[2] == "string" ? n[2] : "", a = typeof n[3] == "string" ? n[3] : "", u = Math.max(0, Number(n[4] ?? 0) || 0), h = a || l || "", f = `${" ".repeat(u)}${h}${M(o)}`;
+          this.setCmdline(f), this.scheduleSearchHighlightRefresh();
+          continue;
+        }
+        if (i === "cmdline_pos") {
+          this.scheduleSearchHighlightRefresh();
+          continue;
+        }
+        if (i === "msg_clear") {
+          this.setMessage(null);
+          continue;
+        }
+        if (i === "msg_show") {
+          const o = typeof n[0] == "string" ? n[0] : "", l = n[1], a = !!n[2], u = !!n[4], h = M(l);
+          if (o === "empty" && !h) {
+            this.setMessage(null);
+            continue;
+          }
+          if (!h) continue;
+          if (u && this.messageEl?.textContent) {
+            this.setMessage(`${this.messageEl.textContent}${h}`);
+            continue;
+          }
+          if (a) {
+            this.setMessage(h);
+            continue;
+          }
+          this.setMessage(h);
+          continue;
+        }
+        if (i === "msg_showmode" || i === "msg_showcmd" || i === "msg_ruler") {
+          const o = n[0], l = M(o);
+          this.setMessage(l || null);
+          continue;
+        }
+        if (i === "popupmenu_hide") {
+          this.setPopupmenu(null, -1);
+          continue;
+        }
+        if (i === "popupmenu_show") {
+          const o = n[0], l = Number(n[1] ?? -1), a = me(o);
+          this.setPopupmenu(a, Number.isFinite(l) ? l : -1);
+          continue;
+        }
+        if (i === "popupmenu_select") {
+          const o = Number(n[0] ?? -1);
+          this.updatePopupmenuSelection(Number.isFinite(o) ? o : -1);
+          continue;
+        }
+        if (i === "mode_change") {
+          const o = typeof n[0] == "string" ? n[0] : "";
+          this.applyNvimMode(o);
+          continue;
+        }
+      }
+  }
+  initTextInputListeners() {
+    const t = this.editor.getDomNode();
+    if (!t) return;
+    const e = Array.from(t.querySelectorAll("textarea.inputarea"));
+    if (!e.length) return;
+    const i = (c) => {
+      try {
+        c.stopImmediatePropagation?.();
+      } catch {
+      }
+      try {
+        c.stopPropagation();
+      } catch {
+      }
+    }, s = (c) => {
+      if (this.compositionActive || c.isComposing || !c.ctrlKey && !c.altKey && !c.metaKey) return;
+      const d = this.modifiedKeyName(c);
+      if (!d || !this.opts.shouldHandleKey(c)) return;
+      const p = this.delegateInsertToMonaco;
+      if (this.hasExplicitModAllowlist(p)) {
+        if (!this.shouldForwardModifiedKeys(c, p)) return;
+      } else if (p || !c.ctrlKey || c.altKey || c.metaKey || d !== "f" && d !== "b" && d !== "d" && d !== "u" && d !== "e" && d !== "y") return;
+      const g = this.opts.translateKey(c);
+      if (g) {
+        i(c);
+        try {
+          c.preventDefault();
+        } catch {
+        }
+        p && this.flushPendingMonacoSync(), this.sendInput(g);
+      }
+    }, n = () => {
+      if (this.compositionActive = !0, this.delegateInsertToMonaco) {
+        this.setPreedit(null);
+        return;
+      }
+      this.setPreedit("");
+    }, o = () => {
+      this.compositionActive = !1, this.setPreedit(null);
+    }, l = (c) => {
+      if (this.compositionActive = !1, this.setPreedit(null), this.delegateInsertToMonaco) {
+        this.scheduleCursorSyncToNvim();
+        return;
+      }
+      const d = c.target;
+      try {
+        d && (d.value = "");
+      } catch {
+      }
+      this.pendingResyncAfterComposition && (this.pendingResyncAfterComposition = !1, this.scheduleResync());
+    }, a = (c) => {
+      if (this.compositionActive || (this.compositionActive = !0), this.delegateInsertToMonaco) return;
+      const d = c.target, p = typeof c.data == "string" ? c.data : d?.value ? String(d.value) : "";
+      this.setPreedit(p || "");
+    }, u = (c) => {
+      this.delegateInsertToMonaco || i(c);
+    }, h = (c) => {
+      if (this.delegateInsertToMonaco) return;
+      i(c);
+      const p = c.target;
+      if (this.ignoreNextInputEvent) {
+        this.ignoreNextInputEvent = !1;
+        try {
+          p && (p.value = "");
+        } catch {
+        }
+        return;
+      }
+      if (!this.compositionActive)
+        try {
+          p && (p.value = "");
+        } catch {
+        }
+    }, f = (c) => {
+      if (this.delegateInsertToMonaco) return;
+      i(c);
+      const d = c.clipboardData?.getData("text/plain") ?? "";
+      d && (c.preventDefault(), this.pasteText(d));
+      try {
+        c.target?.value && (c.target.value = "");
+      } catch {
+      }
+    };
+    this.disposables.push(
+      // Capture phase to ensure we see events even if Monaco stops propagation.
+      b(t, "keydown", s, !0),
+      b(t, "compositionstart", n, !0),
+      b(t, "compositionupdate", a, !0),
+      b(t, "compositionend", o, !0)
+    );
+    for (const c of e)
+      this.disposables.push(
+        b(c, "beforeinput", u, !0),
+        b(c, "input", h, !0),
+        b(c, "compositionstart", (d) => {
+          n();
+        }, !0),
+        b(c, "compositionupdate", (d) => {
+          a(d);
+        }, !0),
+        b(c, "compositionend", (d) => {
+          l(d);
+        }, !0),
+        b(c, "paste", f, !0)
+      );
+  }
+  scheduleResync() {
+    this.resyncTimer || (this.resyncTimer = window.setTimeout(() => {
+      this.resyncTimer = null, this.resyncBufferFromNvim();
+    }, 50));
+  }
+  async resyncBufferFromNvim() {
+    if (!this.compositionActive && !(!this.session || !this.session.isRunning()) && this.bufHandle)
+      try {
+        const t = await this.rpcCall("nvim_buf_get_lines", [this.bufHandle, 0, -1, !1]);
+        this.applyBuffer(Array.isArray(t) ? t : [""]);
+      } catch {
+      }
+  }
+  applyBuffer(t = [""]) {
+    const e = this.editor.getModel();
+    if (!e) return;
+    const i = (t && t.length ? t : [""]).join(`
+`);
+    if (e.getValue() === i) return;
+    const s = this.lastCursorPos ?? this.editor.getPosition() ?? new m.Position(1, 1);
+    if (this.suppressCursorSync = !0, this.applyingFromNvim = !0, e.setValue(i), this.applyingFromNvim = !1, s && this.editor.setPosition(s), this.suppressCursorSync = !1, this.delegateInsertToMonaco) {
+      const n = this.getActiveState();
+      if (n && n.model === e)
+        try {
+          n.shadowLines = e.getLinesContent();
+        } catch {
+        }
+    }
+  }
+  ensureVisualStyle() {
+    if (this.visualStyleEl) return;
+    const t = document.createElement("style");
+    t.id = "monaco-neovim-wasm-visual-style", t.textContent = `
+.monaco-neovim-visual-line {
+  background-color: ${this.visualBgCss};
+}
+.monaco-neovim-visual-inline {
+  background-color: ${this.visualBgCss};
+}
+`, document.head.appendChild(t), this.visualStyleEl = t;
+  }
+  setVisualBgCss(t) {
+    const e = t || this.visualBgCss;
+    e === this.visualBgCss && this.visualStyleEl || (this.visualBgCss = e, this.visualStyleEl && (this.visualStyleEl.textContent = `
+.monaco-neovim-visual-line {
+  background-color: ${this.visualBgCss};
+}
+.monaco-neovim-visual-inline {
+  background-color: ${this.visualBgCss};
+}
+`));
+  }
+  clearVisualDecorations() {
+    if (this.visualDecorationIds.length) {
+      try {
+        this.visualDecorationIds = this.editor.deltaDecorations(this.visualDecorationIds, []);
+      } catch {
+        this.visualDecorationIds = [];
+      }
+      this.visualSelectionActive = !1;
+    }
+  }
+  ensureSearchStyle() {
+    if (this.searchStyleEl) return;
+    const t = document.createElement("style");
+    t.id = "monaco-neovim-wasm-search-style", t.textContent = `
+.monaco-neovim-search-match {
+  background-color: rgba(255, 210, 77, 0.22);
+}
+.monaco-neovim-search-current {
+  background-color: rgba(255, 210, 77, 0.45);
+}
+`, document.head.appendChild(t), this.searchStyleEl = t;
+  }
+  clearSearchHighlights() {
+    if (this.searchDecorationIds.length)
+      try {
+        this.searchDecorationIds = this.editor.deltaDecorations(this.searchDecorationIds, []);
+      } catch {
+        this.searchDecorationIds = [];
+      }
+  }
+  scheduleSearchHighlightRefresh() {
+    this.opts.searchHighlights && (this.searchRefreshTimer || (this.searchRefreshTimer = window.setTimeout(() => {
+      this.searchRefreshTimer = null, this.refreshSearchHighlights();
+    }, 60)));
+  }
+  async refreshSearchHighlights() {
+    if (!this.opts.searchHighlights || !this.session || !this.session.isRunning() || !this.bufHandle) return;
+    const t = this.editor.getModel();
+    if (t) {
+      if (this.searchRefreshInFlight) {
+        this.searchRefreshPending = !0;
+        return;
+      }
+      this.searchRefreshInFlight = !0;
+      try {
+        let e = 1, i = t.getLineCount();
+        try {
+          const n = this.editor.getVisibleRanges();
+          n && n.length && (e = Math.min(...n.map((o) => o.startLineNumber)), i = Math.max(...n.map((o) => o.endLineNumber)));
+        } catch {
+        }
+        e = Math.max(1, Math.min(e, t.getLineCount())), i = Math.max(1, Math.min(i, t.getLineCount()));
+        const s = await this.execLua(ne, [e, i]);
+        this.applySearchHighlights(s, t);
+      } catch {
+      }
+      this.searchRefreshInFlight = !1, this.searchRefreshPending && (this.searchRefreshPending = !1, this.scheduleSearchHighlightRefresh());
+    }
+  }
+  applySearchHighlights(t, e) {
+    if (!t || typeof t != "object") {
+      this.clearSearchHighlights();
+      return;
+    }
+    const i = t;
+    if (!!!i.enabled) {
+      this.clearSearchHighlights();
+      return;
+    }
+    const n = Array.isArray(i.matches) ? i.matches : [], o = i.current && typeof i.current == "object" ? i.current : null, l = o && Number.isFinite(Number(o.l)) ? `${Number(o.l)}:${Number(o.s)}:${Number(o.e)}` : null, a = [], u = 2e3, h = /* @__PURE__ */ new Map(), f = (c) => {
+      if (h.has(c)) return h.get(c);
+      const d = e.getLineContent(c) ?? "";
+      return h.set(c, d), d;
+    };
+    for (let c = 0; c < n.length && a.length < u; c += 1) {
+      const d = n[c], p = Number(d?.l), g = Number(d?.s), y = Number(d?.e);
+      if (!Number.isFinite(p) || !Number.isFinite(g) || !Number.isFinite(y)) continue;
+      const C = p + 1;
+      if (C < 1 || C > e.getLineCount()) continue;
+      const T = f(C), A = v(T, Math.max(0, g)) + 1, P = v(T, Math.max(0, y)) + 1;
+      if (P <= A) continue;
+      const B = `${p}:${g}:${y}`, K = l && B === l ? "monaco-neovim-search-current" : "monaco-neovim-search-match";
+      a.push({
+        range: new m.Range(C, A, C, P),
+        options: { inlineClassName: K }
+      });
+    }
+    this.ensureSearchStyle();
+    try {
+      this.searchDecorationIds = this.editor.deltaDecorations(this.searchDecorationIds, a);
+    } catch {
+      this.searchDecorationIds = [];
+    }
+  }
+  applyVisualDecorations(t, e) {
+    this.ensureVisualStyle();
+    const s = fe(e) === "V", n = [];
+    if (s) {
+      let o = 1 / 0, l = -1 / 0;
+      for (const a of t) {
+        const u = a.getStartPosition(), h = a.getEndPosition();
+        o = Math.min(o, u.lineNumber, h.lineNumber), l = Math.max(l, u.lineNumber, h.lineNumber);
+      }
+      Number.isFinite(o) && Number.isFinite(l) && l >= o && n.push({
+        range: new m.Range(o, 1, l, 1),
+        options: { isWholeLine: !0, className: "monaco-neovim-visual-line" }
+      });
+    } else
+      for (const o of t) {
+        const l = o.getStartPosition(), a = o.getEndPosition();
+        n.push({
+          range: m.Range.fromPositions(l, a),
+          options: { inlineClassName: "monaco-neovim-visual-inline" }
+        });
+      }
+    try {
+      this.visualDecorationIds = this.editor.deltaDecorations(this.visualDecorationIds, n), this.visualSelectionActive = n.length > 0;
+    } catch {
+      this.visualDecorationIds = [], this.visualSelectionActive = !1;
+    }
+  }
+  applyNvimMode(t) {
+    const e = typeof t == "string" ? t : "";
+    if (!e || e === this.lastMode) return;
+    this.lastMode = e;
+    const i = de(e);
+    if (i !== this.delegateInsertToMonaco) {
+      this.delegateInsertToMonaco = i;
+      const s = this.ensureActiveState();
+      i ? (this.setPreedit(null), s && (s.shadowLines = this.editor.getModel()?.getLinesContent() ?? null, s.pendingBufEdits = [], s.pendingFullSync = !1, s.pendingCursorSync = !1)) : s && ((s.pendingBufEdits.length || s.pendingCursorSync || s.pendingFullSync) && this.flushPendingMonacoSync(), s.shadowLines = null, s.pendingBufEdits = [], s.pendingFullSync = !1, s.pendingCursorSync = !1);
+    }
+    this.applyCursorStyle(e), this.opts.onModeChange && this.opts.onModeChange(e), this.updateVisualSelection(e), this.scheduleSearchHighlightRefresh();
+  }
+  handleKey(t) {
+    const e = t.browserEvent;
+    if (e.defaultPrevented && e.key !== "Escape") return;
+    if (this.delegateInsertToMonaco) {
+      if (e.key === "Escape") {
+        t.preventDefault(), this.flushPendingMonacoSync(), this.sendInput("<Esc>");
+        return;
+      }
+      if (!this.opts.shouldHandleKey(e) || this.hasExplicitModAllowlist(!0) && !this.shouldForwardModifiedKeys(e, !0))
+        return;
+      if (e.ctrlKey || e.altKey || e.metaKey) {
+        const s = this.opts.translateKey(e);
+        if (!s) return;
+        t.preventDefault(), this.flushPendingMonacoSync(), this.sendInput(s);
+        return;
+      }
+      return;
+    }
+    if (this.ignoreTextKeydownUntil > 0 && typeof e.key == "string" && e.key.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey && (typeof performance < "u" && performance.now ? performance.now() : Date.now()) < this.ignoreTextKeydownUntil)
+      return;
+    if (e.key === "Process" || e.keyCode === 229) {
+      this.compositionActive = !0;
+      return;
+    }
+    if (this.compositionActive || e.isComposing || !this.opts.shouldHandleKey(e) || this.hasExplicitModAllowlist(!1) && !this.shouldForwardModifiedKeys(e, !1))
+      return;
+    const i = this.opts.translateKey(e);
+    i && (this.ignoreNextInputEvent = !0, t.preventDefault(), this.sendInput(i));
+  }
+  handleMouse(t) {
+    if (this.delegateInsertToMonaco || !this.bufHandle || !t.target?.position) return;
+    const { lineNumber: e, column: i } = t.target.position, s = this.editor.getModel(), n = Math.max(0, i - 1), o = s ? s.getLineContent(e) ?? "" : "", l = s ? S(o, n) : n;
+    this.sendNotify("nvim_win_set_cursor", [0, [e, l]]);
+  }
+  sendInput(t) {
+    this.sendNotify("nvim_input", [t]);
+  }
+  modifiedKeyName(t) {
+    const e = t.key;
+    if (!e) return null;
+    if (e.length === 1)
+      return /^[A-Za-z]$/.test(e), e.toLowerCase();
+    switch (e) {
+      case "ArrowUp":
+        return "up";
+      case "ArrowDown":
+        return "down";
+      case "ArrowLeft":
+        return "left";
+      case "ArrowRight":
+        return "right";
+      case "Backspace":
+        return "backspace";
+      case "Delete":
+        return "delete";
+      default:
+        return null;
+    }
+  }
+  hasExplicitModAllowlist(t) {
+    return !!((t ? this.ctrlKeysInsert : this.ctrlKeysNormal) || (t ? this.altKeysInsert : this.altKeysNormal) || (t ? this.metaKeysInsert : this.metaKeysNormal));
+  }
+  shouldForwardModifiedKeys(t, e) {
+    const i = this.modifiedKeyName(t);
+    if (!i) return !1;
+    if (t.ctrlKey) {
+      const s = e ? this.ctrlKeysInsert : this.ctrlKeysNormal;
+      if (s && !s.has(i)) return !1;
+    }
+    if (t.altKey) {
+      const s = e ? this.altKeysInsert : this.altKeysNormal;
+      if (s && !s.has(i)) return !1;
+    }
+    if (t.metaKey) {
+      const s = e ? this.metaKeysInsert : this.metaKeysNormal;
+      if (s && !s.has(i)) return !1;
+    }
+    return !0;
+  }
+  pasteText(t) {
+    const e = String(t ?? "");
+    if (!e) return;
+    const i = e.includes(`\r
+`);
+    this.sendNotify("nvim_paste", [e, i, -1]);
+  }
+  handleMonacoModelChange(t) {
+    if (!this.delegateInsertToMonaco || this.applyingFromNvim || !this.session || !this.session.isRunning() || !this.bufHandle) return;
+    const e = this.editor.getModel();
+    if (!e) return;
+    const i = this.ensureActiveState();
+    if (!i || i.model !== e) return;
+    if (!i.shadowLines) {
+      i.pendingFullSync = !0, i.pendingCursorSync = !0, i.shadowLines = e.getLinesContent(), this.scheduleFlushPendingMonacoSync();
+      return;
+    }
+    if (!t.changes || t.changes.length !== 1) {
+      i.pendingFullSync = !0, i.pendingCursorSync = !0, i.shadowLines = e.getLinesContent(), this.scheduleFlushPendingMonacoSync();
+      return;
+    }
+    const s = t.changes[0], n = s.range, o = n.startLineNumber - 1, l = n.endLineNumber - 1;
+    if (o < 0 || l < 0) return;
+    if (i.shadowLines[o] == null || i.shadowLines[l] == null) {
+      i.pendingFullSync = !0, i.pendingCursorSync = !0, i.shadowLines = e.getLinesContent(), this.scheduleFlushPendingMonacoSync();
+      return;
+    }
+    const a = i.shadowLines[o] ?? "", u = i.shadowLines[l] ?? "", h = Math.max(0, n.startColumn - 1), f = Math.max(0, n.endColumn - 1), c = S(a, h), d = S(u, f), p = String(s.text ?? ""), g = p.length ? p.split(/\r?\n/) : [];
+    i.pendingBufEdits.push({ startRow: o, startColByte: c, endRow: l, endColByte: d, lines: g }), pe(i.shadowLines, o, h, l, f, p), i.pendingCursorSync = !0, this.scheduleFlushPendingMonacoSync();
+  }
+  scheduleCursorSyncToNvim() {
+    if (!this.delegateInsertToMonaco) return;
+    const t = this.getActiveState();
+    t && (t.pendingCursorSync = !0, this.scheduleFlushPendingMonacoSync());
+  }
+  scheduleFlushPendingMonacoSync() {
+    this.cursorSyncTimer || (this.cursorSyncTimer = window.setTimeout(() => {
+      this.cursorSyncTimer = null, this.flushPendingMonacoSync();
+    }, 0));
+  }
+  flushPendingMonacoSync() {
+    if (!this.session || !this.session.isRunning() || !this.bufHandle) return;
+    const t = this.getActiveState();
+    if (!t) return;
+    const e = this.editor.getModel();
+    if (e && t.model === e) {
+      if (t.pendingFullSync) {
+        const i = e.getLinesContent();
+        this.sendNotify("nvim_buf_set_lines", [this.bufHandle, 0, -1, !1, i]), t.pendingFullSync = !1, t.pendingBufEdits = [], t.shadowLines = i.slice();
+      } else if (t.pendingBufEdits.length) {
+        for (const i of t.pendingBufEdits)
+          this.sendNotify("nvim_buf_set_text", [this.bufHandle, i.startRow, i.startColByte, i.endRow, i.endColByte, i.lines]);
+        t.pendingBufEdits = [];
+      }
+      t.pendingCursorSync && (t.pendingCursorSync = !1, this.syncCursorToNvimNow());
+    }
+  }
+  syncCursorToNvimNow() {
+    if (!this.session || !this.session.isRunning() || !this.bufHandle) return;
+    const t = this.editor.getModel(), e = this.editor.getPosition();
+    if (!t || !e) return;
+    const i = e.lineNumber, s = t.getLineContent(i) ?? "", n = S(s, Math.max(0, e.column - 1));
+    this.sendNotify("nvim_win_set_cursor", [0, [i, n]]);
+  }
+  scheduleVisualSelectionRefresh() {
+    this.visualSelectionRefreshTimer || (this.visualSelectionRefreshTimer = window.setTimeout(() => {
+      this.visualSelectionRefreshTimer = null, this.updateVisualSelection(this.lastMode || "n");
+    }, 16));
+  }
+  async installHostAutocmds() {
+    if (!this.hostAutocmdInstalled)
+      try {
+        const t = await this.rpcCall("nvim_get_api_info", []), e = Array.isArray(t) ? Number(t[0]) : NaN;
+        if (!Number.isFinite(e) || e <= 0) return;
+        this.nvimChannelId = e;
+        const i = this.opts.wrappedLineMotions ? "true" : "false", s = this.opts.scrollMotions ? "true" : "false", n = this.opts.syncScrolloff && this.opts.scrolloff == null ? "true" : "false", o = this.opts.hostCommands ? "true" : "false", l = `
+local chan = ...
+local api = vim.api
+vim.g.monaco_neovim_wasm_chan = chan
+
+local function send_cursor()
+  local cur = api.nvim_win_get_cursor(0)
+  vim.rpcnotify(chan, "monaco_cursor", cur[1], cur[2])
+end
+
+local function send_mode()
+  local m = api.nvim_get_mode().mode or ""
+  vim.rpcnotify(chan, "monaco_mode", m)
+end
+
+local function send_scrolloff()
+  local so = vim.o.scrolloff or 0
+  vim.rpcnotify(chan, "monaco_scrolloff", so)
+end
+
+if ${i} then
+  pcall(vim.cmd, "silent! source $HOME/.config/nvim/monaco-neovim-wasm/motion.vim")
+end
+
+if ${s} then
+  pcall(vim.cmd, "silent! source $HOME/.config/nvim/monaco-neovim-wasm/scrolling.vim")
+end
+if ${o} then
+  pcall(vim.cmd, "silent! source $HOME/.config/nvim/monaco-neovim-wasm/host-commands.vim")
+end
+
+local group = api.nvim_create_augroup("MonacoNeovimWasm", { clear = true })
+api.nvim_create_autocmd({ "CursorMoved", "CursorMovedI" }, {
+  group = group,
+  callback = function() send_cursor() end,
+})
+api.nvim_create_autocmd({ "ModeChanged", "InsertEnter", "InsertLeave" }, {
+  group = group,
+  callback = function() send_mode(); send_cursor() end,
+})
+api.nvim_create_autocmd({ "VisualEnter", "VisualLeave" }, {
+  group = group,
+  callback = function() send_mode(); send_cursor() end,
+})
+if ${n} then
+  api.nvim_create_autocmd({ "OptionSet" }, {
+    group = group,
+    pattern = { "scrolloff" },
+    callback = function() send_scrolloff() end,
+  })
+end
+api.nvim_create_autocmd({ "BufEnter", "BufWinEnter" }, {
+  group = group,
+  callback = function()
+    local b = api.nvim_get_current_buf()
+    local name = api.nvim_buf_get_name(b) or ""
+    local ft = (vim.bo[b] and vim.bo[b].filetype) or ""
+    vim.rpcnotify(chan, "monaco_buf_enter", { buf = b, name = name, filetype = ft })
+    send_cursor()
+  end,
+})
+api.nvim_create_autocmd({ "BufDelete" }, {
+  group = group,
+  callback = function(ev)
+    local b = (ev and ev.buf) or api.nvim_get_current_buf()
+    vim.rpcnotify(chan, "monaco_buf_delete", { buf = b })
+  end,
+})
+
+send_mode()
+send_cursor()
+send_scrolloff()
+vim.rpcnotify(chan, "monaco_buf_enter", {
+  buf = api.nvim_get_current_buf(),
+  name = api.nvim_buf_get_name(api.nvim_get_current_buf()) or "",
+  filetype = (vim.bo[api.nvim_get_current_buf()] and vim.bo[api.nvim_get_current_buf()].filetype) or "",
+})
+`;
+        await this.execLua(l, [e]), this.hostAutocmdInstalled = !0;
+      } catch {
+      }
+  }
+  async handleHostCommand(t) {
+    const e = typeof t.action == "string" ? t.action : "";
+    if (!e) return;
+    const i = { ...t, action: e };
+    if (this.opts.onHostCommand) {
+      try {
+        await this.opts.onHostCommand(i);
+      } catch {
+      }
+      return;
+    }
+    const s = this.opts.fileSystem;
+    if (!s) {
+      this.opts.status(`host command ignored: ${e}`, !0);
+      return;
+    }
+    if (e === "edit") {
+      const n = typeof i.path == "string" ? String(i.path) : "";
+      if (!n) {
+        this.opts.status("edit: no path (provide onHostCommand or fileSystem.readFile)", !0);
+        return;
+      }
+      if (!s.readFile) {
+        this.opts.status("edit: fileSystem.readFile not set", !0);
+        return;
+      }
+      try {
+        const o = await s.readFile(n);
+        if (o == null) return;
+        const l = o instanceof Uint8Array ? new TextDecoder().decode(o) : String(o);
+        await this.openText({ path: n, text: l }), this.opts.status(`opened: ${n}`);
+      } catch (o) {
+        this.opts.status(`edit failed: ${o?.message ?? o}`, !0);
+      }
+      return;
+    }
+    if (e === "write" || e === "wq") {
+      const n = this.editor.getModel(), o = n ? n.getValue() : "";
+      let l = typeof i.path == "string" ? String(i.path) : "";
+      if (!l)
+        try {
+          const a = await this.rpcCall("nvim_buf_get_name", [0]);
+          typeof a == "string" && (l = a);
+        } catch {
+        }
+      if (l || (l = this.opts.seedName), !s.writeFile) {
+        this.opts.status("write: fileSystem.writeFile not set", !0);
+        return;
+      }
+      try {
+        await s.writeFile(l, o);
+        try {
+          await this.rpcCall("nvim_buf_set_name", [0, l]);
+        } catch {
+        }
+        try {
+          await this.rpcCall("nvim_buf_set_option", [0, "modified", !1]);
+        } catch {
+        }
+        const a = this.getActiveState();
+        a && (a.name && a.name !== l && this.buffersByName.delete(a.name), a.name = l, this.buffersByName.set(l, a.id)), this.opts.status(`written: ${l}`), e === "wq" && this.opts.status("wq requested (provide onHostCommand to close the editor)");
+      } catch (a) {
+        this.opts.status(`write failed: ${a?.message ?? a}`, !0);
+      }
+      return;
+    }
+    if (e === "quit") {
+      this.opts.status("quit requested (provide onHostCommand to close the editor)");
+      return;
+    }
+    this.opts.status(`host command ignored: ${e}`, !0);
+  }
+  async handleBufEnter(t) {
+    const e = Number(t.buf);
+    if (!Number.isFinite(e) || e <= 0) return;
+    const i = typeof t.name == "string" ? String(t.name) : "", s = typeof t.filetype == "string" ? String(t.filetype) : "";
+    this.delegateInsertToMonaco && this.flushPendingMonacoSync();
+    let n = this.buffers.get(e) ?? null;
+    if (!n && this.bufHandle === e && (n = this.ensureActiveState()), !n) {
+      try {
+        await this.rpcCall("nvim_buf_attach", [e, !1, {}]);
+      } catch {
+      }
+      let l = [""];
+      try {
+        const c = await this.rpcCall("nvim_buf_get_lines", [e, 0, -1, !1]);
+        Array.isArray(c) && (l = c.map((d) => String(d ?? "")));
+      } catch {
+      }
+      const a = m.Uri.from({ scheme: "nvim", authority: "buf", path: `/${e}` }), u = l.join(`
+`), h = s && m.languages.getLanguages().some((c) => c.id === s), f = m.editor.createModel(u, h ? s : void 0, a);
+      n = {
+        id: e,
+        name: i || "",
+        filetype: s || "",
+        model: f,
+        createdModel: !0,
+        shadowLines: null,
+        pendingBufEdits: [],
+        pendingFullSync: !1,
+        pendingCursorSync: !1
+      }, this.buffers.set(e, n);
+    }
+    if (i && (n.name = i), s && (n.filetype = s), n.name && this.buffersByName.set(n.name, e), this.bufHandle = e, this.editor.getModel() !== n.model) {
+      this.suppressCursorSync = !0;
+      try {
+        this.editor.setModel(n.model);
+      } catch {
+      }
+      this.suppressCursorSync = !1;
+    }
+    if (this.delegateInsertToMonaco) {
+      try {
+        n.shadowLines = n.model.getLinesContent();
+      } catch {
+        n.shadowLines = null;
+      }
+      n.pendingBufEdits = [], n.pendingFullSync = !1, n.pendingCursorSync = !1;
+    }
+    this.opts.syncTabstop && this.syncTabstopFromMonaco(), this.scheduleSearchHighlightRefresh();
+  }
+  handleBufDelete(t) {
+    const e = Number(t.buf);
+    if (!Number.isFinite(e) || e <= 0) return;
+    const i = this.buffers.get(e);
+    if (i && (this.buffers.delete(e), i.name && this.buffersByName.delete(i.name), i.createdModel))
+      try {
+        i.model.dispose();
+      } catch {
+      }
+  }
+  async openText({ path: t, text: e }) {
+    if (!this.session || !this.session.isRunning()) return;
+    const i = String(e ?? "").split(/\r?\n/), s = String(t ?? "");
+    if (!s) return;
+    let n = this.buffersByName.get(s) ?? null;
+    if (!n)
+      try {
+        const o = await this.rpcCall("nvim_create_buf", [!0, !1]);
+        n = _(o) ?? Number(o);
+      } catch {
+        n = null;
+      }
+    if (!(!n || !Number.isFinite(n) || n <= 0)) {
+      try {
+        await this.rpcCall("nvim_buf_set_lines", [n, 0, -1, !1, i]);
+      } catch {
+      }
+      try {
+        await this.rpcCall("nvim_buf_set_name", [n, s]);
+      } catch {
+      }
+      try {
+        await this.rpcCall("nvim_buf_set_option", [n, "modified", !1]);
+      } catch {
+      }
+      try {
+        await this.rpcCall("nvim_win_set_buf", [0, n]);
+      } catch {
+      }
+    }
+  }
+  sendNotify(t, e = []) {
+    this.session?.notify(t, e);
+  }
+  sendRpcResponse(t, e, i) {
+    this.session?.respond(t, e, i);
+  }
+  rpcCall(t, e = []) {
+    return this.session ? this.session.call(t, e) : Promise.reject(new Error("session not started"));
+  }
+  doClipboardPaste(t) {
+    const e = (s) => {
+      const n = (s || "").split(/\r?\n/);
+      this.sendRpcResponse(t, null, [n, "v"]);
+    }, i = this.opts.clipboard;
+    if (i === null) {
+      e("");
+      return;
+    }
+    if (i?.readText) {
+      i.readText().then((s) => e(s || "")).catch(() => {
+        const s = window.prompt("Paste text");
+        e(s || "");
+      });
+      return;
+    }
+    if (!navigator.clipboard?.readText) {
+      const s = window.prompt("Paste text");
+      e(s || "");
+      return;
+    }
+    navigator.clipboard.readText().then((s) => e(s || "")).catch(() => e(""));
+  }
+  updateCursor(t, e) {
+    const i = this.editor.getModel(), s = Math.max(1, Number(t) || 1), n = Math.max(1, Number(e) || 1), o = i ? i.validatePosition(new m.Position(s, n)) : new m.Position(s, n);
+    if (this.lastCursorPos = o, this.compositionActive) return;
+    const l = this.editor.getPosition();
+    l && l.lineNumber === o.lineNumber && l.column === o.column || (this.suppressCursorSync = !0, this.editor.setPosition(this.lastCursorPos), this.visualSelectionActive && this.editor.setSelection(new m.Selection(o.lineNumber, o.column, o.lineNumber, o.column)), this.applyScrolloff(this.lastCursorPos) || this.editor.revealPositionInCenterIfOutsideViewport(this.lastCursorPos), this.suppressCursorSync = !1), this.scheduleSearchHighlightRefresh();
+  }
+  scheduleCursorRefresh() {
+    if (this.compositionActive || this.cursorRefreshTimer) return;
+    const t = typeof performance < "u" && performance.now ? performance.now() : Date.now(), e = this.optimisticCursorUntil > t ? Math.max(30, Math.min(180, this.optimisticCursorUntil - t)) : 30;
+    this.cursorRefreshTimer = window.setTimeout(() => {
+      this.cursorRefreshTimer = null, this.refreshCursorMode();
+    }, e);
+  }
+  async refreshCursorMode() {
+    if (this.compositionActive) return;
+    const t = typeof performance < "u" && performance.now ? performance.now() : Date.now();
+    if (this.optimisticCursorUntil > t) {
+      this.scheduleCursorRefresh();
+      return;
+    }
+    if (this.cursorRefreshInFlight) {
+      this.cursorRefreshPending = !0;
+      return;
+    }
+    this.cursorRefreshInFlight = !0;
+    try {
+      const e = await this.rpcCall("nvim_win_get_cursor", [0]);
+      if (Array.isArray(e) && e.length >= 2) {
+        const i = Number(e[0]), s = Number(e[1]), n = L(this.editor, i, s), o = new m.Position(n.line, n.col), l = typeof performance < "u" && performance.now ? performance.now() : Date.now();
+        if (this.optimisticCursorPos && this.optimisticCursorUntil > l) {
+          const a = this.optimisticCursorPrevPos;
+          a && o.lineNumber === a.lineNumber && o.column === a.column || o.lineNumber < this.optimisticCursorPos.lineNumber || o.lineNumber === this.optimisticCursorPos.lineNumber && o.column < this.optimisticCursorPos.column || (this.optimisticCursorPos = null, this.optimisticCursorPrevPos = null, this.optimisticCursorUntil = 0, this.updateCursor(o.lineNumber, o.column));
+        } else
+          this.optimisticCursorPos = null, this.optimisticCursorPrevPos = null, this.optimisticCursorUntil = 0, this.updateCursor(o.lineNumber, o.column);
+      }
+      if (!this.lastMode)
+        try {
+          const i = await this.rpcCall("nvim_get_mode", []);
+          if (i && typeof i.mode == "string") {
+            const s = i.mode;
+            this.lastMode = s, this.applyCursorStyle(s), this.opts.onModeChange && this.opts.onModeChange(s);
+          }
+        } catch {
+        }
+      await this.updateVisualSelection(this.lastMode || "n");
+    } catch {
+    } finally {
+      this.cursorRefreshInFlight = !1, this.cursorRefreshPending && (this.cursorRefreshPending = !1, this.refreshCursorMode());
+    }
+  }
+  applyCursorStyle(t) {
+    const e = typeof t == "string" ? t : "", i = e.startsWith("i") || e.startsWith("R"), s = i ? "line" : "block", n = i ? "blink" : "solid", o = i ? this.initialCursorWidth || 1 : this.typicalFullWidth;
+    s === this.lastCursorStyle && n === this.lastCursorBlink && o === this.lastCursorWidth || (this.editor.updateOptions({ cursorStyle: s, cursorBlinking: n, cursorWidth: o }), this.lastCursorStyle = s, this.lastCursorBlink = n, this.lastCursorWidth = o);
+  }
+  async updateVisualSelection(t) {
+    const e = E(t), i = ++this.visualSelectionToken;
+    if (!e) {
+      this.clearVisualDecorations();
+      return;
+    }
+    try {
+      const s = await this.fetchVisualRanges();
+      if (i !== this.visualSelectionToken || !s.length) return;
+      this.applyVisualDecorations(s, t);
+    } catch {
+    }
+  }
+  async fetchVisualRanges() {
+    const t = await this.execLua(ie, []);
+    return Array.isArray(t) ? t.map(ae(this.editor)).filter((i) => !!i) : [];
+  }
+  async syncVisualSelectionColor() {
+    try {
+      const e = await this.fetchVisualBg() || "#3e4451", i = D(e, 0.45), s = D(e, 0.3);
+      m.editor.defineTheme(this.opts.visualThemeName, {
+        base: "vs-dark",
+        inherit: !0,
+        rules: [],
+        colors: {
+          "editor.selectionBackground": i,
+          "editor.selectionHighlightBackground": s
+        }
+      }), this.editor.updateOptions({ theme: this.opts.visualThemeName }), this.setVisualBgCss(i);
+    } catch {
+    }
+  }
+  async fetchVisualBg() {
+    try {
+      const t = await this.rpcCall("nvim_get_hl", [0, { name: "Visual", link: !1 }]), e = F(t);
+      if (e) return e;
+    } catch {
+    }
+    try {
+      const t = await this.rpcCall("nvim_get_hl_by_name", ["Visual", !0]), e = F(t);
+      if (e) return e;
+    } catch {
+    }
+    return null;
+  }
+  async seedBuffer(t, e) {
+    const i = _(t);
+    if (!i || i <= 0) return null;
+    const s = e ?? this.opts.seedLines;
+    if (!s || !s.length) return null;
+    try {
+      return await this.rpcCall("nvim_buf_set_lines", [i, 0, -1, !1, s]), await this.rpcCall("nvim_buf_set_option", [i, "modifiable", !0]), await this.rpcCall("nvim_buf_set_option", [i, "modified", !0]), await this.rpcCall("nvim_buf_set_option", [i, "buftype", ""]), await this.rpcCall("nvim_buf_set_option", [i, "filetype", this.opts.seedFiletype]), await this.rpcCall("nvim_buf_set_name", [i, this.opts.seedName]), s;
+    } catch {
+      return null;
+    }
+  }
+}
+function ge(r, t = {}) {
+  return new se(r, t);
+}
+function w(r, t, e) {
+  return Math.min(Math.max(r, t), e);
+}
+function L(r, t, e) {
+  const i = Math.max(1, Number(t) || 1), s = Math.max(1, (Number(e) || 0) + 1), n = r.getModel();
+  if (!n)
+    return { line: i, col: s };
+  const o = n.getLineCount(), l = w(i, 1, o), a = n.getLineContent(l) ?? "", u = n.getLineMaxColumn(l), h = Math.max(0, Number(e) || 0), f = v(a, h), c = w(f + 1, 1, u);
+  return { line: l, col: c };
+}
+function oe(r) {
+  const t = r.key;
+  if (!t || t === "Dead" || t === "Unidentified") return null;
+  const e = r.ctrlKey, i = r.altKey, s = r.metaKey, n = r.shiftKey, o = (l, a = !1) => {
+    const u = [];
+    return e && u.push("C-"), a && n && u.push("S-"), i && u.push("A-"), s && u.push("D-"), u.length ? `<${u.join("")}${l}>` : `<${l}>`;
+  };
+  switch (t) {
+    case "Backspace":
+      return o("BS", !0);
+    case "Enter":
+      return o("CR", !0);
+    case "Escape":
+      return o("Esc", !0);
+    case "Tab":
+      return n && !e && !i && !s ? "<S-Tab>" : o("Tab", !0);
+    case "ArrowUp":
+      return o("Up", !0);
+    case "ArrowDown":
+      return o("Down", !0);
+    case "ArrowLeft":
+      return o("Left", !0);
+    case "ArrowRight":
+      return o("Right", !0);
+    case "Delete":
+      return o("Del", !0);
+    case "Home":
+      return o("Home", !0);
+    case "End":
+      return o("End", !0);
+    case "PageUp":
+      return o("PageUp", !0);
+    case "PageDown":
+      return o("PageDown", !0);
+    case "Insert":
+      return o("Insert", !0);
+  }
+  if (/^F\d{1,2}$/.test(t)) return o(t, !0);
+  if (t.length === 1) {
+    if (!e && !i && !s) return t;
+    if (t === " " && e && !i && !s) return "<Nul>";
+    const l = /^[A-Za-z]$/.test(t) ? t.toLowerCase() : t;
+    return `<${(e ? "C-" : "") + (i ? "A-" : "") + (s ? "D-" : "")}${l}>`;
+  }
+  return null;
+}
+function re(r) {
+  if (!r || r.length === 0) return null;
+  const t = r[0];
+  if (r.length === 1)
+    return t <= 127 ? t : t - 256;
+  const e = new DataView(r.buffer, r.byteOffset, r.byteLength);
+  switch (t) {
+    case 204:
+      return e.getUint8(1);
+    case 205:
+      return e.getUint16(1);
+    case 206:
+      return e.getUint32(1);
+    case 207:
+      return Number(e.getBigUint64(1));
+    case 208:
+      return e.getInt8(1);
+    case 209:
+      return e.getInt16(1);
+    case 210:
+      return e.getInt32(1);
+    case 211:
+      return Number(e.getBigInt64(1));
+    default:
+      return t;
+  }
+}
+function le(r) {
+  return r instanceof Uint8Array ? r : r instanceof ArrayBuffer ? new Uint8Array(r) : Array.isArray(r) ? new Uint8Array(r) : Number.isInteger(r) ? new Uint8Array([r & 255]) : r && r.type === "Buffer" && Array.isArray(r.data) ? new Uint8Array(r.data) : null;
+}
+function _(r) {
+  if (r && typeof r == "object" && typeof r.type == "number") {
+    const e = le(r.data);
+    if (e) {
+      const i = re(e);
+      if (i != null && i > 0) return i;
+    }
+  }
+  const t = Number(r);
+  return Number.isInteger(t) && t > 0 ? t : null;
+}
+function v(r, t) {
+  let e = 0, i = 0;
+  const s = Math.max(0, Number(t) || 0);
+  for (; e < s; ) {
+    if (i >= r.length)
+      return i + (s - e);
+    const n = r.codePointAt(i), o = R(n ?? 0);
+    e += o, i += o === 4 ? 2 : 1;
+  }
+  return i;
+}
+function S(r, t) {
+  const e = Math.max(0, Number(t) || 0);
+  let i = 0, s = 0;
+  for (; s < e && s < r.length; ) {
+    const n = r.codePointAt(s), o = R(n ?? 0);
+    i += o, s += o === 4 ? 2 : 1;
+  }
+  return i;
+}
+function R(r) {
+  return r == null ? 0 : r <= 127 ? 1 : r <= 2047 ? 2 : r >= 55296 && r <= 57343 ? 4 : r < 65535 ? 3 : 4;
+}
+function ae(r) {
+  return (t) => {
+    if (!t || !t.start || !t.end) return null;
+    const e = k(r, t.start, !1), i = k(r, t.end, !!t.inclusive);
+    return !e || !i ? null : new m.Selection(e.lineNumber, e.column, i.lineNumber, i.column);
+  };
+}
+function k(r, t, e) {
+  if (!t || typeof t.line != "number" || typeof t.col != "number") return null;
+  const i = r.getModel(), s = w(t.line + 1, 1, i?.getLineCount() || 1 / 0);
+  if (!i) {
+    const h = Math.max(1, t.col + 1);
+    return { lineNumber: s, column: h + (e ? 1 : 0) };
+  }
+  const n = i.getLineContent(s) ?? "", o = Math.max(0, Number(t.col) || 0);
+  let l = o;
+  if (e) {
+    const h = v(n, o);
+    if (h < n.length) {
+      const f = n.codePointAt(h);
+      l = o + R(f ?? 0);
+    }
+  }
+  const a = v(n, l) + 1, u = i.getLineMaxColumn(s);
+  return { lineNumber: s, column: w(a, 1, u) };
+}
+function E(r) {
+  const t = typeof r == "string" ? r : "";
+  return t.includes("v") || t.includes("V") || t.includes("") || t.includes("s") || t.includes("S") || t.includes("");
+}
+function ce(r) {
+  if (!r || !Array.isArray(r) || r.length === 0) return;
+  const t = new TextEncoder(), e = [];
+  for (const i of r) {
+    if (!i) continue;
+    const s = String(i.path ?? "");
+    if (!s) continue;
+    const n = i.data;
+    n instanceof Uint8Array ? e.push({ path: s, data: n }) : e.push({ path: s, data: t.encode(String(n ?? "")) });
+  }
+  return e.length ? e : void 0;
+}
+function ue(r, t) {
+  const e = Array.isArray(t) ? t.filter(Boolean) : [], i = Array.isArray(r) ? r.filter(Boolean) : [], s = [...e, ...i];
+  return s.length ? s : void 0;
+}
+function D(r, t) {
+  const e = r.replace("#", "");
+  if (e.length !== 6) return r;
+  const i = Math.round(w(t, 0, 1) * 255);
+  return `#${e}${i.toString(16).padStart(2, "0")}`;
+}
+function F(r) {
+  if (!r || typeof r != "object") return null;
+  const t = r, e = t.background ?? t.bg;
+  return typeof e == "number" && e >= 0 ? he(e) : typeof t.background == "string" && t.background.startsWith("#") ? t.background : typeof t.bg == "string" && t.bg.startsWith("#") ? t.bg : null;
+}
+function he(r) {
+  return `#${Number(r >>> 0).toString(16).padStart(6, "0").slice(-6)}`;
+}
+function b(r, t, e, i) {
+  return r.addEventListener(t, e, i), { dispose: () => r.removeEventListener(t, e, i) };
+}
+function de(r) {
+  const t = typeof r == "string" ? r : "";
+  return t.startsWith("i") || t.startsWith("R");
+}
+function fe(r) {
+  const t = typeof r == "string" ? r : "";
+  return t.length ? t[t.length - 1] : "";
+}
+function pe(r, t, e, i, s, n) {
+  const o = r[t] ?? "", l = r[i] ?? "", a = o.slice(0, Math.max(0, e)), u = l.slice(Math.max(0, s)), f = String(n ?? "").split(/\r?\n/);
+  let c;
+  if (f.length <= 1)
+    c = [`${a}${f[0] ?? ""}${u}`];
+  else {
+    const d = `${a}${f[0] ?? ""}`, p = `${f[f.length - 1] ?? ""}${u}`, g = f.slice(1, -1);
+    c = [d, ...g, p];
+  }
+  r.splice(t, Math.max(0, i - t + 1), ...c);
+}
+function M(r) {
+  if (!r) return "";
+  if (typeof r == "string") return r;
+  if (!Array.isArray(r)) return "";
+  let t = "";
+  for (const e of r) {
+    if (typeof e == "string") {
+      t += e;
+      continue;
+    }
+    if (Array.isArray(e)) {
+      typeof e[1] == "string" ? t += e[1] : typeof e[0] == "string" ? t += e[0] : t += M(e);
+      continue;
+    }
+    e && typeof e == "object" && typeof e.text == "string" && (t += e.text);
+  }
+  return t;
+}
+function me(r) {
+  if (!Array.isArray(r)) return [];
+  const t = [];
+  for (const e of r) {
+    if (Array.isArray(e)) {
+      t.push({
+        word: String(e[0] ?? ""),
+        kind: e[1] == null ? void 0 : String(e[1]),
+        menu: e[2] == null ? void 0 : String(e[2]),
+        info: e[3] == null ? void 0 : String(e[3])
+      });
+      continue;
+    }
+    if (e && typeof e == "object") {
+      const i = e, s = i.word ?? i.abbr ?? i.text;
+      s != null && t.push({ word: String(s), kind: i.kind ? String(i.kind) : void 0, menu: i.menu ? String(i.menu) : void 0, info: i.info ? String(i.info) : void 0 });
+    }
+  }
+  return t.filter((e) => e.word.length > 0);
+}
+const ye = new URL("./nvimWorker.js", import.meta.url), be = new URL("./nvimWorkerAsyncify.js", import.meta.url);
+export {
+  se as MonacoNeovimClient,
+  Y as NeovimWasmSession,
+  ge as createMonacoNeovim,
+  ye as defaultWorkerUrl,
+  be as defaultWorkerUrlAsyncify,
+  G as isSharedArrayBufferAvailable
+};