EVOLUTION-MANAGER

Edit File: keybinding-vim.js

define("ace/keyboard/vim",["require","exports","module","ace/range","ace/lib/event_emitter","ace/lib/dom","ace/lib/oop","ace/lib/keys","ace/lib/event","ace/search","ace/lib/useragent","ace/search_highlight","ace/commands/multi_select_commands","ace/mode/text","ace/multi_select"], function(require, exports, module) {
  'use strict';

if (map.fallthrough) {
 if (!Array.isArray(map.fallthrough))
 return lookupKey(key, map.fallthrough, handle);
 for (var i = 0; i < map.fallthrough.length; i++) {
 var result = lookupKey(key, map.fallthrough[i], handle);
 if (result) return result;
 }
 }
 };

CodeMirror.signal = function(o, name, e) { return o._signal(name, e) };
 CodeMirror.on = event.addListener;
 CodeMirror.off = event.removeListener;
 CodeMirror.isWordChar = function(ch) {
 if (ch < "\x7f") return /^\w$/.test(ch);
 TextModeTokenRe.lastIndex = 0;
 return TextModeTokenRe.test(ch);
 };
 
(function() {
 oop.implement(CodeMirror.prototype, EventEmitter);
 
 this.destroy = function() {
 this.ace.off('change', this.onChange);
 this.ace.off('changeSelection', this.onSelectionChange);
 this.ace.off('beforeEndOperation', this.onBeforeEndOperation);
 this.removeOverlay();
 };
 this.virtualSelectionMode = function() {
 return this.ace.inVirtualSelectionMode && this.ace.selection.index;
 };
 this.onChange = function(delta) {
 var change = { text: delta.action[0] == 'i' ? delta.lines : [] };
 var curOp = this.curOp = this.curOp || {};
 if (!curOp.changeHandlers)
 curOp.changeHandlers = this._eventRegistry["change"] && this._eventRegistry["change"].slice();
 if (!curOp.lastChange) {
 curOp.lastChange = curOp.change = change;
 } else {
 curOp.lastChange.next = curOp.lastChange = change;
 }
 this.$updateMarkers(delta);
 };
 this.onSelectionChange = function() {
 var curOp = this.curOp = this.curOp || {};
 if (!curOp.cursorActivityHandlers)
 curOp.cursorActivityHandlers = this._eventRegistry["cursorActivity"] && this._eventRegistry["cursorActivity"].slice();
 this.curOp.cursorActivity = true;
 if (this.ace.inMultiSelectMode) {
 this.ace.keyBinding.removeKeyboardHandler(multiSelectCommands.keyboardHandler);
 }
 };
 this.operation = function(fn, force) {
 if (!force && this.curOp || force && this.curOp && this.curOp.force) {
 return fn();
 }
 if (force || !this.ace.curOp) {
 if (this.curOp)
 this.onBeforeEndOperation();
 }
 if (!this.ace.curOp) {
 var prevOp = this.ace.prevOp;
 this.ace.startOperation({
 command: { name: "vim", scrollIntoView: "cursor" }
 });
 }
 var curOp = this.curOp = this.curOp || {};
 this.curOp.force = force;
 var result = fn();
 if (this.ace.curOp && this.ace.curOp.command.name == "vim") {
 if (this.state.dialog)
 this.ace.curOp.command.scrollIntoView = false;
 this.ace.endOperation();
 if (!curOp.cursorActivity && !curOp.lastChange && prevOp)
 this.ace.prevOp = prevOp;
 }
 if (force || !this.ace.curOp) {
 if (this.curOp)
 this.onBeforeEndOperation();
 }
 return result;
 };
 this.onBeforeEndOperation = function() {
 var op = this.curOp;
 if (op) {
 if (op.change) { this.signal("change", op.change, op); }
 if (op && op.cursorActivity) { this.signal("cursorActivity", null, op); }
 this.curOp = null;
 }
 };

this.signal = function(eventName, e, handlers) {
 var listeners = handlers ? handlers[eventName + "Handlers"]
 : (this._eventRegistry || {})[eventName];
 if (!listeners)
 return;
 listeners = listeners.slice();
 for (var i=0; i<listeners.length; i++)
 listeners[i](this, e);
 };
 this.firstLine = function() { return 0; };
 this.lastLine = function() { return this.ace.session.getLength() - 1; };
 this.lineCount = function() { return this.ace.session.getLength(); };
 this.setCursor = function(line, ch) {
 if (typeof line === 'object') {
 ch = line.ch;
 line = line.line;
 }
 if (!this.ace.inVirtualSelectionMode)
 this.ace.exitMultiSelectMode();
 this.ace.session.unfold({row: line, column: ch});
 this.ace.selection.moveTo(line, ch);
 };
 this.getCursor = function(p) {
 var sel = this.ace.selection;
 var pos = p == 'anchor' ? (sel.isEmpty() ? sel.lead : sel.anchor) :
 p == 'head' || !p ? sel.lead : sel.getRange()[p];
 return toCmPos(pos);
 };
 this.listSelections = function(p) {
 var ranges = this.ace.multiSelect.rangeList.ranges;
 if (!ranges.length || this.ace.inVirtualSelectionMode)
 return [{anchor: this.getCursor('anchor'), head: this.getCursor('head')}];
 return ranges.map(function(r) {
 return {
 anchor: this.clipPos(toCmPos(r.cursor == r.end ? r.start : r.end)),
 head: this.clipPos(toCmPos(r.cursor))
 };
 }, this);
 };
 this.setSelections = function(p, primIndex) {
 var sel = this.ace.multiSelect;
 var ranges = p.map(function(x) {
 var anchor = toAcePos(x.anchor);
 var head = toAcePos(x.head);
 var r = Range.comparePoints(anchor, head) < 0
 ? new Range.fromPoints(anchor, head)
 : new Range.fromPoints(head, anchor);
 r.cursor = Range.comparePoints(r.start, head) ? r.end : r.start;
 return r;
 });
 
 if (this.ace.inVirtualSelectionMode) {
 this.ace.selection.fromOrientedRange(ranges[0]);
 return;
 }
 if (!primIndex) {
 ranges = ranges.reverse();
 } else if (ranges[primIndex]) {
 ranges.push(ranges.splice(primIndex, 1)[0]);
 }
 sel.toSingleRange(ranges[0].clone());
 var session = this.ace.session;
 for (var i = 0; i < ranges.length; i++) {
 var range = session.$clipRangeToDocument(ranges[i]); // todo why ace doesn't do this?
 sel.addRange(range);
 }
 };
 this.setSelection = function(a, h, options) {
 var sel = this.ace.selection;
 sel.moveTo(a.line, a.ch);
 sel.selectTo(h.line, h.ch);
 if (options && options.origin == '*mouse') {
 this.onBeforeEndOperation();
 }
 };
 this.somethingSelected = function(p) {
 return !this.ace.selection.isEmpty();
 };
 this.clipPos = function(p) {
 var pos = this.ace.session.$clipPositionToDocument(p.line, p.ch);
 return toCmPos(pos);
 };
 this.markText = function(cursor) {
 return {clear: function() {}, find: function() {}};
 };
 this.$updateMarkers = function(delta) {
 var isInsert = delta.action == "insert";
 var start = delta.start;
 var end = delta.end;
 var rowShift = (end.row - start.row) * (isInsert ? 1 : -1);
 var colShift = (end.column - start.column) * (isInsert ? 1 : -1);
 if (isInsert) end = start;
 
 for (var i in this.marks) {
 var point = this.marks[i];
 var cmp = Range.comparePoints(point, start);
 if (cmp < 0) {
 continue; // delta starts after the range
 }
 if (cmp === 0) {
 if (isInsert) {
 if (point.bias == 1) {
 cmp = 1;
 } else {
 point.bias = -1;
 continue;
 }
 }
 }
 var cmp2 = isInsert ? cmp : Range.comparePoints(point, end);
 if (cmp2 > 0) {
 point.row += rowShift;
 point.column += point.row == end.row ? colShift : 0;
 continue;
 }
 if (!isInsert && cmp2 <= 0) {
 point.row = start.row;
 point.column = start.column;
 if (cmp2 === 0)
 point.bias = 1;
 }
 }
 };
 var Marker = function(cm, id, row, column) {
 this.cm = cm;
 this.id = id;
 this.row = row;
 this.column = column;
 cm.marks[this.id] = this;
 };
 Marker.prototype.clear = function() { delete this.cm.marks[this.id] };
 Marker.prototype.find = function() { return toCmPos(this) };
 this.setBookmark = function(cursor, options) {
 var bm = new Marker(this, this.$uid++, cursor.line, cursor.ch);
 if (!options || !options.insertLeft)
 bm.$insertRight = true;
 this.marks[bm.id] = bm;
 return bm;
 };
 this.moveH = function(increment, unit) {
 if (unit == 'char') {
 var sel = this.ace.selection;
 sel.clearSelection();
 sel.moveCursorBy(0, increment);
 }
 };
 this.findPosV = function(start, amount, unit, goalColumn) {
 if (unit == 'page') {
 var renderer = this.ace.renderer;
 var config = renderer.layerConfig;
 amount = amount * Math.floor(config.height / config.lineHeight);
 unit = 'line';
 }
 if (unit == 'line') {
 var screenPos = this.ace.session.documentToScreenPosition(start.line, start.ch);
 if (goalColumn != null)
 screenPos.column = goalColumn;
 screenPos.row += amount;
 screenPos.row = Math.min(Math.max(0, screenPos.row), this.ace.session.getScreenLength() - 1);
 var pos = this.ace.session.screenToDocumentPosition(screenPos.row, screenPos.column);
 return toCmPos(pos);
 } else {
 debugger;
 }
 };
 this.charCoords = function(pos, mode) {
 if (mode == 'div' || !mode) {
 var sc = this.ace.session.documentToScreenPosition(pos.line, pos.ch);
 return {left: sc.column, top: sc.row};
 }if (mode == 'local') {
 var renderer = this.ace.renderer;
 var sc = this.ace.session.documentToScreenPosition(pos.line, pos.ch);
 var lh = renderer.layerConfig.lineHeight;
 var cw = renderer.layerConfig.characterWidth;
 var top = lh * sc.row;
 return {left: sc.column * cw, top: top, bottom: top + lh};
 }
 };
 this.coordsChar = function(pos, mode) {
 var renderer = this.ace.renderer;
 if (mode == 'local') {
 var row = Math.max(0, Math.floor(pos.top / renderer.lineHeight));
 var col = Math.max(0, Math.floor(pos.left / renderer.characterWidth));
 var ch = renderer.session.screenToDocumentPosition(row, col);
 return toCmPos(ch);
 } else if (mode == 'div') {
 throw "not implemented";
 }
 };
 this.getSearchCursor = function(query, pos, caseFold) {
 var caseSensitive = false;
 var isRegexp = false;
 if (query instanceof RegExp && !query.global) {
 caseSensitive = !query.ignoreCase;
 query = query.source;
 isRegexp = true;
 }
 var search = new Search();
 if (pos.ch == undefined) pos.ch = Number.MAX_VALUE;
 var acePos = {row: pos.line, column: pos.ch};
 var cm = this;
 var last = null;
 return {
 findNext: function() { return this.find(false) },
 findPrevious: function() {return this.find(true) },
 find: function(back) {
 search.setOptions({
 needle: query,
 caseSensitive: caseSensitive,
 wrap: false,
 backwards: back,
 regExp: isRegexp,
 start: last || acePos
 });
 var range = search.find(cm.ace.session);
 if (range && range.isEmpty()) {
 if (cm.getLine(range.start.row).length == range.start.column) {
 search.$options.start = range;
 range = search.find(cm.ace.session);
 }
 }
 last = range;
 return last;
 },
 from: function() { return last && toCmPos(last.start) },
 to: function() { return last && toCmPos(last.end) },
 replace: function(text) {
 if (last) {
 last.end = cm.ace.session.doc.replace(last, text);
 }
 }
 };
 };
 this.scrollTo = function(x, y) {
 var renderer = this.ace.renderer;
 var config = renderer.layerConfig;
 var maxHeight = config.maxHeight;
 maxHeight -= (renderer.$size.scrollerHeight - renderer.lineHeight) * renderer.$scrollPastEnd;
 if (y != null) this.ace.session.setScrollTop(Math.max(0, Math.min(y, maxHeight)));
 if (x != null) this.ace.session.setScrollLeft(Math.max(0, Math.min(x, config.width)));
 };
 this.scrollInfo = function() { return 0; };
 this.scrollIntoView = function(pos, margin) {
 if (pos) {
 var renderer = this.ace.renderer;
 var viewMargin = { "top": 0, "bottom": margin };
 renderer.scrollCursorIntoView(toAcePos(pos),
 (renderer.lineHeight * 2) / renderer.$size.scrollerHeight, viewMargin);
 }
 };
 this.getLine = function(row) { return this.ace.session.getLine(row) };
 this.getRange = function(s, e) {
 return this.ace.session.getTextRange(new Range(s.line, s.ch, e.line, e.ch));
 };
 this.replaceRange = function(text, s, e) {
 if (!e) e = s;
 return this.ace.session.replace(new Range(s.line, s.ch, e.line, e.ch), text);
 };
 this.replaceSelection = 
 this.replaceSelections = function(p) {
 var sel = this.ace.selection;
 if (this.ace.inVirtualSelectionMode) {
 this.ace.session.replace(sel.getRange(), p[0] || "");
 return;
 }
 sel.inVirtualSelectionMode = true;
 var ranges = sel.rangeList.ranges;
 if (!ranges.length) ranges = [this.ace.multiSelect.getRange()];
 for (var i = ranges.length; i--;)
 this.ace.session.replace(ranges[i], p[i] || "");
 sel.inVirtualSelectionMode = false;
 };
 this.getSelection = function() {
 return this.ace.getSelectedText();
 };
 this.getSelections = function() {
 return this.listSelections().map(function(x) {
 return this.getRange(x.anchor, x.head);
 }, this);
 };
 this.getInputField = function() {
 return this.ace.textInput.getElement();
 };
 this.getWrapperElement = function() {
 return this.ace.container;
 };
 var optMap = {
 indentWithTabs: "useSoftTabs",
 indentUnit: "tabSize",
 tabSize: "tabSize",
 firstLineNumber: "firstLineNumber",
 readOnly: "readOnly"
 };
 this.setOption = function(name, val) {
 this.state[name] = val;
 switch (name) {
 case 'indentWithTabs':
 name = optMap[name];
 val = !val;
 break;
 case 'keyMap':
 this.state.$keyMap = val;
 return;
 break;
 default:
 name = optMap[name];
 }
 if (name)
 this.ace.setOption(name, val);
 };
 this.getOption = function(name, val) {
 var aceOpt = optMap[name];
 if (aceOpt)
 val = this.ace.getOption(aceOpt);
 switch (name) {
 case 'indentWithTabs':
 name = optMap[name];
 return !val;
 case 'keyMap':
 return this.state.$keyMap;
 }
 return aceOpt ? val : this.state[name];
 };
 this.toggleOverwrite = function(on) {
 this.state.overwrite = on;
 return this.ace.setOverwrite(on);
 };
 this.addOverlay = function(o) {
 if (!this.$searchHighlight || !this.$searchHighlight.session) {
 var highlight = new SearchHighlight(null, "ace_highlight-marker", "text");
 var marker = this.ace.session.addDynamicMarker(highlight);
 highlight.id = marker.id;
 highlight.session = this.ace.session;
 highlight.destroy = function(o) {
 highlight.session.off("change", highlight.updateOnChange);
 highlight.session.off("changeEditor", highlight.destroy);
 highlight.session.removeMarker(highlight.id);
 highlight.session = null;
 };
 highlight.updateOnChange = function(delta) {
 var row = delta.start.row;
 if (row == delta.end.row) highlight.cache[row] = undefined;
 else highlight.cache.splice(row, highlight.cache.length);
 };
 highlight.session.on("changeEditor", highlight.destroy);
 highlight.session.on("change", highlight.updateOnChange);
 }
 var re = new RegExp(o.query.source, "gmi");
 this.$searchHighlight = o.highlight = highlight;
 this.$searchHighlight.setRegexp(re);
 this.ace.renderer.updateBackMarkers();
 };
 this.removeOverlay = function(o) {
 if (this.$searchHighlight && this.$searchHighlight.session) {
 this.$searchHighlight.destroy();
 }
 };
 this.getScrollInfo = function() {
 var renderer = this.ace.renderer;
 var config = renderer.layerConfig;
 return {
 left: renderer.scrollLeft,
 top: renderer.scrollTop,
 height: config.maxHeight,
 width: config.width,
 clientHeight: config.height,
 clientWidth: config.width
 };
 };
 this.getValue = function() {
 return this.ace.getValue();
 };
 this.setValue = function(v) {
 return this.ace.setValue(v, -1);
 };
 this.getTokenTypeAt = function(pos) {
 var token = this.ace.session.getTokenAt(pos.line, pos.ch);
 return token && /comment|string/.test(token.type) ? "string" : "";
 };
 this.findMatchingBracket = function(pos) {
 var m = this.ace.session.findMatchingBracket(toAcePos(pos));
 return {to: m && toCmPos(m)};
 };
 this.indentLine = function(line, method) {
 if (method === true)
 this.ace.session.indentRows(line, line, "\t");
 else if (method === false)
 this.ace.session.outdentRows(new Range(line, 0, line, 0));
 };
 this.indexFromPos = function(pos) {
 return this.ace.session.doc.positionToIndex(toAcePos(pos));
 };
 this.posFromIndex = function(index) {
 return toCmPos(this.ace.session.doc.indexToPosition(index));
 };
 this.focus = function(index) {
 return this.ace.textInput.focus();
 };
 this.blur = function(index) {
 return this.ace.blur();
 };
 this.defaultTextHeight = function(index) {
 return this.ace.renderer.layerConfig.lineHeight;
 };
 this.scanForBracket = function(pos, dir, _, options) {
 var re = options.bracketRegex.source;
 var tokenRe = /paren|text|operator|tag/;
 if (dir == 1) {
 var m = this.ace.session.$findClosingBracket(re.slice(1, 2), toAcePos(pos), tokenRe);
 } else {
 var m = this.ace.session.$findOpeningBracket(re.slice(-2, -1), {row: pos.line, column: pos.ch + 1}, tokenRe);
 }
 return m && {pos: toCmPos(m)};
 };
 this.refresh = function() {
 return this.ace.resize(true);
 };
 this.getMode = function() {
 return { name : this.getOption("mode") };
 };
 this.execCommand = function(name) {
 if (name == "indentAuto") this.ace.execCommand("autoindent");
 else console.log(name + " is not implemented");
 };
}).call(CodeMirror.prototype);
 function toAcePos(cmPos) {
 return {row: cmPos.line, column: cmPos.ch};
 }
 function toCmPos(acePos) {
 return new Pos(acePos.row, acePos.column);
 }

var StringStream = CodeMirror.StringStream = function(string, tabSize) {
    this.pos = this.start = 0;
    this.string = string;
    this.tabSize = tabSize || 8;
    this.lastColumnPos = this.lastColumnValue = 0;
    this.lineStart = 0;
  };

StringStream.prototype = {
 eol: function() {return this.pos >= this.string.length;},
 sol: function() {return this.pos == this.lineStart;},
 peek: function() {return this.string.charAt(this.pos) || undefined;},
 next: function() {
 if (this.pos < this.string.length)
 return this.string.charAt(this.pos++);
 },
 eat: function(match) {
 var ch = this.string.charAt(this.pos);
 if (typeof match == "string") var ok = ch == match;
 else var ok = ch && (match.test ? match.test(ch) : match(ch));
 if (ok) {++this.pos; return ch;}
 },
 eatWhile: function(match) {
 var start = this.pos;
 while (this.eat(match)){}
 return this.pos > start;
 },
 eatSpace: function() {
 var start = this.pos;
 while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) ++this.pos;
 return this.pos > start;
 },
 skipToEnd: function() {this.pos = this.string.length;},
 skipTo: function(ch) {
 var found = this.string.indexOf(ch, this.pos);
 if (found > -1) {this.pos = found; return true;}
 },
 backUp: function(n) {this.pos -= n;},
 column: function() {
 throw "not implemented";
 },
 indentation: function() {
 throw "not implemented";
 },
 match: function(pattern, consume, caseInsensitive) {
 if (typeof pattern == "string") {
 var cased = function(str) {return caseInsensitive ? str.toLowerCase() : str;};
 var substr = this.string.substr(this.pos, pattern.length);
 if (cased(substr) == cased(pattern)) {
 if (consume !== false) this.pos += pattern.length;
 return true;
 }
 } else {
 var match = this.string.slice(this.pos).match(pattern);
 if (match && match.index > 0) return null;
 if (match && consume !== false) this.pos += match[0].length;
 return match;
 }
 },
 current: function(){return this.string.slice(this.start, this.pos);},
 hideFirstChars: function(n, inner) {
 this.lineStart += n;
 try { return inner(); }
 finally { this.lineStart -= n; }
 }
 };
