@monaco-neovim-wasm/lib 0.1.18 → 0.1.20

package/dist/client/bufferSync.d.ts

@@ -0,0 +1,92 @@
+import * as monaco from "monaco-editor";
+import type { editor as MonacoEditor } from "monaco-editor";
+export type PendingBufSetText = {
+    startRow: number;
+    startColByte: number;
+    endRow: number;
+    endColByte: number;
+    lines: string[];
+};
+export type BufferState = {
+    id: number;
+    name: string;
+    filetype: string;
+    model: monaco.editor.ITextModel;
+    createdModel: boolean;
+    shadowLines: string[] | null;
+    pendingBufEdits: PendingBufSetText[];
+    pendingFullSync: boolean;
+    pendingCursorSync: boolean;
+};
+export type BufferSyncManagerInit = {
+    editor: MonacoEditor.IStandaloneCodeEditor;
+    nowMs: () => number;
+    debugLog: (line: string) => void;
+    rpcCall: (method: string, params: unknown[]) => Promise<any>;
+    sendNotify: (method: string, params: unknown[]) => void;
+    isSessionRunning: () => boolean;
+    getBufHandle: () => number | null;
+    getActiveState: () => BufferState | null;
+    ensureActiveState: () => BufferState | null;
+    getBufferState: (id: number) => BufferState | null;
+    isDelegateInsertToMonaco: () => boolean;
+    isExitingInsertMode: () => boolean;
+    isCompositionActive: () => boolean;
+    setPendingResyncAfterComposition: (pending: boolean) => void;
+    getSyncModelFromMonaco: () => "insertOnly" | "always" | "never";
+    getInsertSyncDebounceMs: () => number;
+    scheduleVisualSelectionRefresh: () => void;
+    getLastMode: () => string;
+    isVisualMode: (mode: string) => boolean;
+    incrementPendingNvimBufUpdates: () => void;
+    decrementPendingNvimBufUpdates: () => number;
+    isPendingVisualRefresh: () => boolean;
+    setPendingVisualRefresh: (pending: boolean) => void;
+    getLastCursorPos: () => monaco.Position | null;
+    getEditorPosition: () => monaco.Position | null;
+    setSuppressCursorSync: (suppress: boolean) => void;
+    setApplyingFromNvim: (applying: boolean) => void;
+    isApplyingFromNvim: () => boolean;
+    syncCursorToNvimNow: () => void;
+};
+export type MonacoModelChangeResult = {
+    kind: "noop";
+} | {
+    kind: "resyncScheduled";
+} | {
+    kind: "syncToNvimScheduled";
+} | {
+    kind: "delegatedInsertPatched";
+    dotRepeat?: {
+        deleted: number;
+        text: string;
+        simple: boolean;
+    };
+    resetDotRepeat?: boolean;
+    resetReplayPossible?: boolean;
+};
+export declare class BufferSyncManager {
+    private readonly init;
+    private resyncTimer;
+    private monacoToNvimTimer;
+    private flushTimer;
+    private ignoreActiveBufLinesEventsUntil;
+    constructor(init: BufferSyncManagerInit);
+    reset(): void;
+    cancelPendingFlush(): void;
+    scheduleResync(): void;
+    private resyncBufferFromNvim;
+    scheduleSyncBufferToNvim(): void;
+    syncBufferToNvimNow(): void;
+    applyBuffer(lines?: string[]): void;
+    handleMonacoModelChange(ev: monaco.editor.IModelContentChangedEvent): MonacoModelChangeResult;
+    scheduleCursorSyncToNvim(): void;
+    private scheduleFlushPendingMonacoSync;
+    flushPendingMonacoSync(): void;
+    flushPendingMonacoSyncBlocking(): Promise<void>;
+    handleNvimBufLinesEvent(params: unknown[], extractBufId: (val: unknown) => number | null): Promise<void>;
+    private computeLinePatch;
+    private applyLinePatch;
+    private applyLinePatchToModel;
+    private setModelText;
+}

package/dist/client/buffers.d.ts

