@google/gemini-cli 0.1.13-nightly.250726.fb751c54 → 0.1.14

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

@@ -12,7 +12,6 @@ import { useState, useCallback, useEffect, useMemo, useReducer } from 'react';
 import stringWidth from 'string-width';
 import { unescapePath } from '@google/gemini-cli-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) {
@@ -20,209 +19,6 @@ 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.
  *
@@ -310,24 +106,6 @@ 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 = [];
@@ -501,27 +279,26 @@ function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
     };
 }
 const historyLimit = 100;
-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 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: [] };
+    };
     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 = pushUndoLocal(state);
+                nextState = pushUndo(state);
             }
             const newContentLines = action.payload
                 .replace(/\r\n?/g, '\n')
@@ -537,7 +314,7 @@ export function textBufferReducer(state, action) {
             };
         }
         case 'insert': {
-            const nextState = pushUndoLocal(state);
+            const nextState = pushUndo(state);
             const newLines = [...nextState.lines];
             let newCursorRow = nextState.cursorRow;
             let newCursorCol = nextState.cursorCol;
@@ -569,7 +346,7 @@ export function textBufferReducer(state, action) {
             };
         }
         case 'backspace': {
-            const nextState = pushUndoLocal(state);
+            const nextState = pushUndo(state);
             const newLines = [...nextState.lines];
             let newCursorRow = nextState.cursorRow;
             let newCursorCol = nextState.cursorCol;
@@ -746,7 +523,7 @@ export function textBufferReducer(state, action) {
             const { cursorRow, cursorCol, lines } = state;
             const lineContent = currentLine(cursorRow);
             if (cursorCol < currentLineLen(cursorRow)) {
-                const nextState = pushUndoLocal(state);
+                const nextState = pushUndo(state);
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] =
                     cpSlice(lineContent, 0, cursorCol) +
@@ -754,7 +531,7 @@ export function textBufferReducer(state, action) {
                 return { ...nextState, lines: newLines, preferredCol: null };
             }
             else if (cursorRow < lines.length - 1) {
-                const nextState = pushUndoLocal(state);
+                const nextState = pushUndo(state);
                 const nextLineContent = currentLine(cursorRow + 1);
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] = lineContent + nextLineContent;
@@ -769,7 +546,7 @@ export function textBufferReducer(state, action) {
                 return state;
             if (cursorCol === 0) {
                 // Act as a backspace
-                const nextState = pushUndoLocal(state);
+                const nextState = pushUndo(state);
                 const prevLineContent = currentLine(cursorRow - 1);
                 const currentLineContentVal = currentLine(cursorRow);
                 const newCol = cpLen(prevLineContent);
@@ -784,7 +561,7 @@ export function textBufferReducer(state, action) {
                     preferredCol: null,
                 };
             }
-            const nextState = pushUndoLocal(state);
+            const nextState = pushUndo(state);
             const lineContent = currentLine(cursorRow);
             const arr = toCodePoints(lineContent);
             let start = cursorCol;
@@ -822,14 +599,14 @@ export function textBufferReducer(state, action) {
                 return state;
             if (cursorCol >= arr.length) {
                 // Act as a delete
-                const nextState = pushUndoLocal(state);
+                const nextState = pushUndo(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 = pushUndoLocal(state);
+            const nextState = pushUndo(state);
             let end = cursorCol;
             while (end < arr.length && !isWordChar(arr[end]))
                 end++;
@@ -844,14 +621,14 @@ export function textBufferReducer(state, action) {
             const { cursorRow, cursorCol, lines } = state;
             const lineContent = currentLine(cursorRow);
             if (cursorCol < currentLineLen(cursorRow)) {
-                const nextState = pushUndoLocal(state);
+                const nextState = pushUndo(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 = pushUndoLocal(state);
+                const nextState = pushUndo(state);
                 const nextLineContent = currentLine(cursorRow + 1);
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] = lineContent + nextLineContent;
@@ -863,7 +640,7 @@ export function textBufferReducer(state, action) {
         case 'kill_line_left': {
             const { cursorRow, cursorCol } = state;
             if (cursorCol > 0) {
-                const nextState = pushUndoLocal(state);
+                const nextState = pushUndo(state);
                 const lineContent = currentLine(cursorRow);
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] = cpSlice(lineContent, cursorCol);
@@ -910,8 +687,51 @@ export function textBufferReducer(state, action) {
         }
         case 'replace_range': {
             const { startRow, startCol, endRow, endCol, text } = action.payload;
-            const nextState = pushUndoLocal(state);
-            return replaceRangeInternal(nextState, startRow, startCol, endRow, endCol, text);
+            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,
+            };
         }
         case 'move_to_offset': {
             const { offset } = action.payload;
@@ -924,42 +744,8 @@ export function textBufferReducer(state, action) {
             };
         }
         case 'create_undo_snapshot': {
-            return pushUndoLocal(state);
+            return pushUndo(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}`);
@@ -1081,104 +867,6 @@ 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'] ??
@@ -1317,39 +1005,6 @@ 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;
 }