CodeMirror.defineExtension = function(name, fn) {
 CodeMirror.prototype[name] = fn;
};
dom.importCssString(".normal-mode .ace_cursor{\
 border: none;\
 background-color: rgba(255,0,0,0.5);\
}\
.normal-mode .ace_hidden-cursors .ace_cursor{\
 background-color: transparent;\
 border: 1px solid red;\
 opacity: 0.7\
}\
.ace_dialog {\
 position: absolute;\
 left: 0; right: 0;\
 background: inherit;\
 z-index: 15;\
 padding: .1em .8em;\
 overflow: hidden;\
 color: inherit;\
}\
.ace_dialog-top {\
 border-bottom: 1px solid #444;\
 top: 0;\
}\
.ace_dialog-bottom {\
 border-top: 1px solid #444;\
 bottom: 0;\
}\
.ace_dialog input {\
 border: none;\
 outline: none;\
 background: transparent;\
 width: 20em;\
 color: inherit;\
 font-family: monospace;\
}", "vimMode");
(function() {
 function dialogDiv(cm, template, bottom) {
 var wrap = cm.ace.container;
 var dialog;
 dialog = wrap.appendChild(document.createElement("div"));
 if (bottom)
 dialog.className = "ace_dialog ace_dialog-bottom";
 else
 dialog.className = "ace_dialog ace_dialog-top";

if (typeof template == "string") {
      dialog.innerHTML = template;
    } else { // Assuming it's a detached DOM element.
      dialog.appendChild(template);
    }
    return dialog;
  }

function closeNotification(cm, newVal) {
    if (cm.state.currentNotificationClose)
      cm.state.currentNotificationClose();
    cm.state.currentNotificationClose = newVal;
  }

CodeMirror.defineExtension("openDialog", function(template, callback, options) {
    if (this.virtualSelectionMode()) return;
    if (!options) options = {};

closeNotification(this, null);

var dialog = dialogDiv(this, template, options.bottom);
    var closed = false, me = this;
    this.state.dialog = dialog;
    function close(newVal) {
      if (typeof newVal == 'string') {
        inp.value = newVal;
      } else {
        if (closed) return;
        
        if (newVal && newVal.type == "blur") {
          if (document.activeElement === inp)
            return;
        }
        
        me.state.dialog = null;
        closed = true;
        dialog.parentNode.removeChild(dialog);
        me.focus();

if (options.onClose) options.onClose(dialog);
      }
    }

var inp = dialog.getElementsByTagName("input")[0], button;
    if (inp) {
      if (options.value) {
        inp.value = options.value;
        if (options.selectValueOnOpen !== false) inp.select();
      }

if (options.onInput)
        CodeMirror.on(inp, "input", function(e) { options.onInput(e, inp.value, close);});
      if (options.onKeyUp)
        CodeMirror.on(inp, "keyup", function(e) {options.onKeyUp(e, inp.value, close);});

CodeMirror.on(inp, "keydown", function(e) {
        if (options && options.onKeyDown && options.onKeyDown(e, inp.value, close)) { return; }
        if (e.keyCode == 13) callback(inp.value);
        if (e.keyCode == 27 || (options.closeOnEnter !== false && e.keyCode == 13)) {
          inp.blur();
          CodeMirror.e_stop(e);
          close();
        }
      });

if (options.closeOnBlur !== false) CodeMirror.on(inp, "blur", close);

inp.focus();
    } else if (button = dialog.getElementsByTagName("button")[0]) {
      CodeMirror.on(button, "click", function() {
        close();
        me.focus();
      });

if (options.closeOnBlur !== false) CodeMirror.on(button, "blur", close);

button.focus();
    }
    return close;
  });

CodeMirror.defineExtension("openNotification", function(template, options) {
    if (this.virtualSelectionMode()) return;
    closeNotification(this, close);
    var dialog = dialogDiv(this, template, options && options.bottom);
    var closed = false, doneTimer;
    var duration = options && typeof options.duration !== "undefined" ? options.duration : 5000;

function close() {
      if (closed) return;
      closed = true;
      clearTimeout(doneTimer);
      dialog.parentNode.removeChild(dialog);
    }

CodeMirror.on(dialog, 'click', function(e) {
      CodeMirror.e_preventDefault(e);
      close();
    });

if (duration)
      doneTimer = setTimeout(close, duration);

return close;
  });
})();