@@ -0,0 +1,42 @@
+import type { editor as MonacoEditor } from "monaco-editor";
+import type { BufferState } from "./bufferSync";
+export type BufferManagerInit = {
+    editor: MonacoEditor.IStandaloneCodeEditor;
+};
+export declare class BufferManager {
+    private readonly editor;
+    private readonly buffers;
+    private readonly buffersByName;
+    constructor(init: BufferManagerInit);
+    getById(id: number): BufferState | null;
+    getIdByName(name: string): number | null;
+    getActiveState(bufHandle: number | null): BufferState | null;
+    ensureState(bufHandle: number | null): BufferState | null;
+    clear(): void;
+    detach(id: number): void;
+    delete(id: number): void;
+    setName(id: number, name: string): void;
+    setFiletype(id: number, filetype: string): void;
+    enterBuffer(arg: {
+        buf: number;
+        name?: string;
+        filetype?: string;
+    }, deps: {
+        bufHandle: number | null;
+        setBufHandle: (id: number) => void;
+        rpcCall: (method: string, params: unknown[]) => Promise<any>;
+        setSuppressCursorSync: (suppress: boolean) => void;
+        delegateInsertToMonaco: boolean;
+        flushPendingBeforeSwitch?: () => void;
+        syncTabstopFromMonaco?: () => void;
+        syncTabstop: boolean;
+        requestSearchHighlightRefresh: () => void;
+    }): Promise<void>;
+    openText(input: {
+        path: string;
+        text: string;
+    }, deps: {
+        rpcCall: (method: string, params: unknown[]) => Promise<any>;
+        extractBufId: (val: unknown) => number | null;
+    }): Promise<void>;
+}

package/dist/client/clipboard.d.ts

@@ -0,0 +1,15 @@
+import type { ClipboardAdapter, StatusEmitter } from "../types";
+export type ClipboardManagerInit = {
+    adapter?: ClipboardAdapter | null;
+    status?: StatusEmitter;
+    getLastClipboardText: () => string;
+    setLastClipboardText: (text: string) => void;
+    sendRpcResponse: (msgid: number, error: unknown, result: unknown) => void;
+    debugLog?: (line: string) => void;
+};
+export declare class ClipboardManager {
+    private readonly init;
+    constructor(init: ClipboardManagerInit);
+    handleCopy(lines: string[]): void;
+    handlePaste(msgid: number): void;
+}

package/dist/client/cursor.d.ts

@@ -0,0 +1,45 @@
+import * as monaco from "monaco-editor";
+import type { editor as MonacoEditor } from "monaco-editor";
+export type CursorManagerInit = {
+    editor: MonacoEditor.IStandaloneCodeEditor;
+    nowMs: () => number;
+    debugLog: (line: string) => void;
+    isCompositionActive: () => boolean;
+    setSuppressCursorSync: (suppress: boolean) => void;
+    isSessionRunning: () => boolean;
+    rpcCall: (method: string, params: unknown[]) => Promise<any>;
+    getLastMode: () => string;
+    setLastMode: (mode: string) => void;
+    onModeChange?: (mode: string) => void;
+};
+export declare class CursorManager {
+    private readonly init;
+    private lastCursorPos;
+    private lastCursorStyle;
+    private lastCursorBlink;
+    private lastCursorWidth;
+    private initialCursorWidth;
+    private typicalFullWidth;
+    private optimisticCursorUntil;
+    private optimisticCursorPos;
+    private optimisticCursorPrevPos;
+    private cursorRefreshTimer;
+    private cursorRefreshInFlight;
+    private cursorRefreshPending;
+    private cursorUpdateTimer;
+    private pendingCursorUpdate;
+    constructor(init: CursorManagerInit);
+    reset(): void;
+    setCursorMetricsFromEditor(): void;
+    getLastCursorPos(): monaco.Position | null;
+    setLastCursorPos(pos: monaco.Position | null): void;
+    applyCursorStyle(mode: string): void;
+    applyOptimisticInsert(text: string, isCmdlineVisible: () => boolean): void;
+    scheduleCursorUpdate(lineNumber: number, column: number, applyCursorSelectionFromNvim: (ln: number, col: number) => Promise<void>): void;
+    scheduleCursorRefresh(refreshCursorMode: () => Promise<unknown>): void;
+    refreshCursorMode(applyCursorSelectionFromNvim: (ln: number, col: number) => Promise<void>): Promise<boolean>;
+}
+export declare function clampCursor(editor: MonacoEditor.IStandaloneCodeEditor, ln: number, col0: number): {
+    line: number;
+    col: number;
+};

