@vybestack/llxprt-code 0.1.14-nightly.250729.2076f7c6 → 0.1.15

package/dist/src/ui/components/shared/text-buffer.js

@@ -12,6 +12,7 @@ import { useState, useCallback, useEffect, useMemo, useReducer } from 'react';
 import stringWidth from 'string-width';
 import { unescapePath } from '@vybestack/llxprt-code-core';
 import { toCodePoints, cpLen, cpSlice } from '../../utils/textUtils.js';
+import { handleVimAction } from './vim-buffer-actions.js';
 // Simple helper for word‑wise ops.
 function isWordChar(ch) {
     if (ch === undefined) {
@@ -19,6 +20,209 @@ function isWordChar(ch) {
     }
     return !/[\s,.;!?]/.test(ch);
 }
+// Vim-specific word boundary functions
+export const findNextWordStart = (text, currentOffset) => {
+    let i = currentOffset;
+    if (i >= text.length)
+        return i;
+    const currentChar = text[i];
+    // Skip current word/sequence based on character type
+    if (/\w/.test(currentChar)) {
+        // Skip current word characters
+        while (i < text.length && /\w/.test(text[i])) {
+            i++;
+        }
+    }
+    else if (!/\s/.test(currentChar)) {
+        // Skip current non-word, non-whitespace characters (like "/", ".", etc.)
+        while (i < text.length && !/\w/.test(text[i]) && !/\s/.test(text[i])) {
+            i++;
+        }
+    }
+    // Skip whitespace
+    while (i < text.length && /\s/.test(text[i])) {
+        i++;
+    }
+    // If we reached the end of text and there's no next word,
+    // vim behavior for dw is to delete to the end of the current word
+    if (i >= text.length) {
+        // Go back to find the end of the last word
+        let endOfLastWord = text.length - 1;
+        while (endOfLastWord >= 0 && /\s/.test(text[endOfLastWord])) {
+            endOfLastWord--;
+        }
+        // For dw on last word, return position AFTER the last character to delete entire word
+        return Math.max(currentOffset + 1, endOfLastWord + 1);
+    }
+    return i;
+};
+export const findPrevWordStart = (text, currentOffset) => {
+    let i = currentOffset;
+    // If at beginning of text, return current position
+    if (i <= 0) {
+        return currentOffset;
+    }
+    // Move back one character to start searching
+    i--;
+    // Skip whitespace moving backwards
+    while (i >= 0 && (text[i] === ' ' || text[i] === '\t' || text[i] === '\n')) {
+        i--;
+    }
+    if (i < 0) {
+        return 0; // Reached beginning of text
+    }
+    const charAtI = text[i];
+    if (/\w/.test(charAtI)) {
+        // We're in a word, move to its beginning
+        while (i >= 0 && /\w/.test(text[i])) {
+            i--;
+        }
+        return i + 1; // Return first character of word
+    }
+    else {
+        // We're in punctuation, move to its beginning
+        while (i >= 0 &&
+            !/\w/.test(text[i]) &&
+            text[i] !== ' ' &&
+            text[i] !== '\t' &&
+            text[i] !== '\n') {
+            i--;
+        }
+        return i + 1; // Return first character of punctuation sequence
+    }
+};
+export const findWordEnd = (text, currentOffset) => {
+    let i = currentOffset;
+    // If we're already at the end of a word, advance to next word
+    if (i < text.length &&
+        /\w/.test(text[i]) &&
+        (i + 1 >= text.length || !/\w/.test(text[i + 1]))) {
+        // We're at the end of a word, move forward to find next word
+        i++;
+        // Skip whitespace/punctuation to find next word
+        while (i < text.length && !/\w/.test(text[i])) {
+            i++;
+        }
+    }
+    // If we're not on a word character, find the next word
+    if (i < text.length && !/\w/.test(text[i])) {
+        while (i < text.length && !/\w/.test(text[i])) {
+            i++;
+        }
+    }
+    // Move to end of current word
+    while (i < text.length && /\w/.test(text[i])) {
+        i++;
+    }
+    // Move back one to be on the last character of the word
+    return Math.max(currentOffset, i - 1);
+};
+// Helper functions for vim operations
+export const getOffsetFromPosition = (row, col, lines) => {
+    let offset = 0;
+    for (let i = 0; i < row; i++) {
+        offset += lines[i].length + 1; // +1 for newline
+    }
+    offset += col;
+    return offset;
+};
+export const getPositionFromOffsets = (startOffset, endOffset, lines) => {
+    let offset = 0;
+    let startRow = 0;
+    let startCol = 0;
+    let endRow = 0;
+    let endCol = 0;
+    // Find start position
+    for (let i = 0; i < lines.length; i++) {
+        const lineLength = lines[i].length + 1; // +1 for newline
+        if (offset + lineLength > startOffset) {
+            startRow = i;
+            startCol = startOffset - offset;
+            break;
+        }
+        offset += lineLength;
+    }
+    // Find end position
+    offset = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const lineLength = lines[i].length + (i < lines.length - 1 ? 1 : 0); // +1 for newline except last line
+        if (offset + lineLength >= endOffset) {
+            endRow = i;
+            endCol = endOffset - offset;
+            break;
+        }
+        offset += lineLength;
+    }
+    return { startRow, startCol, endRow, endCol };
+};
+export const getLineRangeOffsets = (startRow, lineCount, lines) => {
+    let startOffset = 0;
+    // Calculate start offset
+    for (let i = 0; i < startRow; i++) {
+        startOffset += lines[i].length + 1; // +1 for newline
+    }
+    // Calculate end offset
+    let endOffset = startOffset;
+    for (let i = 0; i < lineCount; i++) {
+        const lineIndex = startRow + i;
+        if (lineIndex < lines.length) {
+            endOffset += lines[lineIndex].length;
+            if (lineIndex < lines.length - 1) {
+                endOffset += 1; // +1 for newline
+            }
+        }
+    }
+    return { startOffset, endOffset };
+};
+export const replaceRangeInternal = (state, startRow, startCol, endRow, endCol, text) => {
+    const currentLine = (row) => state.lines[row] || '';
+    const currentLineLen = (row) => cpLen(currentLine(row));
+    const clamp = (value, min, max) => Math.min(Math.max(value, min), max);
+    if (startRow > endRow ||
+        (startRow === endRow && startCol > endCol) ||
+        startRow < 0 ||
+        startCol < 0 ||
+        endRow >= state.lines.length ||
+        (endRow < state.lines.length && endCol > currentLineLen(endRow))) {
+        return state; // Invalid range
+    }
+    const newLines = [...state.lines];
+    const sCol = clamp(startCol, 0, currentLineLen(startRow));
+    const eCol = clamp(endCol, 0, currentLineLen(endRow));
+    const prefix = cpSlice(currentLine(startRow), 0, sCol);
+    const suffix = cpSlice(currentLine(endRow), eCol);
+    const normalisedReplacement = text
+        .replace(/\r\n/g, '\n')
+        .replace(/\r/g, '\n');
+    const replacementParts = normalisedReplacement.split('\n');
+    // Replace the content
+    if (startRow === endRow) {
+        newLines[startRow] = prefix + normalisedReplacement + suffix;
+    }
+    else {
+        const firstLine = prefix + replacementParts[0];
+        if (replacementParts.length === 1) {
+            // Single line of replacement text, but spanning multiple original lines
+            newLines.splice(startRow, endRow - startRow + 1, firstLine + suffix);
+        }
+        else {
+            // Multi-line replacement text
+            const lastLine = replacementParts[replacementParts.length - 1] + suffix;
+            const middleLines = replacementParts.slice(1, -1);
+            newLines.splice(startRow, endRow - startRow + 1, firstLine, ...middleLines, lastLine);
+        }
+    }
+    const finalCursorRow = startRow + replacementParts.length - 1;
+    const finalCursorCol = (replacementParts.length > 1 ? 0 : sCol) +
+        cpLen(replacementParts[replacementParts.length - 1]);
+    return {
+        ...state,
+        lines: newLines,
+        cursorRow: Math.min(Math.max(finalCursorRow, 0), newLines.length - 1),
+        cursorCol: Math.max(0, Math.min(finalCursorCol, cpLen(newLines[finalCursorRow] || ''))),
+        preferredCol: null,
+    };
+};
 /**
  * Strip characters that can break terminal rendering.
  *
@@ -106,6 +310,24 @@ export function offsetToLogicalPos(text, offset) {
     }
     return [row, col];
 }
+/**
+ * Converts logical row/col position to absolute text offset
+ * Inverse operation of offsetToLogicalPos
+ */
+export function logicalPosToOffset(lines, row, col) {
+    let offset = 0;
+    // Clamp row to valid range
+    const actualRow = Math.min(row, lines.length - 1);
+    // Add lengths of all lines before the target row
+    for (let i = 0; i < actualRow; i++) {
+        offset += cpLen(lines[i]) + 1; // +1 for newline
+    }
+    // Add column offset within the target row
+    if (actualRow >= 0 && actualRow < lines.length) {
+        offset += Math.min(col, cpLen(lines[actualRow]));
+    }
+    return offset;
+}
 // Helper to calculate visual lines and map cursor positions
 function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
     const visualLines = [];