var Pos = CodeMirror.Pos;

function leaveVimMode(cm) {
      cm.setOption('disableInput', false);
      cm.off('cursorActivity', onCursorActivity);
      CodeMirror.off(cm.getInputField(), 'paste', getOnPasteFn(cm));
      cm.state.vim = null;
    }
    function detachVimMap(cm, next) {
      if (this == CodeMirror.keyMap.vim)
        CodeMirror.rmClass(cm.getWrapperElement(), "cm-fat-cursor");

if (!next || next.attach != attachVimMap)
        leaveVimMode(cm);
    }
    function attachVimMap(cm, prev) {
      if (this == CodeMirror.keyMap.vim)
        CodeMirror.addClass(cm.getWrapperElement(), "cm-fat-cursor");

if (!prev || prev.attach != attachVimMap)
        enterVimMode(cm);
    }
    CodeMirror.defineOption('vimMode', false, function(cm, val, prev) {
      if (val && cm.getOption("keyMap") != "vim")
        cm.setOption("keyMap", "vim");
      else if (!val && prev != CodeMirror.Init && /^vim/.test(cm.getOption("keyMap")))
        cm.setOption("keyMap", "default");
    });

defineOption('filetype', undefined, 'string', ['ft'], function(name, cm) {
      if (cm === undefined) {
        return;
      }
      if (name === undefined) {
        var mode = cm.getOption('mode');
        return mode == 'null' ? '' : mode;
      } else {
        var mode = name == '' ? 'null' : name;
        cm.setOption('mode', mode);
      }
    });