package/dist/client/editorCursorPosition.d.ts

@@ -0,0 +1,22 @@
+import * as monaco from "monaco-editor";
+import type { editor as MonacoEditor } from "monaco-editor";
+export type CursorPositionHandlerInit = {
+    editor: MonacoEditor.IStandaloneCodeEditor;
+    nowMs: () => number;
+    getLastCursorPos: () => monaco.Position | null;
+    setLastCursorPos: (pos: monaco.Position) => void;
+    isDelegatingInsert: () => boolean;
+    isSuppressCursorSync: () => boolean;
+    getLastMode: () => string;
+    getIgnoreMonacoCursorSyncToNvimUntil: () => number;
+    isCompositionActive: () => boolean;
+    positionPreedit: () => void;
+    scheduleCursorSyncToNvim: () => void;
+    syncCursorToNvimNow: (force: boolean) => void;
+    restorePendingSelections: () => boolean;
+};
+export declare class CursorPositionHandler {
+    private readonly init;
+    constructor(init: CursorPositionHandlerInit);
+    handle(ev: monaco.editor.ICursorPositionChangedEvent): void;
+}

package/dist/client/editorListeners.d.ts

@@ -0,0 +1,35 @@
+import * as monaco from "monaco-editor";
+import type { editor as MonacoEditor } from "monaco-editor";
+export type DisposableLike = {
+    dispose(): void;
+};
+export type EditorListenersManagerInit = {
+    editor: MonacoEditor.IStandaloneCodeEditor;
+    instanceClassName: string;
+};
+export type EditorListenersHandlers = {
+    onDidChangeModel: () => void;
+    onKeyDown: (ev: monaco.IKeyboardEvent) => void;
+    onMouseDown: (ev: monaco.editor.IEditorMouseEvent) => void;
+    onDidChangeCursorSelection: (ev: monaco.editor.ICursorSelectionChangedEvent) => void;
+    onDidChangeCursorPosition: (ev: monaco.editor.ICursorPositionChangedEvent) => void;
+    onDidScrollChangePreedit: () => void;
+    onDidScrollChangeSearch: () => void;
+    onDidChangeConfiguration: (e: monaco.editor.ConfigurationChangedEvent) => void;
+    onDidLayoutChange?: () => void;
+    onDidChangeConfigurationLayout?: (e: monaco.editor.ConfigurationChangedEvent) => void;
+    onModelContentChange: (ev: monaco.editor.IModelContentChangedEvent) => void;
+    initTextInputListeners: () => DisposableLike[];
+};
+export declare class EditorListenersManager {
+    private readonly init;
+    private disposables;
+    private modelContentDisposable;
+    private originalOptions;
+    constructor(init: EditorListenersManagerInit);
+    private captureOriginalOptions;
+    private applyInstanceClass;
+    private attachActiveModelListener;
+    attach(handlers: EditorListenersHandlers): void;
+    detach(): void;
+}

package/dist/client/execLua.d.ts

@@ -0,0 +1,7 @@
+export type RpcCall = (method: string, params: unknown[]) => Promise<unknown>;
+export declare class ExecLuaClient {
+    private execLuaAvailable;
+    private readonly rpcCall;
+    constructor(rpcCall: RpcCall);
+    execLua<T = unknown>(code: string, args?: unknown[]): Promise<T>;
+}

package/dist/client/hostAutocmdInstaller.d.ts

