codemirror-rails 2.36 → 3.00

data/vendor/assets/javascripts/codemirror/keymaps/vim.js

@@ -1,897 +1,2298 @@
-// Supported keybindings:
-//
-// Cursor movement:
-// h, j, k, l
-// e, E, w, W, b, B
-// Ctrl-f, Ctrl-b
-// Ctrl-n, Ctrl-p
-// $, ^, 0
-// G
-// ge, gE
-// gg
-// f<char>, F<char>, t<char>, T<char>
-// Ctrl-o, Ctrl-i TODO (FIXME - Ctrl-O wont work in Chrome)
-// /, ?, n, N TODO (does not work)
-// #, * TODO
-//
-// Entering insert mode:
-// i, I, a, A, o, O
-// s
-// ce, cb
-// cc
-// S, C TODO
-// cf<char>, cF<char>, ct<char>, cT<char>
-//
-// Deleting text:
-// x, X
-// J
-// dd, D
-// de, db
-// df<char>, dF<char>, dt<char>, dT<char>
-//
-// Yanking and pasting:
-// yy, Y
-// p, P
-// p'<char> TODO - test
-// y'<char> TODO - test
-// m<char> TODO - test
-//
-// Changing text in place:
-// ~
-// r<char>
-//
-// Visual mode:
-// v, V TODO
-//
-// Misc:
-// . TODO
-//
+/**
+ * Supported keybindings:
+ *
+ *   Motion:
+ *   h, j, k, l
+ *   e, E, w, W, b, B, ge, gE
+ *   f<character>, F<character>, t<character>, T<character>
+ *   $, ^, 0
+ *   gg, G
+ *   %
+ *   '<character>, `<character>
+ *
+ *   Operator:
+ *   d, y, c
+ *   dd, yy, cc
+ *   g~, g~g~
+ *   >, <, >>, <<
+ *
+ *   Operator-Motion:
+ *   x, X, D, Y, C, ~
+ *
+ *   Action:
+ *   a, i, s, A, I, S, o, O
+ *   J
+ *   u, Ctrl-r
+ *   m<character>
+ *   r<character>
+ *
+ *   Modes:
+ *   ESC - leave insert mode, visual mode, and clear input state.
+ *   Ctrl-[, Ctrl-c - same as ESC.
+ *
+ * Registers: unamed, -, a-z, A-Z, 0-9
+ *   (Does not respect the special case for number registers when delete
+ *    operator is made with these commands: %, (, ),  , /, ?, n, N, {, } )
+ *   TODO: Implement the remaining registers.
+ * Marks: a-z, A-Z, and 0-9
+ *   TODO: Implement the remaining special marks. They have more complex
+ *       behavior.
+ *
+ * Code structure:
+ *  1. Default keymap
+ *  2. Variable declarations and short basic helpers
+ *  3. Instance (External API) implementation
+ *  4. Internal state tracking objects (input state, counter) implementation
+ *     and instanstiation
+ *  5. Key handler (the main command dispatcher) implementation
+ *  6. Motion, operator, and action implementations
+ *  7. Helper functions for the key handler, motions, operators, and actions
+ *  8. Set up Vim to work as a keymap for CodeMirror.
+ */
 
 (function() {
-  var sdir = "f";
-  var buf = "";
-  var mark = {};
-  var repeatCount = 0;
-  function isLine(cm, line) { return line >= 0 && line < cm.lineCount(); }
-  function emptyBuffer() { buf = ""; }
-  function pushInBuffer(str) { buf += str; }
-  function pushRepeatCountDigit(digit) {return function(cm) {repeatCount = (repeatCount * 10) + digit}; }
-  function getCountOrOne() {
-    var i = repeatCount;
-    return i || 1;
-  }
-  function clearCount() {
-    repeatCount = 0;
-  }
-  function iterTimes(func) {
-    for (var i = 0, c = getCountOrOne(); i < c; ++i) func(i, i == c - 1);
-    clearCount();
-  }
-  function countTimes(func) {
-    if (typeof func == "string") func = CodeMirror.commands[func];
-    return function(cm) { iterTimes(function (i, last) { func(cm, i, last); }); };
-  }
-
-  function iterObj(o, f) {
-    for (var prop in o) if (o.hasOwnProperty(prop)) f(prop, o[prop]);
-  }
-  function iterList(l, f) {
-    for (var i = 0; i < l.length; ++i) f(l[i]);
-  }
-  function toLetter(ch) {
-    // T -> t, Shift-T -> T, '*' -> *, "Space" -> " "
-    if (ch.slice(0, 6) == "Shift-") {
-      return ch.slice(0, 1);
-    } else {
-      if (ch == "Space") return " ";
-      if (ch.length == 3 && ch[0] == "'" && ch[2] == "'") return ch[1];
-      return ch.toLowerCase();
-    }
-  }
-  var SPECIAL_SYMBOLS = "~`!@#$%^&*()_-+=[{}]\\|/?.,<>:;\"\'1234567890";
-  function toCombo(ch) {
-    // t -> T, T -> Shift-T, * -> '*', " " -> "Space"
-    if (ch == " ") return "Space";
-    var specialIdx = SPECIAL_SYMBOLS.indexOf(ch);
-    if (specialIdx != -1) return "'" + ch + "'";
-    if (ch.toLowerCase() == ch) return ch.toUpperCase();
-    return "Shift-" + ch.toUpperCase();
-  }
-
-  var word = [/\w/, /[^\w\s]/], bigWord = [/\S/];
-  // Finds a word on the given line, and continue searching the next line if it can't find one.
-  function findWord(cm, lineNum, pos, dir, regexps) {
-    var line = cm.getLine(lineNum);
-    while (true) {
-      var stop = (dir > 0) ? line.length : -1;
-      var wordStart = stop, wordEnd = stop;
-      // Find bounds of next word.
-      for (; pos != stop; pos += dir) {
-        for (var i = 0; i < regexps.length; ++i) {
-          if (regexps[i].test(line.charAt(pos))) {
-            wordStart = pos;
-            // Advance to end of word.
-            for (; pos != stop && regexps[i].test(line.charAt(pos)); pos += dir) {}
-            wordEnd = (dir > 0) ? pos : pos + 1;
-            return {
-                from: Math.min(wordStart, wordEnd),
-                to: Math.max(wordStart, wordEnd),
-                line: lineNum};
-          }
-        }
-      }
-      // Advance to next/prev line.
-      lineNum += dir;
-      if (!isLine(cm, lineNum)) return null;
-      line = cm.getLine(lineNum);
-      pos = (dir > 0) ? 0 : line.length;
-    }
-  }
-  /**
-   * @param {boolean} cm CodeMirror object.
-   * @param {regexp} regexps Regular expressions for word characters.
-   * @param {number} dir Direction, +/- 1.
-   * @param {number} times Number of times to advance word.
-   * @param {string} where Go to "start" or "end" of word, 'e' vs 'w'.
-   * @param {boolean} yank Whether we are finding words to yank. If true,
-   *     do not go to the next line to look for the last word. This is to
-   *     prevent deleting new line on 'dw' at the end of a line.
-   */
-  function moveToWord(cm, regexps, dir, times, where, yank) {
-    var cur = cm.getCursor();
-    if (yank) {
-      where = 'start';
-    }
-    for (var i = 0; i < times; i++) {
-      var startCh = cur.ch, startLine = cur.line, word;
-      while (true) {
-        // Search and advance.
-        word = findWord(cm, cur.line, cur.ch, dir, regexps);
-        if (word) {
-          if (yank && times == 1 && dir == 1 && cur.line != word.line) {
-            // Stop at end of line of last word. Don't want to delete line return
-            // for dw if the last deleted word is at the end of a line.
-            cur.ch = cm.getLine(cur.line).length;
-            break;
-          } else {
-            // Move to the word we just found. If by moving to the word we end up
-            // in the same spot, then move an extra character and search again.
-            cur.line = word.line;
-            if (dir > 0 && where == 'end') {
-              // 'e'
-              if (startCh != word.to - 1 || startLine != word.line) {
-                cur.ch = word.to - 1;
-                break;
+  'use strict';
+
+  var defaultKeymap = [
+    // Key to key mapping. This goes first to make it possible to override
+    // existing mappings.
+    { keys: ['Left'], type: 'keyToKey', toKeys: ['h'] },
+    { keys: ['Right'], type: 'keyToKey', toKeys: ['l'] },
+    { keys: ['Up'], type: 'keyToKey', toKeys: ['k'] },
+    { keys: ['Down'], type: 'keyToKey', toKeys: ['j'] },
+    { keys: ['Space'], type: 'keyToKey', toKeys: ['l'] },
+    { keys: ['Backspace'], type: 'keyToKey', toKeys: ['h'] },
+    { keys: ['Ctrl-Space'], type: 'keyToKey', toKeys: ['W'] },
+    { keys: ['Ctrl-Backspace'], type: 'keyToKey', toKeys: ['B'] },
+    { keys: ['Shift-Space'], type: 'keyToKey', toKeys: ['w'] },
+    { keys: ['Shift-Backspace'], type: 'keyToKey', toKeys: ['b'] },
+    { keys: ['Ctrl-n'], type: 'keyToKey', toKeys: ['j'] },
+    { keys: ['Ctrl-p'], type: 'keyToKey', toKeys: ['k'] },
+    { keys: ['Ctrl-['], type: 'keyToKey', toKeys: ['Esc'] },
+    { keys: ['Ctrl-c'], type: 'keyToKey', toKeys: ['Esc'] },
+    { keys: ['s'], type: 'keyToKey', toKeys: ['c', 'l'] },
+    { keys: ['S'], type: 'keyToKey', toKeys: ['c', 'c'] },
+    { keys: ['Home'], type: 'keyToKey', toKeys: ['0'] },
+    { keys: ['End'], type: 'keyToKey', toKeys: ['$'] },
+    { keys: ['PageUp'], type: 'keyToKey', toKeys: ['Ctrl-b'] },
+    { keys: ['PageDown'], type: 'keyToKey', toKeys: ['Ctrl-f'] },
+    // Motions
+    { keys: ['h'], type: 'motion',
+        motion: 'moveByCharacters',
+        motionArgs: { forward: false }},
+    { keys: ['l'], type: 'motion',
+        motion: 'moveByCharacters',
+        motionArgs: { forward: true }},
+    { keys: ['j'], type: 'motion',
+        motion: 'moveByLines',
+        motionArgs: { forward: true, linewise: true }},
+    { keys: ['k'], type: 'motion',
+        motion: 'moveByLines',
+        motionArgs: { forward: false, linewise: true }},
+    { keys: ['w'], type: 'motion',
+        motion: 'moveByWords',
+        motionArgs: { forward: true, wordEnd: false }},
+    { keys: ['W'], type: 'motion',
+        motion: 'moveByWords',
+        motionArgs: { forward: true, wordEnd: false, bigWord: true }},
+    { keys: ['e'], type: 'motion',
+        motion: 'moveByWords',
+        motionArgs: { forward: true, wordEnd: true, inclusive: true }},
+    { keys: ['E'], type: 'motion',
+        motion: 'moveByWords',
+        motionArgs: { forward: true, wordEnd: true, bigWord: true,
+            inclusive: true }},
+    { keys: ['b'], type: 'motion',
+        motion: 'moveByWords',
+        motionArgs: { forward: false, wordEnd: false }},
+    { keys: ['B'], type: 'motion',
+        motion: 'moveByWords',
+        motionArgs: { forward: false, wordEnd: false, bigWord: true }},
+    { keys: ['g', 'e'], type: 'motion',
+        motion: 'moveByWords',
+        motionArgs: { forward: false, wordEnd: true, inclusive: true }},
+    { keys: ['g', 'E'], type: 'motion',
+        motion: 'moveByWords',
+        motionArgs: { forward: false, wordEnd: true, bigWord: true,
+            inclusive: true }},
+    { keys: ['Ctrl-f'], type: 'motion',
+        motion: 'moveByPage', motionArgs: { forward: true }},
+    { keys: ['Ctrl-b'], type: 'motion',
+        motion: 'moveByPage', motionArgs: { forward: false }},
+    { keys: ['g', 'g'], type: 'motion',
+        motion: 'moveToLineOrEdgeOfDocument',
+        motionArgs: { forward: false, explicitRepeat: true, linewise: true }},
+    { keys: ['G'], type: 'motion',
+        motion: 'moveToLineOrEdgeOfDocument',
+        motionArgs: { forward: true, explicitRepeat: true, linewise: true }},
+    { keys: ['0'], type: 'motion', motion: 'moveToStartOfLine' },
+    { keys: ['^'], type: 'motion',
+        motion: 'moveToFirstNonWhiteSpaceCharacter' },
+    { keys: ['$'], type: 'motion',
+        motion: 'moveToEol',
+        motionArgs: { inclusive: true }},
+    { keys: ['%'], type: 'motion',
+        motion: 'moveToMatchedSymbol',
+        motionArgs: { inclusive: true }},
+    { keys: ['f', 'character'], type: 'motion',
+        motion: 'moveToCharacter',
+        motionArgs: { forward: true , inclusive: true }},
+    { keys: ['F', 'character'], type: 'motion',
+        motion: 'moveToCharacter',
+        motionArgs: { forward: false }},
+    { keys: ['t', 'character'], type: 'motion',
+        motion: 'moveTillCharacter',
+        motionArgs: { forward: true, inclusive: true }},
+    { keys: ['T', 'character'], type: 'motion',
+        motion: 'moveTillCharacter',
+        motionArgs: { forward: false }},
+    { keys: ['\'', 'character'], type: 'motion', motion: 'goToMark' },
+    { keys: ['`', 'character'], type: 'motion', motion: 'goToMark' },
+    { keys: ['|'], type: 'motion',
+        motion: 'moveToColumn',
+        motionArgs: { }},
+    // Operators
+    { keys: ['d'], type: 'operator', operator: 'delete' },
+    { keys: ['y'], type: 'operator', operator: 'yank' },
+    { keys: ['c'], type: 'operator', operator: 'change',
+        operatorArgs: { enterInsertMode: true } },
+    { keys: ['>'], type: 'operator', operator: 'indent',
+        operatorArgs: { indentRight: true }},
+    { keys: ['<'], type: 'operator', operator: 'indent',
+        operatorArgs: { indentRight: false }},
+    { keys: ['g', '~'], type: 'operator', operator: 'swapcase' },
+    { keys: ['n'], type: 'motion', motion: 'findNext' },
+    { keys: ['N'], type: 'motion', motion: 'findPrev' },
+    // Operator-Motion dual commands
+    { keys: ['x'], type: 'operatorMotion', operator: 'delete',
+        motion: 'moveByCharacters', motionArgs: { forward: true },
+        operatorMotionArgs: { visualLine: false }},
+    { keys: ['X'], type: 'operatorMotion', operator: 'delete',
+        motion: 'moveByCharacters', motionArgs: { forward: false },
+        operatorMotionArgs: { visualLine: true }},
+    { keys: ['D'], type: 'operatorMotion', operator: 'delete',
+      motion: 'moveToEol', motionArgs: { inclusive: true },
+        operatorMotionArgs: { visualLine: true }},
+    { keys: ['Y'], type: 'operatorMotion', operator: 'yank',
+        motion: 'moveToEol', motionArgs: { inclusive: true },
+        operatorMotionArgs: { visualLine: true }},
+    { keys: ['C'], type: 'operatorMotion',
+        operator: 'change', operatorArgs: { enterInsertMode: true },
+        motion: 'moveToEol', motionArgs: { inclusive: true },
+        operatorMotionArgs: { visualLine: true }},
+    { keys: ['~'], type: 'operatorMotion', operator: 'swapcase',
+        motion: 'moveByCharacters', motionArgs: { forward: true }},
+    // Actions
+    { keys: ['a'], type: 'action', action: 'enterInsertMode',
+        actionArgs: { insertAt: 'charAfter' }},
+    { keys: ['A'], type: 'action', action: 'enterInsertMode',
+        actionArgs: { insertAt: 'eol' }},
+    { keys: ['i'], type: 'action', action: 'enterInsertMode' },
+    { keys: ['I'], type: 'action', action: 'enterInsertMode',
+        motion: 'moveToFirstNonWhiteSpaceCharacter' },
+    { keys: ['o'], type: 'action', action: 'newLineAndEnterInsertMode',
+        actionArgs: { after: true }},
+    { keys: ['O'], type: 'action', action: 'newLineAndEnterInsertMode',
+        actionArgs: { after: false }},
+    { keys: ['v'], type: 'action', action: 'toggleVisualMode' },
+    { keys: ['V'], type: 'action', action: 'toggleVisualMode',
+        actionArgs: { linewise: true }},
+    { keys: ['J'], type: 'action', action: 'joinLines' },
+    { keys: ['p'], type: 'action', action: 'paste',
+        actionArgs: { after: true }},
+    { keys: ['P'], type: 'action', action: 'paste',
+        actionArgs: { after: false }},
+    { keys: ['r', 'character'], type: 'action', action: 'replace' },
+    { keys: ['u'], type: 'action', action: 'undo' },
+    { keys: ['Ctrl-r'], type: 'action', action: 'redo' },
+    { keys: ['m', 'character'], type: 'action', action: 'setMark' },
+    { keys: ['\"', 'character'], type: 'action', action: 'setRegister' },
+    { keys: [',', '/'], type: 'action', action: 'clearSearchHighlight' },
+    // Text object motions
+    { keys: ['a', 'character'], type: 'motion',
+        motion: 'textObjectManipulation' },
+    { keys: ['i', 'character'], type: 'motion',
+        motion: 'textObjectManipulation',
+        motionArgs: { textObjectInner: true }},
+    // Search
+    { keys: ['/'], type: 'search',
+        searchArgs: { forward: true, querySrc: 'prompt' }},
+    { keys: ['?'], type: 'search',
+        searchArgs: { forward: false, querySrc: 'prompt' }},
+    { keys: ['*'], type: 'search',
+        searchArgs: { forward: true, querySrc: 'wordUnderCursor' }},
+    { keys: ['#'], type: 'search',
+        searchArgs: { forward: false, querySrc: 'wordUnderCursor' }},
+    // Ex command
+    { keys: [':'], type: 'ex' }
+  ];
+
+  var Vim = function() {
+    var alphabetRegex = /[A-Za-z]/;
+    var numberRegex = /[\d]/;
+    var whiteSpaceRegex = /\s/;
+    var wordRegexp = [(/\w/), (/[^\w\s]/)], bigWordRegexp = [(/\S/)];
+    function makeKeyRange(start, size) {
+      var keys = [];
+      for (var i = start; i < start + size; i++) {
+        keys.push(String.fromCharCode(i));
+      }
+      return keys;
+    }
+    var upperCaseAlphabet = makeKeyRange(65, 26);
+    var lowerCaseAlphabet = makeKeyRange(97, 26);
+    var numbers = makeKeyRange(48, 10);
+    var SPECIAL_SYMBOLS = '~`!@#$%^&*()_-+=[{}]\\|/?.,<>:;\"\'';
+    var specialSymbols = SPECIAL_SYMBOLS.split('');
+    var specialKeys = ['Left', 'Right', 'Up', 'Down', 'Space', 'Backspace',
+        'Esc', 'Home', 'End', 'PageUp', 'PageDown'];
+    var validMarks = upperCaseAlphabet.concat(lowerCaseAlphabet).concat(
+        numbers);
+    var validRegisters = upperCaseAlphabet.concat(lowerCaseAlphabet).concat(
+        numbers).concat('-\"'.split(''));
+
+    function isAlphabet(k) {
+      return alphabetRegex.test(k);
+    }
+    function isLine(cm, line) {
+      return line >= 0 && line < cm.lineCount();
+    }
+    function isLowerCase(k) {
+      return (/^[a-z]$/).test(k);
+    }
+    function isMatchableSymbol(k) {
+      return '()[]{}'.indexOf(k) != -1;
+    }
+    function isNumber(k) {
+      return numberRegex.test(k);
+    }
+    function isUpperCase(k) {
+      return (/^[A-Z]$/).test(k);
+    }
+    function isAlphanumeric(k) {
+      return (/^[\w]$/).test(k);
+    }
+    function isWhiteSpace(k) {
+      return whiteSpaceRegex.test(k);
+    }
+    function isWhiteSpaceString(k) {
+      return (/^\s*$/).test(k);
+    }
+    function inRangeInclusive(x, start, end) {
+      return x >= start && x <= end;
+    }
+    function inArray(val, arr) {
+      for (var i = 0; i < arr.length; i++) {
+        if (arr[i] == val) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    // Global Vim state. Call getVimGlobalState to get and initialize.
+    var vimGlobalState;
+    function getVimGlobalState() {
+      if (!vimGlobalState) {
+        vimGlobalState = {
+          // The current search query.
+          searchQuery: null,
+          // Whether we are searching backwards.
+          searchIsReversed: false,
+          registerController: new RegisterController({})
+        };
+      }
+      return vimGlobalState;
+    }
+    function getVimState(cm) {
+      if (!cm.vimState) {
+        // Store instance state in the CodeMirror object.
+        cm.vimState = {
+          inputState: new InputState(),
+          // When using jk for navigation, if you move from a longer line to a
+          // shorter line, the cursor may clip to the end of the shorter line.
+          // If j is pressed again and cursor goes to the next line, the
+          // cursor should go back to its horizontal position on the longer
+          // line if it can. This is to keep track of the horizontal position.
+          lastHPos: -1,
+          // The last motion command run. Cleared if a non-motion command gets
+          // executed in between.
+          lastMotion: null,
+          marks: {},
+          visualMode: false,
+          // If we are in visual line mode. No effect if visualMode is false.
+          visualLine: false
+        };
+      }
+      return cm.vimState;
+    }
+
+    var vimApi= {
+      buildKeyMap: function() {
+        // TODO: Convert keymap into dictionary format for fast lookup.
+      },
+      // Testing hook, though it might be useful to expose the register
+      // controller anyways.
+      getRegisterController: function() {
+        return getVimGlobalState().registerController;
+      },
+      // Testing hook.
+      clearVimGlobalState_: function() {
+        vimGlobalState = null;
+      },
+      map: function(lhs, rhs) {
+        // Add user defined key bindings.
+        exCommandDispatcher.map(lhs, rhs);
+      },
+      // Initializes vim state variable on the CodeMirror object. Should only be
+      // called lazily by handleKey or for testing.
+      maybeInitState: function(cm) {
+        getVimState(cm);
+      },
+      // This is the outermost function called by CodeMirror, after keys have
+      // been mapped to their Vim equivalents.
+      handleKey: function(cm, key) {
+        var command;
+        var vim = getVimState(cm);
+        if (key == 'Esc') {
+          // Clear input state and get back to normal mode.
+          vim.inputState.reset();
+          if (vim.visualMode) {
+            exitVisualMode(cm, vim);
+          }
+          return;
+        }
+        if (vim.visualMode &&
+            cursorEqual(cm.getCursor('head'), cm.getCursor('anchor'))) {
+          // The selection was cleared. Exit visual mode.
+          exitVisualMode(cm, vim);
+        }
+        if (!vim.visualMode &&
+            !cursorEqual(cm.getCursor('head'), cm.getCursor('anchor'))) {
+          vim.visualMode = true;
+          vim.visualLine = false;
+        }
+        if (key != '0' || (key == '0' && vim.inputState.getRepeat() === 0)) {
+          // Have to special case 0 since it's both a motion and a number.
+          command = commandDispatcher.matchCommand(key, defaultKeymap, vim);
+        }
+        if (!command) {
+          if (isNumber(key)) {
+            // Increment count unless count is 0 and key is 0.
+            vim.inputState.pushRepeatDigit(key);
+          }
+          return;
+        }
+        if (command.type == 'keyToKey') {
+          // TODO: prevent infinite recursion.
+          for (var i = 0; i < command.toKeys.length; i++) {
+            this.handleKey(cm, command.toKeys[i]);
+          }
+        } else {
+          commandDispatcher.processCommand(cm, vim, command);
+        }
+      }
+    };
+
+    // Represents the current input state.
+    function InputState() {
+      this.reset();
+    }
+    InputState.prototype.reset = function() {
+      this.prefixRepeat = [];
+      this.motionRepeat = [];
+
+      this.operator = null;
+      this.operatorArgs = null;
+      this.motion = null;
+      this.motionArgs = null;
+      this.keyBuffer = []; // For matching multi-key commands.
+      this.registerName = null; // Defaults to the unamed register.
+    };
+    InputState.prototype.pushRepeatDigit = function(n) {
+      if (!this.operator) {
+        this.prefixRepeat = this.prefixRepeat.concat(n);
+      } else {
+        this.motionRepeat = this.motionRepeat.concat(n);
+      }
+    };
+    InputState.prototype.getRepeat = function() {
+      var repeat = 0;
+      if (this.prefixRepeat.length > 0 || this.motionRepeat.length > 0) {
+        repeat = 1;
+        if (this.prefixRepeat.length > 0) {
+          repeat *= parseInt(this.prefixRepeat.join(''), 10);
+        }
+        if (this.motionRepeat.length > 0) {
+          repeat *= parseInt(this.motionRepeat.join(''), 10);
+        }
+      }
+      return repeat;
+    };
+
+    /*
+     * Register stores information about copy and paste registers.  Besides
+     * text, a register must store whether it is linewise (i.e., when it is
+     * pasted, should it insert itself into a new line, or should the text be
+     * inserted at the cursor position.)
+     */
+    function Register(text, linewise) {
+      this.clear();
+      if (text) {
+        this.set(text, linewise);
+      }
+    }
+    Register.prototype = {
+      set: function(text, linewise) {
+        this.text = text;
+        this.linewise = !!linewise;
+      },
+      append: function(text, linewise) {
+        // if this register has ever been set to linewise, use linewise.
+        if (linewise || this.linewise) {
+          this.text += '\n' + text;
+          this.linewise = true;
+        } else {
+          this.text += text;
+        }
+      },
+      clear: function() {
+        this.text = '';
+        this.linewise = false;
+      },
+      toString: function() { return this.text; }
+    };
+
+    /*
+     * vim registers allow you to keep many independent copy and paste buffers.
+     * See http://usevim.com/2012/04/13/registers/ for an introduction.
+     *
+     * RegisterController keeps the state of all the registers.  An initial
+     * state may be passed in.  The unnamed register '"' will always be
+     * overridden.
+     */
+    function RegisterController(registers) {
+      this.registers = registers;
+      this.unamedRegister = registers['\"'] = new Register();
+    }
+    RegisterController.prototype = {
+      pushText: function(registerName, operator, text, linewise) {
+        // Lowercase and uppercase registers refer to the same register.
+        // Uppercase just means append.
+        var register = this.isValidRegister(registerName) ?
+            this.getRegister(registerName) : null;
+        // if no register/an invalid register was specified, things go to the
+        // default registers
+        if (!register) {
+          switch (operator) {
+            case 'yank':
+              // The 0 register contains the text from the most recent yank.
+              this.registers['0'] = new Register(text, linewise);
+              break;
+            case 'delete':
+            case 'change':
+              if (text.indexOf('\n') == -1) {
+                // Delete less than 1 line. Update the small delete register.
+                this.registers['-'] = new Register(text, linewise);
               } else {
-                cur.ch = word.to;
+                // Shift down the contents of the numbered registers and put the
+                // deleted text into register 1.
+                this.shiftNumericRegisters_();
+                this.registers['1'] = new Register(text, linewise);
               }
-            } else if (dir > 0 && where == 'start') {
-              // 'w'
-              if (startCh != word.from || startLine != word.line) {
-                cur.ch = word.from;
-                break;
-              } else {
-                cur.ch = word.to;
+              break;
+          }
+          // Make sure the unnamed register is set to what just happened
+          this.unamedRegister.set(text, linewise);
+          return;
+        }
+
+        // If we've gotten to this point, we've actually specified a register
+        var append = isUpperCase(registerName);
+        if (append) {
+          register.append(text, linewise);
+          // The unamed register always has the same value as the last used
+          // register.
+          this.unamedRegister.append(text, linewise);
+        } else {
+          register.set(text, linewise);
+          this.unamedRegister.set(text, linewise);
+        }
+      },
+      // Gets the register named @name.  If one of @name doesn't already exist,
+      // create it.  If @name is invalid, return the unamedRegister.
+      getRegister: function(name) {
+        if (!this.isValidRegister(name)) {
+          return this.unamedRegister;
+        }
+        name = name.toLowerCase();
+        if (!this.registers[name]) {
+          this.registers[name] = new Register();
+        }
+        return this.registers[name];
+      },
+      isValidRegister: function(name) {
+        return name && inArray(name, validRegisters);
+      },
+      shiftNumericRegisters_: function() {
+        for (var i = 9; i >= 2; i--) {
+          this.registers[i] = this.getRegister('' + (i - 1));
+        }
+      }
+    };
+
+    var commandDispatcher = {
+      matchCommand: function(key, keyMap, vim) {
+        var inputState = vim.inputState;
+        var keys = inputState.keyBuffer.concat(key);
+        for (var i = 0; i < keyMap.length; i++) {
+          var command = keyMap[i];
+          if (matchKeysPartial(keys, command.keys)) {
+            if (keys.length < command.keys.length) {
+              // Matches part of a multi-key command. Buffer and wait for next
+              // stroke.
+              inputState.keyBuffer.push(key);
+              return null;
+            } else {
+              if (inputState.operator && command.type == 'action') {
+                // Ignore matched action commands after an operator. Operators
+                // only operate on motions. This check is really for text
+                // objects since aW, a[ etcs conflicts with a.
+                continue;
               }
-            } else if (dir < 0 && where == 'end') {
-              // 'ge'
-              if (startCh != word.to || startLine != word.line) {
-                cur.ch = word.to;
-                break;
-              } else {
-                cur.ch = word.from - 1;
+              // Matches whole comand. Return the command.
+              if (command.keys[keys.length - 1] == 'character') {
+                inputState.selectedCharacter = keys[keys.length - 1];
               }
-            } else if (dir < 0 && where == 'start') {
-              // 'b'
-              if (startCh != word.from || startLine != word.line) {
-                cur.ch = word.from;
-                break;
+              inputState.keyBuffer = [];
+              return command;
+            }
+          }
+        }
+        // Clear the buffer since there are no partial matches.
+        inputState.keyBuffer = [];
+        return null;
+      },
+      processCommand: function(cm, vim, command) {
+        switch (command.type) {
+          case 'motion':
+            this.processMotion(cm, vim, command);
+            break;
+          case 'operator':
+            this.processOperator(cm, vim, command);
+            break;
+          case 'operatorMotion':
+            this.processOperatorMotion(cm, vim, command);
+            break;
+          case 'action':
+            this.processAction(cm, vim, command);
+            break;
+          case 'search':
+            this.processSearch(cm, vim, command);
+            break;
+          case 'ex':
+          case 'keyToEx':
+            this.processEx(cm, vim, command);
+            break;
+          default:
+            break;
+        }
+      },
+      processMotion: function(cm, vim, command) {
+        vim.inputState.motion = command.motion;
+        vim.inputState.motionArgs = copyArgs(command.motionArgs);
+        this.evalInput(cm, vim);
+      },
+      processOperator: function(cm, vim, command) {
+        var inputState = vim.inputState;
+        if (inputState.operator) {
+          if (inputState.operator == command.operator) {
+            // Typing an operator twice like 'dd' makes the operator operate
+            // linewise
+            inputState.motion = 'expandToLine';
+            inputState.motionArgs = { linewise: true };
+            this.evalInput(cm, vim);
+            return;
+          } else {
+            // 2 different operators in a row doesn't make sense.
+            inputState.reset();
+          }
+        }
+        inputState.operator = command.operator;
+        inputState.operatorArgs = copyArgs(command.operatorArgs);
+        if (vim.visualMode) {
+          // Operating on a selection in visual mode. We don't need a motion.
+          this.evalInput(cm, vim);
+        }
+      },
+      processOperatorMotion: function(cm, vim, command) {
+        var visualMode = vim.visualMode;
+        var operatorMotionArgs = copyArgs(command.operatorMotionArgs);
+        if (operatorMotionArgs) {
+          // Operator motions may have special behavior in visual mode.
+          if (visualMode && operatorMotionArgs.visualLine) {
+            vim.visualLine = true;
+          }
+        }
+        this.processOperator(cm, vim, command);
+        if (!visualMode) {
+          this.processMotion(cm, vim, command);
+        }
+      },
+      processAction: function(cm, vim, command) {
+        var inputState = vim.inputState;
+        var repeat = inputState.getRepeat();
+        var repeatIsExplicit = !!repeat;
+        var actionArgs = copyArgs(command.actionArgs) || {};
+        if (inputState.selectedCharacter) {
+          actionArgs.selectedCharacter = inputState.selectedCharacter;
+        }
+        // Actions may or may not have motions and operators. Do these first.
+        if (command.operator) {
+          this.processOperator(cm, vim, command);
+        }
+        if (command.motion) {
+          this.processMotion(cm, vim, command);
+        }
+        if (command.motion || command.operator) {
+          this.evalInput(cm, vim);
+        }
+        actionArgs.repeat = repeat || 1;
+        actionArgs.repeatIsExplicit = repeatIsExplicit;
+        actionArgs.registerName = inputState.registerName;
+        inputState.reset();
+        vim.lastMotion = null,
+        actions[command.action](cm, actionArgs, vim);
+      },
+      processSearch: function(cm, vim, command) {
+        if (!cm.getSearchCursor) {
+          // Search depends on SearchCursor.
+          return;
+        }
+        var forward = command.searchArgs.forward;
+        getSearchState(cm).setReversed(!forward);
+        var promptPrefix = (forward) ? '/' : '?';
+        function handleQuery(query, ignoreCase, smartCase) {
+          updateSearchQuery(cm, query, ignoreCase, smartCase);
+          commandDispatcher.processMotion(cm, vim, {
+            type: 'motion',
+            motion: 'findNext'
+          });
+        }
+        function onPromptClose(query) {
+          handleQuery(query, true /** ignoreCase */, true /** smartCase */);
+        }
+        switch (command.searchArgs.querySrc) {
+          case 'prompt':
+            showPrompt(cm, onPromptClose, promptPrefix, searchPromptDesc);
+            break;
+          case 'wordUnderCursor':
+            var word = expandWordUnderCursor(cm, false /** inclusive */,
+                true /** forward */, false /** bigWord */,
+                true /** noSymbol */);
+            var isKeyword = true;
+            if (!word) {
+              word = expandWordUnderCursor(cm, false /** inclusive */,
+                  true /** forward */, false /** bigWord */,
+                  false /** noSymbol */);
+              isKeyword = false;
+            }
+            if (!word) {
+              return;
+            }
+            var query = cm.getLine(word.start.line).substring(word.start.ch,
+                word.end.ch + 1);
+            if (isKeyword) {
+              query = '\\b' + query + '\\b';
+            } else {
+              query = escapeRegex(query);
+            }
+            cm.setCursor(word.start);
+            handleQuery(query, true /** ignoreCase */, false /** smartCase */);
+            break;
+        }
+      },
+      processEx: function(cm, vim, command) {
+        function onPromptClose(input) {
+          exCommandDispatcher.processCommand(cm, input);
+        }
+        if (command.type == 'keyToEx') {
+          // Handle user defined Ex to Ex mappings
+          exCommandDispatcher.processCommand(cm, command.exArgs.input);
+        } else {
+          showPrompt(cm, onPromptClose, ':');
+        }
+      },
+      evalInput: function(cm, vim) {
+        // If the motion comand is set, execute both the operator and motion.
+        // Otherwise return.
+        var inputState = vim.inputState;
+        var motion = inputState.motion;
+        var motionArgs = inputState.motionArgs || {};
+        var operator = inputState.operator;
+        var operatorArgs = inputState.operatorArgs || {};
+        var registerName = inputState.registerName;
+        var selectionEnd = cm.getCursor('head');
+        var selectionStart = cm.getCursor('anchor');
+        // The difference between cur and selection cursors are that cur is
+        // being operated on and ignores that there is a selection.
+        var curStart = copyCursor(selectionEnd);
+        var curOriginal = copyCursor(curStart);
+        var curEnd;
+        var repeat;
+        if (motionArgs.repeat !== undefined) {
+          // If motionArgs specifies a repeat, that takes precedence over the
+          // input state's repeat. Used by Ex mode and can be user defined.
+          repeat = inputState.motionArgs.repeat;
+        } else {
+          repeat = inputState.getRepeat();
+        }
+        if (repeat > 0 && motionArgs.explicitRepeat) {
+          motionArgs.repeatIsExplicit = true;
+        } else if (motionArgs.noRepeat ||
+            (!motionArgs.explicitRepeat && repeat === 0)) {
+          repeat = 1;
+          motionArgs.repeatIsExplicit = false;
+        }
+        if (inputState.selectedCharacter) {
+          // If there is a character input, stick it in all of the arg arrays.
+          motionArgs.selectedCharacter = operatorArgs.selectedCharacter =
+              inputState.selectedCharacter;
+        }
+        motionArgs.repeat = repeat;
+        inputState.reset();
+        if (motion) {
+          var motionResult = motions[motion](cm, motionArgs, vim);
+          vim.lastMotion = motions[motion];
+          if (!motionResult) {
+            return;
+          }
+          if (motionResult instanceof Array) {
+            curStart = motionResult[0];
+            curEnd = motionResult[1];
+          } else {
+            curEnd = motionResult;
+          }
+          // TODO: Handle null returns from motion commands better.
+          if (!curEnd) {
+            curEnd = { ch: curStart.ch, line: curStart.line };
+          }
+          if (vim.visualMode) {
+            // Check if the selection crossed over itself. Will need to shift
+            // the start point if that happened.
+            if (cursorIsBefore(selectionStart, selectionEnd) &&
+                (cursorEqual(selectionStart, curEnd) ||
+                    cursorIsBefore(curEnd, selectionStart))) {
+              // The end of the selection has moved from after the start to
+              // before the start. We will shift the start right by 1.
+              selectionStart.ch += 1;
+            } else if (cursorIsBefore(selectionEnd, selectionStart) &&
+                (cursorEqual(selectionStart, curEnd) ||
+                    cursorIsBefore(selectionStart, curEnd))) {
+              // The opposite happened. We will shift the start left by 1.
+              selectionStart.ch -= 1;
+            }
+            selectionEnd = curEnd;
+            if (vim.visualLine) {
+              if (cursorIsBefore(selectionStart, selectionEnd)) {
+                selectionStart.ch = 0;
+                selectionEnd.ch = lineLength(cm, selectionEnd.line);
               } else {
-                cur.ch = word.from - 1;
+                selectionEnd.ch = 0;
+                selectionStart.ch = lineLength(cm, selectionStart.line);
               }
             }
+            // Need to set the cursor to clear the selection. Otherwise,
+            // CodeMirror can't figure out that we changed directions...
+            cm.setCursor(selectionStart);
+            cm.setSelection(selectionStart, selectionEnd);
+          } else if (!operator) {
+            curEnd = clipCursorToContent(cm, curEnd);
+            cm.setCursor(curEnd.line, curEnd.ch);
           }
-        } else {
-          // No more words to be found. Move to end of document.
-          for (; isLine(cm, cur.line + dir); cur.line += dir) {}
-          cur.ch = (dir > 0) ? cm.getLine(cur.line).length : 0;
-          break;
-        }
-      }
-    }
-    if (where == 'end' && yank) {
-      // Include the last character of the word for actions.
-      cur.ch++;
-    }
-    return cur;
-  }
-  function joinLineNext(cm) {
-    var cur = cm.getCursor(), ch = cur.ch, line = cm.getLine(cur.line);
-    CodeMirror.commands.goLineEnd(cm);
-    if (cur.line != cm.lineCount()) {
-      CodeMirror.commands.goLineEnd(cm);
-      cm.replaceSelection(" ", "end");
-      CodeMirror.commands.delCharRight(cm);
-    }
-  }
-  function delTillMark(cm, cHar) {
-    var i = mark[cHar];
-    if (i === undefined) {
-      // console.log("Mark not set"); // TODO - show in status bar
-      return;
-    }
-    var l = cm.getCursor().line, start = i > l ? l : i, end = i > l ? i : l;
-    cm.setCursor(start);
-    for (var c = start; c <= end; c++) {
-      pushInBuffer("\n" + cm.getLine(start));
-      cm.removeLine(start);
-    }
-  }
-  function yankTillMark(cm, cHar) {
-    var i = mark[cHar];
-    if (i === undefined) {
-      // console.log("Mark not set"); // TODO - show in status bar
-      return;
-    }
-    var l = cm.getCursor().line, start = i > l ? l : i, end = i > l ? i : l;
-    for (var c = start; c <= end; c++) {
-      pushInBuffer("\n" + cm.getLine(c));
-    }
-    cm.setCursor(start);
-  }
-  function goLineStartText(cm) {
-    // Go to the start of the line where the text begins, or the end for whitespace-only lines
-    var cur = cm.getCursor(), firstNonWS = cm.getLine(cur.line).search(/\S/);
-    cm.setCursor(cur.line, firstNonWS == -1 ? line.length : firstNonWS, true);
-  }
-
-  function charIdxInLine(cm, cHar, motion_options) {
-    // Search for cHar in line.
-    // motion_options: {forward, inclusive}
-    // If inclusive = true, include it too.
-    // If forward = true, search forward, else search backwards.
-    // If char is not found on this line, do nothing
-    var cur = cm.getCursor(), line = cm.getLine(cur.line), idx;
-    var ch = toLetter(cHar), mo = motion_options;
-    if (mo.forward) {
-      idx = line.indexOf(ch, cur.ch + 1);
-      if (idx != -1 && mo.inclusive) idx += 1;
-    } else {
-      idx = line.lastIndexOf(ch, cur.ch);
-      if (idx != -1 && !mo.inclusive) idx += 1;
-    }
-    return idx;
-  }
-
-  function moveTillChar(cm, cHar, motion_options) {
-    // Move to cHar in line, as found by charIdxInLine.
-    var idx = charIdxInLine(cm, cHar, motion_options), cur = cm.getCursor();
-    if (idx != -1) cm.setCursor({line: cur.line, ch: idx});
-  }
-
-  function delTillChar(cm, cHar, motion_options) {
-    // delete text in this line, untill cHar is met,
-    // as found by charIdxInLine.
-    // If char is not found on this line, do nothing
-    var idx = charIdxInLine(cm, cHar, motion_options);
-    var cur = cm.getCursor();
-    if (idx !== -1) {
-      if (motion_options.forward) {
-        cm.replaceRange("", {line: cur.line, ch: cur.ch}, {line: cur.line, ch: idx});
-      } else {
-        cm.replaceRange("", {line: cur.line, ch: idx}, {line: cur.line, ch: cur.ch});
-      }
-    }
-  }
-
-  function enterInsertMode(cm) {
-    // enter insert mode: switch mode and cursor
-    clearCount();
-    cm.setOption("keyMap", "vim-insert");
-  }
-
-  function dialog(cm, text, shortText, f) {
-    if (cm.openDialog) cm.openDialog(text, f);
-    else f(prompt(shortText, ""));
-  }
-  function showAlert(cm, text) {
-    var esc = text.replace(/[<&]/, function(ch) { return ch == "<" ? "&lt;" : "&amp;"; });
-    if (cm.openDialog) cm.openDialog(esc + " <button type=button>OK</button>");
-    else alert(text);
-  }
-
-  // main keymap
-  var map = CodeMirror.keyMap.vim = {
-    // Pipe (|); TODO: should be *screen* chars, so need a util function to turn tabs into spaces?
-    "'|'": function(cm) {
-      cm.setCursor(cm.getCursor().line, getCountOrOne() - 1, true);
-      clearCount();
-    },
-    "A": function(cm) {
-      cm.setCursor(cm.getCursor().line, cm.getCursor().ch+1, true);
-      enterInsertMode(cm);
-    },
-    "Shift-A": function(cm) { CodeMirror.commands.goLineEnd(cm); enterInsertMode(cm);},
-    "I": function(cm) { enterInsertMode(cm);},
-    "Shift-I": function(cm) { goLineStartText(cm); enterInsertMode(cm);},
-    "O": function(cm) {
-      CodeMirror.commands.goLineEnd(cm);
-      CodeMirror.commands.newlineAndIndent(cm);
-      enterInsertMode(cm);
-    },
-    "Shift-O": function(cm) {
-      CodeMirror.commands.goLineStart(cm);
-      cm.replaceSelection("\n", "start");
-      cm.indentLine(cm.getCursor().line);
-      enterInsertMode(cm);
-    },
-    "G": function(cm) { cm.setOption("keyMap", "vim-prefix-g");},
-    "Shift-D": function(cm) {
-      var cursor = cm.getCursor();
-      var lineN = cursor.line;
-      var line = cm.getLine(lineN);
-      cm.setLine(lineN, line.slice(0, cursor.ch));
-
-      emptyBuffer();
-      pushInBuffer(line.slice(cursor.ch));
-
-      if (repeatCount > 1) {
-        // we've already done it once
-        --repeatCount;
-        // the lines dissapear (ie, cursor stays on the same lineN),
-        // so only incremenet once
-        ++lineN;
-
-        iterTimes(function() {
-          pushInBuffer(cm.getLine(lineN));
-          cm.removeLine(lineN);
-        });
+        }
+
+        if (operator) {
+          var inverted = false;
+          vim.lastMotion = null;
+          operatorArgs.repeat = repeat; // Indent in visual mode needs this.
+          if (vim.visualMode) {
+            curStart = selectionStart;
+            curEnd = selectionEnd;
+            motionArgs.inclusive = true;
+          }
+          // Swap start and end if motion was backward.
+          if (cursorIsBefore(curEnd, curStart)) {
+            var tmp = curStart;
+            curStart = curEnd;
+            curEnd = tmp;
+            inverted = true;
+          }
+          if (motionArgs.inclusive && !(vim.visualMode && inverted)) {
+            // Move the selection end one to the right to include the last
+            // character.
+            curEnd.ch++;
+          }
+          var linewise = motionArgs.linewise ||
+              (vim.visualMode && vim.visualLine);
+          if (linewise) {
+            // Expand selection to entire line.
+            expandSelectionToLine(cm, curStart, curEnd);
+          } else if (motionArgs.forward) {
+            // Clip to trailing newlines only if we the motion goes forward.
+            clipToLine(cm, curStart, curEnd);
+          }
+          operatorArgs.registerName = registerName;
+          // Keep track of linewise as it affects how paste and change behave.
+          operatorArgs.linewise = linewise;
+          operators[operator](cm, operatorArgs, vim, curStart,
+              curEnd, curOriginal);
+          if (vim.visualMode) {
+            exitVisualMode(cm, vim);
+          }
+          if (operatorArgs.enterInsertMode) {
+            actions.enterInsertMode(cm);
+          }
+        }
       }
-    },
-
-    "S": function (cm) {
-      countTimes(function (_cm) {
-        CodeMirror.commands.delCharRight(_cm);
-      })(cm);
-      enterInsertMode(cm);
-    },
-    "M": function(cm) {cm.setOption("keyMap", "vim-prefix-m"); mark = {};},
-    "Y": function(cm) {cm.setOption("keyMap", "vim-prefix-y"); emptyBuffer();},
-    "Shift-Y": function(cm) {
-      emptyBuffer();
-      iterTimes(function(i) { pushInBuffer("\n" + cm.getLine(cm.getCursor().line + i)); });
-    },
-    "/": function(cm) {var f = CodeMirror.commands.find; f && f(cm); sdir = "f";},
-    "'?'": function(cm) {
-      var f = CodeMirror.commands.find;
-      if (f) { f(cm); CodeMirror.commands.findPrev(cm); sdir = "r"; }
-    },
-    "N": function(cm) {
-      var fn = CodeMirror.commands.findNext;
-      if (fn) sdir != "r" ? fn(cm) : CodeMirror.commands.findPrev(cm);
-    },
-    "Shift-N": function(cm) {
-      var fn = CodeMirror.commands.findNext;
-      if (fn) sdir != "r" ? CodeMirror.commands.findPrev(cm) : fn.findNext(cm);
-    },
-    "Shift-G": function(cm) {
-      (repeatCount == 0) ? cm.setCursor(cm.lineCount()) : cm.setCursor(repeatCount - 1);
-      clearCount();
-      CodeMirror.commands.goLineStart(cm);
-    },
-    "':'": function(cm) {
-      var exModeDialog = ': <input type="text" style="width: 90%"/>';
-      dialog(cm, exModeDialog, ':', function(command) {
-        if (command.match(/^\d+$/)) {
-          cm.setCursor(command - 1, cm.getCursor().ch);
+    };
+
+    /**
+     * typedef {Object{line:number,ch:number}} Cursor An object containing the
+     *     position of the cursor.
+     */
+    // All of the functions below return Cursor objects.
+    var motions = {
+      expandToLine: function(cm, motionArgs) {
+        // Expands forward to end of line, and then to next line if repeat is
+        // >1. Does not handle backward motion!
+        var cur = cm.getCursor();
+        return { line: cur.line + motionArgs.repeat - 1, ch: Infinity };
+      },
+      findNext: function(cm, motionArgs, vim) {
+        return findNext(cm, false /** prev */, motionArgs.repeat);
+      },
+      findPrev: function(cm, motionArgs, vim) {
+        return findNext(cm, true /** prev */, motionArgs.repeat);
+      },
+      goToMark: function(cm, motionArgs, vim) {
+        var mark = vim.marks[motionArgs.selectedCharacter];
+        if (mark) {
+          return mark.find();
+        }
+        return null;
+      },
+      moveByCharacters: function(cm, motionArgs) {
+        var cur = cm.getCursor();
+        var repeat = motionArgs.repeat;
+        var ch = motionArgs.forward ? cur.ch + repeat : cur.ch - repeat;
+        return { line: cur.line, ch: ch };
+      },
+      moveByLines: function(cm, motionArgs, vim) {
+        var endCh = cm.getCursor().ch;
+        // Depending what our last motion was, we may want to do different
+        // things. If our last motion was moving vertically, we want to
+        // preserve the HPos from our last horizontal move.  If our last motion
+        // was going to the end of a line, moving vertically we should go to
+        // the end of the line, etc.
+        switch (vim.lastMotion) {
+          case this.moveByLines:
+          case this.moveToColumn:
+          case this.moveToEol:
+            endCh = vim.lastHPos;
+            break;
+          default:
+            vim.lastHPos = endCh;
+        }
+        var cur = cm.getCursor();
+        var repeat = motionArgs.repeat;
+        var line = motionArgs.forward ? cur.line + repeat : cur.line - repeat;
+        if (line < 0 || line > cm.lineCount() - 1) {
+          return null;
+        }
+        return { line: line, ch: endCh };
+      },
+      moveByPage: function(cm, motionArgs) {
+        // CodeMirror only exposes functions that move the cursor page down, so
+        // doing this bad hack to move the cursor and move it back. evalInput
+        // will move the cursor to where it should be in the end.
+        var curStart = cm.getCursor();
+        var repeat = motionArgs.repeat;
+        cm.moveV((motionArgs.forward ? repeat : -repeat), 'page');
+        var curEnd = cm.getCursor();
+        cm.setCursor(curStart);
+        return curEnd;
+      },
+      moveByWords: function(cm, motionArgs) {
+        return moveToWord(cm, motionArgs.repeat, !!motionArgs.forward,
+            !!motionArgs.wordEnd, !!motionArgs.bigWord);
+      },
+      moveTillCharacter: function(cm, motionArgs) {
+        var repeat = motionArgs.repeat;
+        var curEnd = moveToCharacter(cm, repeat, motionArgs.forward,
+            motionArgs.selectedCharacter);
+        var increment = motionArgs.forward ? -1 : 1;
+        curEnd.ch += increment;
+        return curEnd;
+      },
+      moveToCharacter: function(cm, motionArgs) {
+        var repeat = motionArgs.repeat;
+        return moveToCharacter(cm, repeat, motionArgs.forward,
+            motionArgs.selectedCharacter);
+      },
+      moveToColumn: function(cm, motionArgs, vim) {
+        var repeat = motionArgs.repeat;
+        // repeat is equivalent to which column we want to move to!
+        vim.lastHPos = repeat - 1;
+        return moveToColumn(cm, repeat);
+      },
+      moveToEol: function(cm, motionArgs, vim) {
+        var cur = cm.getCursor();
+        vim.lastHPos = Infinity;
+        return { line: cur.line + motionArgs.repeat - 1, ch: Infinity };
+      },
+      moveToFirstNonWhiteSpaceCharacter: function(cm) {
+        // Go to the start of the line where the text begins, or the end for
+        // whitespace-only lines
+        var cursor = cm.getCursor();
+        var line = cm.getLine(cursor.line);
+        return { line: cursor.line,
+            ch: findFirstNonWhiteSpaceCharacter(cm.getLine(cursor.line)) };
+      },
+      moveToMatchedSymbol: function(cm, motionArgs) {
+        var cursor = cm.getCursor();
+        var symbol = cm.getLine(cursor.line).charAt(cursor.ch);
+        if (isMatchableSymbol(symbol)) {
+          return findMatchedSymbol(cm, cm.getCursor(), motionArgs.symbol);
         } else {
-          showAlert(cm, "Bad command: " + command);
+          return cursor;
         }
-      });
-    },
-    nofallthrough: true, style: "fat-cursor"
-  };
-
-  // standard mode switching
-  iterList(["d", "t", "T", "f", "F", "c", "r"], function (ch) {
-    CodeMirror.keyMap.vim[toCombo(ch)] = function (cm) {
-      cm.setOption("keyMap", "vim-prefix-" + ch);
-      emptyBuffer();
+      },
+      moveToStartOfLine: function(cm) {
+        var cursor = cm.getCursor();
+        return { line: cursor.line, ch: 0 };
+      },
+      moveToLineOrEdgeOfDocument: function(cm, motionArgs) {
+        var lineNum = motionArgs.forward ? cm.lineCount() - 1 : 0;
+        if (motionArgs.repeatIsExplicit) {
+          lineNum = motionArgs.repeat - 1;
+        }
+        return { line: lineNum,
+            ch: findFirstNonWhiteSpaceCharacter(cm.getLine(lineNum)) };
+      },
+      textObjectManipulation: function(cm, motionArgs) {
+        var character = motionArgs.selectedCharacter;
+        // Inclusive is the difference between a and i
+        // TODO: Instead of using the additional text object map to perform text
+        //     object operations, merge the map into the defaultKeyMap and use
+        //     motionArgs to define behavior. Define separate entries for 'aw',
+        //     'iw', 'a[', 'i[', etc.
+        var inclusive = !motionArgs.textObjectInner;
+        if (!textObjects[character]) {
+          // No text object defined for this, don't move.
+          return null;
+        }
+        var tmp = textObjects[character](cm, inclusive);
+        var start = tmp.start;
+        var end = tmp.end;
+        return [start, end];
+      }
     };
-  });
-
-  // main num keymap
-  // Add bindings that are influenced by number keys
-  iterObj({
-    "X": function(cm) {CodeMirror.commands.delCharRight(cm);},
-    "P": function(cm) {
-      var cur = cm.getCursor().line;
-      if (buf!= "") {
-        if (buf[0] == "\n") CodeMirror.commands.goLineEnd(cm);
-        cm.replaceRange(buf, cm.getCursor());
-      }
-    },
-    "Shift-X": function(cm) {CodeMirror.commands.delCharLeft(cm);},
-    "Shift-J": function(cm) {joinLineNext(cm);},
-    "Shift-P": function(cm) {
-      var cur = cm.getCursor().line;
-      if (buf!= "") {
-        CodeMirror.commands.goLineUp(cm);
-        CodeMirror.commands.goLineEnd(cm);
-        cm.replaceSelection(buf, "end");
-      }
-      cm.setCursor(cur+1);
-    },
-    "'~'": function(cm) {
-      var cur = cm.getCursor(), cHar = cm.getRange({line: cur.line, ch: cur.ch}, {line: cur.line, ch: cur.ch+1});
-      cHar = cHar != cHar.toLowerCase() ? cHar.toLowerCase() : cHar.toUpperCase();
-      cm.replaceRange(cHar, {line: cur.line, ch: cur.ch}, {line: cur.line, ch: cur.ch+1});
-      cm.setCursor(cur.line, cur.ch+1);
-    },
-    "Ctrl-B": function(cm) {CodeMirror.commands.goPageUp(cm);},
-    "Ctrl-F": function(cm) {CodeMirror.commands.goPageDown(cm);},
-    "Ctrl-P": "goLineUp", "Ctrl-N": "goLineDown",
-    "U": "undo", "Ctrl-R": "redo"
-  }, function(key, cmd) { map[key] = countTimes(cmd); });
-
-  // empty key maps
-  iterList([
-      "vim-prefix-d'",
-      "vim-prefix-y'",
-      "vim-prefix-df",
-      "vim-prefix-dF",
-      "vim-prefix-dt",
-      "vim-prefix-dT",
-      "vim-prefix-c",
-      "vim-prefix-cf",
-      "vim-prefix-cF",
-      "vim-prefix-ct",
-      "vim-prefix-cT",
-      "vim-prefix-",
-      "vim-prefix-f",
-      "vim-prefix-F",
-      "vim-prefix-t",
-      "vim-prefix-T",
-      "vim-prefix-r",
-      "vim-prefix-m"
-      ],
-      function (prefix) {
-        CodeMirror.keyMap[prefix] = {
-          auto: "vim",
-          nofallthrough: true,
-          style: "fat-cursor"
-        };
-      });
 
-  CodeMirror.keyMap["vim-prefix-g"] = {
-    "E": countTimes(function(cm) { cm.setCursor(moveToWord(cm, word, -1, 1, "end"));}),
-    "Shift-E": countTimes(function(cm) { cm.setCursor(moveToWord(cm, bigWord, -1, 1, "end"));}),
-    "G": function (cm) {
-      cm.setCursor({line: repeatCount - 1, ch: cm.getCursor().ch});
-      clearCount();
-    },
-    auto: "vim", nofallthrough: true, style: "fat-cursor"
-  };
+    var operators = {
+      change: function(cm, operatorArgs, vim, curStart, curEnd) {
+        getVimGlobalState().registerController.pushText(
+            operatorArgs.registerName, 'change', cm.getRange(curStart, curEnd),
+            operatorArgs.linewise);
+        if (operatorArgs.linewise) {
+          // Delete starting at the first nonwhitespace character of the first
+          // line, instead of from the start of the first line. This way we get
+          // an indent when we get into insert mode. This behavior isn't quite
+          // correct because we should treat this as a completely new line, and
+          // indent should be whatever codemirror thinks is the right indent.
+          // But cm.indentLine doesn't seem work on empty lines.
+          // TODO: Fix the above.
+          curStart.ch =
+              findFirstNonWhiteSpaceCharacter(cm.getLine(curStart.line));
+          // Insert an additional newline so that insert mode can start there.
+          // curEnd should be on the first character of the new line.
+          cm.replaceRange('\n', curStart, curEnd);
+        } else {
+          cm.replaceRange('', curStart, curEnd);
+        }
+        cm.setCursor(curStart);
+      },
+      // delete is a javascript keyword.
+      'delete': function(cm, operatorArgs, vim, curStart, curEnd) {
+        getVimGlobalState().registerController.pushText(
+            operatorArgs.registerName, 'delete', cm.getRange(curStart, curEnd),
+            operatorArgs.linewise);
+        cm.replaceRange('', curStart, curEnd);
+        if (operatorArgs.linewise) {
+          cm.setCursor(motions.moveToFirstNonWhiteSpaceCharacter(cm));
+        } else {
+          cm.setCursor(curStart);
+        }
+      },
+      indent: function(cm, operatorArgs, vim, curStart, curEnd) {
+        var startLine = curStart.line;
+        var endLine = curEnd.line;
+        // In visual mode, n> shifts the selection right n times, instead of
+        // shifting n lines right once.
+        var repeat = (vim.visualMode) ? operatorArgs.repeat : 1;
+        if (operatorArgs.linewise) {
+          // The only way to delete a newline is to delete until the start of
+          // the next line, so in linewise mode evalInput will include the next
+          // line. We don't want this in indent, so we go back a line.
+          endLine--;
+        }
+        for (var i = startLine; i <= endLine; i++) {
+          for (var j = 0; j < repeat; j++) {
+            cm.indentLine(i, operatorArgs.indentRight);
+          }
+        }
+        cm.setCursor(curStart);
+        cm.setCursor(motions.moveToFirstNonWhiteSpaceCharacter(cm));
+      },
+      swapcase: function(cm, operatorArgs, vim, curStart, curEnd, curOriginal) {
+        var toSwap = cm.getRange(curStart, curEnd);
+        var swapped = '';
+        for (var i = 0; i < toSwap.length; i++) {
+          var character = toSwap.charAt(i);
+          swapped += isUpperCase(character) ? character.toLowerCase() :
+              character.toUpperCase();
+        }
+        cm.replaceRange(swapped, curStart, curEnd);
+        cm.setCursor(curOriginal);
+      },
+      yank: function(cm, operatorArgs, vim, curStart, curEnd, curOriginal) {
+        getVimGlobalState().registerController.pushText(
+            operatorArgs.registerName, 'yank',
+            cm.getRange(curStart, curEnd), operatorArgs.linewise);
+        cm.setCursor(curOriginal);
+      }
+    };
 
-  CodeMirror.keyMap["vim-prefix-d"] = {
-    "D": countTimes(function(cm) {
-      pushInBuffer("\n" + cm.getLine(cm.getCursor().line));
-      cm.removeLine(cm.getCursor().line);
-      cm.setOption("keyMap", "vim");
-    }),
-    "'": function(cm) {
-      cm.setOption("keyMap", "vim-prefix-d'");
-      emptyBuffer();
-    },
-    "B": function(cm) {
-      var cur = cm.getCursor();
-      var line = cm.getLine(cur.line);
-      var index = line.lastIndexOf(" ", cur.ch);
+    var actions = {
+      clearSearchHighlight: clearSearchHighlight,
+      enterInsertMode: function(cm, actionArgs) {
+        var insertAt = (actionArgs) ? actionArgs.insertAt : null;
+        if (insertAt == 'eol') {
+          var cursor = cm.getCursor();
+          cursor = { line: cursor.line, ch: lineLength(cm, cursor.line) };
+          cm.setCursor(cursor);
+        } else if (insertAt == 'charAfter') {
+          cm.setCursor(offsetCursor(cm.getCursor(), 0, 1));
+        }
+        cm.setOption('keyMap', 'vim-insert');
+      },
+      toggleVisualMode: function(cm, actionArgs, vim) {
+        var repeat = actionArgs.repeat;
+        var curStart = cm.getCursor();
+        var curEnd;
+        // TODO: The repeat should actually select number of characters/lines
+        //     equal to the repeat times the size of the previous visual
+        //     operation.
+        if (!vim.visualMode) {
+          vim.visualMode = true;
+          vim.visualLine = !!actionArgs.linewise;
+          if (vim.visualLine) {
+            curStart.ch = 0;
+            curEnd = clipCursorToContent(cm, {
+              line: curStart.line + repeat - 1,
+              ch: lineLength(cm, curStart.line)
+            }, true /** includeLineBreak */);
+          } else {
+            curEnd = clipCursorToContent(cm, {
+              line: curStart.line,
+              ch: curStart.ch + repeat
+            }, true /** includeLineBreak */);
+          }
+          // Make the initial selection.
+          if (!actionArgs.repeatIsExplicit && !vim.visualLine) {
+            // This is a strange case. Here the implicit repeat is 1. The
+            // following commands lets the cursor hover over the 1 character
+            // selection.
+            cm.setCursor(curEnd);
+            cm.setSelection(curEnd, curStart);
+          } else {
+            cm.setSelection(curStart, curEnd);
+          }
+        } else {
+          if (!vim.visualLine && actionArgs.linewise) {
+            // Shift-V pressed in characterwise visual mode. Switch to linewise
+            // visual mode instead of exiting visual mode.
+            vim.visualLine = true;
+            curStart = cm.getCursor('anchor');
+            curEnd = cm.getCursor('head');
+            curStart.ch = cursorIsBefore(curStart, curEnd) ? 0 :
+                lineLength(cm, curStart.line);
+            curEnd.ch = cursorIsBefore(curStart, curEnd) ?
+                lineLength(cm, curEnd.line) : 0;
+            cm.setSelection(curStart, curEnd);
+          } else {
+            exitVisualMode(cm, vim);
+          }
+        }
+      },
+      joinLines: function(cm, actionArgs, vim) {
+        var curStart, curEnd;
+        if (vim.visualMode) {
+          curStart = cm.getCursor('anchor');
+          curEnd = cm.getCursor('head');
+          curEnd.ch = lineLength(cm, curEnd.line) - 1;
+        } else {
+          // Repeat is the number of lines to join. Minimum 2 lines.
+          var repeat = Math.max(actionArgs.repeat, 2);
+          curStart = cm.getCursor();
+          curEnd = clipCursorToContent(cm, { line: curStart.line + repeat - 1,
+              ch: Infinity });
+        }
+        var finalCh = 0;
+        cm.operation(function() {
+          for (var i = curStart.line; i < curEnd.line; i++) {
+            finalCh = lineLength(cm, curStart.line);
+            var tmp = { line: curStart.line + 1,
+                ch: lineLength(cm, curStart.line + 1) };
+            var text = cm.getRange(curStart, tmp);
+            text = text.replace(/\n\s*/g, ' ');
+            cm.replaceRange(text, curStart, tmp);
+          }
+          var curFinalPos = { line: curStart.line, ch: finalCh };
+          cm.setCursor(curFinalPos);
+        });
+      },
+      newLineAndEnterInsertMode: function(cm, actionArgs) {
+        var insertAt = cm.getCursor();
+        if (insertAt.line === 0 && !actionArgs.after) {
+          // Special case for inserting newline before start of document.
+          cm.replaceRange('\n', { line: 0, ch: 0 });
+          cm.setCursor(0, 0);
+        } else {
+          insertAt.line = (actionArgs.after) ? insertAt.line :
+              insertAt.line - 1;
+          insertAt.ch = lineLength(cm, insertAt.line);
+          cm.setCursor(insertAt);
+          var newlineFn = CodeMirror.commands.newlineAndIndentContinueComment ||
+              CodeMirror.commands.newlineAndIndent;
+          newlineFn(cm);
+        }
+        this.enterInsertMode(cm);
+      },
+      paste: function(cm, actionArgs, vim) {
+        var cur = cm.getCursor();
+        var register = getVimGlobalState().registerController.getRegister(
+            actionArgs.registerName);
+        if (!register.text) {
+          return;
+        }
+        for (var text = '', i = 0; i < actionArgs.repeat; i++) {
+          text += register.text;
+        }
+        var linewise = register.linewise;
+        if (linewise) {
+          if (actionArgs.after) {
+            // Move the newline at the end to the start instead, and paste just
+            // before the newline character of the line we are on right now.
+            text = '\n' + text.slice(0, text.length - 1);
+            cur.ch = lineLength(cm, cur.line);
+          } else {
+            cur.ch = 0;
+          }
+        } else {
+          cur.ch += actionArgs.after ? 1 : 0;
+        }
+        cm.replaceRange(text, cur);
+        // Now fine tune the cursor to where we want it.
+        var curPosFinal;
+        var idx;
+        if (linewise && actionArgs.after) {
+          curPosFinal = { line: cur.line + 1,
+              ch: findFirstNonWhiteSpaceCharacter(cm.getLine(cur.line + 1)) };
+        } else if (linewise && !actionArgs.after) {
+          curPosFinal = { line: cur.line,
+              ch: findFirstNonWhiteSpaceCharacter(cm.getLine(cur.line)) };
+        } else if (!linewise && actionArgs.after) {
+          idx = cm.indexFromPos(cur);
+          curPosFinal = cm.posFromIndex(idx + text.length - 1);
+        } else {
+          idx = cm.indexFromPos(cur);
+          curPosFinal = cm.posFromIndex(idx + text.length);
+        }
+        cm.setCursor(curPosFinal);
+      },
+      undo: function(cm, actionArgs) {
+        repeatFn(cm, CodeMirror.commands.undo, actionArgs.repeat)();
+      },
+      redo: function(cm, actionArgs) {
+        repeatFn(cm, CodeMirror.commands.redo, actionArgs.repeat)();
+      },
+      setRegister: function(cm, actionArgs, vim) {
+        vim.inputState.registerName = actionArgs.selectedCharacter;
+      },
+      setMark: function(cm, actionArgs, vim) {
+        var markName = actionArgs.selectedCharacter;
+        if (!inArray(markName, validMarks)) {
+          return;
+        }
+        if (vim.marks[markName]) {
+          vim.marks[markName].clear();
+        }
+        vim.marks[markName] = cm.setBookmark(cm.getCursor());
+      },
+      replace: function(cm, actionArgs) {
+        var replaceWith = actionArgs.selectedCharacter;
+        var curStart = cm.getCursor();
+        var line = cm.getLine(curStart.line);
+        var replaceTo = curStart.ch + actionArgs.repeat;
+        if (replaceTo > line.length) {
+          return;
+        }
+        var curEnd = { line: curStart.line, ch: replaceTo };
+        var replaceWithStr = '';
+        for (var i = 0; i < curEnd.ch - curStart.ch; i++) {
+          replaceWithStr += replaceWith;
+        }
+        cm.replaceRange(replaceWithStr, curStart, curEnd);
+        cm.setCursor(offsetCursor(curEnd, 0, -1));
+      }
+    };
 
-      pushInBuffer(line.substring(index, cur.ch));
-      cm.replaceRange("", {line: cur.line, ch: index}, cur);
-      cm.setOption("keyMap", "vim");
-    },
-    nofallthrough: true, style: "fat-cursor"
-  };
+    var textObjects = {
+      // TODO: lots of possible exceptions that can be thrown here. Try da(
+      //     outside of a () block.
+      // TODO: implement text objects for the reverse like }. Should just be
+      //     an additional mapping after moving to the defaultKeyMap.
+      'w': function(cm, inclusive) {
+        return expandWordUnderCursor(cm, inclusive, true /** forward */,
+            false /** bigWord */);
+      },
+      'W': function(cm, inclusive) {
+        return expandWordUnderCursor(cm, inclusive,
+            true /** forward */, true /** bigWord */);
+      },
+      '{': function(cm, inclusive) {
+        return selectCompanionObject(cm, '}', inclusive);
+      },
+      '(': function(cm, inclusive) {
+        return selectCompanionObject(cm, ')', inclusive);
+      },
+      '[': function(cm, inclusive) {
+        return selectCompanionObject(cm, ']', inclusive);
+      },
+      '\'': function(cm, inclusive) {
+        return findBeginningAndEnd(cm, "'", inclusive);
+      },
+      '\"': function(cm, inclusive) {
+        return findBeginningAndEnd(cm, '"', inclusive);
+      }
+    };
 
-  CodeMirror.keyMap["vim-prefix-c"] = {
-    "B": function (cm) {
-      countTimes("delWordLeft")(cm);
-      enterInsertMode(cm);
-    },
-    "C": function (cm) {
-      iterTimes(function (i, last) {
-        CodeMirror.commands.deleteLine(cm);
-        if (i) {
-          CodeMirror.commands.delCharRight(cm);
-          if (last) CodeMirror.commands.deleteLine(cm);
+    /*
+     * Below are miscellaneous utility functions used by vim.js
+     */
+
+    /**
+     * Clips cursor to ensure that:
+     *   0 <= cur.ch < lineLength
+     *       AND
+     *   0 <= cur.line < lineCount
+     * If includeLineBreak is true, then allow cur.ch == lineLength.
+     */
+    function clipCursorToContent(cm, cur, includeLineBreak) {
+      var line = Math.min(Math.max(0, cur.line), cm.lineCount() - 1);
+      var maxCh = lineLength(cm, line) - 1;
+      maxCh = (includeLineBreak) ? maxCh + 1 : maxCh;
+      var ch = Math.min(Math.max(0, cur.ch), maxCh);
+      return { line: line, ch: ch };
+    }
+    // Merge arguments in place, for overriding arguments.
+    function mergeArgs(to, from) {
+      for (var prop in from) {
+        if (from.hasOwnProperty(prop)) {
+          to[prop] = from[prop];
         }
-      });
-      enterInsertMode(cm);
-    },
-    nofallthrough: true, style: "fat-cursor"
-  };
+      }
+    }
+    function copyArgs(args) {
+      var ret = {};
+      for (var prop in args) {
+        if (args.hasOwnProperty(prop)) {
+          ret[prop] = args[prop];
+        }
+      }
+      return ret;
+    }
+    function offsetCursor(cur, offsetLine, offsetCh) {
+      return { line: cur.line + offsetLine, ch: cur.ch + offsetCh };
+    }
+    function arrayEq(a1, a2) {
+      if (a1.length != a2.length) {
+        return false;
+      }
+      for (var i = 0; i < a1.length; i++) {
+        if (a1[i] != a2[i]) {
+          return false;
+        }
+      }
+      return true;
+    }
+    function matchKeysPartial(pressed, mapped) {
+      for (var i = 0; i < pressed.length; i++) {
+        // 'character' means any character. For mark, register commads, etc.
+        if (pressed[i] != mapped[i] && mapped[i] != 'character') {
+          return false;
+        }
+      }
+      return true;
+    }
+    function arrayIsSubsetFromBeginning(small, big) {
+      for (var i = 0; i < small.length; i++) {
+        if (small[i] != big[i]) {
+          return false;
+        }
+      }
+      return true;
+    }
+    function repeatFn(cm, fn, repeat) {
+      return function() {
+        for (var i = 0; i < repeat; i++) {
+          fn(cm);
+        }
+      };
+    }
+    function copyCursor(cur) {
+      return { line: cur.line, ch: cur.ch };
+    }
+    function cursorEqual(cur1, cur2) {
+      return cur1.ch == cur2.ch && cur1.line == cur2.line;
+    }
+    function cursorIsBefore(cur1, cur2) {
+      if (cur1.line < cur2.line) {
+        return true;
+      } else if (cur1.line == cur2.line && cur1.ch < cur2.ch) {
+        return true;
+      }
+      return false;
+    }
+    function lineLength(cm, lineNum) {
+      return cm.getLine(lineNum).length;
+    }
+    function reverse(s){
+      return s.split("").reverse().join("");
+    }
+    function trim(s) {
+      if (s.trim) {
+        return s.trim();
+      } else {
+        return s.replace(/^\s+|\s+$/g, '');
+      }
+    }
+    function escapeRegex(s) {
+      return s.replace(/([.?*+$\[\]\/\\(){}|\-])/g, "\\$1");
+    }
 
-  iterList(["vim-prefix-d", "vim-prefix-c", "vim-prefix-"], function (prefix) {
-    iterList(["f", "F", "T", "t"],
-      function (ch) {
-        CodeMirror.keyMap[prefix][toCombo(ch)] = function (cm) {
-          cm.setOption("keyMap", prefix + ch);
-          emptyBuffer();
-        };
-      });
-  });
+    function exitVisualMode(cm, vim) {
+      vim.visualMode = false;
+      vim.visualLine = false;
+      var selectionStart = cm.getCursor('anchor');
+      var selectionEnd = cm.getCursor('head');
+      if (!cursorEqual(selectionStart, selectionEnd)) {
+        // Clear the selection and set the cursor only if the selection has not
+        // already been cleared. Otherwise we risk moving the cursor somewhere
+        // it's not supposed to be.
+        cm.setCursor(clipCursorToContent(cm, selectionEnd));
+      }
+    }
 
-  var MOTION_OPTIONS = {
-    "t": {inclusive: false, forward: true},
-    "f": {inclusive: true,  forward: true},
-    "T": {inclusive: false, forward: false},
-    "F": {inclusive: true,  forward: false}
-  };
+    // Remove any trailing newlines from the selection. For
+    // example, with the caret at the start of the last word on the line,
+    // 'dw' should word, but not the newline, while 'w' should advance the
+    // caret to the first character of the next line.
+    function clipToLine(cm, curStart, curEnd) {
+      var selection = cm.getRange(curStart, curEnd);
+      var lines = selection.split('\n');
+      if (lines.length > 1 && isWhiteSpaceString(lines.pop())) {
+        curEnd.line--;
+        curEnd.ch = lineLength(cm, curEnd.line);
+      }
+    }
 
-  function setupPrefixBindingForKey(m) {
-    CodeMirror.keyMap["vim-prefix-m"][m] = function(cm) {
-      mark[m] = cm.getCursor().line;
-    };
-    CodeMirror.keyMap["vim-prefix-d'"][m] = function(cm) {
-      delTillMark(cm, m);
-    };
-    CodeMirror.keyMap["vim-prefix-y'"][m] = function(cm) {
-      yankTillMark(cm, m);
-    };
-    CodeMirror.keyMap["vim-prefix-r"][m] = function (cm) {
-      var cur = cm.getCursor();
-      cm.replaceRange(toLetter(m),
-          {line: cur.line, ch: cur.ch},
-          {line: cur.line, ch: cur.ch + 1});
-      CodeMirror.commands.goColumnLeft(cm);
-    };
-    // all commands, related to motions till char in line
-    iterObj(MOTION_OPTIONS, function (ch, options) {
-      CodeMirror.keyMap["vim-prefix-" + ch][m] = function(cm) {
-        moveTillChar(cm, m, options);
-      };
-      CodeMirror.keyMap["vim-prefix-d" + ch][m] = function(cm) {
-        delTillChar(cm, m, options);
-      };
-      CodeMirror.keyMap["vim-prefix-c" + ch][m] = function(cm) {
-        delTillChar(cm, m, options);
-        enterInsertMode(cm);
-      };
-    });
-  }
-  for (var i = 65; i < 65 + 26; i++) { // uppercase alphabet char codes
-    var ch = String.fromCharCode(i);
-    setupPrefixBindingForKey(toCombo(ch));
-    setupPrefixBindingForKey(toCombo(ch.toLowerCase()));
-  }
-  for (var i = 0; i < SPECIAL_SYMBOLS.length; ++i) {
-    setupPrefixBindingForKey(toCombo(SPECIAL_SYMBOLS.charAt(i)));
-  }
-  setupPrefixBindingForKey("Space");
-
-  CodeMirror.keyMap["vim-prefix-y"] = {
-    "Y": countTimes(function(cm, i, last) {
-      pushInBuffer("\n" + cm.getLine(cm.getCursor().line + i));
-      cm.setOption("keyMap", "vim");
-    }),
-    "'": function(cm) {cm.setOption("keyMap", "vim-prefix-y'"); emptyBuffer();},
-    nofallthrough: true, style: "fat-cursor"
-  };
+    // Expand the selection to line ends.
+    function expandSelectionToLine(cm, curStart, curEnd) {
+      curStart.ch = 0;
+      curEnd.ch = 0;
+      curEnd.line++;
+    }
 
-  CodeMirror.keyMap["vim-insert"] = {
-    // TODO: override navigation keys so that Esc will cancel automatic indentation from o, O, i_<CR>
-    "Esc": function(cm) {
-      cm.setCursor(cm.getCursor().line, cm.getCursor().ch-1, true);
-      cm.setOption("keyMap", "vim");
-    },
-    "Ctrl-N": "autocomplete",
-    "Ctrl-P": "autocomplete",
-    fallthrough: ["default"]
-  };
+    function findFirstNonWhiteSpaceCharacter(text) {
+      if (!text) {
+        return 0;
+      }
+      var firstNonWS = text.search(/\S/);
+      return firstNonWS == -1 ? text.length : firstNonWS;
+    }
 
-  function findMatchedSymbol(cm, cur, symb) {
-    var line = cur.line;
-    var symb = symb ? symb : cm.getLine(line)[cur.ch];
+    function expandWordUnderCursor(cm, inclusive, forward, bigWord, noSymbol) {
+      var cur = cm.getCursor();
+      var line = cm.getLine(cur.line);
+      var idx = cur.ch;
+
+      // Seek to first word or non-whitespace character, depending on if
+      // noSymbol is true.
+      var textAfterIdx = line.substring(idx);
+      var firstMatchedChar;
+      if (noSymbol) {
+        firstMatchedChar = textAfterIdx.search(/\w/);
+      } else {
+        firstMatchedChar = textAfterIdx.search(/\S/);
+      }
+      if (firstMatchedChar == -1) {
+        return null;
+      }
+      idx += firstMatchedChar;
+      textAfterIdx = line.substring(idx);
+      var textBeforeIdx = line.substring(0, idx);
+
+      var matchRegex;
+      // Greedy matchers for the "word" we are trying to expand.
+      if (bigWord) {
+        matchRegex = /^\S+/;
+      } else {
+        if ((/\w/).test(line.charAt(idx))) {
+          matchRegex = /^\w+/;
+        } else {
+          matchRegex = /^[^\w\s]+/;
+        }
+      }
 
-    // Are we at the opening or closing char
-    var forwards = ['(', '[', '{'].indexOf(symb) != -1;
+      var wordAfterRegex = matchRegex.exec(textAfterIdx);
+      var wordStart = idx;
+      var wordEnd = idx + wordAfterRegex[0].length - 1;
+      // TODO: Find a better way to do this. It will be slow on very long lines.
+      var wordBeforeRegex = matchRegex.exec(reverse(textBeforeIdx));
+      if (wordBeforeRegex) {
+        wordStart -= wordBeforeRegex[0].length;
+      }
 
-    var reverseSymb = (function(sym) {
-      switch (sym) {
-        case '(' : return ')';
-        case '[' : return ']';
-        case '{' : return '}';
-        case ')' : return '(';
-        case ']' : return '[';
-        case '}' : return '{';
-        default : return null;
+      if (inclusive) {
+        wordEnd++;
       }
-    })(symb);
 
-    // Couldn't find a matching symbol, abort
-    if (reverseSymb == null) return cur;
+      return { start: { line: cur.line, ch: wordStart },
+        end: { line: cur.line, ch: wordEnd }};
+    }
 
-    // Tracking our imbalance in open/closing symbols. An opening symbol wii be
-    // the first thing we pick up if moving forward, this isn't true moving backwards
-    var disBal = forwards ? 0 : 1;
+    /*
+     * Returns the boundaries of the next word. If the cursor in the middle of
+     * the word, then returns the boundaries of the current word, starting at
+     * the cursor. If the cursor is at the start/end of a word, and we are going
+     * forward/backward, respectively, find the boundaries of the next word.
+     *
+     * @param {CodeMirror} cm CodeMirror object.
+     * @param {Cursor} cur The cursor position.
+     * @param {boolean} forward True to search forward. False to search
+     *     backward.
+     * @param {boolean} bigWord True if punctuation count as part of the word.
+     *     False if only [a-zA-Z0-9] characters count as part of the word.
+     * @return {Object{from:number, to:number, line: number}} The boundaries of
+     *     the word, or null if there are no more words.
+     */
+    // TODO: Treat empty lines (with no whitespace) as words.
+    function findWord(cm, cur, forward, bigWord) {
+      var lineNum = cur.line;
+      var pos = cur.ch;
+      var line = cm.getLine(lineNum);
+      var dir = forward ? 1 : -1;
+      var regexps = bigWord ? bigWordRegexp : wordRegexp;
 
-    while (true) {
-      if (line == cur.line) {
-        // First pass, do some special stuff
-        var currLine =  forwards ? cm.getLine(line).substr(cur.ch).split('') : cm.getLine(line).substr(0,cur.ch).split('').reverse();
-      } else {
-        var currLine =  forwards ? cm.getLine(line).split('') : cm.getLine(line).split('').reverse();
+      while (true) {
+        var stop = (dir > 0) ? line.length : -1;
+        var wordStart = stop, wordEnd = stop;
+        // Find bounds of next word.
+        while (pos != stop) {
+          var foundWord = false;
+          for (var i = 0; i < regexps.length && !foundWord; ++i) {
+            if (regexps[i].test(line.charAt(pos))) {
+              wordStart = pos;
+              // Advance to end of word.
+              while (pos != stop && regexps[i].test(line.charAt(pos))) {
+                pos += dir;
+              }
+              wordEnd = pos;
+              foundWord = wordStart != wordEnd;
+              if (wordStart == cur.ch && lineNum == cur.line &&
+                  wordEnd == wordStart + dir) {
+                // We started at the end of a word. Find the next one.
+                continue;
+              } else {
+                return {
+                  from: Math.min(wordStart, wordEnd + 1),
+                  to: Math.max(wordStart, wordEnd),
+                  line: lineNum };
+              }
+            }
+          }
+          if (!foundWord) {
+            pos += dir;
+          }
+        }
+        // Advance to next/prev line.
+        lineNum += dir;
+        if (!isLine(cm, lineNum)) {
+          return null;
+        }
+        line = cm.getLine(lineNum);
+        pos = (dir > 0) ? 0 : line.length;
       }
+      // Should never get here.
+      throw 'The impossible happened.';
+    }
 
-      for (var index = 0;  index < currLine.length; index++) {
-        if (currLine[index] == symb) disBal++;
-        else if (currLine[index] == reverseSymb) disBal--;
+    /**
+     * @param {CodeMirror} cm CodeMirror object.
+     * @param {int} repeat Number of words to move past.
+     * @param {boolean} forward True to search forward. False to search
+     *     backward.
+     * @param {boolean} wordEnd True to move to end of word. False to move to
+     *     beginning of word.
+     * @param {boolean} bigWord True if punctuation count as part of the word.
+     *     False if only alphabet characters count as part of the word.
+     * @return {Cursor} The position the cursor should move to.
+     */
+    function moveToWord(cm, repeat, forward, wordEnd, bigWord) {
+      var cur = cm.getCursor();
+      for (var i = 0; i < repeat; i++) {
+        var startCh = cur.ch, startLine = cur.line, word;
+        var movedToNextWord = false;
+        while (!movedToNextWord) {
+          // Search and advance.
+          word = findWord(cm, cur, forward, bigWord);
+          movedToNextWord = true;
+          if (word) {
+            // Move to the word we just found. If by moving to the word we end
+            // up in the same spot, then move an extra character and search
+            // again.
+            cur.line = word.line;
+            if (forward && wordEnd) {
+              // 'e'
+              cur.ch = word.to - 1;
+            } else if (forward && !wordEnd) {
+              // 'w'
+              if (inRangeInclusive(cur.ch, word.from, word.to) &&
+                  word.line == startLine) {
+                // Still on the same word. Go to the next one.
+                movedToNextWord = false;
+                cur.ch = word.to - 1;
+              } else {
+                cur.ch = word.from;
+              }
+            } else if (!forward && wordEnd) {
+              // 'ge'
+              if (inRangeInclusive(cur.ch, word.from, word.to) &&
+                  word.line == startLine) {
+                // still on the same word. Go to the next one.
+                movedToNextWord = false;
+                cur.ch = word.from;
+              } else {
+                cur.ch = word.to;
+              }
+            } else if (!forward && !wordEnd) {
+              // 'b'
+              cur.ch = word.from;
+            }
+          } else {
+            // No more words to be found. Move to the end.
+            if (forward) {
+              return { line: cur.line, ch: lineLength(cm, cur.line) };
+            } else {
+              return { line: cur.line, ch: 0 };
+            }
+          }
+        }
+      }
+      return cur;
+    }
 
-        if (disBal == 0) {
-          if (forwards && cur.line == line) return {line: line, ch: index + cur.ch};
-          else if (forwards) return {line: line, ch: index};
-          else return {line: line, ch: currLine.length - index - 1 };
+    function moveToCharacter(cm, repeat, forward, character) {
+      var cur = cm.getCursor();
+      var start = cur.ch;
+      var idx;
+      for (var i = 0; i < repeat; i ++) {
+        var line = cm.getLine(cur.line);
+        idx = charIdxInLine(start, line, character, forward, true);
+        if (idx == -1) {
+          return cur;
         }
+        start = idx;
       }
+      return { line: cm.getCursor().line, ch: idx };
+    }
 
-      if (forwards) line++;
-      else line--;
+    function moveToColumn(cm, repeat) {
+      // repeat is always >= 1, so repeat - 1 always corresponds
+      // to the column we want to go to.
+      var line = cm.getCursor().line;
+      return clipCursorToContent(cm, { line: line, ch: repeat - 1 });
     }
-  }
 
-  function selectCompanionObject(cm, revSymb, inclusive) {
-    var cur = cm.getCursor();
+    function charIdxInLine(start, line, character, forward, includeChar) {
+      // Search for char in line.
+      // motion_options: {forward, includeChar}
+      // If includeChar = true, include it too.
+      // If forward = true, search forward, else search backwards.
+      // If char is not found on this line, do nothing
+      var idx;
+      if (forward) {
+        idx = line.indexOf(character, start + 1);
+        if (idx != -1 && !includeChar) {
+          idx -= 1;
+        }
+      } else {
+        idx = line.lastIndexOf(character, start - 1);
+        if (idx != -1 && !includeChar) {
+          idx += 1;
+        }
+      }
+      return idx;
+    }
 
-    var end = findMatchedSymbol(cm, cur, revSymb);
-    var start = findMatchedSymbol(cm, end);
-    start.ch += inclusive ? 1 : 0;
-    end.ch += inclusive ? 0 : 1;
+    function findMatchedSymbol(cm, cur, symb) {
+      var line = cur.line;
+      symb = symb ? symb : cm.getLine(line).charAt(cur.ch);
 
-    return {start: start, end: end};
-  }
+      // Are we at the opening or closing char
+      var forwards = inArray(symb, ['(', '[', '{']);
 
-  // takes in a symbol and a cursor and tries to simulate text objects that have
-  // identical opening and closing symbols
-  // TODO support across multiple lines
-  function findBeginningAndEnd(cm, symb, inclusive) {
-    var cur = cm.getCursor();
-    var line = cm.getLine(cur.line);
-    var chars = line.split('');
-    var start = undefined;
-    var end = undefined;
-    var firstIndex = chars.indexOf(symb);
+      var reverseSymb = ({
+        '(': ')', ')': '(',
+        '[': ']', ']': '[',
+        '{': '}', '}': '{'})[symb];
 
-    // the decision tree is to always look backwards for the beginning first,
-    // but if the cursor is in front of the first instance of the symb,
-    // then move the cursor forward
-    if (cur.ch < firstIndex) {
-      cur.ch = firstIndex;
-      cm.setCursor(cur.line, firstIndex+1);
-    }
-    // otherwise if the cursor is currently on the closing symbol
-    else if (firstIndex < cur.ch && chars[cur.ch] == symb) {
-      end = cur.ch; // assign end to the current cursor
-      --cur.ch; // make sure to look backwards
-    }
+      // Couldn't find a matching symbol, abort
+      if (!reverseSymb) {
+        return cur;
+      }
 
-    // if we're currently on the symbol, we've got a start
-    if (chars[cur.ch] == symb && end == null)
-      start = cur.ch + 1; // assign start to ahead of the cursor
-    else {
-      // go backwards to find the start
-      for (var i = cur.ch; i > -1 && start == null; i--)
-        if (chars[i] == symb) start = i + 1;
-    }
+      // set our increment to move forward (+1) or backwards (-1)
+      // depending on which bracket we're matching
+      var increment = ({'(': 1, '{': 1, '[': 1})[symb] || -1;
+      var depth = 1, nextCh = symb, index = cur.ch, lineText = cm.getLine(line);
+      // Simple search for closing paren--just count openings and closings till
+      // we find our match
+      // TODO: use info from CodeMirror to ignore closing brackets in comments
+      // and quotes, etc.
+      while (nextCh && depth > 0) {
+        index += increment;
+        nextCh = lineText.charAt(index);
+        if (!nextCh) {
+          line += increment;
+          index = 0;
+          lineText = cm.getLine(line) || '';
+          nextCh = lineText.charAt(index);
+        }
+        if (nextCh === symb) {
+          depth++;
+        } else if (nextCh === reverseSymb) {
+          depth--;
+        }
+      }
 
-    // look forwards for the end symbol
-    if (start != null && end == null) {
-      for (var i = start, len = chars.length; i < len && end == null; i++) {
-        if (chars[i] == symb) end = i;
+      if (nextCh) {
+        return { line: line, ch: index };
       }
+      return cur;
     }
 
-    // nothing found
-    // FIXME still enters insert mode
-    if (start == null || end == null) return {
-      start: cur, end: cur  
-    };
+    function selectCompanionObject(cm, revSymb, inclusive) {
+      var cur = cm.getCursor();
+
+      var end = findMatchedSymbol(cm, cur, revSymb);
+      var start = findMatchedSymbol(cm, end);
+      start.ch += inclusive ? 1 : 0;
+      end.ch += inclusive ? 0 : 1;
 
-    // include the symbols
-    if (inclusive) {
-      --start; ++end;
+      return { start: start, end: end };
     }
 
-    return {
-      start: {line: cur.line, ch: start},
-      end: {line: cur.line, ch: end}
-    };
-  }
-
-  function offsetCursor(cm, line, ch) {
-    var cur = cm.getCursor(); return {line: cur.line + line, ch: cur.ch + ch};
-  }
-
-  // These are the motion commands we use for navigation and selection with
-  // certain other commands. All should return a cursor object.
-  var motions = {
-    "J": function(cm, times) { return offsetCursor(cm, times, 0); },
-    "Down": function(cm, times) { return offsetCursor(cm, times, 0); },
-    "K": function(cm, times) { return offsetCursor(cm, -times, 0); },
-    "Up": function(cm, times) { return offsetCursor(cm, -times, 0); },
-    "L": function(cm, times) { return offsetCursor(cm, 0, times); },
-    "Right": function(cm, times) { return offsetCursor(cm, 0, times); },
-    "Space": function(cm, times) { return offsetCursor(cm, 0, times); },
-    "H": function(cm, times) { return offsetCursor(cm, 0, -times); },
-    "Left": function(cm, times) { return offsetCursor(cm, 0, -times); },
-    "Backspace": function(cm, times) { return offsetCursor(cm, 0, -times); },
-    "B": function(cm, times, yank) { return moveToWord(cm, word, -1, times, 'start', yank); },
-    "Shift-B": function(cm, times, yank) { return moveToWord(cm, bigWord, -1, times, 'start', yank); },
-    "E": function(cm, times, yank) { return moveToWord(cm, word, 1, times, 'end', yank); },
-    "Shift-E": function(cm, times, yank) { return moveToWord(cm, bigWord, 1, times, 'end', yank); },
-    "W": function(cm, times, yank) { return moveToWord(cm, word, 1, times, 'start', yank); },
-    "Shift-W": function(cm, times, yank) { return moveToWord(cm, bigWord, 1, times, 'start', yank); },
-    "'^'": function(cm, times) {
-      var cur = cm.getCursor(), line = cm.getLine(cur.line).split('');
-      for (var i = 0; i < line.length; i++) {
-        if (line[i].match(/[^\s]/)) return {line: cur.line, ch: index};
+    function regexLastIndexOf(string, pattern, startIndex) {
+      for (var i = !startIndex ? string.length : startIndex;
+          i >= 0; --i) {
+        if (pattern.test(string.charAt(i))) {
+          return i;
+        }
       }
-      return cur;
-    },
-    "'$'": function(cm) {
-      var cur = cm.getCursor(), ch = cm.getLine(cur.line).length;
-      return {line: cur.line, ch: ch};
-    },
-    "'%'": function(cm) { return findMatchedSymbol(cm, cm.getCursor()); },
-    "Esc" : function(cm) { cm.setOption("keyMap", "vim"); repeatCount = 0; return cm.getCursor(); }
-  };
+      return -1;
+    }
 
-  // Map our movement actions each operator and non-operational movement
-  iterObj(motions, function(key, motion) {
-    CodeMirror.keyMap['vim-prefix-d'][key] = function(cm) {
-      // Get our selected range
-      var start = cm.getCursor();
-      var end = motion(cm, repeatCount ? repeatCount : 1, true);
+    // Takes in a symbol and a cursor and tries to simulate text objects that
+    // have identical opening and closing symbols
+    // TODO support across multiple lines
+    function findBeginningAndEnd(cm, symb, inclusive) {
+      var cur = cm.getCursor();
+      var line = cm.getLine(cur.line);
+      var chars = line.split('');
+      var start, end, i, len;
+      var firstIndex = chars.indexOf(symb);
+
+      // the decision tree is to always look backwards for the beginning first,
+      // but if the cursor is in front of the first instance of the symb,
+      // then move the cursor forward
+      if (cur.ch < firstIndex) {
+        cur.ch = firstIndex;
+        // Why is this line even here???
+        // cm.setCursor(cur.line, firstIndex+1);
+      }
+      // otherwise if the cursor is currently on the closing symbol
+      else if (firstIndex < cur.ch && chars[cur.ch] == symb) {
+        end = cur.ch; // assign end to the current cursor
+        --cur.ch; // make sure to look backwards
+      }
 
-      // Set swap var if range is of negative length
-      if ((start.line > end.line) || (start.line == end.line && start.ch > end.ch)) var swap = true;
+      // if we're currently on the symbol, we've got a start
+      if (chars[cur.ch] == symb && !end) {
+        start = cur.ch + 1; // assign start to ahead of the cursor
+      } else {
+        // go backwards to find the start
+        for (i = cur.ch; i > -1 && !start; i--) {
+          if (chars[i] == symb) {
+            start = i + 1;
+          }
+        }
+      }
 
-      // Take action, switching start and end if swap var is set
-      pushInBuffer(cm.getRange(swap ? end : start, swap ? start : end));
-      cm.replaceRange("", swap ? end : start, swap ? start : end);
+      // look forwards for the end symbol
+      if (start && !end) {
+        for (i = start, len = chars.length; i < len && !end; i++) {
+          if (chars[i] == symb) {
+            end = i;
+          }
+        }
+      }
 
-      // And clean up
-      repeatCount = 0;
-      cm.setOption("keyMap", "vim");
-    };
+      // nothing found
+      if (!start || !end) {
+        return { start: cur, end: cur };
+      }
 
-    CodeMirror.keyMap['vim-prefix-c'][key] = function(cm) {
-      var start = cm.getCursor();
-      var end = motion(cm, repeatCount ? repeatCount : 1, true);
+      // include the symbols
+      if (inclusive) {
+        --start; ++end;
+      }
 
-      if ((start.line > end.line) || (start.line == end.line && start.ch > end.ch)) var swap = true;
-      pushInBuffer(cm.getRange(swap ? end : start, swap ? start : end));
-      cm.replaceRange("", swap ? end : start, swap ? start : end);
+      return {
+        start: { line: cur.line, ch: start },
+        end: { line: cur.line, ch: end }
+      };
+    }
 
-      repeatCount = 0;
-      cm.setOption('keyMap', 'vim-insert');
+    // Search functions
+    function SearchState() {
+      // Highlighted text that match the query.
+      this.marked = null;
+    }
+    SearchState.prototype = {
+      getQuery: function() {
+        return getVimGlobalState().query;
+      },
+      setQuery: function(query) {
+        getVimGlobalState().query = query;
+      },
+      getMarked: function() {
+        return this.marked;
+      },
+      setMarked: function(marked) {
+        this.marked = marked;
+      },
+      isReversed: function() {
+        return getVimGlobalState().isReversed;
+      },
+      setReversed: function(reversed) {
+        getVimGlobalState().isReversed = reversed;
+      }
+    };
+    function getSearchState(cm) {
+      var vim = getVimState(cm);
+      return vim.searchState_ || (vim.searchState_ = new SearchState());
+    }
+    function dialog(cm, text, shortText, callback) {
+      if (cm.openDialog) {
+        cm.openDialog(text, callback, {bottom: true});
+      }
+      else {
+        callback(prompt(shortText, ""));
+      }
+    }
+    function findUnescapedSlashes(str) {
+      var escapeNextChar = false;
+      var slashes = [];
+      for (var i = 0; i < str.length; i++) {
+        var c = str.charAt(i);
+        if (!escapeNextChar && c == '/') {
+          slashes.push(i);
+        }
+        escapeNextChar = (c == '\\');
+      }
+      return slashes;
+    }
+    /**
+     * Extract the regular expression from the query and return a Regexp object.
+     * Returns null if the query is blank.
+     * If ignoreCase is passed in, the Regexp object will have the 'i' flag set.
+     * If smartCase is passed in, and the query contains upper case letters,
+     *   then ignoreCase is overridden, and the 'i' flag will not be set.
+     * If the query contains the /i in the flag part of the regular expression,
+     *   then both ignoreCase and smartCase are ignored, and 'i' will be passed
+     *   through to the Regex object.
+     */
+    function parseQuery(cm, query, ignoreCase, smartCase) {
+      // First try to extract regex + flags from the input. If no flags found,
+      // extract just the regex. IE does not accept flags directly defined in
+      // the regex string in the form /regex/flags
+      var slashes = findUnescapedSlashes(query);
+      var regexPart;
+      var forceIgnoreCase;
+      if (!slashes.length) {
+        // Query looks like 'regexp'
+        regexPart = query;
+      } else {
+        // Query looks like 'regexp/...'
+        regexPart = query.substring(0, slashes[0]);
+        var flagsPart = query.substring(slashes[0]);
+        forceIgnoreCase = (flagsPart.indexOf('i') != -1);
+      }
+      if (!regexPart) {
+        return null;
+      }
+      if (smartCase) {
+        ignoreCase = (/^[^A-Z]*$/).test(regexPart);
+      }
+      try {
+        var regexp = new RegExp(regexPart,
+            (ignoreCase || forceIgnoreCase) ? 'i' : undefined);
+        return regexp;
+      } catch (e) {
+        showConfirm(cm, 'Invalid regex: ' + regexPart);
+      }
+    }
+    function showConfirm(cm, text) {
+      if (cm.openConfirm) {
+        cm.openConfirm('<span style="color: red">' + text +
+            '</span> <button type="button">OK</button>', function() {},
+            {bottom: true});
+      } else {
+        alert(text);
+      }
+    }
+    function makePrompt(prefix, desc) {
+      var raw = '';
+      if (prefix) {
+        raw += '<span style="font-family: monospace">' + prefix + '</span>';
+      }
+      raw += '<input type="text"/> ' +
+          '<span style="color: #888">';
+      if (desc) {
+        raw += '<span style="color: #888">';
+        raw += desc;
+        raw += '</span>';
+      }
+      return raw;
+    }
+    var searchPromptDesc = '(Javascript regexp)';
+    function showPrompt(cm, onPromptClose, prefix, desc) {
+      var shortText = (prefix || '') + ' ' + (desc || '');
+      dialog(cm, makePrompt(prefix, desc), shortText, onPromptClose);
+    }
+    function regexEqual(r1, r2) {
+      if (r1 instanceof RegExp && r2 instanceof RegExp) {
+          var props = ["global", "multiline", "ignoreCase", "source"];
+          for (var i = 0; i < props.length; i++) {
+              var prop = props[i];
+              if (r1[prop] !== r2[prop]) {
+                  return(false);
+              }
+          }
+          return(true);
+      }
+      return(false);
+    }
+    function updateSearchQuery(cm, rawQuery, ignoreCase, smartCase) {
+      cm.operation(function() {
+        var state = getSearchState(cm);
+        if (!rawQuery) {
+          return;
+        }
+        var query = parseQuery(cm, rawQuery, !!ignoreCase, !!smartCase);
+        if (!query) {
+          return;
+        }
+        if (regexEqual(query, state.getQuery())) {
+          return;
+        }
+        clearSearchHighlight(cm);
+        highlightSearchMatches(cm, query);
+        state.setQuery(query);
+      });
+    }
+    function highlightSearchMatches(cm, query) {
+      // TODO: Highlight only text inside the viewport. Highlighting everything
+      // is inefficient and expensive.
+      if (cm.lineCount() < 2000) { // This is too expensive on big documents.
+        var marked = [];
+        for (var cursor = cm.getSearchCursor(query);
+            cursor.findNext();) {
+          marked.push(cm.markText(cursor.from(), cursor.to(),
+              { className: 'CodeMirror-searching' }));
+        }
+        getSearchState(cm).setMarked(marked);
+      }
+    }
+    function findNext(cm, prev, repeat) {
+      return cm.operation(function() {
+        var state = getSearchState(cm);
+        var query = state.getQuery();
+        if (!query) {
+          return;
+        }
+        if (!state.getMarked()) {
+          highlightSearchMatches(cm, query);
+        }
+        var pos = cm.getCursor();
+        // If search is initiated with ? instead of /, negate direction.
+        prev = (state.isReversed()) ? !prev : prev;
+        if (!prev) {
+          pos.ch += 1;
+        }
+        var cursor = cm.getSearchCursor(query, pos);
+        for (var i = 0; i < repeat; i++) {
+          if (!cursor.find(prev)) {
+            // SearchCursor may have returned null because it hit EOF, wrap
+            // around and try again.
+            cursor = cm.getSearchCursor(query,
+                (prev) ? { line: cm.lineCount() - 1} : {line: 0, ch: 0} );
+            if (!cursor.find(prev)) {
+              return;
+            }
+          }
+        }
+        return cursor.from();
+      });}
+    function clearSearchHighlight(cm) {
+      cm.operation(function() {
+        var state = getSearchState(cm);
+        if (!state.getQuery()) {
+          return;
+        }
+        var marked = state.getMarked();
+        if (!marked) {
+          return;
+        }
+        for (var i = 0; i < marked.length; ++i) {
+          marked[i].clear();
+        }
+        state.setMarked(null);
+      });}
+
+    // Ex command handling
+    // Care must be taken when adding to the default Ex command map. For any
+    // pair of commands that have a shared prefix, at least one of their
+    // shortNames must not match the prefix of the other command.
+    var defaultExCommandMap = [
+      { name: 'map', type: 'builtIn' },
+      { name: 'write', shortName: 'w', type: 'builtIn' },
+      { name: 'undo', shortName: 'u', type: 'builtIn' },
+      { name: 'redo', shortName: 'red', type: 'builtIn' }
+    ];
+    var ExCommandDispatcher = function() {
+      this.buildCommandMap_();
     };
+    ExCommandDispatcher.prototype = {
+      processCommand: function(cm, input) {
+        var params = this.parseInput_(input);
+        var commandName;
+        if (!params.commandName) {
+          // If only a line range is defined, move to the line.
+          if (params.line !== undefined) {
+            commandName = 'move';
+          }
+        } else {
+          var command = this.matchCommand_(params.commandName);
+          if (command) {
+            commandName = command.name;
+            if (command.type == 'exToKey') {
+              // Handle Ex to Key mapping.
+              for (var i = 0; i < command.toKeys.length; i++) {
+                vim.handleKey(cm, command.toKeys[i]);
+              }
+              return;
+            } else if (command.type == 'exToEx') {
+              // Handle Ex to Ex mapping.
+              this.processCommand(cm, command.toInput);
+              return;
+            }
+          }
+        }
+        if (!commandName) {
+          showConfirm(cm, 'Not an editor command ":' + input + '"');
+          return;
+        }
+        exCommands[commandName](cm, params);
+      },
+      parseInput_: function(input) {
+        var result = {};
+        result.input = input;
+        var idx = 0;
+        // Trim preceding ':'.
+        var colons = (/^:+/).exec(input);
+        if (colons) {
+          idx += colons[0].length;
+        }
 
-    CodeMirror.keyMap['vim-prefix-y'][key] = function(cm) {
-      var start = cm.getCursor();
-      var end = motion(cm, repeatCount ? repeatCount : 1, true);
+        // Parse range.
+        var numberMatch = (/^(\d+)/).exec(input.substring(idx));
+        if (numberMatch) {
+          result.line = parseInt(numberMatch[1], 10);
+          idx += numberMatch[0].length;
+        }
 
-      if ((start.line > end.line) || (start.line == end.line && start.ch > end.ch)) var swap = true;
-      pushInBuffer(cm.getRange(swap ? end : start, swap ? start : end));
+        // Parse command name.
+        var commandMatch = (/^(\w+)/).exec(input.substring(idx));
+        if (commandMatch) {
+          result.commandName = commandMatch[1];
+          idx += commandMatch[1].length;
+        }
+
+        // Parse command-line arguments
+        var args = trim(input.substring(idx)).split(/\s+/);
+        if (args.length && args[0]) {
+          result.commandArgs = args;
+        }
 
-      repeatCount = 0;
-      cm.setOption("keyMap", "vim");
+        return result;
+      },
+      matchCommand_: function(commandName) {
+        // Return the command in the command map that matches the shortest
+        // prefix of the passed in command name. The match is guaranteed to be
+        // unambiguous if the defaultExCommandMap's shortNames are set up
+        // correctly. (see @code{defaultExCommandMap}).
+        for (var i = commandName.length; i > 0; i--) {
+          var prefix = commandName.substring(0, i);
+          if (this.commandMap_[prefix]) {
+            var command = this.commandMap_[prefix];
+            if (command.name.indexOf(commandName) === 0) {
+              return command;
+            }
+          }
+        }
+        return null;
+      },
+      buildCommandMap_: function() {
+        this.commandMap_ = {};
+        for (var i = 0; i < defaultExCommandMap.length; i++) {
+          var command = defaultExCommandMap[i];
+          var key = command.shortName || command.name;
+          this.commandMap_[key] = command;
+        }
+      },
+      map: function(lhs, rhs) {
+        if (lhs.charAt(0) == ':') {
+          var commandName = lhs.substring(1);
+          if (rhs.charAt(0) == ':') {
+            // Ex to Ex mapping
+            this.commandMap_[commandName] = {
+              name: commandName,
+              type: 'exToEx',
+              toInput: rhs.substring(1)
+            };
+          } else {
+            // Ex to key mapping
+            this.commandMap_[commandName] = {
+              name: commandName,
+              type: 'exToKey',
+              toKeys: parseKeyString(rhs)
+            };
+          }
+        } else {
+          if (rhs.charAt(0) == ':') {
+            // Key to Ex mapping.
+            defaultKeymap.unshift({
+              keys: parseKeyString(lhs),
+              type: 'keyToEx',
+              exArgs: { input: rhs.substring(1) }});
+          } else {
+            // Key to key mapping
+            defaultKeymap.unshift({
+              keys: parseKeyString(lhs),
+              type: 'keyToKey',
+              toKeys: parseKeyString(rhs)
+            });
+          }
+        }
+      }
     };
 
-    CodeMirror.keyMap['vim'][key] = function(cm) {
-      var cur = motion(cm, repeatCount ? repeatCount : 1);
-      cm.setCursor(cur.line, cur.ch);
+    // Converts a key string sequence of the form a<C-w>bd<Left> into Vim's
+    // keymap representation.
+    function parseKeyString(str) {
+      var idx = 0;
+      var keys = [];
+      while (idx < str.length) {
+        if (str.charAt(idx) != '<') {
+          keys.push(str.charAt(idx));
+          idx++;
+          continue;
+        }
+        // Vim key notation here means desktop Vim key-notation.
+        // See :help key-notation in desktop Vim.
+        var vimKeyNotationStart = ++idx;
+        while (str.charAt(idx++) != '>') {}
+        var vimKeyNotation = str.substring(vimKeyNotationStart, idx - 1);
+        var match = (/^C-(.+)$/).exec(vimKeyNotation);
+        if (match) {
+          var key;
+          switch (match[1]) {
+            case 'BS':
+              key = 'Backspace';
+              break;
+            case 'CR':
+              key = 'Enter';
+              break;
+            case 'Del':
+              key = 'Delete';
+              break;
+            default:
+              key = match[1];
+              break;
+          }
+          keys.push('Ctrl-' + key);
+        }
+      }
+      return keys;
+    }
 
-      repeatCount = 0;
-    };
-  });
-
-  function addCountBindings(keyMapName) {
-    // Add bindings for number keys
-    keyMap = CodeMirror.keyMap[keyMapName];
-    keyMap["0"] = function(cm) {
-      if (repeatCount > 0) {
-        pushRepeatCountDigit(0)(cm);
-      } else {
-        CodeMirror.commands.goLineStart(cm);
+    var exCommands = {
+      map: function(cm, params) {
+        var mapArgs = params.commandArgs;
+        if (!mapArgs || mapArgs.length < 2) {
+          if (cm) {
+            showConfirm(cm, 'Invalid mapping: ' + params.input);
+          }
+          return;
+        }
+        exCommandDispatcher.map(mapArgs[0], mapArgs[1], cm);
+      },
+      move: function(cm, params) {
+        commandDispatcher.processMotion(cm, getVimState(cm), {
+            motion: 'moveToLineOrEdgeOfDocument',
+            motionArgs: { forward: false, explicitRepeat: true,
+              linewise: true, repeat: params.line }});
+      },
+      redo: CodeMirror.commands.redo,
+      undo: CodeMirror.commands.undo,
+      write: function(cm) {
+        if (CodeMirror.commands.save) {
+          // If a save command is defined, call it.
+          CodeMirror.commands.save(cm);
+        } else {
+          // Saves to text area if no save command is defined.
+          cm.save();
+        }
       }
     };
-    for (var i = 1; i < 10; ++i) {
-      keyMap[i] = pushRepeatCountDigit(i);
-    }
-  }
-  addCountBindings('vim');
-  addCountBindings('vim-prefix-d');
-  addCountBindings('vim-prefix-y');
-  addCountBindings('vim-prefix-c');
-
-  // Create our keymaps for each operator and make xa and xi where x is an operator
-  // change to the corrosponding keymap
-  var operators = ['d', 'y', 'c'];
-  iterList(operators, function(key, index, array) {
-    CodeMirror.keyMap['vim-prefix-'+key+'a'] = {
-      auto: 'vim', nofallthrough: true, style: "fat-cursor"
-    };
-    CodeMirror.keyMap['vim-prefix-'+key+'i'] = {
-      auto: 'vim', nofallthrough: true, style: "fat-cursor"
-    };
 
-    CodeMirror.keyMap['vim-prefix-'+key]['A'] = function(cm) {
-      repeatCount = 0;
-      cm.setOption('keyMap', 'vim-prefix-' + key + 'a');
-    };
+    var exCommandDispatcher = new ExCommandDispatcher();
+
+    // Register Vim with CodeMirror
+    function buildVimKeyMap() {
+      /**
+       * Handle the raw key event from CodeMirror. Translate the
+       * Shift + key modifier to the resulting letter, while preserving other
+       * modifers.
+       */
+      // TODO: Figure out a way to catch capslock.
+      function handleKeyEvent_(cm, key, modifier) {
+        if (isUpperCase(key)) {
+          // Convert to lower case if shift is not the modifier since the key
+          // we get from CodeMirror is always upper case.
+          if (modifier == 'Shift') {
+            modifier = null;
+          }
+          else {
+            key = key.toLowerCase();
+          }
+        }
+        if (modifier) {
+          // Vim will parse modifier+key combination as a single key.
+          key = modifier + '-' + key;
+        }
+        vim.handleKey(cm, key);
+      }
 
-    CodeMirror.keyMap['vim-prefix-'+key]['I'] = function(cm) {
-      repeatCount = 0;
-      cm.setOption('keyMap', 'vim-prefix-' + key + 'i');
+      // Closure to bind CodeMirror, key, modifier.
+      function keyMapper(key, modifier) {
+        return function(cm) {
+          handleKeyEvent_(cm, key, modifier);
+        };
+      }
+
+      var modifiers = ['Shift', 'Ctrl'];
+      var keyMap = {
+        'nofallthrough': true,
+        'style': 'fat-cursor'
+      };
+      function bindKeys(keys, modifier) {
+        for (var i = 0; i < keys.length; i++) {
+          var key = keys[i];
+          if (!modifier && inArray(key, specialSymbols)) {
+            // Wrap special symbols with '' because that's how CodeMirror binds
+            // them.
+            key = "'" + key + "'";
+          }
+          if (modifier) {
+            keyMap[modifier + '-' + key] = keyMapper(keys[i], modifier);
+          } else {
+            keyMap[key] = keyMapper(keys[i]);
+          }
+        }
+      }
+      bindKeys(upperCaseAlphabet);
+      bindKeys(upperCaseAlphabet, 'Shift');
+      bindKeys(upperCaseAlphabet, 'Ctrl');
+      bindKeys(specialSymbols);
+      bindKeys(specialSymbols, 'Ctrl');
+      bindKeys(numbers);
+      bindKeys(numbers, 'Ctrl');
+      bindKeys(specialKeys);
+      bindKeys(specialKeys, 'Ctrl');
+      return keyMap;
+    }
+    CodeMirror.keyMap.vim = buildVimKeyMap();
+
+    function exitInsertMode(cm) {
+      cm.setCursor(cm.getCursor().line, cm.getCursor().ch-1, true);
+      cm.setOption('keyMap', 'vim');
+    }
+
+    CodeMirror.keyMap['vim-insert'] = {
+      // TODO: override navigation keys so that Esc will cancel automatic
+      // indentation from o, O, i_<CR>
+      'Esc': exitInsertMode,
+      'Ctrl-[': exitInsertMode,
+      'Ctrl-C': exitInsertMode,
+      'Ctrl-N': 'autocomplete',
+      'Ctrl-P': 'autocomplete',
+      'Enter': function(cm) {
+        var fn = CodeMirror.commands.newlineAndIndentContinueComment ||
+            CodeMirror.commands.newlineAndIndent;
+        fn(cm);
+      },
+      fallthrough: ['default']
     };
-  });
-
-  function regexLastIndexOf(string, pattern, startIndex) {
-    for (var i = startIndex == null ? string.length : startIndex; i >= 0; --i)
-      if (pattern.test(string.charAt(i))) return i;
-    return -1;
-  }
-
-  // Create our text object functions. They work similar to motions but they
-  // return a start cursor as well
-  var textObjectList = ['W', 'Shift-[', 'Shift-9', '[', "'", "Shift-'"];
-  var textObjects = {
-    'W': function(cm, inclusive) {
-      var cur = cm.getCursor();
-      var line = cm.getLine(cur.line);
 
-      var line_to_char = new String(line.substring(0, cur.ch));
-      var start = regexLastIndexOf(line_to_char, /[^a-zA-Z0-9]/) + 1;
-      var end = motions["E"](cm, 1) ;
-
-      end.ch += inclusive ? 1 : 0 ;
-      return {start: {line: cur.line, ch: start}, end: end };
-    },
-    'Shift-[': function(cm, inclusive) { return selectCompanionObject(cm, '}', inclusive); },
-    'Shift-9': function(cm, inclusive) { return selectCompanionObject(cm, ')', inclusive); },
-    '[': function(cm, inclusive) { return selectCompanionObject(cm, ']', inclusive); },
-    "'": function(cm, inclusive) { return findBeginningAndEnd(cm, "'", inclusive); },
-    "Shift-'": function(cm, inclusive) { return findBeginningAndEnd(cm, '"', inclusive); }
+    return vimApi;
   };
-
-  // One function to handle all operation upon text objects. Kinda funky but it works
-  // better than rewriting this code six times
-  function textObjectManipulation(cm, object, remove, insert, inclusive) {
-    // Object is the text object, delete object if remove is true, enter insert
-    // mode if insert is true, inclusive is the difference between a and i
-    var tmp = textObjects[object](cm, inclusive);
-    var start = tmp.start;
-    var end = tmp.end;
-
-    if ((start.line > end.line) || (start.line == end.line && start.ch > end.ch)) var swap = true ;
-
-    pushInBuffer(cm.getRange(swap ? end : start, swap ? start : end));
-    if (remove) cm.replaceRange("", swap ? end : start, swap ? start : end);
-    if (insert) cm.setOption('keyMap', 'vim-insert');
-  }
-
-  // And finally build the keymaps up from the text objects
-  for (var i = 0; i < textObjectList.length; ++i) {
-    var object = textObjectList[i];
-    (function(object) {
-      CodeMirror.keyMap['vim-prefix-di'][object] = function(cm) { textObjectManipulation(cm, object, true, false, false); };
-      CodeMirror.keyMap['vim-prefix-da'][object] = function(cm) { textObjectManipulation(cm, object, true, false, true); };
-      CodeMirror.keyMap['vim-prefix-yi'][object] = function(cm) { textObjectManipulation(cm, object, false, false, false); };
-      CodeMirror.keyMap['vim-prefix-ya'][object] = function(cm) { textObjectManipulation(cm, object, false, false, true); };
-      CodeMirror.keyMap['vim-prefix-ci'][object] = function(cm) { textObjectManipulation(cm, object, true, true, false); };
-      CodeMirror.keyMap['vim-prefix-ca'][object] = function(cm) { textObjectManipulation(cm, object, true, true, true); };
-    })(object)
-  }
-})();
+  // Initialize Vim and make it available as an API.
+  var vim = Vim();
+  CodeMirror.Vim = vim;
+}
+)();