var lastInsertModeKeyTimer;
    var vimApi= {
      buildKeyMap: function() {
      },
      getRegisterController: function() {
        return vimGlobalState.registerController;
      },
      resetVimGlobalState_: resetVimGlobalState,
      getVimGlobalState_: function() {
        return vimGlobalState;
      },
      maybeInitVimState_: maybeInitVimState,

suppressErrorLogging: false,

InsertModeKey: InsertModeKey,
 map: function(lhs, rhs, ctx) {
 exCommandDispatcher.map(lhs, rhs, ctx);
 },
 unmap: function(lhs, ctx) {
 exCommandDispatcher.unmap(lhs, ctx);
 },
 noremap: function(lhs, rhs, ctx) {
 function toCtxArray(ctx) {
 return ctx ? [ctx] : ['normal', 'insert', 'visual'];
 }
 var ctxsToMap = toCtxArray(ctx);
 var actualLength = defaultKeymap.length, origLength = defaultKeymapLength;
 for (var i = actualLength - origLength;
 i < actualLength && ctxsToMap.length;
 i++) {
 var mapping = defaultKeymap[i];
 if (mapping.keys == rhs &&
 (!ctx || !mapping.context || mapping.context === ctx) &&
 mapping.type.substr(0, 2) !== 'ex' &&
 mapping.type.substr(0, 3) !== 'key') {
 var newMapping = {};
 for (var key in mapping) {
 newMapping[key] = mapping[key];
 }
 newMapping.keys = lhs;
 if (ctx && !newMapping.context) {
 newMapping.context = ctx;
 }
 this._mapCommand(newMapping);
 var mappedCtxs = toCtxArray(mapping.context);
 ctxsToMap = ctxsToMap.filter(function(el) { return mappedCtxs.indexOf(el) === -1; });
 }
 }
 },
 mapclear: function(ctx) {
 var actualLength = defaultKeymap.length,
 origLength = defaultKeymapLength;
 var userKeymap = defaultKeymap.slice(0, actualLength - origLength);
 defaultKeymap = defaultKeymap.slice(actualLength - origLength);
 if (ctx) {
 for (var i = userKeymap.length - 1; i >= 0; i--) {
 var mapping = userKeymap[i];
 if (ctx !== mapping.context) {
 if (mapping.context) {
 this._mapCommand(mapping);
 } else {
 var contexts = ['normal', 'insert', 'visual'];
 for (var j in contexts) {
 if (contexts[j] !== ctx) {
 var newMapping = {};
 for (var key in mapping) {
 newMapping[key] = mapping[key];
 }
 newMapping.context = contexts[j];
 this._mapCommand(newMapping);
 }
 }
 }
 }
 }
 }
 },
 setOption: setOption,
 getOption: getOption,
 defineOption: defineOption,
 defineEx: function(name, prefix, func){
 if (!prefix) {
 prefix = name;
 } else if (name.indexOf(prefix) !== 0) {
 throw new Error('(Vim.defineEx) "'+prefix+'" is not a prefix of "'+name+'", command not registered');
 }
 exCommands[name]=func;
 exCommandDispatcher.commandMap_[prefix]={name:name, shortName:prefix, type:'api'};
 },
 handleKey: function (cm, key, origin) {
 var command = this.findKey(cm, key, origin);
 if (typeof command === 'function') {
 return command();
 }
 },
 findKey: function(cm, key, origin) {
 var vim = maybeInitVimState(cm);
 function handleMacroRecording() {
 var macroModeState = vimGlobalState.macroModeState;
 if (macroModeState.isRecording) {
 if (key == 'q') {
 macroModeState.exitMacroRecordMode();
 clearInputState(cm);
 return true;
 }
 if (origin != 'mapping') {
 logKey(macroModeState, key);
 }
 }
 }
 function handleEsc() {
 if (key == '<Esc>') {
 clearInputState(cm);
 if (vim.visualMode) {
 exitVisualMode(cm);
 } else if (vim.insertMode) {
 exitInsertMode(cm);
 }
 return true;
 }
 }
 function doKeyToKey(keys) {
 var match;
 while (keys) {
 match = (/<\w+-.+?>|<\w+>|./).exec(keys);
 key = match[0];
 keys = keys.substring(match.index + key.length);
 CodeMirror.Vim.handleKey(cm, key, 'mapping');
 }
 }

if (lastInsertModeKeyTimer) { window.clearTimeout(lastInsertModeKeyTimer); }
 if (keysAreChars) {
 var selections = cm.listSelections();
 for (var i = 0; i < selections.length; i++) {
 var here = selections[i].head;
 cm.replaceRange('', offsetCursor(here, 0, -(keys.length - 1)), here, '+input');
 }
 vimGlobalState.macroModeState.lastInsertModeChanges.changes.pop();
 }
 clearInputState(cm);
 return match.command;
 }

function handleKeyNonInsertMode() {
          if (handleMacroRecording() || handleEsc()) { return true; }

var keys = vim.inputState.keyBuffer = vim.inputState.keyBuffer + key;
          if (/^[1-9]\d*$/.test(keys)) { return true; }

vim.inputState.keyBuffer = '';
          var keysMatcher = /^(\d*)(.*)$/.exec(keys);
          if (keysMatcher[1] && keysMatcher[1] != '0') {
            vim.inputState.pushRepeatDigit(keysMatcher[1]);
          }
          return match.command;
        }

var command;
        if (vim.insertMode) { command = handleKeyInsertMode(); }
        else { command = handleKeyNonInsertMode(); }
        if (command === false) {
          return undefined; //ace_patch
        } else if (command === true) {
          return function() { return true; };
        } else {
          return function() {
            if ((command.operator || command.isEdit) && cm.getOption('readOnly'))
              return; // ace_patch
            return cm.operation(function() {
              cm.curOp.isVimOp = true;
              try {
                if (command.type == 'keyToKey') {
                  doKeyToKey(command.toKeys);
                } else {
                  commandDispatcher.processCommand(cm, vim, command);
                }
              } catch (e) {
                cm.state.vim = undefined;
                maybeInitVimState(cm);
                if (!CodeMirror.Vim.suppressErrorLogging) {
                  console['log'](e);
                }
                throw e;
              }
              return true;
            });
          };
        }
      },
      handleEx: function(cm, input) {
        exCommandDispatcher.processCommand(cm, input);
      },

defineMotion: defineMotion,
      defineAction: defineAction,
      defineOperator: defineOperator,
      mapCommand: mapCommand,
      _mapCommand: _mapCommand,

defineRegister: defineRegister,

exitVisualMode: exitVisualMode,
      exitInsertMode: exitInsertMode
    };
    function InputState() {
      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 unnamed 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;
    };