@@ -0,0 +1,21 @@
+export type HostAutocmdInstallerInit = {
+    isClipboardEnabled: () => boolean;
+    isWrappedLineMotionsEnabled: () => boolean;
+    isScrollMotionsEnabled: () => boolean;
+    isSyncScrolloffEnabled: () => boolean;
+    hasScrolloffOverride: () => boolean;
+    isHostCommandsEnabled: () => boolean;
+    rpcCall: (method: string, params: unknown[]) => Promise<any>;
+    execLua: (code: string, args: unknown[]) => Promise<any>;
+};
+export declare class HostAutocmdInstaller {
+    private readonly init;
+    private installed;
+    private channelId;
+    constructor(init: HostAutocmdInstallerInit);
+    reset(): void;
+    isInstalled(): boolean;
+    markInstalledFromNotify(): void;
+    getChannelId(): number | null;
+    install(): Promise<void>;
+}

package/dist/client/hostAutocmds.d.ts

@@ -0,0 +1,8 @@
+export type HostAutocmdsLuaOptions = {
+    clipboard: boolean;
+    wrappedLineMotions: boolean;
+    scrollMotions: boolean;
+    syncScrolloff: boolean;
+    hostCommands: boolean;
+};
+export declare function buildHostAutocmdsLua(opts: HostAutocmdsLuaOptions): string;

package/dist/client/hostCommands.d.ts

@@ -0,0 +1,23 @@
+import type { editor as MonacoEditor } from "monaco-editor";
+import type { BufferState } from "./bufferSync";
+import type { BufferManager } from "./buffers";
+import type { FileSystemAdapter, HostCommand, StatusEmitter } from "../types";
+export type HostCommandManagerInit = {
+    editor: MonacoEditor.IStandaloneCodeEditor;
+    bufferManager: BufferManager;
+    fileSystem?: FileSystemAdapter | null;
+    onHostCommand?: (cmd: HostCommand) => void | Promise<void>;
+    status: StatusEmitter;
+    seedName: string;
+    rpcCall: (method: string, params: unknown[]) => Promise<any>;
+    openText: (args: {
+        path: string;
+        text: string;
+    }) => Promise<void>;
+    getActiveState: () => BufferState | null;
+};
+export declare class HostCommandManager {
+    private readonly init;
+    constructor(init: HostCommandManagerInit);
+    handle(arg: Record<string, unknown>): Promise<void>;
+}

package/dist/client/inputEventDeduper.d.ts

@@ -0,0 +1,14 @@
+export type InputEventDeduperInit = {
+    nowMs: () => number;
+};
+export declare class InputEventDeduper {
+    private readonly init;
+    private armed;
+    private untilMs;
+    private target;
+    constructor(init: InputEventDeduperInit);
+    reset(): void;
+    arm(target?: EventTarget | null, ms?: number): void;
+    shouldIgnore(target?: EventTarget | null): boolean;
+    clear(): void;
+}

package/dist/client/insertDelegation.d.ts