@@ -279,26 +501,27 @@ function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
     };
 }
 const historyLimit = 100;
-export function textBufferReducer(state, action) {
-    const pushUndo = (currentState) => {
-        const snapshot = {
-            lines: [...currentState.lines],
-            cursorRow: currentState.cursorRow,
-            cursorCol: currentState.cursorCol,
-        };
-        const newStack = [...currentState.undoStack, snapshot];
-        if (newStack.length > historyLimit) {
-            newStack.shift();
-        }
-        return { ...currentState, undoStack: newStack, redoStack: [] };
+export const pushUndo = (currentState) => {
+    const snapshot = {
+        lines: [...currentState.lines],
+        cursorRow: currentState.cursorRow,
+        cursorCol: currentState.cursorCol,
     };
+    const newStack = [...currentState.undoStack, snapshot];
+    if (newStack.length > historyLimit) {
+        newStack.shift();
+    }
+    return { ...currentState, undoStack: newStack, redoStack: [] };
+};
+export function textBufferReducer(state, action) {
+    const pushUndoLocal = pushUndo;
     const currentLine = (r) => state.lines[r] ?? '';
     const currentLineLen = (r) => cpLen(currentLine(r));
     switch (action.type) {
         case 'set_text': {
             let nextState = state;
             if (action.pushToUndo !== false) {
-                nextState = pushUndo(state);
+                nextState = pushUndoLocal(state);
             }
             const newContentLines = action.payload
                 .replace(/\r\n?/g, '\n')
@@ -314,7 +537,7 @@ export function textBufferReducer(state, action) {
             };
         }
         case 'insert': {
-            const nextState = pushUndo(state);
+            const nextState = pushUndoLocal(state);
             const newLines = [...nextState.lines];
             let newCursorRow = nextState.cursorRow;
             let newCursorCol = nextState.cursorCol;
@@ -351,7 +574,7 @@ export function textBufferReducer(state, action) {
             };
         }
         case 'backspace': {
-            const nextState = pushUndo(state);
+            const nextState = pushUndoLocal(state);
             const newLines = [...nextState.lines];
             let newCursorRow = nextState.cursorRow;
             let newCursorCol = nextState.cursorCol;
@@ -528,7 +751,7 @@ export function textBufferReducer(state, action) {
             const { cursorRow, cursorCol, lines } = state;
             const lineContent = currentLine(cursorRow);
             if (cursorCol < currentLineLen(cursorRow)) {
-                const nextState = pushUndo(state);
+                const nextState = pushUndoLocal(state);
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] =
                     cpSlice(lineContent, 0, cursorCol) +
@@ -536,7 +759,7 @@ export function textBufferReducer(state, action) {
                 return { ...nextState, lines: newLines, preferredCol: null };
             }
             else if (cursorRow < lines.length - 1) {
-                const nextState = pushUndo(state);
+                const nextState = pushUndoLocal(state);
                 const nextLineContent = currentLine(cursorRow + 1);
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] = lineContent + nextLineContent;
@@ -551,7 +774,7 @@ export function textBufferReducer(state, action) {
                 return state;
             if (cursorCol === 0) {
                 // Act as a backspace
-                const nextState = pushUndo(state);
+                const nextState = pushUndoLocal(state);
                 const prevLineContent = currentLine(cursorRow - 1);
                 const currentLineContentVal = currentLine(cursorRow);
                 const newCol = cpLen(prevLineContent);
@@ -566,7 +789,7 @@ export function textBufferReducer(state, action) {
                     preferredCol: null,
                 };
             }
-            const nextState = pushUndo(state);
+            const nextState = pushUndoLocal(state);
             const lineContent = currentLine(cursorRow);
             const arr = toCodePoints(lineContent);
             let start = cursorCol;
@@ -604,14 +827,14 @@ export function textBufferReducer(state, action) {
                 return state;
             if (cursorCol >= arr.length) {
                 // Act as a delete
-                const nextState = pushUndo(state);
+                const nextState = pushUndoLocal(state);
                 const nextLineContent = currentLine(cursorRow + 1);
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] = lineContent + nextLineContent;
                 newLines.splice(cursorRow + 1, 1);
                 return { ...nextState, lines: newLines, preferredCol: null };
             }
-            const nextState = pushUndo(state);
+            const nextState = pushUndoLocal(state);
             let end = cursorCol;
             while (end < arr.length && !isWordChar(arr[end]))
                 end++;
@@ -626,14 +849,14 @@ export function textBufferReducer(state, action) {
             const { cursorRow, cursorCol, lines } = state;
             const lineContent = currentLine(cursorRow);
             if (cursorCol < currentLineLen(cursorRow)) {
-                const nextState = pushUndo(state);
+                const nextState = pushUndoLocal(state);
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] = cpSlice(lineContent, 0, cursorCol);
                 return { ...nextState, lines: newLines };
             }
             else if (cursorRow < lines.length - 1) {
                 // Act as a delete
-                const nextState = pushUndo(state);
+                const nextState = pushUndoLocal(state);
                 const nextLineContent = currentLine(cursorRow + 1);
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] = lineContent + nextLineContent;
@@ -645,7 +868,7 @@ export function textBufferReducer(state, action) {
         case 'kill_line_left': {
             const { cursorRow, cursorCol } = state;
             if (cursorCol > 0) {
-                const nextState = pushUndo(state);
+                const nextState = pushUndoLocal(state);
                 const lineContent = currentLine(cursorRow);
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] = cpSlice(lineContent, cursorCol);
@@ -692,51 +915,8 @@ export function textBufferReducer(state, action) {
         }
         case 'replace_range': {
             const { startRow, startCol, endRow, endCol, text } = action.payload;
-            if (startRow > endRow ||
-                (startRow === endRow && startCol > endCol) ||
-                startRow < 0 ||
-                startCol < 0 ||
-                endRow >= state.lines.length ||
-                (endRow < state.lines.length && endCol > currentLineLen(endRow))) {
-                return state; // Invalid range
-            }
-            const nextState = pushUndo(state);
-            const newLines = [...nextState.lines];
-            const sCol = clamp(startCol, 0, currentLineLen(startRow));
-            const eCol = clamp(endCol, 0, currentLineLen(endRow));
-            const prefix = cpSlice(currentLine(startRow), 0, sCol);
-            const suffix = cpSlice(currentLine(endRow), eCol);
-            const normalisedReplacement = text
-                .replace(/\r\n/g, '\n')
-                .replace(/\r/g, '\n');
-            const replacementParts = normalisedReplacement.split('\n');
-            // Replace the content
-            if (startRow === endRow) {
-                newLines[startRow] = prefix + normalisedReplacement + suffix;
-            }
-            else {
-                const firstLine = prefix + replacementParts[0];
-                if (replacementParts.length === 1) {
-                    // Single line of replacement text, but spanning multiple original lines
-                    newLines.splice(startRow, endRow - startRow + 1, firstLine + suffix);
-                }
-                else {
-                    // Multi-line replacement text
-                    const lastLine = replacementParts[replacementParts.length - 1] + suffix;
-                    const middleLines = replacementParts.slice(1, -1);
-                    newLines.splice(startRow, endRow - startRow + 1, firstLine, ...middleLines, lastLine);
-                }
-            }
-            const finalCursorRow = startRow + replacementParts.length - 1;
-            const finalCursorCol = (replacementParts.length > 1 ? 0 : sCol) +
-                cpLen(replacementParts[replacementParts.length - 1]);
-            return {
-                ...nextState,
-                lines: newLines,
-                cursorRow: finalCursorRow,
-                cursorCol: finalCursorCol,
-                preferredCol: null,
-            };
+            const nextState = pushUndoLocal(state);
+            return replaceRangeInternal(nextState, startRow, startCol, endRow, endCol, text);
         }
         case 'move_to_offset': {
             const { offset } = action.payload;
@@ -749,8 +929,42 @@ export function textBufferReducer(state, action) {
             };
         }
         case 'create_undo_snapshot': {
-            return pushUndo(state);
+            return pushUndoLocal(state);
         }
+        // Vim-specific operations
+        case 'vim_delete_word_forward':
+        case 'vim_delete_word_backward':
+        case 'vim_delete_word_end':
+        case 'vim_change_word_forward':
+        case 'vim_change_word_backward':
+        case 'vim_change_word_end':
+        case 'vim_delete_line':
+        case 'vim_change_line':
+        case 'vim_delete_to_end_of_line':
+        case 'vim_change_to_end_of_line':
+        case 'vim_change_movement':
+        case 'vim_move_left':
+        case 'vim_move_right':
+        case 'vim_move_up':
+        case 'vim_move_down':
+        case 'vim_move_word_forward':
+        case 'vim_move_word_backward':
+        case 'vim_move_word_end':
+        case 'vim_delete_char':
+        case 'vim_insert_at_cursor':
+        case 'vim_append_at_cursor':
+        case 'vim_open_line_below':
+        case 'vim_open_line_above':
+        case 'vim_append_at_line_end':
+        case 'vim_insert_at_line_start':
+        case 'vim_move_to_line_start':
+        case 'vim_move_to_line_end':
+        case 'vim_move_to_first_nonwhitespace':
+        case 'vim_move_to_first_line':
+        case 'vim_move_to_last_line':
+        case 'vim_move_to_line':
+        case 'vim_escape_insert_mode':
+            return handleVimAction(state, action);
         default: {
             const exhaustiveCheck = action;
             console.error(`Unknown action encountered: ${exhaustiveCheck}`);
@@ -872,6 +1086,104 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
     const killLineLeft = useCallback(() => {
         dispatch({ type: 'kill_line_left' });
     }, []);
+    // Vim-specific operations
+    const vimDeleteWordForward = useCallback((count) => {
+        dispatch({ type: 'vim_delete_word_forward', payload: { count } });
+    }, []);
+    const vimDeleteWordBackward = useCallback((count) => {
+        dispatch({ type: 'vim_delete_word_backward', payload: { count } });
+    }, []);
+    const vimDeleteWordEnd = useCallback((count) => {
+        dispatch({ type: 'vim_delete_word_end', payload: { count } });
+    }, []);
+    const vimChangeWordForward = useCallback((count) => {
+        dispatch({ type: 'vim_change_word_forward', payload: { count } });
+    }, []);
+    const vimChangeWordBackward = useCallback((count) => {
+        dispatch({ type: 'vim_change_word_backward', payload: { count } });
+    }, []);
+    const vimChangeWordEnd = useCallback((count) => {
+        dispatch({ type: 'vim_change_word_end', payload: { count } });
+    }, []);
+    const vimDeleteLine = useCallback((count) => {
+        dispatch({ type: 'vim_delete_line', payload: { count } });
+    }, []);
+    const vimChangeLine = useCallback((count) => {
+        dispatch({ type: 'vim_change_line', payload: { count } });
+    }, []);
+    const vimDeleteToEndOfLine = useCallback(() => {
+        dispatch({ type: 'vim_delete_to_end_of_line' });
+    }, []);
+    const vimChangeToEndOfLine = useCallback(() => {
+        dispatch({ type: 'vim_change_to_end_of_line' });
+    }, []);
+    const vimChangeMovement = useCallback((movement, count) => {
+        dispatch({ type: 'vim_change_movement', payload: { movement, count } });
+    }, []);
+    // New vim navigation and operation methods
+    const vimMoveLeft = useCallback((count) => {
+        dispatch({ type: 'vim_move_left', payload: { count } });
+    }, []);
+    const vimMoveRight = useCallback((count) => {
+        dispatch({ type: 'vim_move_right', payload: { count } });
+    }, []);
+    const vimMoveUp = useCallback((count) => {
+        dispatch({ type: 'vim_move_up', payload: { count } });
+    }, []);
+    const vimMoveDown = useCallback((count) => {
+        dispatch({ type: 'vim_move_down', payload: { count } });
+    }, []);
+    const vimMoveWordForward = useCallback((count) => {
+        dispatch({ type: 'vim_move_word_forward', payload: { count } });
+    }, []);
+    const vimMoveWordBackward = useCallback((count) => {
+        dispatch({ type: 'vim_move_word_backward', payload: { count } });
+    }, []);
+    const vimMoveWordEnd = useCallback((count) => {
+        dispatch({ type: 'vim_move_word_end', payload: { count } });
+    }, []);
+    const vimDeleteChar = useCallback((count) => {
+        dispatch({ type: 'vim_delete_char', payload: { count } });
+    }, []);
+    const vimInsertAtCursor = useCallback(() => {
+        dispatch({ type: 'vim_insert_at_cursor' });
+    }, []);
+    const vimAppendAtCursor = useCallback(() => {
+        dispatch({ type: 'vim_append_at_cursor' });
+    }, []);
+    const vimOpenLineBelow = useCallback(() => {
+        dispatch({ type: 'vim_open_line_below' });
+    }, []);
+    const vimOpenLineAbove = useCallback(() => {
+        dispatch({ type: 'vim_open_line_above' });
+    }, []);
+    const vimAppendAtLineEnd = useCallback(() => {
+        dispatch({ type: 'vim_append_at_line_end' });
+    }, []);
+    const vimInsertAtLineStart = useCallback(() => {
+        dispatch({ type: 'vim_insert_at_line_start' });
+    }, []);
+    const vimMoveToLineStart = useCallback(() => {
+        dispatch({ type: 'vim_move_to_line_start' });
+    }, []);
+    const vimMoveToLineEnd = useCallback(() => {
+        dispatch({ type: 'vim_move_to_line_end' });
+    }, []);
+    const vimMoveToFirstNonWhitespace = useCallback(() => {
+        dispatch({ type: 'vim_move_to_first_nonwhitespace' });
+    }, []);
+    const vimMoveToFirstLine = useCallback(() => {
+        dispatch({ type: 'vim_move_to_first_line' });
+    }, []);
+    const vimMoveToLastLine = useCallback(() => {
+        dispatch({ type: 'vim_move_to_last_line' });
+    }, []);
+    const vimMoveToLine = useCallback((lineNumber) => {
+        dispatch({ type: 'vim_move_to_line', payload: { lineNumber } });
+    }, []);
+    const vimEscapeInsertMode = useCallback(() => {
+        dispatch({ type: 'vim_escape_insert_mode' });
+    }, []);
     const openInExternalEditor = useCallback(async (opts = {}) => {
         const editor = opts.editor ??
             process.env['VISUAL'] ??
@@ -1016,6 +1328,39 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         killLineLeft,
         handleInput,
         openInExternalEditor,
+        // Vim-specific operations
+        vimDeleteWordForward,
+        vimDeleteWordBackward,
+        vimDeleteWordEnd,
+        vimChangeWordForward,
+        vimChangeWordBackward,
+        vimChangeWordEnd,
+        vimDeleteLine,
+        vimChangeLine,
+        vimDeleteToEndOfLine,
+        vimChangeToEndOfLine,
+        vimChangeMovement,
+        vimMoveLeft,
+        vimMoveRight,
+        vimMoveUp,
+        vimMoveDown,
+        vimMoveWordForward,
+        vimMoveWordBackward,
+        vimMoveWordEnd,
+        vimDeleteChar,
+        vimInsertAtCursor,
+        vimAppendAtCursor,
+        vimOpenLineBelow,
+        vimOpenLineAbove,
+        vimAppendAtLineEnd,
+        vimInsertAtLineStart,
+        vimMoveToLineStart,
+        vimMoveToLineEnd,
+        vimMoveToFirstNonWhitespace,
+        vimMoveToFirstLine,
+        vimMoveToLastLine,
+        vimMoveToLine,
+        vimEscapeInsertMode,
     };
     return returnValue;
 }