var bestMatch;
 for (var i = 0; i < matches.full.length; i++) {
 var match = matches.full[i];
 if (!bestMatch) {
 bestMatch = match;
 }
 }
 if (bestMatch.keys.slice(-11) == '<character>') {
 var character = lastChar(keys);
 if (/<C-.>/.test(character) || !character) return {type: 'none'}; //ace_patch
 inputState.selectedCharacter = character;
 }
 return {type: 'full', command: bestMatch};
 },
 processCommand: function(cm, vim, command) {
 vim.inputState.repeatOverride = command.repeatOverride;
 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) {
 inputState.motion = 'expandToLine';
 inputState.motionArgs = { linewise: true };
 this.evalInput(cm, vim);
 return;
 } else {
 clearInputState(cm);
 }
 }
 inputState.operator = command.operator;
 inputState.operatorArgs = copyArgs(command.operatorArgs);
 if (command.exitVisualBlock) {
 vim.visualBlock = false;
 updateCmSelection(cm);
 }
 if (vim.visualMode) {
 this.evalInput(cm, vim);
 }
 },
 processOperatorMotion: function(cm, vim, command) {
 var visualMode = vim.visualMode;
 var operatorMotionArgs = copyArgs(command.operatorMotionArgs);
 if (operatorMotionArgs) {
 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;
 }
 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;
 clearInputState(cm);
 vim.lastMotion = null;
 if (command.isEdit) {
 this.recordLastEdit(vim, inputState, command);
 }
 actions[command.action](cm, actionArgs, vim);
 },
 processSearch: function(cm, vim, command) {
 if (!cm.getSearchCursor) {
 return;
 }
 var forward = command.searchArgs.forward;
 var wholeWordOnly = command.searchArgs.wholeWordOnly;
 getSearchState(cm).setReversed(!forward);
 var promptPrefix = (forward) ? '/' : '?';
 var originalQuery = getSearchState(cm).getQuery();
 var originalScrollPos = cm.getScrollInfo();
 function handleQuery(query, ignoreCase, smartCase) {
 vimGlobalState.searchHistoryController.pushInput(query);
 vimGlobalState.searchHistoryController.reset();
 try {
 updateSearchQuery(cm, query, ignoreCase, smartCase);
 } catch (e) {
 showConfirm(cm, 'Invalid regex: ' + query);
 clearInputState(cm);
 return;
 }
 commandDispatcher.processMotion(cm, vim, {
 type: 'motion',
 motion: 'findNext',
 motionArgs: { forward: true, toJumplist: command.searchArgs.toJumplist }
 });
 }
 function onPromptClose(query) {
 cm.scrollTo(originalScrollPos.left, originalScrollPos.top);
 handleQuery(query, true /** ignoreCase */, true /** smartCase */);
 var macroModeState = vimGlobalState.macroModeState;
 if (macroModeState.isRecording) {
 logSearchQuery(macroModeState, query);
 }
 }
 function onPromptKeyUp(e, query, close) {
 var keyName = CodeMirror.keyName(e), up, offset;
 if (keyName == 'Up' || keyName == 'Down') {
 up = keyName == 'Up' ? true : false;
 offset = e.target ? e.target.selectionEnd : 0;
 query = vimGlobalState.searchHistoryController.nextMatch(query, up) || '';
 close(query);
 if (offset && e.target) e.target.selectionEnd = e.target.selectionStart = Math.min(offset, e.target.value.length);
 } else {
 if ( keyName != 'Left' && keyName != 'Right' && keyName != 'Ctrl' && keyName != 'Alt' && keyName != 'Shift')
 vimGlobalState.searchHistoryController.reset();
 }
 var parsedQuery;
 try {
 parsedQuery = updateSearchQuery(cm, query,
 true /** ignoreCase */, true /** smartCase */);
 } catch (e) {
 }
 if (parsedQuery) {
 cm.scrollIntoView(findNext(cm, !forward, parsedQuery), 30);
 } else {
 clearSearchHighlight(cm);
 cm.scrollTo(originalScrollPos.left, originalScrollPos.top);
 }
 }
 function onPromptKeyDown(e, query, close) {
 var keyName = CodeMirror.keyName(e);
 if (keyName == 'Esc' || keyName == 'Ctrl-C' || keyName == 'Ctrl-[' ||
 (keyName == 'Backspace' && query == '')) {
 vimGlobalState.searchHistoryController.pushInput(query);
 vimGlobalState.searchHistoryController.reset();
 updateSearchQuery(cm, originalQuery);
 clearSearchHighlight(cm);
 cm.scrollTo(originalScrollPos.left, originalScrollPos.top);
 CodeMirror.e_stop(e);
 clearInputState(cm);
 close();
 cm.focus();
 } else if (keyName == 'Up' || keyName == 'Down') {
 CodeMirror.e_stop(e);
 } else if (keyName == 'Ctrl-U') {
 CodeMirror.e_stop(e);
 close('');
 }
 }
 switch (command.searchArgs.querySrc) {
 case 'prompt':
 var macroModeState = vimGlobalState.macroModeState;
 if (macroModeState.isPlaying) {
 var query = macroModeState.replaySearchQueries.shift();
 handleQuery(query, true /** ignoreCase */, false /** smartCase */);
 } else {
 showPrompt(cm, {
 onClose: onPromptClose,
 prefix: promptPrefix,
 desc: searchPromptDesc,
 onKeyUp: onPromptKeyUp,
 onKeyDown: onPromptKeyDown
 });
 }
 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);
 if (isKeyword && wholeWordOnly) {
 query = '\\b' + query + '\\b';
 } else {
 query = escapeRegex(query);
 }
 vimGlobalState.jumpList.cachedCursor = cm.getCursor();
 cm.setCursor(word.start);

handleQuery(query, true /** ignoreCase */, false /** smartCase */);
 break;
 }
 },
 processEx: function(cm, vim, command) {
 function onPromptClose(input) {
 vimGlobalState.exCommandHistoryController.pushInput(input);
 vimGlobalState.exCommandHistoryController.reset();
 exCommandDispatcher.processCommand(cm, input);
 }
 function onPromptKeyDown(e, input, close) {
 var keyName = CodeMirror.keyName(e), up, offset;
 if (keyName == 'Esc' || keyName == 'Ctrl-C' || keyName == 'Ctrl-[' ||
 (keyName == 'Backspace' && input == '')) {
 vimGlobalState.exCommandHistoryController.pushInput(input);
 vimGlobalState.exCommandHistoryController.reset();
 CodeMirror.e_stop(e);
 clearInputState(cm);
 close();
 cm.focus();
 }
 if (keyName == 'Up' || keyName == 'Down') {
 CodeMirror.e_stop(e);
 up = keyName == 'Up' ? true : false;
 offset = e.target ? e.target.selectionEnd : 0;
 input = vimGlobalState.exCommandHistoryController.nextMatch(input, up) || '';
 close(input);
 if (offset && e.target) e.target.selectionEnd = e.target.selectionStart = Math.min(offset, e.target.value.length);
 } else if (keyName == 'Ctrl-U') {
 CodeMirror.e_stop(e);
 close('');
 } else {
 if ( keyName != 'Left' && keyName != 'Right' && keyName != 'Ctrl' && keyName != 'Alt' && keyName != 'Shift')
 vimGlobalState.exCommandHistoryController.reset();
 }
 }
 if (command.type == 'keyToEx') {
 exCommandDispatcher.processCommand(cm, command.exArgs.input);
 } else {
 if (vim.visualMode) {
 showPrompt(cm, { onClose: onPromptClose, prefix: ':', value: '\'<,\'>',
 onKeyDown: onPromptKeyDown, selectValueOnOpen: false});
 } else {
 showPrompt(cm, { onClose: onPromptClose, prefix: ':',
 onKeyDown: onPromptKeyDown});
 }
 }
 },
 evalInput: function(cm, vim) {
 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 sel = vim.sel;
 var origHead = copyCursor(vim.visualMode ? clipCursorToContent(cm, sel.head): cm.getCursor('head'));
 var origAnchor = copyCursor(vim.visualMode ? clipCursorToContent(cm, sel.anchor) : cm.getCursor('anchor'));
 var oldHead = copyCursor(origHead);
 var oldAnchor = copyCursor(origAnchor);
 var newHead, newAnchor;
 var repeat;
 if (operator) {
 this.recordLastEdit(vim, inputState);
 }
 if (inputState.repeatOverride !== undefined) {
 repeat = inputState.repeatOverride;
 } 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) {
 motionArgs.selectedCharacter = operatorArgs.selectedCharacter =
 inputState.selectedCharacter;
 }
 motionArgs.repeat = repeat;
 clearInputState(cm);
 if (motion) {
 var motionResult = motions[motion](cm, origHead, motionArgs, vim);
 vim.lastMotion = motions[motion];
 if (!motionResult) {
 return;
 }
 if (motionArgs.toJumplist) {
 if (!operator && cm.ace.curOp != null)
 cm.ace.curOp.command.scrollIntoView = "center-animate"; // ace_patch
 var jumpList = vimGlobalState.jumpList;
 var cachedCursor = jumpList.cachedCursor;
 if (cachedCursor) {
 recordJumpPosition(cm, cachedCursor, motionResult);
 delete jumpList.cachedCursor;
 } else {
 recordJumpPosition(cm, origHead, motionResult);
 }
 }
 if (motionResult instanceof Array) {
 newAnchor = motionResult[0];
 newHead = motionResult[1];
 } else {
 newHead = motionResult;
 }
 if (!newHead) {
 newHead = copyCursor(origHead);
 }
 if (vim.visualMode) {
 if (!(vim.visualBlock && newHead.ch === Infinity)) {
 newHead = clipCursorToContent(cm, newHead, vim.visualBlock);
 }
 if (newAnchor) {
 newAnchor = clipCursorToContent(cm, newAnchor, true);
 }
 newAnchor = newAnchor || oldAnchor;
 sel.anchor = newAnchor;
 sel.head = newHead;
 updateCmSelection(cm);
 updateMark(cm, vim, '<',
 cursorIsBefore(newAnchor, newHead) ? newAnchor
 : newHead);
 updateMark(cm, vim, '>',
 cursorIsBefore(newAnchor, newHead) ? newHead
 : newAnchor);
 } else if (!operator) {
 newHead = clipCursorToContent(cm, newHead);
 cm.setCursor(newHead.line, newHead.ch);
 }
 }
 if (operator) {
 if (operatorArgs.lastSel) {
 newAnchor = oldAnchor;
 var lastSel = operatorArgs.lastSel;
 var lineOffset = Math.abs(lastSel.head.line - lastSel.anchor.line);
 var chOffset = Math.abs(lastSel.head.ch - lastSel.anchor.ch);
 if (lastSel.visualLine) {
 newHead = Pos(oldAnchor.line + lineOffset, oldAnchor.ch);
 } else if (lastSel.visualBlock) {
 newHead = Pos(oldAnchor.line + lineOffset, oldAnchor.ch + chOffset);
 } else if (lastSel.head.line == lastSel.anchor.line) {
 newHead = Pos(oldAnchor.line, oldAnchor.ch + chOffset);
 } else {
 newHead = Pos(oldAnchor.line + lineOffset, oldAnchor.ch);
 }
 vim.visualMode = true;
 vim.visualLine = lastSel.visualLine;
 vim.visualBlock = lastSel.visualBlock;
 sel = vim.sel = {
 anchor: newAnchor,
 head: newHead
 };
 updateCmSelection(cm);
 } else if (vim.visualMode) {
 operatorArgs.lastSel = {
 anchor: copyCursor(sel.anchor),
 head: copyCursor(sel.head),
 visualBlock: vim.visualBlock,
 visualLine: vim.visualLine
 };
 }
 var curStart, curEnd, linewise, mode;
 var cmSel;
 if (vim.visualMode) {
 curStart = cursorMin(sel.head, sel.anchor);
 curEnd = cursorMax(sel.head, sel.anchor);
 linewise = vim.visualLine || operatorArgs.linewise;
 mode = vim.visualBlock ? 'block' :
 linewise ? 'line' :
 'char';
 cmSel = makeCmSelection(cm, {
 anchor: curStart,
 head: curEnd
 }, mode);
 if (linewise) {
 var ranges = cmSel.ranges;
 if (mode == 'block') {
 for (var i = 0; i < ranges.length; i++) {
 ranges[i].head.ch = lineLength(cm, ranges[i].head.line);
 }
 } else if (mode == 'line') {
 ranges[0].head = Pos(ranges[0].head.line + 1, 0);
 }
 }
 } else {
 curStart = copyCursor(newAnchor || oldAnchor);
 curEnd = copyCursor(newHead || oldHead);
 if (cursorIsBefore(curEnd, curStart)) {
 var tmp = curStart;
 curStart = curEnd;
 curEnd = tmp;
 }
 linewise = motionArgs.linewise || operatorArgs.linewise;
 if (linewise) {
 expandSelectionToLine(cm, curStart, curEnd);
 } else if (motionArgs.forward) {
 clipToLine(cm, curStart, curEnd);
 }
 mode = 'char';
 var exclusive = !motionArgs.inclusive || linewise;
 cmSel = makeCmSelection(cm, {
 anchor: curStart,
 head: curEnd
 }, mode, exclusive);
 }
 cm.setSelections(cmSel.ranges, cmSel.primary);
 vim.lastMotion = null;
 operatorArgs.repeat = repeat; // For indent in visual mode.
 operatorArgs.registerName = registerName;
 operatorArgs.linewise = linewise;
 var operatorMoveTo = operators[operator](
 cm, operatorArgs, cmSel.ranges, oldAnchor, newHead);
 if (vim.visualMode) {
 exitVisualMode(cm, operatorMoveTo != null);
 }
 if (operatorMoveTo) {
 cm.setCursor(operatorMoveTo);
 }
 }
 },
 recordLastEdit: function(vim, inputState, actionCommand) {
 var macroModeState = vimGlobalState.macroModeState;
 if (macroModeState.isPlaying) { return; }
 vim.lastEditInputState = inputState;
 vim.lastEditActionCommand = actionCommand;
 macroModeState.lastInsertModeChanges.changes = [];
 macroModeState.lastInsertModeChanges.expectCursorActivityForChange = false;
 macroModeState.lastInsertModeChanges.visualBlock = vim.visualBlock ? vim.sel.head.line - vim.sel.anchor.line : 0;
 }
 };
 var motions = {
 moveToTopLine: function(cm, _head, motionArgs) {
 var line = getUserVisibleLines(cm).top + motionArgs.repeat -1;
 return Pos(line, findFirstNonWhiteSpaceCharacter(cm.getLine(line)));
 },
 moveToMiddleLine: function(cm) {
 var range = getUserVisibleLines(cm);
 var line = Math.floor((range.top + range.bottom) * 0.5);
 return Pos(line, findFirstNonWhiteSpaceCharacter(cm.getLine(line)));
 },
 moveToBottomLine: function(cm, _head, motionArgs) {
 var line = getUserVisibleLines(cm).bottom - motionArgs.repeat +1;
 return Pos(line, findFirstNonWhiteSpaceCharacter(cm.getLine(line)));
 },
 expandToLine: function(_cm, head, motionArgs) {
 var cur = head;
 return Pos(cur.line + motionArgs.repeat - 1, Infinity);
 },
 findNext: function(cm, _head, motionArgs) {
 var state = getSearchState(cm);
 var query = state.getQuery();
 if (!query) {
 return;
 }
 var prev = !motionArgs.forward;
 prev = (state.isReversed()) ? !prev : prev;
 highlightSearchMatches(cm, query);
 return findNext(cm, prev/** prev */, query, motionArgs.repeat);
 },
 goToMark: function(cm, _head, motionArgs, vim) {
 var pos = getMarkPos(cm, vim, motionArgs.selectedCharacter);
 if (pos) {
 return motionArgs.linewise ? { line: pos.line, ch: findFirstNonWhiteSpaceCharacter(cm.getLine(pos.line)) } : pos;
 }
 return null;
 },
 moveToOtherHighlightedEnd: function(cm, _head, motionArgs, vim) {
 if (vim.visualBlock && motionArgs.sameLine) {
 var sel = vim.sel;
 return [
 clipCursorToContent(cm, Pos(sel.anchor.line, sel.head.ch)),
 clipCursorToContent(cm, Pos(sel.head.line, sel.anchor.ch))
 ];
 } else {
 return ([vim.sel.head, vim.sel.anchor]);
 }
 },
 jumpToMark: function(cm, head, motionArgs, vim) {
 var best = head;
 for (var i = 0; i < motionArgs.repeat; i++) {
 var cursor = best;
 for (var key in vim.marks) {
 if (!isLowerCase(key)) {
 continue;
 }
 var mark = vim.marks[key].find();
 var isWrongDirection = (motionArgs.forward) ?
 cursorIsBefore(mark, cursor) : cursorIsBefore(cursor, mark);

if (isWrongDirection) {
              continue;
            }
            if (motionArgs.linewise && (mark.line == cursor.line)) {
              continue;
            }

var equal = cursorEqual(cursor, best);
            var between = (motionArgs.forward) ?
              cursorIsBetween(cursor, mark, best) :
              cursorIsBetween(best, mark, cursor);

if (equal || between) {
              best = mark;
            }
          }
        }

if (motionArgs.linewise) {
 best = Pos(best.line, findFirstNonWhiteSpaceCharacter(cm.getLine(best.line)));
 }
 return best;
 },
 moveByCharacters: function(_cm, head, motionArgs) {
 var cur = head;
 var repeat = motionArgs.repeat;
 var ch = motionArgs.forward ? cur.ch + repeat : cur.ch - repeat;
 return Pos(cur.line, ch);
 },
 moveByLines: function(cm, head, motionArgs, vim) {
 var cur = head;
 var endCh = cur.ch;
 switch (vim.lastMotion) {
 case this.moveByLines:
 case this.moveByDisplayLines:
 case this.moveByScroll:
 case this.moveToColumn:
 case this.moveToEol:
 endCh = vim.lastHPos;
 break;
 default:
 vim.lastHPos = endCh;
 }
 var repeat = motionArgs.repeat+(motionArgs.repeatOffset||0);
 var line = motionArgs.forward ? cur.line + repeat : cur.line - repeat;
 var first = cm.firstLine();
 var last = cm.lastLine();
 if (line < first && cur.line == first){
 return this.moveToStartOfLine(cm, head, motionArgs, vim);
 }else if (line > last && cur.line == last){
 return this.moveToEol(cm, head, motionArgs, vim, true);
 }
 var fold = cm.ace.session.getFoldLine(line);
 if (fold) {
 if (motionArgs.forward) {
 if (line > fold.start.row)
 line = fold.end.row + 1;
 } else {
 line = fold.start.row;
 }
 }
 if (motionArgs.toFirstChar){
 endCh=findFirstNonWhiteSpaceCharacter(cm.getLine(line));
 vim.lastHPos = endCh;
 }
 vim.lastHSPos = cm.charCoords(Pos(line, endCh),'div').left;
 return Pos(line, endCh);
 },
 moveByDisplayLines: function(cm, head, motionArgs, vim) {
 var cur = head;
 switch (vim.lastMotion) {
 case this.moveByDisplayLines:
 case this.moveByScroll:
 case this.moveByLines:
 case this.moveToColumn:
 case this.moveToEol:
 break;
 default:
 vim.lastHSPos = cm.charCoords(cur,'div').left;
 }
 var repeat = motionArgs.repeat;
 var res=cm.findPosV(cur,(motionArgs.forward ? repeat : -repeat),'line',vim.lastHSPos);
 if (res.hitSide) {
 if (motionArgs.forward) {
 var lastCharCoords = cm.charCoords(res, 'div');
 var goalCoords = { top: lastCharCoords.top + 8, left: vim.lastHSPos };
 var res = cm.coordsChar(goalCoords, 'div');
 } else {
 var resCoords = cm.charCoords(Pos(cm.firstLine(), 0), 'div');
 resCoords.left = vim.lastHSPos;
 res = cm.coordsChar(resCoords, 'div');
 }
 }
 vim.lastHPos = res.ch;
 return res;
 },
 moveByPage: function(cm, head, motionArgs) {
 var curStart = head;
 var repeat = motionArgs.repeat;
 return cm.findPosV(curStart, (motionArgs.forward ? repeat : -repeat), 'page');
 },
 moveByParagraph: function(cm, head, motionArgs) {
 var dir = motionArgs.forward ? 1 : -1;
 return findParagraph(cm, head, motionArgs.repeat, dir);
 },
 moveBySentence: function(cm, head, motionArgs) {
 var dir = motionArgs.forward ? 1 : -1;
 return findSentence(cm, head, motionArgs.repeat, dir);
 },
 moveByScroll: function(cm, head, motionArgs, vim) {
 var scrollbox = cm.getScrollInfo();
 var curEnd = null;
 var repeat = motionArgs.repeat;
 if (!repeat) {
 repeat = scrollbox.clientHeight / (2 * cm.defaultTextHeight());
 }
 var orig = cm.charCoords(head, 'local');
 motionArgs.repeat = repeat;
 var curEnd = motions.moveByDisplayLines(cm, head, motionArgs, vim);
 if (!curEnd) {
 return null;
 }
 var dest = cm.charCoords(curEnd, 'local');
 cm.scrollTo(null, scrollbox.top + dest.top - orig.top);
 return curEnd;
 },
 moveByWords: function(cm, head, motionArgs) {
 return moveToWord(cm, head, motionArgs.repeat, !!motionArgs.forward,
 !!motionArgs.wordEnd, !!motionArgs.bigWord);
 },
 moveTillCharacter: function(cm, _head, motionArgs) {
 var repeat = motionArgs.repeat;
 var curEnd = moveToCharacter(cm, repeat, motionArgs.forward,
 motionArgs.selectedCharacter);
 var increment = motionArgs.forward ? -1 : 1;
 recordLastCharacterSearch(increment, motionArgs);
 if (!curEnd) return null;
 curEnd.ch += increment;
 return curEnd;
 },
 moveToCharacter: function(cm, head, motionArgs) {
 var repeat = motionArgs.repeat;
 recordLastCharacterSearch(0, motionArgs);
 return moveToCharacter(cm, repeat, motionArgs.forward,
 motionArgs.selectedCharacter) || head;
 },
 moveToSymbol: function(cm, head, motionArgs) {
 var repeat = motionArgs.repeat;
 return findSymbol(cm, repeat, motionArgs.forward,
 motionArgs.selectedCharacter) || head;
 },
 moveToColumn: function(cm, head, motionArgs, vim) {
 var repeat = motionArgs.repeat;
 vim.lastHPos = repeat - 1;
 vim.lastHSPos = cm.charCoords(head,'div').left;
 return moveToColumn(cm, repeat);
 },
 moveToEol: function(cm, head, motionArgs, vim, keepHPos) {
 var cur = head;
 var retval= Pos(cur.line + motionArgs.repeat - 1, Infinity);
 var end=cm.clipPos(retval);
 end.ch--;
 if (!keepHPos) {
 vim.lastHPos = Infinity;
 vim.lastHSPos = cm.charCoords(end,'div').left;
 }
 return retval;
 },
 moveToFirstNonWhiteSpaceCharacter: function(cm, head) {
 var cursor = head;
 return Pos(cursor.line,
 findFirstNonWhiteSpaceCharacter(cm.getLine(cursor.line)));
 },
 moveToMatchedSymbol: function(cm, head) {
 var cursor = head;
 var line = cursor.line;
 var ch = cursor.ch;
 var lineText = cm.getLine(line);
 var symbol;
 for (; ch < lineText.length; ch++) {
 symbol = lineText.charAt(ch);
 if (symbol && isMatchableSymbol(symbol)) {
 var style = cm.getTokenTypeAt(Pos(line, ch + 1));
 if (style !== "string" && style !== "comment") {
 break;
 }
 }
 }
 if (ch < lineText.length) {
 var re = /[<>]/.test(lineText[ch]) ? /[(){}[\]<>]/ : /[(){}[\]]/; //ace_patch?
 var matched = cm.findMatchingBracket(Pos(line, ch+1), {bracketRegex: re});
 return matched.to;
 } else {
 return cursor;
 }
 },
 moveToStartOfLine: function(_cm, head) {
 return Pos(head.line, 0);
 },
 moveToLineOrEdgeOfDocument: function(cm, _head, motionArgs) {
 var lineNum = motionArgs.forward ? cm.lastLine() : cm.firstLine();
 if (motionArgs.repeatIsExplicit) {
 lineNum = motionArgs.repeat - cm.getOption('firstLineNumber');
 }
 return Pos(lineNum,
 findFirstNonWhiteSpaceCharacter(cm.getLine(lineNum)));
 },
 textObjectManipulation: function(cm, head, motionArgs, vim) {
 var mirroredPairs = {'(': ')', ')': '(',
 '{': '}', '}': '{',
 '[': ']', ']': '[',
 '<': '>', '>': '<'};
 var selfPaired = {'\'': true, '"': true, '`': true};

var character = motionArgs.selectedCharacter;
        if (character == 'b') {
          character = '(';
        } else if (character == 'B') {
          character = '{';
        }
        var inclusive = !motionArgs.textObjectInner;

var tmp;
        if (mirroredPairs[character]) {
          tmp = selectCompanionObject(cm, head, character, inclusive);
        } else if (selfPaired[character]) {
          tmp = findBeginningAndEnd(cm, head, character, inclusive);
        } else if (character === 'W') {
          tmp = expandWordUnderCursor(cm, inclusive, true /** forward */,
                                                     true /** bigWord */);
        } else if (character === 'w') {
          tmp = expandWordUnderCursor(cm, inclusive, true /** forward */,
                                                     false /** bigWord */);
        } else if (character === 'p') {
          tmp = findParagraph(cm, head, motionArgs.repeat, 0, inclusive);
          motionArgs.linewise = true;
          if (vim.visualMode) {
            if (!vim.visualLine) { vim.visualLine = true; }
          } else {
            var operatorArgs = vim.inputState.operatorArgs;
            if (operatorArgs) { operatorArgs.linewise = true; }
            tmp.end.line--;
          }
        } else {
          return null;
        }

if (!cm.state.vim.visualMode) {
          return [tmp.start, tmp.end];
        } else {
          return expandSelection(cm, tmp.start, tmp.end);
        }
      },

repeatLastCharacterSearch: function(cm, head, motionArgs) {
        var lastSearch = vimGlobalState.lastCharacterSearch;
        var repeat = motionArgs.repeat;
        var forward = motionArgs.forward === lastSearch.forward;
        var increment = (lastSearch.increment ? 1 : 0) * (forward ? -1 : 1);
        cm.moveH(-increment, 'char');
        motionArgs.inclusive = forward ? true : false;
        var curEnd = moveToCharacter(cm, repeat, forward, lastSearch.selectedCharacter);
        if (!curEnd) {
          cm.moveH(increment, 'char');
          return head;
        }
        curEnd.ch += increment;
        return curEnd;
      }
    };