@@ -0,0 +1,72 @@
+import type { editor as MonacoEditor } from "monaco-editor";
+import type { BufferState } from "./bufferSync";
+export type InsertDelegationManagerInit = {
+    editor: MonacoEditor.IStandaloneCodeEditor;
+    nowMs: () => number;
+    debugLog: (line: string) => void;
+    setPreedit: (text: string | null) => void;
+    setEditorReadOnly: (readOnly: boolean) => void;
+    getRecordingRegister: () => string;
+    isNvimBlocking: () => boolean;
+    getActiveState: () => BufferState | null;
+    ensureActiveState: () => BufferState | null;
+    flushPendingMonacoSync: () => void;
+    flushPendingMonacoSyncBlocking: () => Promise<void>;
+    cancelPendingBufferFlush: () => void;
+    isSessionRunning: () => boolean;
+    getBufHandle: () => number | null;
+    rpcCall: (method: string, params: unknown[]) => Promise<any>;
+    sendInput: (keys: string) => void;
+};
+export type IgnoreInsertExitCursor = {
+    line: number;
+    col0: number;
+    untilMs: number;
+};
+export declare class InsertDelegationManager {
+    private readonly init;
+    private delegateInsertToMonaco;
+    private exitingInsertMode;
+    private pendingKeysAfterExit;
+    private exitInsertTimer;
+    private dotRepeatKeys;
+    private dotRepeatBackspaces;
+    private delegatedInsertReplayPossible;
+    private recentNormalKeys;
+    private lastDelegatedInsertPrefix;
+    private lastDelegatedDotRepeat;
+    private ignoreInsertExitCursor;
+    private ignoreMonacoCursorSyncToNvimUntil;
+    constructor(init: InsertDelegationManagerInit);
+    reset(): void;
+    isDelegating(): boolean;
+    isExitingInsertMode(): boolean;
+    getIgnoreMonacoCursorSyncToNvimUntil(): number;
+    recordRecentNormalKey(key: string): void;
+    getLastDelegatedDotRepeat(): {
+        prefix: string;
+        keys: string;
+    } | null;
+    clearLastDelegatedDotRepeat(): void;
+    setDelegatedInsertReplayPossible(possible: boolean): void;
+    appendPendingKeysAfterExit(keys: string): void;
+    shouldIgnoreInsertExitCursor(nowMs: number, ln: unknown, col0: unknown): boolean;
+    applyMode(mode: string): void;
+    armInsertExit(): void;
+    finalizeDelegatedInsertDotRepeat(): void;
+    exitDelegatedInsertMode(exitKey: string): void;
+    handleDelegatedInsertPatched(res: {
+        resetDotRepeat?: boolean;
+        resetReplayPossible?: boolean;
+        dotRepeat?: {
+            deleted: number;
+            text: string;
+        } | null;
+    }): void;
+    consumeDotRepeat(): {
+        keys: string;
+        backspaces: number;
+    };
+    setIgnoreInsertExitCursorFromEditor(): void;
+    private performDelegatedInsertExit;
+}

package/dist/client/keyAllowlist.d.ts

@@ -0,0 +1,20 @@
+export type KeyAllowlistManagerInit = {
+    ctrlKeysForNormalMode?: string[] | null;
+    ctrlKeysForInsertMode?: string[] | null;
+    altKeysForNormalMode?: string[] | null;
+    altKeysForInsertMode?: string[] | null;
+    metaKeysForNormalMode?: string[] | null;
+    metaKeysForInsertMode?: string[] | null;
+};
+export declare class KeyAllowlistManager {
+    private readonly ctrlKeysNormal;
+    private readonly ctrlKeysInsert;
+    private readonly altKeysNormal;
+    private readonly altKeysInsert;
+    private readonly metaKeysNormal;
+    private readonly metaKeysInsert;
+    constructor(init: KeyAllowlistManagerInit);
+    modifiedKeyName(ev: KeyboardEvent): string | null;
+    hasExplicitModAllowlist(insertMode: boolean): boolean;
+    shouldForwardModifiedKeys(ev: KeyboardEvent, insertMode: boolean): boolean;
+}

package/dist/client/keyHandler.d.ts

@@ -0,0 +1,39 @@
+import * as monaco from "monaco-editor";
+export type KeyHandlerInsertDelegation = {
+    isExitingInsertMode: () => boolean;
+    isDelegating: () => boolean;
+    exitDelegatedInsertMode: (key: string) => void;
+    appendPendingKeysAfterExit: (keys: string) => void;
+    getLastDelegatedDotRepeat: () => {
+        prefix: string;
+        keys: string;
+    } | null;
+    clearLastDelegatedDotRepeat: () => void;
+    recordRecentNormalKey: (key: string) => void;
+};
+export type KeyHandlerManagerInit = {
+    nowMs: () => number;
+    shouldHandleKey: (ev: KeyboardEvent) => boolean;
+    translateKey: (ev: KeyboardEvent) => string | null;
+    hasExplicitModAllowlist: (insertMode: boolean) => boolean;
+    shouldForwardModifiedKeys: (ev: KeyboardEvent, insertMode: boolean) => boolean;
+    getLastMode: () => string;
+    isCompositionActive: () => boolean;
+    setCompositionActive: (active: boolean) => void;
+    setPendingEscAfterComposition: (pending: boolean) => void;
+    insertDelegation: KeyHandlerInsertDelegation;
+    handleNormalModeKey: (key: string) => void;
+    armIgnoreNextInputEvent: (target?: EventTarget | null, ms?: number) => void;
+    flushPendingMonacoSync: () => void;
+    sendInput: (keys: string) => void;
+    scheduleCursorRefresh: () => void;
+    scheduleVisualSelectionRefresh: () => void;
+};
+export declare class KeyHandlerManager {
+    private readonly init;
+    private ignoreTextKeydownUntil;
+    constructor(init: KeyHandlerManagerInit);
+    reset(): void;
+    setIgnoreTextKeydownUntil(deadlineMs: number): void;
+    handleKey(ev: monaco.IKeyboardEvent): void;
+}

