LaravelTest
5734 строки · 219.1 Кб
1// CodeMirror, copyright (c) by Marijn Haverbeke and others2// Distributed under an MIT license: https://codemirror.net/LICENSE3/**5* Supported keybindings:6* Too many to list. Refer to defaultKeymap below.7*8* Supported Ex commands:9* Refer to defaultExCommandMap below.10*11* Registers: unnamed, -, ., :, /, _, a-z, A-Z, 0-912* (Does not respect the special case for number registers when delete13* operator is made with these commands: %, (, ), , /, ?, n, N, {, } )14* TODO: Implement the remaining registers.15*16* Marks: a-z, A-Z, and 0-917* TODO: Implement the remaining special marks. They have more complex18* behavior.19*20* Events:21* 'vim-mode-change' - raised on the editor anytime the current mode changes,22* Event object: {mode: "visual", subMode: "linewise"}23*24* Code structure:25* 1. Default keymap26* 2. Variable declarations and short basic helpers27* 3. Instance (External API) implementation28* 4. Internal state tracking objects (input state, counter) implementation29* and instantiation30* 5. Key handler (the main command dispatcher) implementation31* 6. Motion, operator, and action implementations32* 7. Helper functions for the key handler, motions, operators, and actions33* 8. Set up Vim to work as a keymap for CodeMirror.34* 9. Ex command implementations.35*/36* Ex commands252* Care must be taken when adding to the default Ex command map. For any253* pair of commands that have a shared prefix, at least one of their254* shortNames must not match the prefix of the other command.255*/256var defaultExCommandMap = [257{ name: 'colorscheme', shortName: 'colo' },258{ name: 'map' },259{ name: 'imap', shortName: 'im' },260{ name: 'nmap', shortName: 'nm' },261{ name: 'vmap', shortName: 'vm' },262{ name: 'unmap' },263{ name: 'write', shortName: 'w' },264{ name: 'undo', shortName: 'u' },265{ name: 'redo', shortName: 'red' },266{ name: 'set', shortName: 'se' },267{ name: 'setlocal', shortName: 'setl' },268{ name: 'setglobal', shortName: 'setg' },269{ name: 'sort', shortName: 'sor' },270{ name: 'substitute', shortName: 's', possiblyAsync: true },271{ name: 'nohlsearch', shortName: 'noh' },272{ name: 'yank', shortName: 'y' },273{ name: 'delmarks', shortName: 'delm' },274{ name: 'registers', shortName: 'reg', excludeFromCommandHistory: true },275{ name: 'vglobal', shortName: 'v' },276{ name: 'global', shortName: 'g' }277];278* This is the outermost function called by CodeMirror, after keys have843* been mapped to their Vim equivalents.844*845* Finds a command based on the key (and cached keys if there is a846* multi-key sequence). Returns `undefined` if no key is matched, a noop847* function if a partial match is found (multi-key), and a function to848* execute the bound command if a a key is matched. The function always849* returns true.850*/851findKey: function(cm, key, origin) {852var vim = maybeInitVimState(cm);853function handleMacroRecording() {854var macroModeState = vimGlobalState.macroModeState;855if (macroModeState.isRecording) {856if (key == 'q') {857macroModeState.exitMacroRecordMode();858clearInputState(cm);859return true;860}861if (origin != 'mapping') {862logKey(macroModeState, key);863}864}865}866function handleEsc() {867if (key == '<Esc>') {868// Clear input state and get back to normal mode.869clearInputState(cm);870if (vim.visualMode) {871exitVisualMode(cm);872} else if (vim.insertMode) {873exitInsertMode(cm);874}875return true;876}877}878function doKeyToKey(keys) {879// TODO: prevent infinite recursion.880var match;881while (keys) {882// Pull off one command key, which is either a single character883// or a special sequence wrapped in '<' and '>', e.g. '<Space>'.884match = (/<\w+-.+?>|<\w+>|./).exec(keys);885key = match[0];886keys = keys.substring(match.index + key.length);887vimApi.handleKey(cm, key, 'mapping');888}889}890* Register stores information about copy and paste registers. Besides1041* text, a register must store whether it is linewise (i.e., when it is1042* pasted, should it insert itself into a new line, or should the text be1043* inserted at the cursor position.)1044*/1045function Register(text, linewise, blockwise) {1046this.clear();1047this.keyBuffer = [text || ''];1048this.insertModeChanges = [];1049this.searchQueries = [];1050this.linewise = !!linewise;1051this.blockwise = !!blockwise;1052}1053Register.prototype = {1054setText: function(text, linewise, blockwise) {1055this.keyBuffer = [text || ''];1056this.linewise = !!linewise;1057this.blockwise = !!blockwise;1058},1059pushText: function(text, linewise) {1060// if this register has ever been set to linewise, use linewise.1061if (linewise) {1062if (!this.linewise) {1063this.keyBuffer.push('\n');1064}1065this.linewise = true;1066}1067this.keyBuffer.push(text);1068},1069pushInsertModeChanges: function(changes) {1070this.insertModeChanges.push(createInsertModeChanges(changes));1071},1072pushSearchQuery: function(query) {1073this.searchQueries.push(query);1074},1075clear: function() {1076this.keyBuffer = [];1077this.insertModeChanges = [];1078this.searchQueries = [];1079this.linewise = false;1080},1081toString: function() {1082return this.keyBuffer.join('');1083}1084};1085* Defines an external register.1088*1089* The name should be a single character that will be used to reference the register.1090* The register should support setText, pushText, clear, and toString(). See Register1091* for a reference implementation.1092*/1093function defineRegister(name, register) {1094var registers = vimGlobalState.registerController.registers;1095if (!name || name.length != 1) {1096throw Error('Register name must be 1 character');1097}1098if (registers[name]) {1099throw Error('Register already defined ' + name);1100}1101registers[name] = register;1102validRegisters.push(name);1103}1104* vim registers allow you to keep many independent copy and paste buffers.1107* See http://usevim.com/2012/04/13/registers/ for an introduction.1108*1109* RegisterController keeps the state of all the registers. An initial1110* state may be passed in. The unnamed register '"' will always be1111* overridden.1112*/1113function RegisterController(registers) {1114this.registers = registers;1115this.unnamedRegister = registers['"'] = new Register();1116registers['.'] = new Register();1117registers[':'] = new Register();1118registers['/'] = new Register();1119}1120RegisterController.prototype = {1121pushText: function(registerName, operator, text, linewise, blockwise) {1122// The black hole register, "_, means delete/yank to nowhere.1123if (registerName === '_') return;1124if (linewise && text.charAt(text.length - 1) !== '\n'){1125text += '\n';1126}1127// Lowercase and uppercase registers refer to the same register.1128// Uppercase just means append.1129var register = this.isValidRegister(registerName) ?1130this.getRegister(registerName) : null;1131// if no register/an invalid register was specified, things go to the1132// default registers1133if (!register) {1134switch (operator) {1135case 'yank':1136// The 0 register contains the text from the most recent yank.1137this.registers['0'] = new Register(text, linewise, blockwise);1138break;1139case 'delete':1140case 'change':1141if (text.indexOf('\n') == -1) {1142// Delete less than 1 line. Update the small delete register.1143this.registers['-'] = new Register(text, linewise);1144} else {1145// Shift down the contents of the numbered registers and put the1146// deleted text into register 1.1147this.shiftNumericRegisters_();1148this.registers['1'] = new Register(text, linewise);1149}1150break;1151}1152// Make sure the unnamed register is set to what just happened1153this.unnamedRegister.setText(text, linewise, blockwise);1154return;1155}1156* typedef {Object{line:number,ch:number}} Cursor An object containing the1736* position of the cursor.1737*/1738// All of the functions below return Cursor objects.1739var motions = {1740moveToTopLine: function(cm, _head, motionArgs) {1741var line = getUserVisibleLines(cm).top + motionArgs.repeat -1;1742return new Pos(line, findFirstNonWhiteSpaceCharacter(cm.getLine(line)));1743},1744moveToMiddleLine: function(cm) {1745var range = getUserVisibleLines(cm);1746var line = Math.floor((range.top + range.bottom) * 0.5);1747return new Pos(line, findFirstNonWhiteSpaceCharacter(cm.getLine(line)));1748},1749moveToBottomLine: function(cm, _head, motionArgs) {1750var line = getUserVisibleLines(cm).bottom - motionArgs.repeat +1;1751return new Pos(line, findFirstNonWhiteSpaceCharacter(cm.getLine(line)));1752},1753expandToLine: function(_cm, head, motionArgs) {1754// Expands forward to end of line, and then to next line if repeat is1755// >1. Does not handle backward motion!1756var cur = head;1757return new Pos(cur.line + motionArgs.repeat - 1, Infinity);1758},1759findNext: function(cm, _head, motionArgs) {1760var state = getSearchState(cm);1761var query = state.getQuery();1762if (!query) {1763return;1764}1765var prev = !motionArgs.forward;1766// If search is initiated with ? instead of /, negate direction.1767prev = (state.isReversed()) ? !prev : prev;1768highlightSearchMatches(cm, query);1769return findNext(cm, prev/** prev */, query, motionArgs.repeat);1770},1771/**1772* Find and select the next occurrence of the search query. If the cursor is currently1773* within a match, then find and select the current match. Otherwise, find the next occurrence in the1774* appropriate direction.1775*1776* This differs from `findNext` in the following ways:1777*1778* 1. Instead of only returning the "from", this returns a "from", "to" range.1779* 2. If the cursor is currently inside a search match, this selects the current match1780* instead of the next match.1781* 3. If there is no associated operator, this will turn on visual mode.1782*/1783findAndSelectNextInclusive: function(cm, _head, motionArgs, vim, prevInputState) {1784var state = getSearchState(cm);1785var query = state.getQuery();1786* An operator acts on a text selection. It receives the list of selections2195* as input. The corresponding CodeMirror selection is guaranteed to2196* match the input selection.2197*/2198var operators = {2199change: function(cm, args, ranges) {2200var finalHead, text;2201var vim = cm.state.vim;2202var anchor = ranges[0].anchor,2203head = ranges[0].head;2204if (!vim.visualMode) {2205text = cm.getRange(anchor, head);2206var lastState = vim.lastEditInputState || {};2207if (lastState.motion == "moveByWords" && !isWhiteSpaceString(text)) {2208// Exclude trailing whitespace if the range is not all whitespace.2209var match = (/\s+$/).exec(text);2210if (match && lastState.motionArgs && lastState.motionArgs.forward) {2211head = offsetCursor(head, 0, - match[0].length);2212text = text.slice(0, - match[0].length);2213}2214}2215var prevLineEnd = new Pos(anchor.line - 1, Number.MAX_VALUE);2216var wasLastLine = cm.firstLine() == cm.lastLine();2217if (head.line > cm.lastLine() && args.linewise && !wasLastLine) {2218cm.replaceRange('', prevLineEnd, head);2219} else {2220cm.replaceRange('', anchor, head);2221}2222if (args.linewise) {2223// Push the next line back down, if there is a next line.2224if (!wasLastLine) {2225cm.setCursor(prevLineEnd);2226CodeMirror.commands.newlineAndIndent(cm);2227}2228// make sure cursor ends up at the end of the line.2229anchor.ch = Number.MAX_VALUE;2230}2231finalHead = anchor;2232} else if (args.fullLine) {2233head.ch = Number.MAX_VALUE;2234head.line--;2235cm.setSelection(anchor, head)2236text = cm.getSelection();2237cm.replaceSelection("");2238finalHead = anchor;2239} else {2240text = cm.getSelection();2241var replacement = fillArray('', ranges.length);2242cm.replaceSelections(replacement);2243finalHead = cursorMin(ranges[0].head, ranges[0].anchor);2244}2245vimGlobalState.registerController.pushText(2246args.registerName, 'change', text,2247args.linewise, ranges.length > 1);2248actions.enterInsertMode(cm, {head: finalHead}, cm.state.vim);2249},2250// delete is a javascript keyword.2251'delete': function(cm, args, ranges) {2252var finalHead, text;2253var vim = cm.state.vim;2254if (!vim.visualBlock) {2255var anchor = ranges[0].anchor,2256head = ranges[0].head;2257if (args.linewise &&2258head.line != cm.firstLine() &&2259anchor.line == cm.lastLine() &&2260anchor.line == head.line - 1) {2261// Special case for dd on last line (and first line).2262if (anchor.line == cm.firstLine()) {2263anchor.ch = 0;2264} else {2265anchor = new Pos(anchor.line - 1, lineLength(cm, anchor.line - 1));2266}2267}2268text = cm.getRange(anchor, head);2269cm.replaceRange('', anchor, head);2270finalHead = anchor;2271if (args.linewise) {2272finalHead = motions.moveToFirstNonWhiteSpaceCharacter(cm, anchor);2273}2274} else {2275text = cm.getSelection();2276var replacement = fillArray('', ranges.length);2277cm.replaceSelections(replacement);2278finalHead = cursorMin(ranges[0].head, ranges[0].anchor);2279}2280vimGlobalState.registerController.pushText(2281args.registerName, 'delete', text,2282args.linewise, vim.visualBlock);2283return clipCursorToContent(cm, finalHead);2284},2285indent: function(cm, args, ranges) {2286var vim = cm.state.vim;2287var startLine = ranges[0].anchor.line;2288var endLine = vim.visualBlock ?2289ranges[ranges.length - 1].anchor.line :2290ranges[0].head.line;2291// In visual mode, n> shifts the selection right n times, instead of2292// shifting n lines right once.2293var repeat = (vim.visualMode) ? args.repeat : 1;2294if (args.linewise) {2295// The only way to delete a newline is to delete until the start of2296// the next line, so in linewise mode evalInput will include the next2297// line. We don't want this in indent, so we go back a line.2298endLine--;2299}2300for (var i = startLine; i <= endLine; i++) {2301for (var j = 0; j < repeat; j++) {2302cm.indentLine(i, args.indentRight);2303}2304}2305return motions.moveToFirstNonWhiteSpaceCharacter(cm, ranges[0].anchor);2306},2307indentAuto: function(cm, _args, ranges) {2308cm.execCommand("indentAuto");2309return motions.moveToFirstNonWhiteSpaceCharacter(cm, ranges[0].anchor);2310},2311changeCase: function(cm, args, ranges, oldAnchor, newHead) {2312var selections = cm.getSelections();2313var swapped = [];2314var toLower = args.toLower;2315for (var j = 0; j < selections.length; j++) {2316var toSwap = selections[j];2317var text = '';2318if (toLower === true) {2319text = toSwap.toLowerCase();2320} else if (toLower === false) {2321text = toSwap.toUpperCase();2322} else {2323for (var i = 0; i < toSwap.length; i++) {2324var character = toSwap.charAt(i);2325text += isUpperCase(character) ? character.toLowerCase() :2326character.toUpperCase();2327}2328}2329swapped.push(text);2330}2331cm.replaceSelections(swapped);2332if (args.shouldMoveCursor){2333return newHead;2334} else if (!cm.state.vim.visualMode && args.linewise && ranges[0].anchor.line + 1 == ranges[0].head.line) {2335return motions.moveToFirstNonWhiteSpaceCharacter(cm, oldAnchor);2336} else if (args.linewise){2337return oldAnchor;2338} else {2339return cursorMin(ranges[0].anchor, ranges[0].head);2340}2341},2342yank: function(cm, args, ranges, oldAnchor) {2343var vim = cm.state.vim;2344var text = cm.getSelection();2345var endPos = vim.visualMode2346? cursorMin(vim.sel.anchor, vim.sel.head, ranges[0].head, ranges[0].anchor)2347: oldAnchor;2348vimGlobalState.registerController.pushText(2349args.registerName, 'yank',2350text, args.linewise, vim.visualBlock);2351return endPos;2352}2353};2354* Below are miscellaneous utility functions used by vim.js2912*/2913* Clips cursor to ensure that line is within the buffer's range2916* If includeLineBreak is true, then allow cur.ch == lineLength.2917*/2918function clipCursorToContent(cm, cur) {2919var vim = cm.state.vim;2920var includeLineBreak = vim.insertMode || vim.visualMode;2921var line = Math.min(Math.max(cm.firstLine(), cur.line), cm.lastLine() );2922var maxCh = lineLength(cm, line) - 1 + !!includeLineBreak;2923var ch = Math.min(Math.max(0, cur.ch), maxCh);2924return new Pos(line, ch);2925}2926function copyArgs(args) {2927var ret = {};2928for (var prop in args) {2929if (args.hasOwnProperty(prop)) {2930ret[prop] = args[prop];2931}2932}2933return ret;2934}2935function offsetCursor(cur, offsetLine, offsetCh) {2936if (typeof offsetLine === 'object') {2937offsetCh = offsetLine.ch;2938offsetLine = offsetLine.line;2939}2940return new Pos(cur.line + offsetLine, cur.ch + offsetCh);2941}2942function commandMatches(keys, keyMap, context, inputState) {2943// Partial matches are not applied. They inform the key handler2944// that the current key sequence is a subsequence of a valid key2945// sequence, so that the key buffer is not cleared.2946var match, partial = [], full = [];2947for (var i = 0; i < keyMap.length; i++) {2948var command = keyMap[i];2949if (context == 'insert' && command.context != 'insert' ||2950command.context && command.context != context ||2951inputState.operator && command.type == 'action' ||2952!(match = commandMatch(keys, command.keys))) { continue; }2953if (match == 'partial') { partial.push(command); }2954if (match == 'full') { full.push(command); }2955}2956return {2957partial: partial.length && partial,2958full: full.length && full2959};2960}2961function commandMatch(pressed, mapped) {2962if (mapped.slice(-11) == '<character>') {2963// Last character matches anything.2964var prefixLen = mapped.length - 11;2965var pressedPrefix = pressed.slice(0, prefixLen);2966var mappedPrefix = mapped.slice(0, prefixLen);2967return pressedPrefix == mappedPrefix && pressed.length > prefixLen ? 'full' :2968mappedPrefix.indexOf(pressedPrefix) == 0 ? 'partial' : false;2969} else {2970return pressed == mapped ? 'full' :2971mapped.indexOf(pressed) == 0 ? 'partial' : false;2972}2973}2974function lastChar(keys) {2975var match = /^.*(<[^>]+>)$/.exec(keys);2976var selectedCharacter = match ? match[1] : keys.slice(-1);2977if (selectedCharacter.length > 1){2978switch(selectedCharacter){2979case '<CR>':2980selectedCharacter='\n';2981break;2982case '<Space>':2983selectedCharacter=' ';2984break;2985default:2986selectedCharacter='';2987break;2988}2989}2990return selectedCharacter;2991}2992function repeatFn(cm, fn, repeat) {2993return function() {2994for (var i = 0; i < repeat; i++) {2995fn(cm);2996}2997};2998}2999function copyCursor(cur) {3000return new Pos(cur.line, cur.ch);3001}3002function cursorEqual(cur1, cur2) {3003return cur1.ch == cur2.ch && cur1.line == cur2.line;3004}3005function cursorIsBefore(cur1, cur2) {3006if (cur1.line < cur2.line) {3007return true;3008}3009if (cur1.line == cur2.line && cur1.ch < cur2.ch) {3010return true;3011}3012return false;3013}3014function cursorMin(cur1, cur2) {3015if (arguments.length > 2) {3016cur2 = cursorMin.apply(undefined, Array.prototype.slice.call(arguments, 1));3017}3018return cursorIsBefore(cur1, cur2) ? cur1 : cur2;3019}3020function cursorMax(cur1, cur2) {3021if (arguments.length > 2) {3022cur2 = cursorMax.apply(undefined, Array.prototype.slice.call(arguments, 1));3023}3024return cursorIsBefore(cur1, cur2) ? cur2 : cur1;3025}3026function cursorIsBetween(cur1, cur2, cur3) {3027// returns true if cur2 is between cur1 and cur3.3028var cur1before2 = cursorIsBefore(cur1, cur2);3029var cur2before3 = cursorIsBefore(cur2, cur3);3030return cur1before2 && cur2before3;3031}3032function lineLength(cm, lineNum) {3033return cm.getLine(lineNum).length;3034}3035function trim(s) {3036if (s.trim) {3037return s.trim();3038}3039return s.replace(/^\s+|\s+$/g, '');3040}3041function escapeRegex(s) {3042return s.replace(/([.?*+$\[\]\/\\(){}|\-])/g, '\\$1');3043}3044function extendLineToColumn(cm, lineNum, column) {3045var endCh = lineLength(cm, lineNum);3046var spaces = new Array(column-endCh+1).join(' ');3047cm.setCursor(new Pos(lineNum, endCh));3048cm.replaceRange(spaces, cm.getCursor());3049}3050// This functions selects a rectangular block3051// of text with selectionEnd as any of its corner3052// Height of block:3053// Difference in selectionEnd.line and first/last selection.line3054// Width of the block:3055// Distance between selectionEnd.ch and any(first considered here) selection.ch3056function selectBlock(cm, selectionEnd) {3057var selections = [], ranges = cm.listSelections();3058var head = copyCursor(cm.clipPos(selectionEnd));3059var isClipped = !cursorEqual(selectionEnd, head);3060var curHead = cm.getCursor('head');3061var primIndex = getIndex(ranges, curHead);3062var wasClipped = cursorEqual(ranges[primIndex].head, ranges[primIndex].anchor);3063var max = ranges.length - 1;3064var index = max - primIndex > primIndex ? max : 0;3065var base = ranges[index].anchor;3066* Updates the CodeMirror selection to match the provided vim selection.3203* If no arguments are given, it uses the current vim selection state.3204*/3205function updateCmSelection(cm, sel, mode) {3206var vim = cm.state.vim;3207sel = sel || vim.sel;3208var mode = mode ||3209vim.visualLine ? 'line' : vim.visualBlock ? 'block' : 'char';3210var cmSel = makeCmSelection(cm, sel, mode);3211cm.setSelections(cmSel.ranges, cmSel.primary);3212}3213function makeCmSelection(cm, sel, mode, exclusive) {3214var head = copyCursor(sel.head);3215var anchor = copyCursor(sel.anchor);3216if (mode == 'char') {3217var headOffset = !exclusive && !cursorIsBefore(sel.head, sel.anchor) ? 1 : 0;3218var anchorOffset = cursorIsBefore(sel.head, sel.anchor) ? 1 : 0;3219head = offsetCursor(sel.head, 0, headOffset);3220anchor = offsetCursor(sel.anchor, 0, anchorOffset);3221return {3222ranges: [{anchor: anchor, head: head}],3223primary: 03224};3225} else if (mode == 'line') {3226if (!cursorIsBefore(sel.head, sel.anchor)) {3227anchor.ch = 0;3228* If moveHead is set to false, the CodeMirror selection will not be3276* touched. The caller assumes the responsibility of putting the cursor3277* in the right place.3278*/3279function exitVisualMode(cm, moveHead) {3280var vim = cm.state.vim;3281if (moveHead !== false) {3282cm.setCursor(clipCursorToContent(cm, vim.sel.head));3283}3284updateLastSelection(cm, vim);3285vim.visualMode = false;3286vim.visualLine = false;3287vim.visualBlock = false;3288if (!vim.insertMode) CodeMirror.signal(cm, "vim-mode-change", {mode: "normal"});3289}3290* Depends on the following:3381*3382* - editor mode should be htmlmixedmode / xml3383* - mode/xml/xml.js should be loaded3384* - addon/fold/xml-fold.js should be loaded3385*3386* If any of the above requirements are not true, this function noops.3387*3388* This is _NOT_ a 100% accurate implementation of vim tag text objects.3389* The following caveats apply (based off cursory testing, I'm sure there3390* are other discrepancies):3391*3392* - Does not work inside comments:3393* ```3394* <!-- <div>broken</div> -->3395* ```3396* - Does not work when tags have different cases:3397* ```3398* <div>broken</DIV>3399* ```3400* - Does not work when cursor is inside a broken tag:3401* ```3402* <div><brok><en></div>3403* ```3404*/3405function expandTagUnderCursor(cm, head, inclusive) {3406var cur = head;3407if (!CodeMirror.findMatchingTag || !CodeMirror.findEnclosingTag) {3408return { start: cur, end: cur };3409}3410* Returns the boundaries of the next word. If the cursor in the middle of3557* the word, then returns the boundaries of the current word, starting at3558* the cursor. If the cursor is at the start/end of a word, and we are going3559* forward/backward, respectively, find the boundaries of the next word.3560*3561* @param {CodeMirror} cm CodeMirror object.3562* @param {Cursor} cur The cursor position.3563* @param {boolean} forward True to search forward. False to search3564* backward.3565* @param {boolean} bigWord True if punctuation count as part of the word.3566* False if only [a-zA-Z0-9] characters count as part of the word.3567* @param {boolean} emptyLineIsWord True if empty lines should be treated3568* as words.3569* @return {Object{from:number, to:number, line: number}} The boundaries of3570* the word, or null if there are no more words.3571*/3572function findWord(cm, cur, forward, bigWord, emptyLineIsWord) {3573var lineNum = cur.line;3574var pos = cur.ch;3575var line = cm.getLine(lineNum);3576var dir = forward ? 1 : -1;3577var charTests = bigWord ? bigWordCharTest: wordCharTest;3578* @param {CodeMirror} cm CodeMirror object.3634* @param {Pos} cur The position to start from.3635* @param {int} repeat Number of words to move past.3636* @param {boolean} forward True to search forward. False to search3637* backward.3638* @param {boolean} wordEnd True to move to end of word. False to move to3639* beginning of word.3640* @param {boolean} bigWord True if punctuation count as part of the word.3641* False if only alphabet characters count as part of the word.3642* @return {Cursor} The position the cursor should move to.3643*/3644function moveToWord(cm, cur, repeat, forward, wordEnd, bigWord) {3645var curStart = copyCursor(cur);3646var words = [];3647if (forward && !wordEnd || !forward && wordEnd) {3648repeat++;3649}3650// For 'e', empty lines are not considered words, go figure.3651var emptyLineIsWord = !(forward && wordEnd);3652for (var i = 0; i < repeat; i++) {3653var word = findWord(cm, cur, forward, bigWord, emptyLineIsWord);3654if (!word) {3655var eodCh = lineLength(cm, cm.lastLine());3656words.push(forward3657? {line: cm.lastLine(), from: eodCh, to: eodCh}3658: {line: 0, from: 0, to: 0});3659break;3660}3661words.push(word);3662cur = new Pos(word.line, forward ? (word.to - 1) : word.from);3663}3664var shortCircuit = words.length != repeat;3665var firstWord = words[0];3666var lastWord = words.pop();3667if (forward && !wordEnd) {3668// w3669if (!shortCircuit && (firstWord.from != curStart.ch || firstWord.line != curStart.line)) {3670// We did not start in the middle of a word. Discard the extra word at the end.3671lastWord = words.pop();3672}3673return new Pos(lastWord.line, lastWord.from);3674} else if (forward && wordEnd) {3675return new Pos(lastWord.line, lastWord.to - 1);3676} else if (!forward && wordEnd) {3677// ge3678if (!shortCircuit && (firstWord.to != curStart.ch || firstWord.line != curStart.line)) {3679// We did not start in the middle of a word. Discard the extra word at the end.3680lastWord = words.pop();3681}3682return new Pos(lastWord.line, lastWord.to);3683} else {3684// b3685return new Pos(lastWord.line, lastWord.from);3686}3687}3688Takes an index object3806{3807line: the line string,3808ln: line number,3809pos: index in line,3810dir: direction of traversal (-1 or 1)3811}3812and modifies the line, ln, and pos members to represent the3813next valid position or sets them to null if there are3814no more valid positions.3815*/3816function nextChar(cm, idx) {3817if (idx.pos + idx.dir < 0 || idx.pos + idx.dir >= idx.line.length) {3818idx.ln += idx.dir;3819if (!isLine(cm, idx.ln)) {3820idx.line = null;3821idx.ln = null;3822idx.pos = null;3823return;3824}3825idx.line = cm.getLine(idx.ln);3826idx.pos = (idx.dir > 0) ? 0 : idx.line.length - 1;3827}3828else {3829idx.pos += idx.dir;3830}3831}3832Performs one iteration of traversal in forward direction3835Returns an index object of the new location3836*/3837function forward(cm, ln, pos, dir) {3838var line = cm.getLine(ln);3839var stop = (line === "");3840Set the position to the last non whitespace character on the last3880valid line in the case that we reach the end of the document.3881*/3882var line = cm.getLine(last_valid.ln);3883last_valid.pos = 0;3884for(var i = line.length - 1; i >= 0; --i) {3885if (!isWhiteSpaceString(line[i])) {3886last_valid.pos = i;3887break;3888}3889}3890Performs one iteration of traversal in reverse direction3897Returns an index object of the new location3898*/3899function reverse(cm, ln, pos, dir) {3900var line = cm.getLine(ln);3901Set the position to the first non whitespace character on the last3944valid line in the case that we reach the beginning of the document.3945*/3946var line = cm.getLine(last_valid.ln);3947last_valid.pos = 0;3948for(var i = 0; i < line.length; ++i) {3949if (!isWhiteSpaceString(line[i])) {3950last_valid.pos = i;3951break;3952}3953}3954return last_valid;3955}3956* Extract the regular expression from the query and return a Regexp object.4259* Returns null if the query is blank.4260* If ignoreCase is passed in, the Regexp object will have the 'i' flag set.4261* If smartCase is passed in, and the query contains upper case letters,4262* then ignoreCase is overridden, and the 'i' flag will not be set.4263* If the query contains the /i in the flag part of the regular expression,4264* then both ignoreCase and smartCase are ignored, and 'i' will be passed4265* through to the Regex object.4266*/4267function parseQuery(query, ignoreCase, smartCase) {4268// First update the last search register4269var lastSearchRegister = vimGlobalState.registerController.getRegister('/');4270lastSearchRegister.setText(query);4271// Check if the query is already a regex.4272if (query instanceof RegExp) { return query; }4273// First try to extract regex + flags from the input. If no flags found,4274// extract just the regex. IE does not accept flags directly defined in4275// the regex string in the form /regex/flags4276var slashes = findUnescapedSlashes(query);4277var regexPart;4278var forceIgnoreCase;4279if (!slashes.length) {4280// Query looks like 'regexp'4281regexPart = query;4282} else {4283// Query looks like 'regexp/...'4284regexPart = query.substring(0, slashes[0]);4285var flagsPart = query.substring(slashes[0]);4286forceIgnoreCase = (flagsPart.indexOf('i') != -1);4287}4288if (!regexPart) {4289return null;4290}4291if (!getOption('pcre')) {4292regexPart = translateRegex(regexPart);4293}4294if (smartCase) {4295ignoreCase = (/^[^A-Z]*$/).test(regexPart);4296}4297var regexp = new RegExp(regexPart,4298(ignoreCase || forceIgnoreCase) ? 'im' : 'm');4299return regexp;4300}4301* dom - Document Object Manipulator4304* Usage:4305* dom('<tag>'|<node>[, ...{<attributes>|<$styles>}|<child-node>|'<text>'])4306* Examples:4307* dom('div', {id:'xyz'}, dom('p', 'CM rocks!', {$color:'red'}))4308* dom(document.head, dom('script', 'alert("hello!")'))4309* Not supported:4310* dom('p', ['arrays are objects'], Error('objects specify attributes'))4311*/4312function dom(n) {4313if (typeof n === 'string') n = document.createElement(n);4314for (var a, i = 1; i < arguments.length; i++) {4315if (!(a = arguments[i])) continue;4316if (typeof a !== 'object') a = document.createTextNode(a);4317if (a.nodeType) n.appendChild(a);4318else for (var key in a) {4319if (!Object.prototype.hasOwnProperty.call(a, key)) continue;4320if (key[0] === '$') n.style[key.slice(1)] = a[key];4321else n.setAttribute(key, a[key]);4322}4323}4324return n;4325}4326* Pretty much the same as `findNext`, except for the following differences:4480*4481* 1. Before starting the search, move to the previous search. This way if our cursor is4482* already inside a match, we should return the current match.4483* 2. Rather than only returning the cursor's from, we return the cursor's from and to as a tuple.4484*/4485function findNextFromAndToInclusive(cm, prev, query, repeat, vim) {4486if (repeat === undefined) { repeat = 1; }4487return cm.operation(function() {4488var pos = cm.getCursor();4489var cursor = cm.getSearchCursor(query, pos);4490* Check if pos is in the specified range, INCLUSIVE.4525* Range can be specified with 1 or 2 arguments.4526* If the first range argument is an array, treat it as an array of line4527* numbers. Match pos against any of the lines.4528* If the first range argument is a number,4529* if there is only 1 range argument, check if pos has the same line4530* number4531* if there are 2 range arguments, then check if pos is in between the two4532* range arguments.4533*/4534function isInRange(pos, start, end) {4535if (typeof pos != 'number') {4536// Assume it is a cursor position. Get the line number.4537pos = pos.line;4538}4539if (start instanceof Array) {4540return inArray(pos, start);4541} else {4542if (typeof end == 'number') {4543return (pos >= start && pos <= end);4544} else {4545return pos == start;4546}4547}4548}4549function getUserVisibleLines(cm) {4550var scrollInfo = cm.getScrollInfo();4551var occludeToleranceTop = 6;4552var occludeToleranceBottom = 10;4553var from = cm.coordsChar({left:0, top: occludeToleranceTop + scrollInfo.top}, 'local');4554var bottomY = scrollInfo.clientHeight - occludeToleranceBottom + scrollInfo.top;4555var to = cm.coordsChar({left:0, top: bottomY}, 'local');4556return {top: from.line, bottom: to.line};4557}4558* @param {CodeMirror} cm CodeMirror instance we are in.5271* @param {boolean} confirm Whether to confirm each replace.5272* @param {Cursor} lineStart Line to start replacing from.5273* @param {Cursor} lineEnd Line to stop replacing at.5274* @param {RegExp} query Query for performing matches with.5275* @param {string} replaceWith Text to replace matches with. May contain $1,5276* $2, etc for replacing captured groups using JavaScript replace.5277* @param {function()} callback A callback for when the replace is done.5278*/5279function doReplace(cm, confirm, global, lineStart, lineEnd, searchCursor, query,5280replaceWith, callback) {5281// Set up all the functions.5282cm.state.vim.exMode = true;5283var done = false;5284var lastPos, modifiedLineNumber, joined;5285function replaceAll() {5286cm.operation(function() {5287while (!done) {5288replace();5289next();5290}5291stop();5292});5293}5294function replace() {5295var text = cm.getRange(searchCursor.from(), searchCursor.to());5296var newText = text.replace(query, replaceWith);5297var unmodifiedLineNumber = searchCursor.to().line;5298searchCursor.replace(newText);5299modifiedLineNumber = searchCursor.to().line;5300lineEnd += modifiedLineNumber - unmodifiedLineNumber;5301joined = modifiedLineNumber < unmodifiedLineNumber;5302}5303function findNextValidMatch() {5304var lastMatchTo = lastPos && copyCursor(searchCursor.to());5305var match = searchCursor.findNext();5306if (match && !match[0] && lastMatchTo && cursorEqual(searchCursor.from(), lastMatchTo)) {5307match = searchCursor.findNext();5308}5309return match;5310}5311function next() {5312// The below only loops to skip over multiple occurrences on the same5313// line when 'global' is not true.5314while(findNextValidMatch() &&5315isInRange(searchCursor.from(), lineStart, lineEnd)) {5316if (!global && searchCursor.from().line == modifiedLineNumber && !joined) {5317continue;5318}5319cm.scrollIntoView(searchCursor.from(), 30);5320cm.setSelection(searchCursor.from(), searchCursor.to());5321lastPos = searchCursor.from();5322done = false;5323return;5324}5325done = true;5326}5327function stop(close) {5328if (close) { close(); }5329cm.focus();5330if (lastPos) {5331cm.setCursor(lastPos);5332var vim = cm.state.vim;5333vim.exMode = false;5334vim.lastHPos = vim.lastHSPos = lastPos.ch;5335}5336if (callback) { callback(); }5337}5338function onPromptKeyDown(e, _value, close) {5339// Swallow all keys.5340CodeMirror.e_stop(e);5341var keyName = CodeMirror.keyName(e);5342switch (keyName) {5343case 'Y':5344replace(); next(); break;5345case 'N':5346next(); break;5347case 'A':5348// replaceAll contains a call to close of its own. We don't want it5349// to fire too early or multiple times.5350var savedCallback = callback;5351callback = undefined;5352cm.operation(replaceAll);5353callback = savedCallback;5354break;5355case 'L':5356replace();5357// fall through and exit.5358case 'Q':5359case 'Esc':5360case 'Ctrl-C':5361case 'Ctrl-[':5362stop(close);5363break;5364}5365if (done) { stop(close); }5366return true;5367}5368* Listens for changes made in insert mode.5521* Should only be active in insert mode.5522*/5523function onChange(cm, changeObj) {5524var macroModeState = vimGlobalState.macroModeState;5525var lastChange = macroModeState.lastInsertModeChanges;5526if (!macroModeState.isPlaying) {5527while(changeObj) {5528lastChange.expectCursorActivityForChange = true;5529if (lastChange.ignoreCount > 1) {5530lastChange.ignoreCount--;5531} else if (changeObj.origin == '+input' || changeObj.origin == 'paste'5532|| changeObj.origin === undefined /* only in testing */) {5533var selectionCount = cm.listSelections().length;5534if (selectionCount > 1)5535lastChange.ignoreCount = selectionCount;5536var text = changeObj.text.join('\n');5537if (lastChange.maybeReset) {5538lastChange.changes = [];5539lastChange.maybeReset = false;5540}5541if (text) {5542if (cm.state.overwrite && !/\n/.test(text)) {5543lastChange.changes.push([text]);5544} else {5545lastChange.changes.push(text);5546}5547}5548}5549// Change objects may be chained with next.5550changeObj = changeObj.next;5551}5552}5553}5554* Listens for any kind of cursor activity on CodeMirror.5557*/5558function onCursorActivity(cm) {5559var vim = cm.state.vim;5560if (vim.insertMode) {5561// Tracking cursor activity in insert mode (for macro support).5562var macroModeState = vimGlobalState.macroModeState;5563if (macroModeState.isPlaying) { return; }5564var lastChange = macroModeState.lastInsertModeChanges;5565if (lastChange.expectCursorActivityForChange) {5566lastChange.expectCursorActivityForChange = false;5567} else {5568// Cursor moved outside the context of an edit. Reset the change.5569lastChange.maybeReset = true;5570}5571} else if (!cm.curOp.isVimOp) {5572handleExternalSelection(cm, vim);5573}5574}5575function handleExternalSelection(cm, vim) {5576var anchor = cm.getCursor('anchor');5577var head = cm.getCursor('head');5578// Enter or exit visual mode to match mouse selection.5579if (vim.visualMode && !cm.somethingSelected()) {5580exitVisualMode(cm, false);5581} else if (!vim.visualMode && !vim.insertMode && cm.somethingSelected()) {5582vim.visualMode = true;5583vim.visualLine = false;5584CodeMirror.signal(cm, "vim-mode-change", {mode: "visual"});5585}5586if (vim.visualMode) {5587// Bind CodeMirror selection model to vim selection model.5588// Mouse selections are considered visual characterwise.5589var headOffset = !cursorIsBefore(head, anchor) ? -1 : 0;5590var anchorOffset = cursorIsBefore(head, anchor) ? -1 : 0;5591head = offsetCursor(head, 0, headOffset);5592anchor = offsetCursor(anchor, 0, anchorOffset);5593vim.sel = {5594anchor: anchor,5595head: head5596};5597updateMark(cm, vim, '<', cursorMin(head, anchor));5598updateMark(cm, vim, '>', cursorMax(head, anchor));5599} else if (!vim.insertMode) {5600// Reset lastHPos if selection was modified by something outside of vim mode e.g. by mouse.5601vim.lastHPos = cm.getCursor().ch;5602}5603}5604* Handles raw key down events from the text area.5612* - Should only be active in insert mode.5613* - For recording deletes in insert mode.5614*/5615function onKeyEventTargetKeyDown(e) {5616var macroModeState = vimGlobalState.macroModeState;5617var lastChange = macroModeState.lastInsertModeChanges;5618var keyName = CodeMirror.keyName(e);5619if (!keyName) { return; }5620function onKeyFound() {5621if (lastChange.maybeReset) {5622lastChange.changes = [];5623lastChange.maybeReset = false;5624}5625lastChange.changes.push(new InsertModeKey(keyName));5626return true;5627}5628if (keyName.indexOf('Delete') != -1 || keyName.indexOf('Backspace') != -1) {5629CodeMirror.lookupKey(keyName, 'vim-insert', onKeyFound);5630}5631}5632* Repeats the last edit, which includes exactly 1 command and at most 15635* insert. Operator and motion commands are read from lastEditInputState,5636* while action commands are read from lastEditActionCommand.5637*5638* If repeatForInsert is true, then the function was called by5639* exitInsertMode to repeat the insert mode changes the user just made. The5640* corresponding enterInsertMode call was made with a count.5641*/5642function repeatLastEdit(cm, vim, repeat, repeatForInsert) {5643var macroModeState = vimGlobalState.macroModeState;5644macroModeState.isPlaying = true;5645var isAction = !!vim.lastEditActionCommand;5646var cachedInputState = vim.inputState;5647function repeatCommand() {5648if (isAction) {5649commandDispatcher.processAction(cm, vim, vim.lastEditActionCommand);5650} else {5651commandDispatcher.evalInput(cm, vim);5652}5653}5654function repeatInsert(repeat) {5655if (macroModeState.lastInsertModeChanges.changes.length > 0) {5656// For some reason, repeat cw in desktop VIM does not repeat5657// insert mode changes. Will conform to that behavior.5658repeat = !vim.lastEditActionCommand ? 1 : repeat;5659var changeObject = macroModeState.lastInsertModeChanges;5660repeatInsertModeChanges(cm, changeObject.changes, repeat);5661}5662}5663vim.inputState = vim.lastEditInputState;5664if (isAction && vim.lastEditActionCommand.interlaceInsertRepeat) {5665// o and O repeat have to be interlaced with insert repeats so that the5666// insertions appear on separate lines instead of the last line.5667for (var i = 0; i < repeat; i++) {5668repeatCommand();5669repeatInsert(1);5670}5671} else {5672if (!repeatForInsert) {5673// Hack to get the cursor to end up at the right place. If I is5674// repeated in insert mode repeat, cursor will be 1 insert5675// change set left of where it should be.5676repeatCommand();5677}5678repeatInsert(repeat);5679}5680vim.inputState = cachedInputState;5681if (vim.insertMode && !repeatForInsert) {5682// Don't exit insert mode twice. If repeatForInsert is set, then we5683// were called by an exitInsertMode call lower on the stack.5684exitInsertMode(cm);5685}5686macroModeState.isPlaying = false;5687}5688