function defineMotion(name, fn) {
      motions[name] = fn;
    }

function defineOperator(name, fn) {
      operators[name] = fn;
    }

var actions = {
      jumpListWalk: function(cm, actionArgs, vim) {
        if (vim.visualMode) {
          return;
        }
        var repeat = actionArgs.repeat;
        var forward = actionArgs.forward;
        var jumpList = vimGlobalState.jumpList;

var firstLine = Math.min(base.line, head.line);
      var lastLine = Math.max(base.line, head.line);
      var baseCh = base.ch, headCh = head.ch;

function findFirstNonWhiteSpaceCharacter(text) {
      if (!text) {
        return 0;
      }
      var firstNonWS = text.search(/\S/);
      return firstNonWS == -1 ? text.length : firstNonWS;
    }

function expandWordUnderCursor(cm, inclusive, _forward, bigWord, noSymbol) {
      var cur = getHead(cm);
      var line = cm.getLine(cur.line);
      var idx = cur.ch;
      var test = noSymbol ? wordCharTest[0] : bigWordCharTest [0];
      while (!test(line.charAt(idx))) {
        idx++;
        if (idx >= line.length) { return null; }
      }

if (bigWord) {
        test = bigWordCharTest[0];
      } else {
        test = wordCharTest[0];
        if (!test(line.charAt(idx))) {
          test = wordCharTest[1];
        }
      }

var end = idx, start = idx;
 while (test(line.charAt(end)) && end < line.length) { end++; }
 while (test(line.charAt(start)) && start >= 0) { start--; }
 start++;

if (inclusive) {
 var wordEnd = end;
 while (/\s/.test(line.charAt(end)) && end < line.length) { end++; }
 if (wordEnd == end) {
 var wordStart = start;
 while (/\s/.test(line.charAt(start - 1)) && start > 0) { start--; }
 if (!start) { start = wordStart; }
 }
 }
 return { start: Pos(cur.line, start), end: Pos(cur.line, end) };
 }

function recordJumpPosition(cm, oldCur, newCur) {
      if (!cursorEqual(oldCur, newCur)) {
        vimGlobalState.jumpList.add(cm, oldCur, newCur);
      }
    }

function recordLastCharacterSearch(increment, args) {
        vimGlobalState.lastCharacterSearch.increment = increment;
        vimGlobalState.lastCharacterSearch.forward = args.forward;
        vimGlobalState.lastCharacterSearch.selectedCharacter = args.selectedCharacter;
    }

if (emptyLineIsWord && line == '') {
        lineNum += dir;
        line = cm.getLine(lineNum);
        if (!isLine(cm, lineNum)) {
          return null;
        }
        pos = (forward) ? 0 : line.length;
      }

while (true) {
 if (emptyLineIsWord && line == '') {
 return { from: 0, to: 0, line: lineNum };
 }
 var stop = (dir > 0) ? line.length : -1;
 var wordStart = stop, wordEnd = stop;
 while (pos != stop) {
 var foundWord = false;
 for (var i = 0; i < charTests.length && !foundWord; ++i) {
 if (charTests[i](line.charAt(pos))) {
 wordStart = pos;
 while (pos != stop && charTests[i](line.charAt(pos))) {
 pos += dir;
 }
 wordEnd = pos;
 foundWord = wordStart != wordEnd;
 if (wordStart == cur.ch && lineNum == cur.line &&
 wordEnd == wordStart + dir) {
 continue;
 } else {
 return {
 from: Math.min(wordStart, wordEnd + 1),
 to: Math.max(wordStart, wordEnd),
 line: lineNum };
 }
 }
 }
 if (!foundWord) {
 pos += dir;
 }
 }
 lineNum += dir;
 if (!isLine(cm, lineNum)) {
 return null;
 }
 line = cm.getLine(lineNum);
 pos = (dir > 0) ? 0 : line.length;
 }
 }
 function moveToWord(cm, cur, repeat, forward, wordEnd, bigWord) {
 var curStart = copyCursor(cur);
 var words = [];
 if (forward && !wordEnd || !forward && wordEnd) {
 repeat++;
 }
 var emptyLineIsWord = !(forward && wordEnd);
 for (var i = 0; i < repeat; i++) {
 var word = findWord(cm, cur, forward, bigWord, emptyLineIsWord);
 if (!word) {
 var eodCh = lineLength(cm, cm.lastLine());
 words.push(forward
 ? {line: cm.lastLine(), from: eodCh, to: eodCh}
 : {line: 0, from: 0, to: 0});
 break;
 }
 words.push(word);
 cur = Pos(word.line, forward ? (word.to - 1) : word.from);
 }
 var shortCircuit = words.length != repeat;
 var firstWord = words[0];
 var lastWord = words.pop();
 if (forward && !wordEnd) {
 if (!shortCircuit && (firstWord.from != curStart.ch || firstWord.line != curStart.line)) {
 lastWord = words.pop();
 }
 return Pos(lastWord.line, lastWord.from);
 } else if (forward && wordEnd) {
 return Pos(lastWord.line, lastWord.to - 1);
 } else if (!forward && wordEnd) {
 if (!shortCircuit && (firstWord.to != curStart.ch || firstWord.line != curStart.line)) {
 lastWord = words.pop();
 }
 return Pos(lastWord.line, lastWord.to);
 } else {
 return Pos(lastWord.line, lastWord.from);
 }
 }

function moveToColumn(cm, repeat) {
      var line = cm.getCursor().line;
      return clipCursorToContent(cm, Pos(line, repeat - 1));
    }

var curr = {
          line: line,
          ln: ln,
          pos: pos,
          dir: dir,
        }

var last_valid = {
          ln: curr.ln,
          pos: curr.pos,
        }

var skip_empty_lines = (curr.line === "");
        nextChar(cm, curr);

while (curr.line !== null) {
          last_valid.ln = curr.ln;
          last_valid.pos = curr.pos;

if (curr.line === "" && !skip_empty_lines) {
            return { ln: curr.ln, pos: curr.pos, };
          }
          else if (stop && curr.line !== "" && !isWhiteSpaceString(curr.line[curr.pos])) {
            return { ln: curr.ln, pos: curr.pos, };
          }
          else if (isEndOfSentenceSymbol(curr.line[curr.pos])
            && !stop
            && (curr.pos === curr.line.length - 1
              || isWhiteSpaceString(curr.line[curr.pos + 1]))) {
            stop = true;
          }

nextChar(cm, curr);
        }
        var line = cm.getLine(last_valid.ln);
        last_valid.pos = 0;
        for(var i = line.length - 1; i >= 0; --i) {
          if (!isWhiteSpaceString(line[i])) {
            last_valid.pos = i;
            break;
          }
        }

return last_valid;

}
      function reverse(cm, ln, pos, dir) {
        var line = cm.getLine(ln);

var curr = {
          line: line,
          ln: ln,
          pos: pos,
          dir: dir,
        }

var last_valid = {
          ln: curr.ln,
          pos: null,
        };

var skip_empty_lines = (curr.line === "");
        nextChar(cm, curr);

while (curr.line !== null) {

if (curr.line === "" && !skip_empty_lines) {
            if (last_valid.pos !== null) {
              return last_valid;
            }
            else {
              return { ln: curr.ln, pos: curr.pos };
            }
          }
          else if (isEndOfSentenceSymbol(curr.line[curr.pos])
              && last_valid.pos !== null
              && !(curr.ln === last_valid.ln && curr.pos + 1 === last_valid.pos)) {
            return last_valid;
          }
          else if (curr.line !== "" && !isWhiteSpaceString(curr.line[curr.pos])) {
            skip_empty_lines = false;
            last_valid = { ln: curr.ln, pos: curr.pos }
          }

nextChar(cm, curr);
 }
 var line = cm.getLine(last_valid.ln);
 last_valid.pos = 0;
 for(var i = 0; i < line.length; ++i) {
 if (!isWhiteSpaceString(line[i])) {
 last_valid.pos = i;
 break;
 }
 }
 return last_valid;
 }