package/dist/client/modes.d.ts

@@ -0,0 +1,3 @@
+export declare function isVisualMode(mode: string): boolean;
+export declare function isInsertLike(mode: string): boolean;
+export declare function isCmdlineLike(mode: string): boolean;

package/dist/client/monacoNeovimClient.d.ts

@@ -0,0 +1,141 @@
+import type { editor as MonacoEditor } from "monaco-editor";
+import { NeovimWasmSession } from "../neovimWasmSession";
+import type { MonacoNeovimOptions } from "../types";
+export type { ClipboardAdapter, FileSystemAdapter, HostCommand, MonacoNeovimOptions, PopupMenuItem, StatusEmitter } from "../types";
+export declare class MonacoNeovimClient {
+    private readonly editor;
+    private readonly opts;
+    private session;
+    private readonly notifyHandlers;
+    private bufHandle;
+    private uiCols;
+    private uiRows;
+    private wrapColumnApplied;
+    private wrapStrategyApplied;
+    private primeSent;
+    private suppressCursorSync;
+    private lastMode;
+    private monacoPrevOccurrencesHighlight;
+    private monacoPrevSelectionHighlight;
+    private monacoPrevSelectionHighlightMultiline;
+    private monacoHighlightsSuppressed;
+    private pendingNvimBufUpdates;
+    private readonly notifyRouter;
+    private readonly hostAutocmdInstaller;
+    private nvimScrolloff;
+    private readonly keyAllowlist;
+    private readonly execLuaClient;
+    private nextSeedLines;
+    private readonly overlays;
+    private readonly editorListeners;
+    private readonly redraw;
+    private readonly bufferSync;
+    private readonly bufferManager;
+    private readonly searchHighlights;
+    private readonly clipboard;
+    private readonly hostCommandManager;
+    private readonly cursor;
+    private readonly viewport;
+    private readonly recording;
+    private readonly insertDelegation;
+    private readonly visualSelection;
+    private readonly keyHandler;
+    private readonly mouse;
+    private readonly cursorPositionHandler;
+    private readonly sessionPrime;
+    private readonly instanceId;
+    private readonly instanceClassName;
+    private readonly resizeManager;
+    private compositionActive;
+    private pendingResyncAfterComposition;
+    private readonly inputEventDeduper;
+    private pendingEscAfterComposition;
+    private lastClipboardText;
+    private lastImeCommitAt;
+    private lastImeCommitText;
+    private nvimBlocking;
+    private editorReadOnly;
+    private applyingFromNvim;
+    private ignoreSelectionSyncUntil;
+    private debugLog;
+    private nowMs;
+    private sendImeText;
+    constructor(editor: MonacoEditor.IStandaloneCodeEditor, options?: MonacoNeovimOptions);
+    start(seedLines?: string[]): Promise<void>;
+    stop(silent?: boolean): void;
+    dispose(): void;
+    notify(method: string, params?: unknown[]): void;
+    call<T = unknown>(method: string, params?: unknown[]): Promise<T>;
+    command(cmd: string): void;
+    input(keys: string): void;
+    type(text: string, wrapEnter?: boolean): void;
+    paste(text: string): void;
+    execLua<T = unknown>(code: string, args?: unknown[]): Promise<T>;
+    getSession(): NeovimWasmSession | null;
+    resize(cols: number, rows: number): void;
+    resizeToEditor(): void;
+    private attachEditorListeners;
+    private handleActiveModelChanged;
+    private scheduleResizeToEditor;
+    private setPreedit;
+    private applyOptimisticInsert;
+    private positionPreedit;
+    private disposeEditorListeners;
+    private getActiveState;
+    private ensureActiveState;
+    private clearBufferStates;
+    private primeSession;
+    private handleRequest;
+    private handleNotifyMonacoCursorMove;
+    private handleNotifyMonacoScroll;
+    private handleNotifyMonacoReveal;
+    private handleNotifyMonacoMoveCursor;
+    private handleNotifyMonacoScrolloff;
+    private handleNotifyMonacoHostCommand;
+    private handleNotifyMonacoBufEnter;
+    private handleNotifyMonacoBufDelete;
+    private handleNotifyMonacoCursor;
+    private handleNotifyMonacoMode;
+    private handleNotifyMonacoRecording;
+    private initCmdlineUi;
+    private setCmdline;
+    private setCmdlineCursor;
+    private setMessage;
+    private setPopupmenu;
+    private applyMonacoWrap;
+    private syncTabstopFromMonaco;
+    private updatePopupmenuSelection;
+    private initTextInputListeners;
+    private scheduleResync;
+    private scheduleSyncBufferToNvim;
+    private syncBufferToNvimNow;
+    private applyBuffer;
+    private clearSearchHighlights;
+    private scheduleSearchHighlightRefresh;
+    private applyNvimMode;
+    private setEditorReadOnly;
+    private flushPendingMonacoSyncBlocking;
+    private sendInput;
+    private pasteText;
+    private handleMonacoModelChange;
+    private scheduleCursorSyncToNvim;
+    private flushPendingMonacoSync;
+    private syncCursorToNvimNow;
+    private installHostAutocmds;
+    private handleBufEnter;
+    private handleBufDelete;
+    private openText;
+    private sendNotify;
+    private sendRpcResponse;
+    private rpcCall;
+    private updateCursor;
+    private applyCursorSelectionFromNvim;
+    private scheduleCursorUpdate;
+    private requestSearchHighlightRefresh;
+    private scheduleCursorRefresh;
+    private refreshCursorMode;
+    private syncVisualSelectionColor;
+    private setMonacoHighlightsSuppressed;
+    private seedBuffer;
+}
+export declare function createMonacoNeovim(editor: MonacoEditor.IStandaloneCodeEditor, options?: MonacoNeovimOptions): MonacoNeovimClient;