var curr_index = {
        ln: cur.line,
        pos: cur.ch,
      };

while (repeat > 0) {
 if (dir < 0) {
 curr_index = reverse(cm, curr_index.ln, curr_index.pos, dir);
 }
 else {
 curr_index = forward(cm, curr_index.ln, curr_index.pos, dir);
 }
 repeat--;
 }

return Pos(curr_index.ln, curr_index.pos);
    }
    function selectCompanionObject(cm, head, symb, inclusive) {
      var cur = head, start, end;

start = cm.scanForBracket(Pos(cur.line, cur.ch + offset), -1, undefined, {'bracketRegex': bracketRegexp});
      end = cm.scanForBracket(Pos(cur.line, cur.ch + offset), 1, undefined, {'bracketRegex': bracketRegexp});

if (!start || !end) {
        return { start: cur, end: cur };
      }

start = start.pos;
      end = end.pos;

if ((start.line == end.line && start.ch > end.ch)
          || (start.line > end.line)) {
        var tmp = start;
        start = end;
        end = tmp;
      }

if (inclusive) {
        end.ch += 1;
      } else {
        start.ch += 1;
      }

return { start: start, end: end };
 }
 function findBeginningAndEnd(cm, head, symb, inclusive) {
 var cur = copyCursor(head);
 var line = cm.getLine(cur.line);
 var chars = line.split('');
 var start, end, i, len;
 var firstIndex = chars.indexOf(symb);
 if (cur.ch < firstIndex) {
 cur.ch = firstIndex;
 }
 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
 }
 if (chars[cur.ch] == symb && !end) {
 start = cur.ch + 1; // assign start to ahead of the cursor
 } else {
 for (i = cur.ch; i > -1 && !start; i--) {
 if (chars[i] == symb) {
 start = i + 1;
 }
 }
 }
 if (start && !end) {
 for (i = start, len = chars.length; i < len && !end; i++) {
 if (chars[i] == symb) {
 end = i;
 }
 }
 }
 if (!start || !end) {
 return { start: cur, end: cur };
 }
 if (inclusive) {
 --start; ++end;
 }

return {
        start: Pos(cur.line, start),
        end: Pos(cur.line, end)
      };
    }
    defineOption('pcre', true, 'boolean');
    function SearchState() {}
    SearchState.prototype = {
      getQuery: function() {
        return vimGlobalState.query;
      },
      setQuery: function(query) {
        vimGlobalState.query = query;
      },
      getOverlay: function() {
        return this.searchOverlay;
      },
      setOverlay: function(overlay) {
        this.searchOverlay = overlay;
      },
      isReversed: function() {
        return vimGlobalState.isReversed;
      },
      setReversed: function(reversed) {
        vimGlobalState.isReversed = reversed;
      },
      getScrollbarAnnotate: function() {
        return this.annotate;
      },
      setScrollbarAnnotate: function(annotate) {
        this.annotate = annotate;
      }
    };
    function getSearchState(cm) {
      var vim = cm.state.vim;
      return vim.searchState_ || (vim.searchState_ = new SearchState());
    }
    function dialog(cm, template, shortText, onClose, options) {
      if (cm.openDialog) {
        cm.openDialog(template, onClose, { bottom: true, value: options.value,
            onKeyDown: options.onKeyDown, onKeyUp: options.onKeyUp,
            selectValueOnOpen: false, onClose: function() {
              if (cm.state.vim) {
                cm.state.vim.status = "";
                cm.ace.renderer.$loop.schedule(cm.ace.renderer.CHANGE_CURSOR);
              }
            }});
      }
      else {
        onClose(prompt(shortText, ''));
      }
    }
    function splitBySlash(argString) {
      return splitBySeparator(argString, '/');
    }

function findUnescapedSlashes(argString) {
      return findUnescapedSeparators(argString, '/');
    }

function splitBySeparator(argString, separator) {
 var slashes = findUnescapedSeparators(argString, separator) || [];
 if (!slashes.length) return [];
 var tokens = [];
 if (slashes[0] !== 0) return;
 for (var i = 0; i < slashes.length; i++) {
 if (typeof slashes[i] == 'number')
 tokens.push(argString.substring(slashes[i] + 1, slashes[i+1]));
 }
 return tokens;
 }

function findUnescapedSeparators(str, separator) {
      if (!separator)
        separator = '/';

function getMarkPos(cm, vim, markName) {
      if (markName == '\'' || markName == '`') {
        return vimGlobalState.jumpList.find(cm, -1) || Pos(0, 0);
      } else if (markName == '.') {
        return getLastEditPos(cm);
      }

var mark = vim.marks[markName];
      return mark && mark.find();
    }

function getLastEditPos(cm) {
      var undoManager = cm.ace.session.$undoManager;
      if (undoManager && undoManager.$lastDelta)
        return toCmPos(undoManager.$lastDelta.end);
    }

return result;
 },
 parseLineSpec_: function(cm, inputStream) {
 var numberMatch = inputStream.match(/^(\d+)/);
 if (numberMatch) {
 return parseInt(numberMatch[1], 10) - 1;
 }
 switch (inputStream.next()) {
 case '.':
 return this.parseLineSpecOffset_(inputStream, cm.getCursor().line);
 case '$':
 return this.parseLineSpecOffset_(inputStream, cm.lastLine());
 case '\'':
 var markName = inputStream.next();
 var markPos = getMarkPos(cm, cm.state.vim, markName);
 if (!markPos) throw new Error('Mark not set');
 return this.parseLineSpecOffset_(inputStream, markPos.line);
 case '-':
 case '+':
 inputStream.backUp(1);
 return this.parseLineSpecOffset_(inputStream, cm.getCursor().line);
 default:
 inputStream.backUp(1);
 return undefined;
 }
 },
 parseLineSpecOffset_: function(inputStream, line) {
 var offsetMatch = inputStream.match(/^([+-])?(\d+)/);
 if (offsetMatch) {
 var offset = parseInt(offsetMatch[2], 10);
 if (offsetMatch[1] == "-") {
 line -= offset;
 } else {
 line += offset;
 }
 }
 return line;
 },
 parseCommandArgs_: function(inputStream, params, command) {
 if (inputStream.eol()) {
 return;
 }
 params.argString = inputStream.match(/.*/)[0];
 var delim = command.argDelimiter || /\s+/;
 var args = trim(params.argString).split(delim);
 if (args.length && args[0]) {
 params.args = args;
 }
 },
 matchCommand_: function(commandName) {
 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, ctx) {
 if (lhs != ':' && lhs.charAt(0) == ':') {
 if (ctx) { throw Error('Mode not supported for ex mappings'); }
 var commandName = lhs.substring(1);
 if (rhs != ':' && rhs.charAt(0) == ':') {
 this.commandMap_[commandName] = {
 name: commandName,
 type: 'exToEx',
 toInput: rhs.substring(1),
 user: true
 };
 } else {
 this.commandMap_[commandName] = {
 name: commandName,
 type: 'exToKey',
 toKeys: rhs,
 user: true
 };
 }
 } else {
 if (rhs != ':' && rhs.charAt(0) == ':') {
 var mapping = {
 keys: lhs,
 type: 'keyToEx',
 exArgs: { input: rhs.substring(1) }
 };
 if (ctx) { mapping.context = ctx; }
 defaultKeymap.unshift(mapping);
 } else {
 var mapping = {
 keys: lhs,
 type: 'keyToKey',
 toKeys: rhs
 };
 if (ctx) { mapping.context = ctx; }
 defaultKeymap.unshift(mapping);
 }
 }
 },
 unmap: function(lhs, ctx) {
 if (lhs != ':' && lhs.charAt(0) == ':') {
 if (ctx) { throw Error('Mode not supported for ex mappings'); }
 var commandName = lhs.substring(1);
 if (this.commandMap_[commandName] && this.commandMap_[commandName].user) {
 delete this.commandMap_[commandName];
 return;
 }
 } else {
 var keys = lhs;
 for (var i = 0; i < defaultKeymap.length; i++) {
 if (keys == defaultKeymap[i].keys
 && defaultKeymap[i].context === ctx) {
 defaultKeymap.splice(i, 1);
 return;
 }
 }
 }
 }
 };

if (optionName.charAt(optionName.length - 1) == '?') {
          if (value) { throw Error('Trailing characters: ' + params.argString); }
          optionName = optionName.substring(0, optionName.length - 1);
          forceGet = true;
        }
        if (value === undefined && optionName.substring(0, 2) == 'no') {
          optionName = optionName.substring(2);
          value = false;
        }

var state = cm.state.vim;
        var stream = new CodeMirror.StringStream(trim(params.argString));
        while (!stream.eol()) {
          stream.eatSpace();
          var count = stream.pos;

if (!stream.match(/[a-zA-Z]/, false)) {
            showConfirm(cm, 'Invalid argument: ' + params.argString.substring(count));
            return;
          }

var sym = stream.next();
          if (stream.match('-', true)) {
            if (!stream.match(/[a-zA-Z]/, false)) {
              showConfirm(cm, 'Invalid argument: ' + params.argString.substring(count));
              return;
            }

CodeMirror.keyMap.vim = {
      attach: attachVimMap,
      detach: detachVimMap,
      call: cmKey
    };

function _mapCommand(command) {
      defaultKeymap.unshift(command);
    }

function mapCommand(keys, type, name, args, extra) {
      var command = {keys: keys, type: type};
      command[type] = name;
      command[type + "Args"] = args;
      for (var key in extra)
        command[key] = extra[key];
      _mapCommand(command);
    }
    defineOption('insertModeEscKeysTimeout', 200, 'number');

CodeMirror.keyMap['vim-insert'] = {
      fallthrough: ['default'],
      attach: attachVimMap,
      detach: detachVimMap,
      call: cmKey
    };

CodeMirror.keyMap['vim-replace'] = {
      'Backspace': 'goCharLeft',
      fallthrough: ['vim-insert'],
      attach: attachVimMap,
      detach: detachVimMap,
      call: cmKey
    };

resetVimGlobalState();
  CodeMirror.Vim = Vim();

Vim = CodeMirror.Vim;

name += key;
 if (name.length > 1) { name = '<' + name + '>'; }
 return name;
 }
 var handleKey = Vim.handleKey.bind(Vim);
 Vim.handleKey = function(cm, key, origin) {
 return cm.operation(function() {
 return handleKey(cm, key, origin);
 }, true);
 }
 function cloneVimState(state) {
 var n = new state.constructor();
 Object.keys(state).forEach(function(key) {
 var o = state[key];
 if (Array.isArray(o))
 o = o.slice();
 else if (o && typeof o == "object" && o.constructor != Object)
 o = cloneVimState(o);
 n[key] = o;
 });
 if (state.sel) {
 n.sel = {
 head: state.sel.head && copyCursor(state.sel.head),
 anchor: state.sel.anchor && copyCursor(state.sel.anchor)
 };
 }
 return n;
 }
 function multiSelectHandleKey(cm, key, origin) {
 var isHandled = false;
 var vim = Vim.maybeInitVimState_(cm);
 var visualBlock = vim.visualBlock || vim.wasInVisualBlock;

exports.handler.defaultKeymap = defaultKeymap;
  exports.handler.actions = actions;
  exports.Vim = Vim;
});                (function() {
                    window.require(["ace/keyboard/vim"], function(m) {
                        if (typeof module == "object" && typeof exports == "object" && module) {
                            module.exports = m;
                        }
                    });
                })();