package/dist/client/mouse.d.ts

@@ -0,0 +1,16 @@
+import * as monaco from "monaco-editor";
+import type { editor as MonacoEditor } from "monaco-editor";
+export type MouseManagerInit = {
+    editor: MonacoEditor.IStandaloneCodeEditor;
+    isSessionRunning: () => boolean;
+    getBufHandle: () => number | null;
+    isDelegateInsertToMonaco: () => boolean;
+    sendNotify: (method: string, params: unknown[]) => void;
+    execLua: (code: string, args: unknown[]) => Promise<any>;
+};
+export declare class MouseManager {
+    private readonly init;
+    constructor(init: MouseManagerInit);
+    handleMouseDown(ev: monaco.editor.IEditorMouseEvent): void;
+    sendNvimMouse(button: string, action: "press" | "drag" | "release" | "up" | "down", mods: string, pos: monaco.Position): Promise<void>;
+}

package/dist/client/notifyRouter.d.ts

@@ -0,0 +1,15 @@
+export type NotifyRouterInit = {
+    debugLog: (line: string) => void;
+    notifyHandlers: Map<string, (params: unknown[]) => void | Promise<void>>;
+    handleNvimBufLinesEvent: (params: unknown[]) => Promise<void>;
+    handleNvimBufDetachEvent: (params: unknown[]) => void;
+    handleRedraw: (params: unknown[]) => void;
+};
+export declare class NotifyRouter {
+    private readonly init;
+    private chain;
+    constructor(init: NotifyRouterInit);
+    reset(): void;
+    onNotify(method: string, params: unknown[]): void;
+    private dispatch;
+}