3a591b218bda77eade02913e9938ce5a1c0f2ead
[WebKit-https.git] / Source / WebInspectorUI / UserInterface / External / CodeMirror / codemirror.js
1 // CodeMirror is the only global var we claim
2 window.CodeMirror = (function() {
3   "use strict";
4
5   // BROWSER SNIFFING
6
7   // Crude, but necessary to handle a number of hard-to-feature-detect
8   // bugs and behavior differences.
9   var gecko = /gecko\/\d/i.test(navigator.userAgent);
10   var ie = /MSIE \d/.test(navigator.userAgent);
11   var ie_lt8 = ie && (document.documentMode == null || document.documentMode < 8);
12   var ie_lt9 = ie && (document.documentMode == null || document.documentMode < 9);
13   var webkit = /WebKit\//.test(navigator.userAgent);
14   var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(navigator.userAgent);
15   var chrome = /Chrome\//.test(navigator.userAgent);
16   var opera = /Opera\//.test(navigator.userAgent);
17   var safari = /Apple Computer/.test(navigator.vendor);
18   var khtml = /KHTML\//.test(navigator.userAgent);
19   var mac_geLion = /Mac OS X 1\d\D([7-9]|\d\d)\D/.test(navigator.userAgent);
20   var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(navigator.userAgent);
21   var phantom = /PhantomJS/.test(navigator.userAgent);
22
23   var ios = /AppleWebKit/.test(navigator.userAgent) && /Mobile\/\w+/.test(navigator.userAgent);
24   // This is woefully incomplete. Suggestions for alternative methods welcome.
25   var mobile = ios || /Android|webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(navigator.userAgent);
26   var mac = ios || /Mac/.test(navigator.platform);
27   var windows = /windows/i.test(navigator.platform);
28
29   var opera_version = opera && navigator.userAgent.match(/Version\/(\d*\.\d*)/);
30   if (opera_version) opera_version = Number(opera_version[1]);
31   // Some browsers use the wrong event properties to signal cmd/ctrl on OS X
32   var flipCtrlCmd = mac && (qtwebkit || opera && (opera_version == null || opera_version < 12.11));
33   var captureMiddleClick = gecko || (ie && !ie_lt9);
34
35   // Optimize some code when these features are not used
36   var sawReadOnlySpans = false, sawCollapsedSpans = false;
37
38   // CONSTRUCTOR
39
40   function CodeMirror(place, options) {
41     if (!(this instanceof CodeMirror)) return new CodeMirror(place, options);
42
43     this.options = options = options || {};
44     // Determine effective options based on given values and defaults.
45     for (var opt in defaults) if (!options.hasOwnProperty(opt) && defaults.hasOwnProperty(opt))
46       options[opt] = defaults[opt];
47     setGuttersForLineNumbers(options);
48
49     var docStart = typeof options.value == "string" ? 0 : options.value.first;
50     var display = this.display = makeDisplay(place, docStart);
51     display.wrapper.CodeMirror = this;
52     updateGutters(this);
53     if (options.autofocus && !mobile) focusInput(this);
54
55     this.state = {keyMaps: [],
56                   overlays: [],
57                   modeGen: 0,
58                   overwrite: false, focused: false,
59                   suppressEdits: false, pasteIncoming: false,
60                   draggingText: false,
61                   highlight: new Delayed()};
62
63     themeChanged(this);
64     if (options.lineWrapping)
65       this.display.wrapper.className += " CodeMirror-wrap";
66
67     var doc = options.value;
68     if (typeof doc == "string") doc = new Doc(options.value, options.mode);
69     operation(this, attachDoc)(this, doc);
70
71     // Override magic textarea content restore that IE sometimes does
72     // on our hidden textarea on reload
73     if (ie) setTimeout(bind(resetInput, this, true), 20);
74
75     registerEventHandlers(this);
76     // IE throws unspecified error in certain cases, when
77     // trying to access activeElement before onload
78     var hasFocus; try { hasFocus = (document.activeElement == display.input); } catch(e) { }
79     if (hasFocus || (options.autofocus && !mobile)) setTimeout(bind(onFocus, this), 20);
80     else onBlur(this);
81
82     operation(this, function() {
83       for (var opt in optionHandlers)
84         if (optionHandlers.propertyIsEnumerable(opt))
85           optionHandlers[opt](this, options[opt], Init);
86       for (var i = 0; i < initHooks.length; ++i) initHooks[i](this);
87     })();
88   }
89
90   // DISPLAY CONSTRUCTOR
91
92   function makeDisplay(place, docStart) {
93     var d = {};
94
95     var input = d.input = elt("textarea", null, null, "position: absolute; padding: 0; width: 1px; height: 1em; outline: none; font-size: 4px;");
96     if (webkit) input.style.width = "1000px";
97     else input.setAttribute("wrap", "off");
98     // if border: 0; -- iOS fails to open keyboard (issue #1287)
99     if (ios) input.style.border = "1px solid black";
100     input.setAttribute("autocorrect", "off"); input.setAttribute("autocapitalize", "off"); input.setAttribute("spellcheck", "false");
101
102     // Wraps and hides input textarea
103     d.inputDiv = elt("div", [input], null, "overflow: hidden; position: relative; width: 3px; height: 0px;");
104     // The actual fake scrollbars.
105     d.scrollbarH = elt("div", [elt("div", null, null, "height: 1px")], "CodeMirror-hscrollbar");
106     d.scrollbarV = elt("div", [elt("div", null, null, "width: 1px")], "CodeMirror-vscrollbar");
107     d.scrollbarFiller = elt("div", null, "CodeMirror-scrollbar-filler");
108     d.gutterFiller = elt("div", null, "CodeMirror-gutter-filler");
109     // DIVs containing the selection and the actual code
110     d.lineDiv = elt("div", null, "CodeMirror-code");
111     d.selectionDiv = elt("div", null, null, "position: relative; z-index: 1");
112     // Blinky cursor, and element used to ensure cursor fits at the end of a line
113     d.cursor = elt("div", "\u00a0", "CodeMirror-cursor");
114     // Secondary cursor, shown when on a 'jump' in bi-directional text
115     d.otherCursor = elt("div", "\u00a0", "CodeMirror-cursor CodeMirror-secondarycursor");
116     // Used to measure text size
117     d.measure = elt("div", null, "CodeMirror-measure");
118     // Wraps everything that needs to exist inside the vertically-padded coordinate system
119     d.lineSpace = elt("div", [d.measure, d.selectionDiv, d.lineDiv, d.cursor, d.otherCursor],
120                          null, "position: relative; outline: none");
121     // Moved around its parent to cover visible view
122     d.mover = elt("div", [elt("div", [d.lineSpace], "CodeMirror-lines")], null, "position: relative");
123     // Set to the height of the text, causes scrolling
124     d.sizer = elt("div", [d.mover], "CodeMirror-sizer");
125     // D is needed because behavior of elts with overflow: auto and padding is inconsistent across browsers
126     d.heightForcer = elt("div", null, null, "position: absolute; height: " + scrollerCutOff + "px; width: 1px;");
127     // Will contain the gutters, if any
128     d.gutters = elt("div", null, "CodeMirror-gutters");
129     d.lineGutter = null;
130     // Provides scrolling
131     d.scroller = elt("div", [d.sizer, d.heightForcer, d.gutters], "CodeMirror-scroll");
132     d.scroller.setAttribute("tabIndex", "-1");
133     // The element in which the editor lives.
134     d.wrapper = elt("div", [d.inputDiv, d.scrollbarH, d.scrollbarV,
135                             d.scrollbarFiller, d.gutterFiller, d.scroller], "CodeMirror");
136     // Work around IE7 z-index bug
137     if (ie_lt8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0; }
138     if (place.appendChild) place.appendChild(d.wrapper); else place(d.wrapper);
139
140     // Needed to hide big blue blinking cursor on Mobile Safari
141     if (ios) input.style.width = "0px";
142     if (!webkit) d.scroller.draggable = true;
143     // Needed to handle Tab key in KHTML
144     if (khtml) { d.inputDiv.style.height = "1px"; d.inputDiv.style.position = "absolute"; }
145     // Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8).
146     else if (ie_lt8) d.scrollbarH.style.minWidth = d.scrollbarV.style.minWidth = "18px";
147
148     // Current visible range (may be bigger than the view window).
149     d.viewOffset = d.lastSizeC = 0;
150     d.showingFrom = d.showingTo = docStart;
151
152     // Used to only resize the line number gutter when necessary (when
153     // the amount of lines crosses a boundary that makes its width change)
154     d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null;
155     // See readInput and resetInput
156     d.prevInput = "";
157     // Set to true when a non-horizontal-scrolling widget is added. As
158     // an optimization, widget aligning is skipped when d is false.
159     d.alignWidgets = false;
160     // Flag that indicates whether we currently expect input to appear
161     // (after some event like 'keypress' or 'input') and are polling
162     // intensively.
163     d.pollingFast = false;
164     // Self-resetting timeout for the poller
165     d.poll = new Delayed();
166
167     d.cachedCharWidth = d.cachedTextHeight = null;
168     d.measureLineCache = [];
169     d.measureLineCachePos = 0;
170
171     // Tracks when resetInput has punted to just putting a short
172     // string instead of the (large) selection.
173     d.inaccurateSelection = false;
174
175     // Tracks the maximum line length so that the horizontal scrollbar
176     // can be kept static when scrolling.
177     d.maxLine = null;
178     d.maxLineLength = 0;
179     d.maxLineChanged = false;
180
181     // Used for measuring wheel scrolling granularity
182     d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null;
183
184     return d;
185   }
186
187   // STATE UPDATES
188
189   // Used to get the editor into a consistent state again when options change.
190
191   function loadMode(cm) {
192     cm.doc.mode = CodeMirror.getMode(cm.options, cm.doc.modeOption);
193     cm.doc.iter(function(line) {
194       if (line.stateAfter) line.stateAfter = null;
195       if (line.styles) line.styles = null;
196     });
197     cm.doc.frontier = cm.doc.first;
198     startWorker(cm, 100);
199     cm.state.modeGen++;
200     if (cm.curOp) regChange(cm);
201   }
202
203   function wrappingChanged(cm) {
204     if (cm.options.lineWrapping) {
205       cm.display.wrapper.className += " CodeMirror-wrap";
206       cm.display.sizer.style.minWidth = "";
207     } else {
208       cm.display.wrapper.className = cm.display.wrapper.className.replace(" CodeMirror-wrap", "");
209       computeMaxLength(cm);
210     }
211     estimateLineHeights(cm);
212     regChange(cm);
213     clearCaches(cm);
214     setTimeout(function(){updateScrollbars(cm);}, 100);
215   }
216
217   function estimateHeight(cm) {
218     var th = textHeight(cm.display), wrapping = cm.options.lineWrapping;
219     var perLine = wrapping && Math.max(5, cm.display.scroller.clientWidth / charWidth(cm.display) - 3);
220     return function(line) {
221       if (lineIsHidden(cm.doc, line))
222         return 0;
223       else if (wrapping)
224         return (Math.ceil(line.text.length / perLine) || 1) * th;
225       else
226         return th;
227     };
228   }
229
230   function estimateLineHeights(cm) {
231     var doc = cm.doc, est = estimateHeight(cm);
232     doc.iter(function(line) {
233       var estHeight = est(line);
234       if (estHeight != line.height) updateLineHeight(line, estHeight);
235     });
236   }
237
238   function keyMapChanged(cm) {
239     var style = keyMap[cm.options.keyMap].style;
240     cm.display.wrapper.className = cm.display.wrapper.className.replace(/\s*cm-keymap-\S+/g, "") +
241       (style ? " cm-keymap-" + style : "");
242   }
243
244   function themeChanged(cm) {
245     cm.display.wrapper.className = cm.display.wrapper.className.replace(/\s*cm-s-\S+/g, "") +
246       cm.options.theme.replace(/(^|\s)\s*/g, " cm-s-");
247     clearCaches(cm);
248   }
249
250   function guttersChanged(cm) {
251     updateGutters(cm);
252     regChange(cm);
253     setTimeout(function(){alignHorizontally(cm);}, 20);
254   }
255
256   function updateGutters(cm) {
257     var gutters = cm.display.gutters, specs = cm.options.gutters;
258     removeChildren(gutters);
259     for (var i = 0; i < specs.length; ++i) {
260       var gutterClass = specs[i];
261       var gElt = gutters.appendChild(elt("div", null, "CodeMirror-gutter " + gutterClass));
262       if (gutterClass == "CodeMirror-linenumbers") {
263         cm.display.lineGutter = gElt;
264         gElt.style.width = (cm.display.lineNumWidth || 1) + "px";
265       }
266     }
267     gutters.style.display = i ? "" : "none";
268   }
269
270   function lineLength(doc, line) {
271     if (line.height == 0) return 0;
272     var len = line.text.length, merged, cur = line;
273     while (merged = collapsedSpanAtStart(cur)) {
274       var found = merged.find();
275       cur = getLine(doc, found.from.line);
276       len += found.from.ch - found.to.ch;
277     }
278     cur = line;
279     while (merged = collapsedSpanAtEnd(cur)) {
280       var found = merged.find();
281       len -= cur.text.length - found.from.ch;
282       cur = getLine(doc, found.to.line);
283       len += cur.text.length - found.to.ch;
284     }
285     return len;
286   }
287
288   function computeMaxLength(cm) {
289     var d = cm.display, doc = cm.doc;
290     d.maxLine = getLine(doc, doc.first);
291     d.maxLineLength = lineLength(doc, d.maxLine);
292     d.maxLineChanged = true;
293     doc.iter(function(line) {
294       var len = lineLength(doc, line);
295       if (len > d.maxLineLength) {
296         d.maxLineLength = len;
297         d.maxLine = line;
298       }
299     });
300   }
301
302   // Make sure the gutters options contains the element
303   // "CodeMirror-linenumbers" when the lineNumbers option is true.
304   function setGuttersForLineNumbers(options) {
305     var found = false;
306     for (var i = 0; i < options.gutters.length; ++i) {
307       if (options.gutters[i] == "CodeMirror-linenumbers") {
308         if (options.lineNumbers) found = true;
309         else options.gutters.splice(i--, 1);
310       }
311     }
312     if (!found && options.lineNumbers)
313       options.gutters.push("CodeMirror-linenumbers");
314   }
315
316   // SCROLLBARS
317
318   // Re-synchronize the fake scrollbars with the actual size of the
319   // content. Optionally force a scrollTop.
320   function updateScrollbars(cm) {
321     var d = cm.display, docHeight = cm.doc.height;
322     var totalHeight = docHeight + paddingVert(d);
323     d.sizer.style.minHeight = d.heightForcer.style.top = totalHeight + "px";
324     d.gutters.style.height = Math.max(totalHeight, d.scroller.clientHeight - scrollerCutOff) + "px";
325     var scrollHeight = Math.max(totalHeight, d.scroller.scrollHeight);
326     var needsH = d.scroller.scrollWidth > d.scroller.clientWidth;
327     var needsV = scrollHeight > d.scroller.clientHeight;
328     if (needsV) {
329       d.scrollbarV.style.display = "block";
330       d.scrollbarV.style.bottom = needsH ? scrollbarWidth(d.measure) + "px" : "0";
331       d.scrollbarV.firstChild.style.height =
332         (scrollHeight - d.scroller.clientHeight + d.scrollbarV.clientHeight) + "px";
333     } else d.scrollbarV.style.display = "";
334     if (needsH) {
335       d.scrollbarH.style.display = "block";
336       d.scrollbarH.style.right = needsV ? scrollbarWidth(d.measure) + "px" : "0";
337       d.scrollbarH.firstChild.style.width =
338         (d.scroller.scrollWidth - d.scroller.clientWidth + d.scrollbarH.clientWidth) + "px";
339     } else d.scrollbarH.style.display = "";
340     if (needsH && needsV) {
341       d.scrollbarFiller.style.display = "block";
342       d.scrollbarFiller.style.height = d.scrollbarFiller.style.width = scrollbarWidth(d.measure) + "px";
343     } else d.scrollbarFiller.style.display = "";
344     if (needsH && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) {
345       d.gutterFiller.style.display = "block";
346       d.gutterFiller.style.height = scrollbarWidth(d.measure) + "px";
347       d.gutterFiller.style.width = d.gutters.offsetWidth + "px";
348     } else d.gutterFiller.style.display = "";
349
350     if (mac_geLion && scrollbarWidth(d.measure) === 0)
351       d.scrollbarV.style.minWidth = d.scrollbarH.style.minHeight = mac_geMountainLion ? "18px" : "12px";
352   }
353
354   function visibleLines(display, doc, viewPort) {
355     var top = display.scroller.scrollTop, height = display.wrapper.clientHeight;
356     if (typeof viewPort == "number") top = viewPort;
357     else if (viewPort) {top = viewPort.top; height = viewPort.bottom - viewPort.top;}
358     top = Math.floor(top - paddingTop(display));
359     var bottom = Math.ceil(top + height);
360     return {from: lineAtHeight(doc, top), to: lineAtHeight(doc, bottom)};
361   }
362
363   // LINE NUMBERS
364
365   function alignHorizontally(cm) {
366     var display = cm.display;
367     if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) return;
368     var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft;
369     var gutterW = display.gutters.offsetWidth, l = comp + "px";
370     for (var n = display.lineDiv.firstChild; n; n = n.nextSibling) if (n.alignable) {
371       for (var i = 0, a = n.alignable; i < a.length; ++i) a[i].style.left = l;
372     }
373     if (cm.options.fixedGutter)
374       display.gutters.style.left = (comp + gutterW) + "px";
375   }
376
377   function maybeUpdateLineNumberWidth(cm) {
378     if (!cm.options.lineNumbers) return false;
379     var doc = cm.doc, last = lineNumberFor(cm.options, doc.first + doc.size - 1), display = cm.display;
380     if (last.length != display.lineNumChars) {
381       var test = display.measure.appendChild(elt("div", [elt("div", last)],
382                                                  "CodeMirror-linenumber CodeMirror-gutter-elt"));
383       var innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW;
384       display.lineGutter.style.width = "";
385       display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding);
386       display.lineNumWidth = display.lineNumInnerWidth + padding;
387       display.lineNumChars = display.lineNumInnerWidth ? last.length : -1;
388       display.lineGutter.style.width = display.lineNumWidth + "px";
389       return true;
390     }
391     return false;
392   }
393
394   function lineNumberFor(options, i) {
395     return String(options.lineNumberFormatter(i + options.firstLineNumber));
396   }
397   function compensateForHScroll(display) {
398     return getRect(display.scroller).left - getRect(display.sizer).left;
399   }
400
401   // DISPLAY DRAWING
402
403   function updateDisplay(cm, changes, viewPort) {
404     var oldFrom = cm.display.showingFrom, oldTo = cm.display.showingTo, updated;
405     var visible = visibleLines(cm.display, cm.doc, viewPort);
406     for (;;) {
407       if (!updateDisplayInner(cm, changes, visible)) break;
408       updated = true;
409       updateSelection(cm);
410       updateScrollbars(cm);
411
412       // Clip forced viewport to actual scrollable area
413       if (viewPort)
414         viewPort = Math.min(cm.display.scroller.scrollHeight - cm.display.scroller.clientHeight,
415                             typeof viewPort == "number" ? viewPort : viewPort.top);
416       visible = visibleLines(cm.display, cm.doc, viewPort);
417       if (visible.from >= cm.display.showingFrom && visible.to <= cm.display.showingTo)
418         break;
419       changes = [];
420     }
421
422     if (updated) {
423       signalLater(cm, "update", cm);
424       if (cm.display.showingFrom != oldFrom || cm.display.showingTo != oldTo)
425         signalLater(cm, "viewportChange", cm, cm.display.showingFrom, cm.display.showingTo);
426     }
427     return updated;
428   }
429
430   // Uses a set of changes plus the current scroll position to
431   // determine which DOM updates have to be made, and makes the
432   // updates.
433   function updateDisplayInner(cm, changes, visible) {
434     var display = cm.display, doc = cm.doc;
435     if (!display.wrapper.clientWidth) {
436       display.showingFrom = display.showingTo = doc.first;
437       display.viewOffset = 0;
438       return;
439     }
440
441     // Bail out if the visible area is already rendered and nothing changed.
442     if (changes.length == 0 &&
443         visible.from > display.showingFrom && visible.to < display.showingTo)
444       return;
445
446     if (maybeUpdateLineNumberWidth(cm))
447       changes = [{from: doc.first, to: doc.first + doc.size}];
448     var gutterW = display.sizer.style.marginLeft = display.gutters.offsetWidth + "px";
449     display.scrollbarH.style.left = cm.options.fixedGutter ? gutterW : "0";
450
451     // Used to determine which lines need their line numbers updated
452     var positionsChangedFrom = Infinity;
453     if (cm.options.lineNumbers)
454       for (var i = 0; i < changes.length; ++i)
455         if (changes[i].diff) { positionsChangedFrom = changes[i].from; break; }
456
457     var end = doc.first + doc.size;
458     var from = Math.max(visible.from - cm.options.viewportMargin, doc.first);
459     var to = Math.min(end, visible.to + cm.options.viewportMargin);
460     if (display.showingFrom < from && from - display.showingFrom < 20) from = Math.max(doc.first, display.showingFrom);
461     if (display.showingTo > to && display.showingTo - to < 20) to = Math.min(end, display.showingTo);
462     if (sawCollapsedSpans) {
463       from = lineNo(visualLine(doc, getLine(doc, from)));
464       while (to < end && lineIsHidden(doc, getLine(doc, to))) ++to;
465     }
466
467     // Create a range of theoretically intact lines, and punch holes
468     // in that using the change info.
469     var intact = [{from: Math.max(display.showingFrom, doc.first),
470                    to: Math.min(display.showingTo, end)}];
471     if (intact[0].from >= intact[0].to) intact = [];
472     else intact = computeIntact(intact, changes);
473     // When merged lines are present, we might have to reduce the
474     // intact ranges because changes in continued fragments of the
475     // intact lines do require the lines to be redrawn.
476     if (sawCollapsedSpans)
477       for (var i = 0; i < intact.length; ++i) {
478         var range = intact[i], merged;
479         while (merged = collapsedSpanAtEnd(getLine(doc, range.to - 1))) {
480           var newTo = merged.find().from.line;
481           if (newTo > range.from) range.to = newTo;
482           else { intact.splice(i--, 1); break; }
483         }
484       }
485
486     // Clip off the parts that won't be visible
487     var intactLines = 0;
488     for (var i = 0; i < intact.length; ++i) {
489       var range = intact[i];
490       if (range.from < from) range.from = from;
491       if (range.to > to) range.to = to;
492       if (range.from >= range.to) intact.splice(i--, 1);
493       else intactLines += range.to - range.from;
494     }
495     if (intactLines == to - from && from == display.showingFrom && to == display.showingTo) {
496       updateViewOffset(cm);
497       return;
498     }
499     intact.sort(function(a, b) {return a.from - b.from;});
500
501     // Avoid crashing on IE's "unspecified error" when in iframes
502     try {
503       var focused = document.activeElement;
504     } catch(e) {}
505     if (intactLines < (to - from) * .7) display.lineDiv.style.display = "none";
506     patchDisplay(cm, from, to, intact, positionsChangedFrom);
507     display.lineDiv.style.display = "";
508     if (focused && document.activeElement != focused && focused.offsetHeight) focused.focus();
509
510     var different = from != display.showingFrom || to != display.showingTo ||
511       display.lastSizeC != display.wrapper.clientHeight;
512     // This is just a bogus formula that detects when the editor is
513     // resized or the font size changes.
514     if (different) display.lastSizeC = display.wrapper.clientHeight;
515     display.showingFrom = from; display.showingTo = to;
516     startWorker(cm, 100);
517
518     var prevBottom = display.lineDiv.offsetTop;
519     for (var node = display.lineDiv.firstChild, height; node; node = node.nextSibling) if (node.lineObj) {
520       if (ie_lt8) {
521         var bot = node.offsetTop + node.offsetHeight;
522         height = bot - prevBottom;
523         prevBottom = bot;
524       } else {
525         var box = getRect(node);
526         height = box.bottom - box.top;
527       }
528       var diff = node.lineObj.height - height;
529       if (height < 2) height = textHeight(display);
530       if (diff > .001 || diff < -.001) {
531         updateLineHeight(node.lineObj, height);
532         var widgets = node.lineObj.widgets;
533         if (widgets) for (var i = 0; i < widgets.length; ++i)
534           widgets[i].height = widgets[i].node.offsetHeight;
535       }
536     }
537     updateViewOffset(cm);
538
539     return true;
540   }
541
542   function updateViewOffset(cm) {
543     var off = cm.display.viewOffset = heightAtLine(cm, getLine(cm.doc, cm.display.showingFrom));
544     // Position the mover div to align with the current virtual scroll position
545     cm.display.mover.style.top = off + "px";
546   }
547
548   function computeIntact(intact, changes) {
549     for (var i = 0, l = changes.length || 0; i < l; ++i) {
550       var change = changes[i], intact2 = [], diff = change.diff || 0;
551       for (var j = 0, l2 = intact.length; j < l2; ++j) {
552         var range = intact[j];
553         if (change.to <= range.from && change.diff) {
554           intact2.push({from: range.from + diff, to: range.to + diff});
555         } else if (change.to <= range.from || change.from >= range.to) {
556           intact2.push(range);
557         } else {
558           if (change.from > range.from)
559             intact2.push({from: range.from, to: change.from});
560           if (change.to < range.to)
561             intact2.push({from: change.to + diff, to: range.to + diff});
562         }
563       }
564       intact = intact2;
565     }
566     return intact;
567   }
568
569   function getDimensions(cm) {
570     var d = cm.display, left = {}, width = {};
571     for (var n = d.gutters.firstChild, i = 0; n; n = n.nextSibling, ++i) {
572       left[cm.options.gutters[i]] = n.offsetLeft;
573       width[cm.options.gutters[i]] = n.offsetWidth;
574     }
575     return {fixedPos: compensateForHScroll(d),
576             gutterTotalWidth: d.gutters.offsetWidth,
577             gutterLeft: left,
578             gutterWidth: width,
579             wrapperWidth: d.wrapper.clientWidth};
580   }
581
582   function patchDisplay(cm, from, to, intact, updateNumbersFrom) {
583     var dims = getDimensions(cm);
584     var display = cm.display, lineNumbers = cm.options.lineNumbers;
585     if (!intact.length && (!webkit || !cm.display.currentWheelTarget))
586       removeChildren(display.lineDiv);
587     var container = display.lineDiv, cur = container.firstChild;
588
589     function rm(node) {
590       var next = node.nextSibling;
591       if (webkit && mac && cm.display.currentWheelTarget == node) {
592         node.style.display = "none";
593         node.lineObj = null;
594       } else {
595         node.parentNode.removeChild(node);
596       }
597       return next;
598     }
599
600     var nextIntact = intact.shift(), lineN = from;
601     cm.doc.iter(from, to, function(line) {
602       if (nextIntact && nextIntact.to == lineN) nextIntact = intact.shift();
603       if (lineIsHidden(cm.doc, line)) {
604         if (line.height != 0) updateLineHeight(line, 0);
605         if (line.widgets && cur.previousSibling) for (var i = 0; i < line.widgets.length; ++i)
606           if (line.widgets[i].showIfHidden) {
607             var prev = cur.previousSibling;
608             if (/pre/i.test(prev.nodeName)) {
609               var wrap = elt("div", null, null, "position: relative");
610               prev.parentNode.replaceChild(wrap, prev);
611               wrap.appendChild(prev);
612               prev = wrap;
613             }
614             var wnode = prev.appendChild(elt("div", [line.widgets[i].node], "CodeMirror-linewidget"));
615             positionLineWidget(line.widgets[i], wnode, prev, dims);
616           }
617       } else if (nextIntact && nextIntact.from <= lineN && nextIntact.to > lineN) {
618         // This line is intact. Skip to the actual node. Update its
619         // line number if needed.
620         while (cur.lineObj != line) cur = rm(cur);
621         if (lineNumbers && updateNumbersFrom <= lineN && cur.lineNumber)
622           setTextContent(cur.lineNumber, lineNumberFor(cm.options, lineN));
623         cur = cur.nextSibling;
624       } else {
625         // For lines with widgets, make an attempt to find and reuse
626         // the existing element, so that widgets aren't needlessly
627         // removed and re-inserted into the dom
628         if (line.widgets) for (var j = 0, search = cur, reuse; search && j < 20; ++j, search = search.nextSibling)
629           if (search.lineObj == line && /div/i.test(search.nodeName)) { reuse = search; break; }
630         // This line needs to be generated.
631         var lineNode = buildLineElement(cm, line, lineN, dims, reuse);
632         if (lineNode != reuse) {
633           container.insertBefore(lineNode, cur);
634         } else {
635           while (cur != reuse) cur = rm(cur);
636           cur = cur.nextSibling;
637         }
638
639         lineNode.lineObj = line;
640       }
641       ++lineN;
642     });
643     while (cur) cur = rm(cur);
644   }
645
646   function buildLineElement(cm, line, lineNo, dims, reuse) {
647     var lineElement = lineContent(cm, line);
648     var markers = line.gutterMarkers, display = cm.display, wrap;
649
650     if (!cm.options.lineNumbers && !markers && !line.bgClass && !line.wrapClass && !line.widgets)
651       return lineElement;
652
653     // Lines with gutter elements, widgets or a background class need
654     // to be wrapped again, and have the extra elements added to the
655     // wrapper div
656
657     if (reuse) {
658       reuse.alignable = null;
659       var isOk = true, widgetsSeen = 0;
660       for (var n = reuse.firstChild, next; n; n = next) {
661         next = n.nextSibling;
662         if (!/\bCodeMirror-linewidget\b/.test(n.className)) {
663           reuse.removeChild(n);
664         } else {
665           for (var i = 0, first = true; i < line.widgets.length; ++i) {
666             var widget = line.widgets[i], isFirst = false;
667             if (!widget.above) { isFirst = first; first = false; }
668             if (widget.node == n.firstChild) {
669               positionLineWidget(widget, n, reuse, dims);
670               ++widgetsSeen;
671               if (isFirst) reuse.insertBefore(lineElement, n);
672               break;
673             }
674           }
675           if (i == line.widgets.length) { isOk = false; break; }
676         }
677       }
678       if (isOk && widgetsSeen == line.widgets.length) {
679         wrap = reuse;
680         reuse.className = line.wrapClass || "";
681       }
682     }
683     if (!wrap) {
684       wrap = elt("div", null, line.wrapClass, "position: relative");
685       wrap.appendChild(lineElement);
686     }
687     // Kludge to make sure the styled element lies behind the selection (by z-index)
688     if (line.bgClass)
689       wrap.insertBefore(elt("div", null, line.bgClass + " CodeMirror-linebackground"), wrap.firstChild);
690     if (cm.options.lineNumbers || markers) {
691       var gutterWrap = wrap.insertBefore(elt("div", null, null, "position: absolute; left: " +
692                                              (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + "px"),
693                                          wrap.firstChild);
694       if (cm.options.fixedGutter) (wrap.alignable || (wrap.alignable = [])).push(gutterWrap);
695       if (cm.options.lineNumbers && (!markers || !markers["CodeMirror-linenumbers"]))
696         wrap.lineNumber = gutterWrap.appendChild(
697           elt("div", lineNumberFor(cm.options, lineNo),
698               "CodeMirror-linenumber CodeMirror-gutter-elt",
699               "left: " + dims.gutterLeft["CodeMirror-linenumbers"] + "px; width: "
700               + display.lineNumInnerWidth + "px"));
701       if (markers)
702         for (var k = 0; k < cm.options.gutters.length; ++k) {
703           var id = cm.options.gutters[k], found = markers.hasOwnProperty(id) && markers[id];
704           if (found)
705             gutterWrap.appendChild(elt("div", [found], "CodeMirror-gutter-elt", "left: " +
706                                        dims.gutterLeft[id] + "px; width: " + dims.gutterWidth[id] + "px"));
707         }
708     }
709     if (ie_lt8) wrap.style.zIndex = 2;
710     if (line.widgets && wrap != reuse) for (var i = 0, ws = line.widgets; i < ws.length; ++i) {
711       var widget = ws[i], node = elt("div", [widget.node], "CodeMirror-linewidget");
712       positionLineWidget(widget, node, wrap, dims);
713       if (widget.above)
714         wrap.insertBefore(node, cm.options.lineNumbers && line.height != 0 ? gutterWrap : lineElement);
715       else
716         wrap.appendChild(node);
717       signalLater(widget, "redraw");
718     }
719     return wrap;
720   }
721
722   function positionLineWidget(widget, node, wrap, dims) {
723     if (widget.noHScroll) {
724       (wrap.alignable || (wrap.alignable = [])).push(node);
725       var width = dims.wrapperWidth;
726       node.style.left = dims.fixedPos + "px";
727       if (!widget.coverGutter) {
728         width -= dims.gutterTotalWidth;
729         node.style.paddingLeft = dims.gutterTotalWidth + "px";
730       }
731       node.style.width = width + "px";
732     }
733     if (widget.coverGutter) {
734       node.style.zIndex = 5;
735       node.style.position = "relative";
736       if (!widget.noHScroll) node.style.marginLeft = -dims.gutterTotalWidth + "px";
737     }
738   }
739
740   // SELECTION / CURSOR
741
742   function updateSelection(cm) {
743     var display = cm.display;
744     var collapsed = posEq(cm.doc.sel.from, cm.doc.sel.to);
745     if (collapsed || cm.options.showCursorWhenSelecting)
746       updateSelectionCursor(cm);
747     else
748       display.cursor.style.display = display.otherCursor.style.display = "none";
749     if (!collapsed)
750       updateSelectionRange(cm);
751     else
752       display.selectionDiv.style.display = "none";
753
754     // Move the hidden textarea near the cursor to prevent scrolling artifacts
755     if (cm.options.moveInputWithCursor) {
756       var headPos = cursorCoords(cm, cm.doc.sel.head, "div");
757       var wrapOff = getRect(display.wrapper), lineOff = getRect(display.lineDiv);
758       display.inputDiv.style.top = Math.max(0, Math.min(display.wrapper.clientHeight - 10,
759                                                         headPos.top + lineOff.top - wrapOff.top)) + "px";
760       display.inputDiv.style.left = Math.max(0, Math.min(display.wrapper.clientWidth - 10,
761                                                          headPos.left + lineOff.left - wrapOff.left)) + "px";
762     }
763   }
764
765   // No selection, plain cursor
766   function updateSelectionCursor(cm) {
767     var display = cm.display, pos = cursorCoords(cm, cm.doc.sel.head, "div");
768     display.cursor.style.left = pos.left + "px";
769     display.cursor.style.top = pos.top + "px";
770     display.cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + "px";
771     display.cursor.style.display = "";
772
773     if (pos.other) {
774       display.otherCursor.style.display = "";
775       display.otherCursor.style.left = pos.other.left + "px";
776       display.otherCursor.style.top = pos.other.top + "px";
777       display.otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + "px";
778     } else { display.otherCursor.style.display = "none"; }
779   }
780
781   // Highlight selection
782   function updateSelectionRange(cm) {
783     var display = cm.display, doc = cm.doc, sel = cm.doc.sel;
784     var fragment = document.createDocumentFragment();
785     var clientWidth = display.lineSpace.offsetWidth, pl = paddingLeft(cm.display);
786
787     function add(left, top, width, bottom) {
788       if (top < 0) top = 0;
789       fragment.appendChild(elt("div", null, "CodeMirror-selected", "position: absolute; left: " + left +
790                                "px; top: " + top + "px; width: " + (width == null ? clientWidth - left : width) +
791                                "px; height: " + (bottom - top) + "px"));
792     }
793
794     function drawForLine(line, fromArg, toArg, retTop) {
795       var lineObj = getLine(doc, line);
796       var lineLen = lineObj.text.length, rVal = retTop ? Infinity : -Infinity;
797       function coords(ch) {
798         return charCoords(cm, Pos(line, ch), "div", lineObj);
799       }
800
801       iterateBidiSections(getOrder(lineObj), fromArg || 0, toArg == null ? lineLen : toArg, function(from, to, dir) {
802         var leftPos = coords(from), rightPos, left, right;
803         if (from == to) {
804           rightPos = leftPos;
805           left = right = leftPos.left;
806         } else {
807           rightPos = coords(to - 1);
808           if (dir == "rtl") { var tmp = leftPos; leftPos = rightPos; rightPos = tmp; }
809           left = leftPos.left;
810           right = rightPos.right;
811         }
812         if (rightPos.top - leftPos.top > 3) { // Different lines, draw top part
813           add(left, leftPos.top, null, leftPos.bottom);
814           left = pl;
815           if (leftPos.bottom < rightPos.top) add(left, leftPos.bottom, null, rightPos.top);
816         }
817         if (toArg == null && to == lineLen) right = clientWidth;
818         if (fromArg == null && from == 0) left = pl;
819         rVal = retTop ? Math.min(rightPos.top, rVal) : Math.max(rightPos.bottom, rVal);
820         if (left < pl + 1) left = pl;
821         add(left, rightPos.top, right - left, rightPos.bottom);
822       });
823       return rVal;
824     }
825
826     if (sel.from.line == sel.to.line) {
827       drawForLine(sel.from.line, sel.from.ch, sel.to.ch);
828     } else {
829       var fromObj = getLine(doc, sel.from.line);
830       var cur = fromObj, merged, path = [sel.from.line, sel.from.ch], singleLine;
831       while (merged = collapsedSpanAtEnd(cur)) {
832         var found = merged.find();
833         path.push(found.from.ch, found.to.line, found.to.ch);
834         if (found.to.line == sel.to.line) {
835           path.push(sel.to.ch);
836           singleLine = true;
837           break;
838         }
839         cur = getLine(doc, found.to.line);
840       }
841
842       // This is a single, merged line
843       if (singleLine) {
844         for (var i = 0; i < path.length; i += 3)
845           drawForLine(path[i], path[i+1], path[i+2]);
846       } else {
847         var middleTop, middleBot, toObj = getLine(doc, sel.to.line);
848         if (sel.from.ch)
849           // Draw the first line of selection.
850           middleTop = drawForLine(sel.from.line, sel.from.ch, null, false);
851         else
852           // Simply include it in the middle block.
853           middleTop = heightAtLine(cm, fromObj) - display.viewOffset;
854
855         if (!sel.to.ch)
856           middleBot = heightAtLine(cm, toObj) - display.viewOffset;
857         else
858           middleBot = drawForLine(sel.to.line, collapsedSpanAtStart(toObj) ? null : 0, sel.to.ch, true);
859
860         if (middleTop < middleBot) add(pl, middleTop, null, middleBot);
861       }
862     }
863
864     removeChildrenAndAdd(display.selectionDiv, fragment);
865     display.selectionDiv.style.display = "";
866   }
867
868   // Cursor-blinking
869   function restartBlink(cm) {
870     if (!cm.state.focused) return;
871     var display = cm.display;
872     clearInterval(display.blinker);
873     var on = true;
874     display.cursor.style.visibility = display.otherCursor.style.visibility = "";
875     display.blinker = setInterval(function() {
876       display.cursor.style.visibility = display.otherCursor.style.visibility = (on = !on) ? "" : "hidden";
877     }, cm.options.cursorBlinkRate);
878   }
879
880   // HIGHLIGHT WORKER
881
882   function startWorker(cm, time) {
883     if (cm.doc.mode.startState && cm.doc.frontier < cm.display.showingTo)
884       cm.state.highlight.set(time, bind(highlightWorker, cm));
885   }
886
887   function highlightWorker(cm) {
888     var doc = cm.doc;
889     if (doc.frontier < doc.first) doc.frontier = doc.first;
890     if (doc.frontier >= cm.display.showingTo) return;
891     var end = +new Date + cm.options.workTime;
892     var state = copyState(doc.mode, getStateBefore(cm, doc.frontier));
893     var changed = [], prevChange;
894     doc.iter(doc.frontier, Math.min(doc.first + doc.size, cm.display.showingTo + 500), function(line) {
895       if (doc.frontier >= cm.display.showingFrom) { // Visible
896         var oldStyles = line.styles;
897         line.styles = highlightLine(cm, line, state);
898         var ischange = !oldStyles || oldStyles.length != line.styles.length;
899         for (var i = 0; !ischange && i < oldStyles.length; ++i) ischange = oldStyles[i] != line.styles[i];
900         if (ischange) {
901           if (prevChange && prevChange.end == doc.frontier) prevChange.end++;
902           else changed.push(prevChange = {start: doc.frontier, end: doc.frontier + 1});
903         }
904         line.stateAfter = copyState(doc.mode, state);
905       } else {
906         processLine(cm, line, state);
907         line.stateAfter = doc.frontier % 5 == 0 ? copyState(doc.mode, state) : null;
908       }
909       ++doc.frontier;
910       if (+new Date > end) {
911         startWorker(cm, cm.options.workDelay);
912         return true;
913       }
914     });
915     if (changed.length)
916       operation(cm, function() {
917         for (var i = 0; i < changed.length; ++i)
918           regChange(this, changed[i].start, changed[i].end);
919       })();
920   }
921
922   // Finds the line to start with when starting a parse. Tries to
923   // find a line with a stateAfter, so that it can start with a
924   // valid state. If that fails, it returns the line with the
925   // smallest indentation, which tends to need the least context to
926   // parse correctly.
927   function findStartLine(cm, n) {
928     var minindent, minline, doc = cm.doc;
929     for (var search = n, lim = n - 100; search > lim; --search) {
930       if (search <= doc.first) return doc.first;
931       var line = getLine(doc, search - 1);
932       if (line.stateAfter) return search;
933       var indented = countColumn(line.text, null, cm.options.tabSize);
934       if (minline == null || minindent > indented) {
935         minline = search - 1;
936         minindent = indented;
937       }
938     }
939     return minline;
940   }
941
942   function getStateBefore(cm, n) {
943     var doc = cm.doc, display = cm.display;
944       if (!doc.mode.startState) return true;
945     var pos = findStartLine(cm, n), state = pos > doc.first && getLine(doc, pos-1).stateAfter;
946     if (!state) state = startState(doc.mode);
947     else state = copyState(doc.mode, state);
948     doc.iter(pos, n, function(line) {
949       processLine(cm, line, state);
950       var save = pos == n - 1 || pos % 5 == 0 || pos >= display.showingFrom && pos < display.showingTo;
951       line.stateAfter = save ? copyState(doc.mode, state) : null;
952       ++pos;
953     });
954     return state;
955   }
956
957   // POSITION MEASUREMENT
958
959   function paddingTop(display) {return display.lineSpace.offsetTop;}
960   function paddingVert(display) {return display.mover.offsetHeight - display.lineSpace.offsetHeight;}
961   function paddingLeft(display) {
962     var e = removeChildrenAndAdd(display.measure, elt("pre", null, null, "text-align: left")).appendChild(elt("span", "x"));
963     return e.offsetLeft;
964   }
965
966   function measureChar(cm, line, ch, data) {
967     var dir = -1;
968     data = data || measureLine(cm, line);
969
970     for (var pos = ch;; pos += dir) {
971       var r = data[pos];
972       if (r) break;
973       if (dir < 0 && pos == 0) dir = 1;
974     }
975     return {left: pos < ch ? r.right : r.left,
976             right: pos > ch ? r.left : r.right,
977             top: r.top, bottom: r.bottom};
978   }
979
980   function findCachedMeasurement(cm, line) {
981     var cache = cm.display.measureLineCache;
982     for (var i = 0; i < cache.length; ++i) {
983       var memo = cache[i];
984       if (memo.text == line.text && memo.markedSpans == line.markedSpans &&
985           cm.display.scroller.clientWidth == memo.width &&
986           memo.classes == line.textClass + "|" + line.bgClass + "|" + line.wrapClass)
987         return memo;
988     }
989   }
990
991   function clearCachedMeasurement(cm, line) {
992     var exists = findCachedMeasurement(cm, line);
993     if (exists) exists.text = exists.measure = exists.markedSpans = null;
994   }
995
996   function measureLine(cm, line) {
997     // First look in the cache
998     var cached = findCachedMeasurement(cm, line);
999     if (cached) return cached.measure;
1000
1001     // Failing that, recompute and store result in cache
1002     var measure = measureLineInner(cm, line);
1003     var cache = cm.display.measureLineCache;
1004     var memo = {text: line.text, width: cm.display.scroller.clientWidth,
1005                 markedSpans: line.markedSpans, measure: measure,
1006                 classes: line.textClass + "|" + line.bgClass + "|" + line.wrapClass};
1007     if (cache.length == 16) cache[++cm.display.measureLineCachePos % 16] = memo;
1008     else cache.push(memo);
1009     return measure;
1010   }
1011
1012   function measureLineInner(cm, line) {
1013     var display = cm.display, measure = emptyArray(line.text.length);
1014     var pre = lineContent(cm, line, measure);
1015
1016     // IE does not cache element positions of inline elements between
1017     // calls to getBoundingClientRect. This makes the loop below,
1018     // which gathers the positions of all the characters on the line,
1019     // do an amount of layout work quadratic to the number of
1020     // characters. When line wrapping is off, we try to improve things
1021     // by first subdividing the line into a bunch of inline blocks, so
1022     // that IE can reuse most of the layout information from caches
1023     // for those blocks. This does interfere with line wrapping, so it
1024     // doesn't work when wrapping is on, but in that case the
1025     // situation is slightly better, since IE does cache line-wrapping
1026     // information and only recomputes per-line.
1027     if (ie && !ie_lt8 && !cm.options.lineWrapping && pre.childNodes.length > 100) {
1028       var fragment = document.createDocumentFragment();
1029       var chunk = 10, n = pre.childNodes.length;
1030       for (var i = 0, chunks = Math.ceil(n / chunk); i < chunks; ++i) {
1031         var wrap = elt("div", null, null, "display: inline-block");
1032         for (var j = 0; j < chunk && n; ++j) {
1033           wrap.appendChild(pre.firstChild);
1034           --n;
1035         }
1036         fragment.appendChild(wrap);
1037       }
1038       pre.appendChild(fragment);
1039     }
1040
1041     removeChildrenAndAdd(display.measure, pre);
1042
1043     var outer = getRect(display.lineDiv);
1044     var vranges = [], data = emptyArray(line.text.length), maxBot = pre.offsetHeight;
1045     // Work around an IE7/8 bug where it will sometimes have randomly
1046     // replaced our pre with a clone at this point.
1047     if (ie_lt9 && display.measure.first != pre)
1048       removeChildrenAndAdd(display.measure, pre);
1049
1050     for (var i = 0, cur; i < measure.length; ++i) if (cur = measure[i]) {
1051       var size = getRect(cur);
1052       var top = Math.max(0, size.top - outer.top), bot = Math.min(size.bottom - outer.top, maxBot);
1053       for (var j = 0; j < vranges.length; j += 2) {
1054         var rtop = vranges[j], rbot = vranges[j+1];
1055         if (rtop > bot || rbot < top) continue;
1056         if (rtop <= top && rbot >= bot ||
1057             top <= rtop && bot >= rbot ||
1058             Math.min(bot, rbot) - Math.max(top, rtop) >= (bot - top) >> 1) {
1059           vranges[j] = Math.min(top, rtop);
1060           vranges[j+1] = Math.max(bot, rbot);
1061           break;
1062         }
1063       }
1064       if (j == vranges.length) vranges.push(top, bot);
1065       var right = size.right;
1066       if (cur.measureRight) right = getRect(cur.measureRight).left;
1067       data[i] = {left: size.left - outer.left, right: right - outer.left, top: j};
1068     }
1069     for (var i = 0, cur; i < data.length; ++i) if (cur = data[i]) {
1070       var vr = cur.top;
1071       cur.top = vranges[vr]; cur.bottom = vranges[vr+1];
1072     }
1073
1074     return data;
1075   }
1076
1077   function measureLineWidth(cm, line) {
1078     var hasBadSpan = false;
1079     if (line.markedSpans) for (var i = 0; i < line.markedSpans; ++i) {
1080       var sp = line.markedSpans[i];
1081       if (sp.collapsed && (sp.to == null || sp.to == line.text.length)) hasBadSpan = true;
1082     }
1083     var cached = !hasBadSpan && findCachedMeasurement(cm, line);
1084     if (cached) return measureChar(cm, line, line.text.length, cached.measure).right;
1085
1086     var pre = lineContent(cm, line);
1087     var end = pre.appendChild(zeroWidthElement(cm.display.measure));
1088     removeChildrenAndAdd(cm.display.measure, pre);
1089     return getRect(end).right - getRect(cm.display.lineDiv).left;
1090   }
1091
1092   function clearCaches(cm) {
1093     cm.display.measureLineCache.length = cm.display.measureLineCachePos = 0;
1094     cm.display.cachedCharWidth = cm.display.cachedTextHeight = null;
1095     if (!cm.options.lineWrapping) cm.display.maxLineChanged = true;
1096     cm.display.lineNumChars = null;
1097   }
1098
1099   // Context is one of "line", "div" (display.lineDiv), "local"/null (editor), or "page"
1100   function intoCoordSystem(cm, lineObj, rect, context) {
1101     if (lineObj.widgets) for (var i = 0; i < lineObj.widgets.length; ++i) if (lineObj.widgets[i].above) {
1102       var size = widgetHeight(lineObj.widgets[i]);
1103       rect.top += size; rect.bottom += size;
1104     }
1105     if (context == "line") return rect;
1106     if (!context) context = "local";
1107     var yOff = heightAtLine(cm, lineObj);
1108     if (context != "local") yOff -= cm.display.viewOffset;
1109     if (context == "page") {
1110       var lOff = getRect(cm.display.lineSpace);
1111       yOff += lOff.top + (window.pageYOffset || (document.documentElement || document.body).scrollTop);
1112       var xOff = lOff.left + (window.pageXOffset || (document.documentElement || document.body).scrollLeft);
1113       rect.left += xOff; rect.right += xOff;
1114     }
1115     rect.top += yOff; rect.bottom += yOff;
1116     return rect;
1117   }
1118
1119   // Context may be "window", "page", "div", or "local"/null
1120   // Result is in "div" coords
1121   function fromCoordSystem(cm, coords, context) {
1122     if (context == "div") return coords;
1123     var left = coords.left, top = coords.top;
1124     if (context == "page") {
1125       left -= window.pageXOffset || (document.documentElement || document.body).scrollLeft;
1126       top -= window.pageYOffset || (document.documentElement || document.body).scrollTop;
1127     }
1128     var lineSpaceBox = getRect(cm.display.lineSpace);
1129     left -= lineSpaceBox.left;
1130     top -= lineSpaceBox.top;
1131     if (context == "local" || !context) {
1132       var editorBox = getRect(cm.display.wrapper);
1133       left += editorBox.left;
1134       top += editorBox.top;
1135     }
1136     return {left: left, top: top};
1137   }
1138
1139   function charCoords(cm, pos, context, lineObj) {
1140     if (!lineObj) lineObj = getLine(cm.doc, pos.line);
1141     return intoCoordSystem(cm, lineObj, measureChar(cm, lineObj, pos.ch), context);
1142   }
1143
1144   function cursorCoords(cm, pos, context, lineObj, measurement) {
1145     lineObj = lineObj || getLine(cm.doc, pos.line);
1146     if (!measurement) measurement = measureLine(cm, lineObj);
1147     function get(ch, right) {
1148       var m = measureChar(cm, lineObj, ch, measurement);
1149       if (right) m.left = m.right; else m.right = m.left;
1150       return intoCoordSystem(cm, lineObj, m, context);
1151     }
1152     function getBidi(ch, partPos) {
1153       var part = order[partPos], right = part.level % 2;
1154       if (ch == bidiLeft(part) && partPos && part.level < order[partPos - 1].level) {
1155         part = order[--partPos];
1156         ch = bidiRight(part) - (part.level % 2 ? 0 : 1);
1157         right = true;
1158       } else if (ch == bidiRight(part) && partPos < order.length - 1 && part.level < order[partPos + 1].level) {
1159         part = order[++partPos];
1160         ch = bidiLeft(part) - part.level % 2;
1161         right = false;
1162       }
1163       if (right && ch == part.to && ch > part.from) return get(ch - 1);
1164       return get(ch, right);
1165     }
1166     var order = getOrder(lineObj), ch = pos.ch;
1167     if (!order) return get(ch);
1168     var partPos = getBidiPartAt(order, ch);
1169     var val = getBidi(ch, partPos);
1170     if (bidiOther != null) val.other = getBidi(ch, bidiOther);
1171     return val;
1172   }
1173
1174   function PosMaybeOutside(line, ch, outside) {
1175     var pos = new Pos(line, ch);
1176     if (outside) pos.outside = true;
1177     return pos;
1178   }
1179
1180   // Coords must be lineSpace-local
1181   function coordsChar(cm, x, y) {
1182     var doc = cm.doc;
1183     y += cm.display.viewOffset;
1184     if (y < 0) return PosMaybeOutside(doc.first, 0, true);
1185     var lineNo = lineAtHeight(doc, y), last = doc.first + doc.size - 1;
1186     if (lineNo > last)
1187       return PosMaybeOutside(doc.first + doc.size - 1, getLine(doc, last).text.length, true);
1188     if (x < 0) x = 0;
1189
1190     for (;;) {
1191       var lineObj = getLine(doc, lineNo);
1192       var found = coordsCharInner(cm, lineObj, lineNo, x, y);
1193       var merged = collapsedSpanAtEnd(lineObj);
1194       var mergedPos = merged && merged.find();
1195       if (merged && found.ch >= mergedPos.from.ch)
1196         lineNo = mergedPos.to.line;
1197       else
1198         return found;
1199     }
1200   }
1201
1202   function coordsCharInner(cm, lineObj, lineNo, x, y) {
1203     var innerOff = y - heightAtLine(cm, lineObj);
1204     var wrongLine = false, adjust = 2 * cm.display.wrapper.clientWidth;
1205     var measurement = measureLine(cm, lineObj);
1206
1207     function getX(ch) {
1208       var sp = cursorCoords(cm, Pos(lineNo, ch), "line",
1209                             lineObj, measurement);
1210       wrongLine = true;
1211       if (innerOff > sp.bottom) return sp.left - adjust;
1212       else if (innerOff < sp.top) return sp.left + adjust;
1213       else wrongLine = false;
1214       return sp.left;
1215     }
1216
1217     var bidi = getOrder(lineObj), dist = lineObj.text.length;
1218     var from = lineLeft(lineObj), to = lineRight(lineObj);
1219     var fromX = getX(from), fromOutside = wrongLine, toX = getX(to), toOutside = wrongLine;
1220
1221     if (x > toX) return PosMaybeOutside(lineNo, to, toOutside);
1222     // Do a binary search between these bounds.
1223     for (;;) {
1224       if (bidi ? to == from || to == moveVisually(lineObj, from, 1) : to - from <= 1) {
1225         var after = x - fromX < toX - x, ch = after ? from : to;
1226         while (isExtendingChar.test(lineObj.text.charAt(ch))) ++ch;
1227         var pos = PosMaybeOutside(lineNo, ch, after ? fromOutside : toOutside);
1228         pos.after = after;
1229         return pos;
1230       }
1231       var step = Math.ceil(dist / 2), middle = from + step;
1232       if (bidi) {
1233         middle = from;
1234         for (var i = 0; i < step; ++i) middle = moveVisually(lineObj, middle, 1);
1235       }
1236       var middleX = getX(middle);
1237       if (middleX > x) {to = middle; toX = middleX; if (toOutside = wrongLine) toX += 1000; dist = step;}
1238       else {from = middle; fromX = middleX; fromOutside = wrongLine; dist -= step;}
1239     }
1240   }
1241
1242   var measureText;
1243   function textHeight(display) {
1244     if (display.cachedTextHeight != null) return display.cachedTextHeight;
1245     if (measureText == null) {
1246       measureText = elt("pre");
1247       // Measure a bunch of lines, for browsers that compute
1248       // fractional heights.
1249       for (var i = 0; i < 49; ++i) {
1250         measureText.appendChild(document.createTextNode("x"));
1251         measureText.appendChild(elt("br"));
1252       }
1253       measureText.appendChild(document.createTextNode("x"));
1254     }
1255     removeChildrenAndAdd(display.measure, measureText);
1256     var height = measureText.offsetHeight / 50;
1257     if (height > 3) display.cachedTextHeight = height;
1258     removeChildren(display.measure);
1259     return height || 1;
1260   }
1261
1262   function charWidth(display) {
1263     if (display.cachedCharWidth != null) return display.cachedCharWidth;
1264     var anchor = elt("span", "x");
1265     var pre = elt("pre", [anchor]);
1266     removeChildrenAndAdd(display.measure, pre);
1267     var width = anchor.offsetWidth;
1268     if (width > 2) display.cachedCharWidth = width;
1269     return width || 10;
1270   }
1271
1272   // OPERATIONS
1273
1274   // Operations are used to wrap changes in such a way that each
1275   // change won't have to update the cursor and display (which would
1276   // be awkward, slow, and error-prone), but instead updates are
1277   // batched and then all combined and executed at once.
1278
1279   var nextOpId = 0;
1280   function startOperation(cm) {
1281     cm.curOp = {
1282       // An array of ranges of lines that have to be updated. See
1283       // updateDisplay.
1284       changes: [],
1285       updateInput: null,
1286       userSelChange: null,
1287       textChanged: null,
1288       selectionChanged: false,
1289       cursorActivity: false,
1290       updateMaxLine: false,
1291       updateScrollPos: false,
1292       id: ++nextOpId
1293     };
1294     if (!delayedCallbackDepth++) delayedCallbacks = [];
1295   }
1296
1297   function endOperation(cm) {
1298     var op = cm.curOp, doc = cm.doc, display = cm.display;
1299     cm.curOp = null;
1300
1301     if (op.updateMaxLine) computeMaxLength(cm);
1302     if (display.maxLineChanged && !cm.options.lineWrapping && display.maxLine) {
1303       var width = measureLineWidth(cm, display.maxLine);
1304       display.sizer.style.minWidth = Math.max(0, width + 3 + scrollerCutOff) + "px";
1305       display.maxLineChanged = false;
1306       var maxScrollLeft = Math.max(0, display.sizer.offsetLeft + display.sizer.offsetWidth - display.scroller.clientWidth);
1307       if (maxScrollLeft < doc.scrollLeft && !op.updateScrollPos)
1308         setScrollLeft(cm, Math.min(display.scroller.scrollLeft, maxScrollLeft), true);
1309     }
1310     var newScrollPos, updated;
1311     if (op.updateScrollPos) {
1312       newScrollPos = op.updateScrollPos;
1313     } else if (op.selectionChanged && display.scroller.clientHeight) { // don't rescroll if not visible
1314       var coords = cursorCoords(cm, doc.sel.head);
1315       newScrollPos = calculateScrollPos(cm, coords.left, coords.top, coords.left, coords.bottom);
1316     }
1317     if (op.changes.length || newScrollPos && newScrollPos.scrollTop != null) {
1318       updated = updateDisplay(cm, op.changes, newScrollPos && newScrollPos.scrollTop);
1319       if (cm.display.scroller.offsetHeight) cm.doc.scrollTop = cm.display.scroller.scrollTop;
1320     }
1321     if (!updated && op.selectionChanged) updateSelection(cm);
1322     if (op.updateScrollPos) {
1323       display.scroller.scrollTop = display.scrollbarV.scrollTop = doc.scrollTop = newScrollPos.scrollTop;
1324       display.scroller.scrollLeft = display.scrollbarH.scrollLeft = doc.scrollLeft = newScrollPos.scrollLeft;
1325       alignHorizontally(cm);
1326       if (op.scrollToPos)
1327         scrollPosIntoView(cm, clipPos(cm.doc, op.scrollToPos), op.scrollToPosMargin);
1328     } else if (newScrollPos) {
1329       scrollCursorIntoView(cm);
1330     }
1331     if (op.selectionChanged) restartBlink(cm);
1332
1333     if (cm.state.focused && op.updateInput)
1334       resetInput(cm, op.userSelChange);
1335
1336     var hidden = op.maybeHiddenMarkers, unhidden = op.maybeUnhiddenMarkers;
1337     if (hidden) for (var i = 0; i < hidden.length; ++i)
1338       if (!hidden[i].lines.length) signal(hidden[i], "hide");
1339     if (unhidden) for (var i = 0; i < unhidden.length; ++i)
1340       if (unhidden[i].lines.length) signal(unhidden[i], "unhide");
1341
1342     var delayed;
1343     if (!--delayedCallbackDepth) {
1344       delayed = delayedCallbacks;
1345       delayedCallbacks = null;
1346     }
1347     if (op.textChanged)
1348       signal(cm, "change", cm, op.textChanged);
1349     if (op.cursorActivity) signal(cm, "cursorActivity", cm);
1350     if (delayed) for (var i = 0; i < delayed.length; ++i) delayed[i]();
1351   }
1352
1353   // Wraps a function in an operation. Returns the wrapped function.
1354   function operation(cm1, f) {
1355     return function() {
1356       var cm = cm1 || this, withOp = !cm.curOp;
1357       if (withOp) startOperation(cm);
1358       try { var result = f.apply(cm, arguments); }
1359       finally { if (withOp) endOperation(cm); }
1360       return result;
1361     };
1362   }
1363   function docOperation(f) {
1364     return function() {
1365       var withOp = this.cm && !this.cm.curOp, result;
1366       if (withOp) startOperation(this.cm);
1367       try { result = f.apply(this, arguments); }
1368       finally { if (withOp) endOperation(this.cm); }
1369       return result;
1370     };
1371   }
1372   function runInOp(cm, f) {
1373     var withOp = !cm.curOp, result;
1374     if (withOp) startOperation(cm);
1375     try { result = f(); }
1376     finally { if (withOp) endOperation(cm); }
1377     return result;
1378   }
1379
1380   function regChange(cm, from, to, lendiff) {
1381     if (from == null) from = cm.doc.first;
1382     if (to == null) to = cm.doc.first + cm.doc.size;
1383     cm.curOp.changes.push({from: from, to: to, diff: lendiff});
1384   }
1385
1386   // INPUT HANDLING
1387
1388   function slowPoll(cm) {
1389     if (cm.display.pollingFast) return;
1390     cm.display.poll.set(cm.options.pollInterval, function() {
1391       readInput(cm);
1392       if (cm.state.focused) slowPoll(cm);
1393     });
1394   }
1395
1396   function fastPoll(cm) {
1397     var missed = false;
1398     cm.display.pollingFast = true;
1399     function p() {
1400       var changed = readInput(cm);
1401       if (!changed && !missed) {missed = true; cm.display.poll.set(60, p);}
1402       else {cm.display.pollingFast = false; slowPoll(cm);}
1403     }
1404     cm.display.poll.set(20, p);
1405   }
1406
1407   // prevInput is a hack to work with IME. If we reset the textarea
1408   // on every change, that breaks IME. So we look for changes
1409   // compared to the previous content instead. (Modern browsers have
1410   // events that indicate IME taking place, but these are not widely
1411   // supported or compatible enough yet to rely on.)
1412   function readInput(cm) {
1413     var input = cm.display.input, prevInput = cm.display.prevInput, doc = cm.doc, sel = doc.sel;
1414     if (!cm.state.focused || hasSelection(input) || isReadOnly(cm)) return false;
1415     var text = input.value;
1416     if (text == prevInput && posEq(sel.from, sel.to)) return false;
1417     if (ie && !ie_lt9 && cm.display.inputHasSelection === text) {
1418       resetInput(cm, true);
1419       return false;
1420     }
1421
1422     var withOp = !cm.curOp;
1423     if (withOp) startOperation(cm);
1424     sel.shift = false;
1425     var same = 0, l = Math.min(prevInput.length, text.length);
1426     while (same < l && prevInput.charCodeAt(same) == text.charCodeAt(same)) ++same;
1427     var from = sel.from, to = sel.to;
1428     if (same < prevInput.length)
1429       from = Pos(from.line, from.ch - (prevInput.length - same));
1430     else if (cm.state.overwrite && posEq(from, to) && !cm.state.pasteIncoming)
1431       to = Pos(to.line, Math.min(getLine(doc, to.line).text.length, to.ch + (text.length - same)));
1432     var updateInput = cm.curOp.updateInput;
1433     makeChange(cm.doc, {from: from, to: to, text: splitLines(text.slice(same)),
1434                         origin: cm.state.pasteIncoming ? "paste" : "+input"}, "end");
1435
1436     cm.curOp.updateInput = updateInput;
1437     if (text.length > 1000 || text.indexOf("\n") > -1) input.value = cm.display.prevInput = "";
1438     else cm.display.prevInput = text;
1439     if (withOp) endOperation(cm);
1440     cm.state.pasteIncoming = false;
1441     return true;
1442   }
1443
1444   function resetInput(cm, user) {
1445     var minimal, selected, doc = cm.doc;
1446     if (!posEq(doc.sel.from, doc.sel.to)) {
1447       cm.display.prevInput = "";
1448       minimal = hasCopyEvent &&
1449         (doc.sel.to.line - doc.sel.from.line > 100 || (selected = cm.getSelection()).length > 1000);
1450       var content = minimal ? "-" : selected || cm.getSelection();
1451       cm.display.input.value = content;
1452       if (cm.state.focused) selectInput(cm.display.input);
1453       if (ie && !ie_lt9) cm.display.inputHasSelection = content;
1454     } else if (user) {
1455       cm.display.prevInput = cm.display.input.value = "";
1456       if (ie && !ie_lt9) cm.display.inputHasSelection = null;
1457     }
1458     cm.display.inaccurateSelection = minimal;
1459   }
1460
1461   function focusInput(cm) {
1462     if (cm.options.readOnly != "nocursor" && (!mobile || document.activeElement != cm.display.input))
1463       cm.display.input.focus();
1464   }
1465
1466   function isReadOnly(cm) {
1467     return cm.options.readOnly || cm.doc.cantEdit;
1468   }
1469
1470   // EVENT HANDLERS
1471
1472   function registerEventHandlers(cm) {
1473     var d = cm.display;
1474     on(d.scroller, "mousedown", operation(cm, onMouseDown));
1475     if (ie)
1476       on(d.scroller, "dblclick", operation(cm, function(e) {
1477         var pos = posFromMouse(cm, e);
1478         if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) return;
1479         e_preventDefault(e);
1480         var word = findWordAt(getLine(cm.doc, pos.line).text, pos);
1481         extendSelection(cm.doc, word.from, word.to);
1482       }));
1483     else
1484       on(d.scroller, "dblclick", e_preventDefault);
1485     on(d.lineSpace, "selectstart", function(e) {
1486       if (!eventInWidget(d, e)) e_preventDefault(e);
1487     });
1488     // Gecko browsers fire contextmenu *after* opening the menu, at
1489     // which point we can't mess with it anymore. Context menu is
1490     // handled in onMouseDown for Gecko.
1491     if (!captureMiddleClick) on(d.scroller, "contextmenu", function(e) {onContextMenu(cm, e);});
1492
1493     on(d.scroller, "scroll", function() {
1494       if (d.scroller.clientHeight) {
1495         setScrollTop(cm, d.scroller.scrollTop);
1496         setScrollLeft(cm, d.scroller.scrollLeft, true);
1497         signal(cm, "scroll", cm);
1498       }
1499     });
1500     on(d.scrollbarV, "scroll", function() {
1501       if (d.scroller.clientHeight) setScrollTop(cm, d.scrollbarV.scrollTop);
1502     });
1503     on(d.scrollbarH, "scroll", function() {
1504       if (d.scroller.clientHeight) setScrollLeft(cm, d.scrollbarH.scrollLeft);
1505     });
1506
1507     on(d.scroller, "mousewheel", function(e){onScrollWheel(cm, e);});
1508     on(d.scroller, "DOMMouseScroll", function(e){onScrollWheel(cm, e);});
1509
1510     function reFocus() { if (cm.state.focused) setTimeout(bind(focusInput, cm), 0); }
1511     on(d.scrollbarH, "mousedown", reFocus);
1512     on(d.scrollbarV, "mousedown", reFocus);
1513     // Prevent wrapper from ever scrolling
1514     on(d.wrapper, "scroll", function() { d.wrapper.scrollTop = d.wrapper.scrollLeft = 0; });
1515
1516     function onResize() {
1517       // Might be a text scaling operation, clear size caches.
1518       d.cachedCharWidth = d.cachedTextHeight = null;
1519       clearCaches(cm);
1520       runInOp(cm, bind(regChange, cm));
1521     }
1522     on(window, "resize", onResize);
1523     // Above handler holds on to the editor and its data structures.
1524     // Here we poll to unregister it when the editor is no longer in
1525     // the document, so that it can be garbage-collected.
1526     function unregister() {
1527       for (var p = d.wrapper.parentNode; p && p != document.body; p = p.parentNode) {}
1528       if (p) setTimeout(unregister, 5000);
1529       else off(window, "resize", onResize);
1530     }
1531     setTimeout(unregister, 5000);
1532
1533     on(d.input, "keyup", operation(cm, function(e) {
1534       if (cm.options.onKeyEvent && cm.options.onKeyEvent(cm, addStop(e))) return;
1535       if (e.keyCode == 16) cm.doc.sel.shift = false;
1536     }));
1537     on(d.input, "input", bind(fastPoll, cm));
1538     on(d.input, "keydown", operation(cm, onKeyDown));
1539     on(d.input, "keypress", operation(cm, onKeyPress));
1540     on(d.input, "focus", bind(onFocus, cm));
1541     on(d.input, "blur", bind(onBlur, cm));
1542
1543     function drag_(e) {
1544       if (cm.options.onDragEvent && cm.options.onDragEvent(cm, addStop(e))) return;
1545       e_stop(e);
1546     }
1547     if (cm.options.dragDrop) {
1548       on(d.scroller, "dragstart", function(e){onDragStart(cm, e);});
1549       on(d.scroller, "dragenter", drag_);
1550       on(d.scroller, "dragover", drag_);
1551       on(d.scroller, "drop", operation(cm, onDrop));
1552     }
1553     on(d.scroller, "paste", function(e){
1554       if (eventInWidget(d, e)) return;
1555       focusInput(cm);
1556       fastPoll(cm);
1557     });
1558     on(d.input, "paste", function() {
1559       cm.state.pasteIncoming = true;
1560       fastPoll(cm);
1561     });
1562
1563     function prepareCopy() {
1564       if (d.inaccurateSelection) {
1565         d.prevInput = "";
1566         d.inaccurateSelection = false;
1567         d.input.value = cm.getSelection();
1568         selectInput(d.input);
1569       }
1570     }
1571     on(d.input, "cut", prepareCopy);
1572     on(d.input, "copy", prepareCopy);
1573
1574     // Needed to handle Tab key in KHTML
1575     if (khtml) on(d.sizer, "mouseup", function() {
1576         if (document.activeElement == d.input) d.input.blur();
1577         focusInput(cm);
1578     });
1579   }
1580
1581   function eventInWidget(display, e) {
1582     for (var n = e_target(e); n != display.wrapper; n = n.parentNode) {
1583       if (!n) return true;
1584       if (/\bCodeMirror-(?:line)?widget\b/.test(n.className) ||
1585           n.parentNode == display.sizer && n != display.mover) return true;
1586     }
1587   }
1588
1589   function posFromMouse(cm, e, liberal) {
1590     var display = cm.display;
1591     if (!liberal) {
1592       var target = e_target(e);
1593       if (target == display.scrollbarH || target == display.scrollbarH.firstChild ||
1594           target == display.scrollbarV || target == display.scrollbarV.firstChild ||
1595           target == display.scrollbarFiller || target == display.gutterFiller) return null;
1596     }
1597     var x, y, space = getRect(display.lineSpace);
1598     // Fails unpredictably on IE[67] when mouse is dragged around quickly.
1599     try { x = e.clientX; y = e.clientY; } catch (e) { return null; }
1600     return coordsChar(cm, x - space.left, y - space.top);
1601   }
1602
1603   var lastClick, lastDoubleClick;
1604   function onMouseDown(e) {
1605     var cm = this, display = cm.display, doc = cm.doc, sel = doc.sel;
1606     sel.shift = e.shiftKey;
1607
1608     if (eventInWidget(display, e)) {
1609       if (!webkit) {
1610         display.scroller.draggable = false;
1611         setTimeout(function(){display.scroller.draggable = true;}, 100);
1612       }
1613       return;
1614     }
1615     if (clickInGutter(cm, e)) return;
1616     var start = posFromMouse(cm, e);
1617
1618     switch (e_button(e)) {
1619     case 3:
1620       if (captureMiddleClick) onContextMenu.call(cm, cm, e);
1621       return;
1622     case 2:
1623       if (start) extendSelection(cm.doc, start);
1624       setTimeout(bind(focusInput, cm), 20);
1625       e_preventDefault(e);
1626       return;
1627     }
1628     // For button 1, if it was clicked inside the editor
1629     // (posFromMouse returning non-null), we have to adjust the
1630     // selection.
1631     if (!start) {if (e_target(e) == display.scroller) e_preventDefault(e); return;}
1632
1633     if (!cm.state.focused) onFocus(cm);
1634
1635     var now = +new Date, type = "single";
1636     if (lastDoubleClick && lastDoubleClick.time > now - 400 && posEq(lastDoubleClick.pos, start)) {
1637       type = "triple";
1638       e_preventDefault(e);
1639       setTimeout(bind(focusInput, cm), 20);
1640       selectLine(cm, start.line);
1641     } else if (lastClick && lastClick.time > now - 400 && posEq(lastClick.pos, start)) {
1642       type = "double";
1643       lastDoubleClick = {time: now, pos: start};
1644       e_preventDefault(e);
1645       var word = findWordAt(getLine(doc, start.line).text, start);
1646       extendSelection(cm.doc, word.from, word.to);
1647     } else { lastClick = {time: now, pos: start}; }
1648
1649     var last = start;
1650     if (cm.options.dragDrop && dragAndDrop && !isReadOnly(cm) && !posEq(sel.from, sel.to) &&
1651         !posLess(start, sel.from) && !posLess(sel.to, start) && type == "single") {
1652       var dragEnd = operation(cm, function(e2) {
1653         if (webkit) display.scroller.draggable = false;
1654         cm.state.draggingText = false;
1655         off(document, "mouseup", dragEnd);
1656         off(display.scroller, "drop", dragEnd);
1657         if (Math.abs(e.clientX - e2.clientX) + Math.abs(e.clientY - e2.clientY) < 10) {
1658           e_preventDefault(e2);
1659           extendSelection(cm.doc, start);
1660           focusInput(cm);
1661         }
1662       });
1663       // Let the drag handler handle this.
1664       if (webkit) display.scroller.draggable = true;
1665       cm.state.draggingText = dragEnd;
1666       // IE's approach to draggable
1667       if (display.scroller.dragDrop) display.scroller.dragDrop();
1668       on(document, "mouseup", dragEnd);
1669       on(display.scroller, "drop", dragEnd);
1670       return;
1671     }
1672     e_preventDefault(e);
1673     if (type == "single") extendSelection(cm.doc, clipPos(doc, start));
1674
1675     var startstart = sel.from, startend = sel.to, lastPos = start;
1676
1677     function doSelect(cur) {
1678       if (posEq(lastPos, cur)) return;
1679       lastPos = cur;
1680
1681       if (type == "single") {
1682         extendSelection(cm.doc, clipPos(doc, start), cur);
1683         return;
1684       }
1685
1686       startstart = clipPos(doc, startstart);
1687       startend = clipPos(doc, startend);
1688       if (type == "double") {
1689         var word = findWordAt(getLine(doc, cur.line).text, cur);
1690         if (posLess(cur, startstart)) extendSelection(cm.doc, word.from, startend);
1691         else extendSelection(cm.doc, startstart, word.to);
1692       } else if (type == "triple") {
1693         if (posLess(cur, startstart)) extendSelection(cm.doc, startend, clipPos(doc, Pos(cur.line, 0)));
1694         else extendSelection(cm.doc, startstart, clipPos(doc, Pos(cur.line + 1, 0)));
1695       }
1696     }
1697
1698     var editorSize = getRect(display.wrapper);
1699     // Used to ensure timeout re-tries don't fire when another extend
1700     // happened in the meantime (clearTimeout isn't reliable -- at
1701     // least on Chrome, the timeouts still happen even when cleared,
1702     // if the clear happens after their scheduled firing time).
1703     var counter = 0;
1704
1705     function extend(e) {
1706       var curCount = ++counter;
1707       var cur = posFromMouse(cm, e, true);
1708       if (!cur) return;
1709       if (!posEq(cur, last)) {
1710         if (!cm.state.focused) onFocus(cm);
1711         last = cur;
1712         doSelect(cur);
1713         var visible = visibleLines(display, doc);
1714         if (cur.line >= visible.to || cur.line < visible.from)
1715           setTimeout(operation(cm, function(){if (counter == curCount) extend(e);}), 150);
1716       } else {
1717         var outside = e.clientY < editorSize.top ? -20 : e.clientY > editorSize.bottom ? 20 : 0;
1718         if (outside) setTimeout(operation(cm, function() {
1719           if (counter != curCount) return;
1720           display.scroller.scrollTop += outside;
1721           extend(e);
1722         }), 50);
1723       }
1724     }
1725
1726     function done(e) {
1727       counter = Infinity;
1728       var cur = posFromMouse(cm, e);
1729       if (cur) doSelect(cur);
1730       e_preventDefault(e);
1731       focusInput(cm);
1732       off(document, "mousemove", move);
1733       off(document, "mouseup", up);
1734     }
1735
1736     var move = operation(cm, function(e) {
1737       if (!ie && !e_button(e)) done(e);
1738       else extend(e);
1739     });
1740     var up = operation(cm, done);
1741     on(document, "mousemove", move);
1742     on(document, "mouseup", up);
1743   }
1744
1745   function onDrop(e) {
1746     var cm = this;
1747     if (eventInWidget(cm.display, e) || (cm.options.onDragEvent && cm.options.onDragEvent(cm, addStop(e))))
1748       return;
1749     e_preventDefault(e);
1750     var pos = posFromMouse(cm, e, true), files = e.dataTransfer.files;
1751     if (!pos || isReadOnly(cm)) return;
1752     if (files && files.length && window.FileReader && window.File) {
1753       var n = files.length, text = Array(n), read = 0;
1754       var loadFile = function(file, i) {
1755         var reader = new FileReader;
1756         reader.onload = function() {
1757           text[i] = reader.result;
1758           if (++read == n) {
1759             pos = clipPos(cm.doc, pos);
1760             makeChange(cm.doc, {from: pos, to: pos, text: splitLines(text.join("\n")), origin: "paste"}, "around");
1761           }
1762         };
1763         reader.readAsText(file);
1764       };
1765       for (var i = 0; i < n; ++i) loadFile(files[i], i);
1766     } else {
1767       // Don't do a replace if the drop happened inside of the selected text.
1768       if (cm.state.draggingText && !(posLess(pos, cm.doc.sel.from) || posLess(cm.doc.sel.to, pos))) {
1769         cm.state.draggingText(e);
1770         // Ensure the editor is re-focused
1771         setTimeout(bind(focusInput, cm), 20);
1772         return;
1773       }
1774       try {
1775         var text = e.dataTransfer.getData("Text");
1776         if (text) {
1777           var curFrom = cm.doc.sel.from, curTo = cm.doc.sel.to;
1778           setSelection(cm.doc, pos, pos);
1779           if (cm.state.draggingText) replaceRange(cm.doc, "", curFrom, curTo, "paste");
1780           cm.replaceSelection(text, null, "paste");
1781           focusInput(cm);
1782           onFocus(cm);
1783         }
1784       }
1785       catch(e){}
1786     }
1787   }
1788
1789   function clickInGutter(cm, e) {
1790     var display = cm.display;
1791     try { var mX = e.clientX, mY = e.clientY; }
1792     catch(e) { return false; }
1793
1794     if (mX >= Math.floor(getRect(display.gutters).right)) return false;
1795     e_preventDefault(e);
1796     if (!hasHandler(cm, "gutterClick")) return true;
1797
1798     var lineBox = getRect(display.lineDiv);
1799     if (mY > lineBox.bottom) return true;
1800     mY -= lineBox.top - display.viewOffset;
1801
1802     for (var i = 0; i < cm.options.gutters.length; ++i) {
1803       var g = display.gutters.childNodes[i];
1804       if (g && getRect(g).right >= mX) {
1805         var line = lineAtHeight(cm.doc, mY);
1806         var gutter = cm.options.gutters[i];
1807         signalLater(cm, "gutterClick", cm, line, gutter, e);
1808         break;
1809       }
1810     }
1811     return true;
1812   }
1813
1814   function onDragStart(cm, e) {
1815     if (ie && !cm.state.draggingText) { e_stop(e); return; }
1816     if (eventInWidget(cm.display, e)) return;
1817
1818     var txt = cm.getSelection();
1819     e.dataTransfer.setData("Text", txt);
1820
1821     // Use dummy image instead of default browsers image.
1822     // Recent Safari (~6.0.2) have a tendency to segfault when this happens, so we don't do it there.
1823     if (e.dataTransfer.setDragImage) {
1824       var img = elt("img", null, null, "position: fixed; left: 0; top: 0;");
1825       if (opera) {
1826         img.width = img.height = 1;
1827         cm.display.wrapper.appendChild(img);
1828         // Force a relayout, or Opera won't use our image for some obscure reason
1829         img._top = img.offsetTop;
1830       }
1831       if (safari) {
1832         if (cm.display.dragImg) {
1833           img = cm.display.dragImg;
1834         } else {
1835           cm.display.dragImg = img;
1836           img.src = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
1837           cm.display.wrapper.appendChild(img);
1838         }
1839       }
1840       e.dataTransfer.setDragImage(img, 0, 0);
1841       if (opera) img.parentNode.removeChild(img);
1842     }
1843   }
1844
1845   function setScrollTop(cm, val) {
1846     if (Math.abs(cm.doc.scrollTop - val) < 2) return;
1847     cm.doc.scrollTop = val;
1848     if (!gecko) updateDisplay(cm, [], val);
1849     if (cm.display.scroller.scrollTop != val) cm.display.scroller.scrollTop = val;
1850     if (cm.display.scrollbarV.scrollTop != val) cm.display.scrollbarV.scrollTop = val;
1851     if (gecko) updateDisplay(cm, []);
1852   }
1853   function setScrollLeft(cm, val, isScroller) {
1854     if (isScroller ? val == cm.doc.scrollLeft : Math.abs(cm.doc.scrollLeft - val) < 2) return;
1855     val = Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth);
1856     cm.doc.scrollLeft = val;
1857     alignHorizontally(cm);
1858     if (cm.display.scroller.scrollLeft != val) cm.display.scroller.scrollLeft = val;
1859     if (cm.display.scrollbarH.scrollLeft != val) cm.display.scrollbarH.scrollLeft = val;
1860   }
1861
1862   // Since the delta values reported on mouse wheel events are
1863   // unstandardized between browsers and even browser versions, and
1864   // generally horribly unpredictable, this code starts by measuring
1865   // the scroll effect that the first few mouse wheel events have,
1866   // and, from that, detects the way it can convert deltas to pixel
1867   // offsets afterwards.
1868   //
1869   // The reason we want to know the amount a wheel event will scroll
1870   // is that it gives us a chance to update the display before the
1871   // actual scrolling happens, reducing flickering.
1872
1873   var wheelSamples = 0, wheelPixelsPerUnit = null;
1874   // Fill in a browser-detected starting value on browsers where we
1875   // know one. These don't have to be accurate -- the result of them
1876   // being wrong would just be a slight flicker on the first wheel
1877   // scroll (if it is large enough).
1878   if (ie) wheelPixelsPerUnit = -.53;
1879   else if (gecko) wheelPixelsPerUnit = 15;
1880   else if (chrome) wheelPixelsPerUnit = -.7;
1881   else if (safari) wheelPixelsPerUnit = -1/3;
1882
1883   function onScrollWheel(cm, e) {
1884     var dx = e.wheelDeltaX, dy = e.wheelDeltaY;
1885     if (dx == null && e.detail && e.axis == e.HORIZONTAL_AXIS) dx = e.detail;
1886     if (dy == null && e.detail && e.axis == e.VERTICAL_AXIS) dy = e.detail;
1887     else if (dy == null) dy = e.wheelDelta;
1888
1889     var display = cm.display, scroll = display.scroller;
1890     // Quit if there's nothing to scroll here
1891     if (!(dx && scroll.scrollWidth > scroll.clientWidth ||
1892           dy && scroll.scrollHeight > scroll.clientHeight)) return;
1893
1894     // Webkit browsers on OS X abort momentum scrolls when the target
1895     // of the scroll event is removed from the scrollable element.
1896     // This hack (see related code in patchDisplay) makes sure the
1897     // element is kept around.
1898     if (dy && mac && webkit) {
1899       for (var cur = e.target; cur != scroll; cur = cur.parentNode) {
1900         if (cur.lineObj) {
1901           cm.display.currentWheelTarget = cur;
1902           break;
1903         }
1904       }
1905     }
1906
1907     // On some browsers, horizontal scrolling will cause redraws to
1908     // happen before the gutter has been realigned, causing it to
1909     // wriggle around in a most unseemly way. When we have an
1910     // estimated pixels/delta value, we just handle horizontal
1911     // scrolling entirely here. It'll be slightly off from native, but
1912     // better than glitching out.
1913     if (dx && !gecko && !opera && wheelPixelsPerUnit != null) {
1914       if (dy)
1915         setScrollTop(cm, Math.max(0, Math.min(scroll.scrollTop + dy * wheelPixelsPerUnit, scroll.scrollHeight - scroll.clientHeight)));
1916       setScrollLeft(cm, Math.max(0, Math.min(scroll.scrollLeft + dx * wheelPixelsPerUnit, scroll.scrollWidth - scroll.clientWidth)));
1917       e_preventDefault(e);
1918       display.wheelStartX = null; // Abort measurement, if in progress
1919       return;
1920     }
1921
1922     if (dy && wheelPixelsPerUnit != null) {
1923       var pixels = dy * wheelPixelsPerUnit;
1924       var top = cm.doc.scrollTop, bot = top + display.wrapper.clientHeight;
1925       if (pixels < 0) top = Math.max(0, top + pixels - 50);
1926       else bot = Math.min(cm.doc.height, bot + pixels + 50);
1927       updateDisplay(cm, [], {top: top, bottom: bot});
1928     }
1929
1930     if (wheelSamples < 20) {
1931       if (display.wheelStartX == null) {
1932         display.wheelStartX = scroll.scrollLeft; display.wheelStartY = scroll.scrollTop;
1933         display.wheelDX = dx; display.wheelDY = dy;
1934         setTimeout(function() {
1935           if (display.wheelStartX == null) return;
1936           var movedX = scroll.scrollLeft - display.wheelStartX;
1937           var movedY = scroll.scrollTop - display.wheelStartY;
1938           var sample = (movedY && display.wheelDY && movedY / display.wheelDY) ||
1939             (movedX && display.wheelDX && movedX / display.wheelDX);
1940           display.wheelStartX = display.wheelStartY = null;
1941           if (!sample) return;
1942           wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1);
1943           ++wheelSamples;
1944         }, 200);
1945       } else {
1946         display.wheelDX += dx; display.wheelDY += dy;
1947       }
1948     }
1949   }
1950
1951   function doHandleBinding(cm, bound, dropShift) {
1952     if (typeof bound == "string") {
1953       bound = commands[bound];
1954       if (!bound) return false;
1955     }
1956     // Ensure previous input has been read, so that the handler sees a
1957     // consistent view of the document
1958     if (cm.display.pollingFast && readInput(cm)) cm.display.pollingFast = false;
1959     var doc = cm.doc, prevShift = doc.sel.shift, done = false;
1960     try {
1961       if (isReadOnly(cm)) cm.state.suppressEdits = true;
1962       if (dropShift) doc.sel.shift = false;
1963       done = bound(cm) != Pass;
1964     } finally {
1965       doc.sel.shift = prevShift;
1966       cm.state.suppressEdits = false;
1967     }
1968     return done;
1969   }
1970
1971   function allKeyMaps(cm) {
1972     var maps = cm.state.keyMaps.slice(0);
1973     if (cm.options.extraKeys) maps.push(cm.options.extraKeys);
1974     maps.push(cm.options.keyMap);
1975     return maps;
1976   }
1977
1978   var maybeTransition;
1979   function handleKeyBinding(cm, e) {
1980     // Handle auto keymap transitions
1981     var startMap = getKeyMap(cm.options.keyMap), next = startMap.auto;
1982     clearTimeout(maybeTransition);
1983     if (next && !isModifierKey(e)) maybeTransition = setTimeout(function() {
1984       if (getKeyMap(cm.options.keyMap) == startMap)
1985         cm.options.keyMap = (next.call ? next.call(null, cm) : next);
1986     }, 50);
1987
1988     var name = keyName(e, true), handled = false;
1989     if (!name) return false;
1990     var keymaps = allKeyMaps(cm);
1991
1992     if (e.shiftKey) {
1993       // First try to resolve full name (including 'Shift-'). Failing
1994       // that, see if there is a cursor-motion command (starting with
1995       // 'go') bound to the keyname without 'Shift-'.
1996       handled = lookupKey("Shift-" + name, keymaps, function(b) {return doHandleBinding(cm, b, true);})
1997              || lookupKey(name, keymaps, function(b) {
1998                   if (typeof b == "string" && /^go[A-Z]/.test(b)) return doHandleBinding(cm, b);
1999                 });
2000     } else {
2001       handled = lookupKey(name, keymaps, function(b) { return doHandleBinding(cm, b); });
2002     }
2003     if (handled == "stop") handled = false;
2004
2005     if (handled) {
2006       e_preventDefault(e);
2007       restartBlink(cm);
2008       if (ie_lt9) { e.oldKeyCode = e.keyCode; e.keyCode = 0; }
2009     }
2010     return handled;
2011   }
2012
2013   function handleCharBinding(cm, e, ch) {
2014     var handled = lookupKey("'" + ch + "'", allKeyMaps(cm),
2015                             function(b) { return doHandleBinding(cm, b, true); });
2016     if (handled) {
2017       e_preventDefault(e);
2018       restartBlink(cm);
2019     }
2020     return handled;
2021   }
2022
2023   var lastStoppedKey = null;
2024   function onKeyDown(e) {
2025     var cm = this;
2026     if (!cm.state.focused) onFocus(cm);
2027     if (ie && e.keyCode == 27) { e.returnValue = false; }
2028     if (cm.options.onKeyEvent && cm.options.onKeyEvent(cm, addStop(e))) return;
2029     var code = e.keyCode;
2030     // IE does strange things with escape.
2031     cm.doc.sel.shift = code == 16 || e.shiftKey;
2032     // First give onKeyEvent option a chance to handle this.
2033     var handled = handleKeyBinding(cm, e);
2034     if (opera) {
2035       lastStoppedKey = handled ? code : null;
2036       // Opera has no cut event... we try to at least catch the key combo
2037       if (!handled && code == 88 && !hasCopyEvent && (mac ? e.metaKey : e.ctrlKey))
2038         cm.replaceSelection("");
2039     }
2040   }
2041
2042   function onKeyPress(e) {
2043     var cm = this;
2044     if (cm.options.onKeyEvent && cm.options.onKeyEvent(cm, addStop(e))) return;
2045     var keyCode = e.keyCode, charCode = e.charCode;
2046     if (opera && keyCode == lastStoppedKey) {lastStoppedKey = null; e_preventDefault(e); return;}
2047     if (((opera && (!e.which || e.which < 10)) || khtml) && handleKeyBinding(cm, e)) return;
2048     var ch = String.fromCharCode(charCode == null ? keyCode : charCode);
2049     if (this.options.electricChars && this.doc.mode.electricChars &&
2050         this.options.smartIndent && !isReadOnly(this) &&
2051         this.doc.mode.electricChars.indexOf(ch) > -1)
2052       setTimeout(operation(cm, function() {indentLine(cm, cm.doc.sel.to.line, "smart");}), 75);
2053     if (handleCharBinding(cm, e, ch)) return;
2054     if (ie && !ie_lt9) cm.display.inputHasSelection = null;
2055     fastPoll(cm);
2056   }
2057
2058   function onFocus(cm) {
2059     if (cm.options.readOnly == "nocursor") return;
2060     if (!cm.state.focused) {
2061       signal(cm, "focus", cm);
2062       cm.state.focused = true;
2063       if (cm.display.wrapper.className.search(/\bCodeMirror-focused\b/) == -1)
2064         cm.display.wrapper.className += " CodeMirror-focused";
2065       resetInput(cm, true);
2066     }
2067     slowPoll(cm);
2068     restartBlink(cm);
2069   }
2070   function onBlur(cm) {
2071     if (cm.state.focused) {
2072       signal(cm, "blur", cm);
2073       cm.state.focused = false;
2074       cm.display.wrapper.className = cm.display.wrapper.className.replace(" CodeMirror-focused", "");
2075     }
2076     clearInterval(cm.display.blinker);
2077     setTimeout(function() {if (!cm.state.focused) cm.doc.sel.shift = false;}, 150);
2078   }
2079
2080   var detectingSelectAll;
2081   function onContextMenu(cm, e) {
2082     var display = cm.display, sel = cm.doc.sel;
2083     if (eventInWidget(display, e)) return;
2084
2085     var pos = posFromMouse(cm, e), scrollPos = display.scroller.scrollTop;
2086     if (!pos || opera) return; // Opera is difficult.
2087     if (posEq(sel.from, sel.to) || posLess(pos, sel.from) || !posLess(pos, sel.to))
2088       operation(cm, setSelection)(cm.doc, pos, pos);
2089
2090     var oldCSS = display.input.style.cssText;
2091     display.inputDiv.style.position = "absolute";
2092     display.input.style.cssText = "position: fixed; width: 30px; height: 30px; top: " + (e.clientY - 5) +
2093       "px; left: " + (e.clientX - 5) + "px; z-index: 1000; background: white; outline: none;" +
2094       "border-width: 0; outline: none; overflow: hidden; opacity: .05; -ms-opacity: .05; filter: alpha(opacity=5);";
2095     focusInput(cm);
2096     resetInput(cm, true);
2097     // Adds "Select all" to context menu in FF
2098     if (posEq(sel.from, sel.to)) display.input.value = display.prevInput = " ";
2099
2100     function prepareSelectAllHack() {
2101       if (display.input.selectionStart != null) {
2102         var extval = display.input.value = " " + (posEq(sel.from, sel.to) ? "" : display.input.value);
2103         display.prevInput = " ";
2104         display.input.selectionStart = 1; display.input.selectionEnd = extval.length;
2105       }
2106     }
2107     function rehide() {
2108       display.inputDiv.style.position = "relative";
2109       display.input.style.cssText = oldCSS;
2110       if (ie_lt9) display.scrollbarV.scrollTop = display.scroller.scrollTop = scrollPos;
2111       slowPoll(cm);
2112
2113       // Try to detect the user choosing select-all
2114       if (display.input.selectionStart != null) {
2115         if (!ie || ie_lt9) prepareSelectAllHack();
2116         clearTimeout(detectingSelectAll);
2117         var i = 0, poll = function(){
2118           if (display.prevInput == " " && display.input.selectionStart == 0)
2119             operation(cm, commands.selectAll)(cm);
2120           else if (i++ < 10) detectingSelectAll = setTimeout(poll, 500);
2121           else resetInput(cm);
2122         };
2123         detectingSelectAll = setTimeout(poll, 200);
2124       }
2125     }
2126
2127     if (ie && !ie_lt9) prepareSelectAllHack();
2128     if (captureMiddleClick) {
2129       e_stop(e);
2130       var mouseup = function() {
2131         off(window, "mouseup", mouseup);
2132         setTimeout(rehide, 20);
2133       };
2134       on(window, "mouseup", mouseup);
2135     } else {
2136       setTimeout(rehide, 50);
2137     }
2138   }
2139
2140   // UPDATING
2141
2142   function changeEnd(change) {
2143     if (!change.text) return change.to;
2144     return Pos(change.from.line + change.text.length - 1,
2145                lst(change.text).length + (change.text.length == 1 ? change.from.ch : 0));
2146   }
2147
2148   // Make sure a position will be valid after the given change.
2149   function clipPostChange(doc, change, pos) {
2150     if (!posLess(change.from, pos)) return clipPos(doc, pos);
2151     var diff = (change.text.length - 1) - (change.to.line - change.from.line);
2152     if (pos.line > change.to.line + diff) {
2153       var preLine = pos.line - diff, lastLine = doc.first + doc.size - 1;
2154       if (preLine > lastLine) return Pos(lastLine, getLine(doc, lastLine).text.length);
2155       return clipToLen(pos, getLine(doc, preLine).text.length);
2156     }
2157     if (pos.line == change.to.line + diff)
2158       return clipToLen(pos, lst(change.text).length + (change.text.length == 1 ? change.from.ch : 0) +
2159                        getLine(doc, change.to.line).text.length - change.to.ch);
2160     var inside = pos.line - change.from.line;
2161     return clipToLen(pos, change.text[inside].length + (inside ? 0 : change.from.ch));
2162   }
2163
2164   // Hint can be null|"end"|"start"|"around"|{anchor,head}
2165   function computeSelAfterChange(doc, change, hint) {
2166     if (hint && typeof hint == "object") // Assumed to be {anchor, head} object
2167       return {anchor: clipPostChange(doc, change, hint.anchor),
2168               head: clipPostChange(doc, change, hint.head)};
2169
2170     if (hint == "start") return {anchor: change.from, head: change.from};
2171
2172     var end = changeEnd(change);
2173     if (hint == "around") return {anchor: change.from, head: end};
2174     if (hint == "end") return {anchor: end, head: end};
2175
2176     // hint is null, leave the selection alone as much as possible
2177     var adjustPos = function(pos) {
2178       if (posLess(pos, change.from)) return pos;
2179       if (!posLess(change.to, pos)) return end;
2180
2181       var line = pos.line + change.text.length - (change.to.line - change.from.line) - 1, ch = pos.ch;
2182       if (pos.line == change.to.line) ch += end.ch - change.to.ch;
2183       return Pos(line, ch);
2184     };
2185     return {anchor: adjustPos(doc.sel.anchor), head: adjustPos(doc.sel.head)};
2186   }
2187
2188   function filterChange(doc, change) {
2189     var obj = {
2190       canceled: false,
2191       from: change.from,
2192       to: change.to,
2193       text: change.text,
2194       origin: change.origin,
2195       update: function(from, to, text, origin) {
2196         if (from) this.from = clipPos(doc, from);
2197         if (to) this.to = clipPos(doc, to);
2198         if (text) this.text = text;
2199         if (origin !== undefined) this.origin = origin;
2200       },
2201       cancel: function() { this.canceled = true; }
2202     };
2203     signal(doc, "beforeChange", doc, obj);
2204     if (doc.cm) signal(doc.cm, "beforeChange", doc.cm, obj);
2205
2206     if (obj.canceled) return null;
2207     return {from: obj.from, to: obj.to, text: obj.text, origin: obj.origin};
2208   }
2209
2210   // Replace the range from from to to by the strings in replacement.
2211   // change is a {from, to, text [, origin]} object
2212   function makeChange(doc, change, selUpdate, ignoreReadOnly) {
2213     if (doc.cm) {
2214       if (!doc.cm.curOp) return operation(doc.cm, makeChange)(doc, change, selUpdate, ignoreReadOnly);
2215       if (doc.cm.state.suppressEdits) return;
2216     }
2217
2218     if (hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")) {
2219       change = filterChange(doc, change);
2220       if (!change) return;
2221     }
2222
2223     // Possibly split or suppress the update based on the presence
2224     // of read-only spans in its range.
2225     var split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to);
2226     if (split) {
2227       for (var i = split.length - 1; i >= 1; --i)
2228         makeChangeNoReadonly(doc, {from: split[i].from, to: split[i].to, text: [""]});
2229       if (split.length)
2230         makeChangeNoReadonly(doc, {from: split[0].from, to: split[0].to, text: change.text}, selUpdate);
2231     } else {
2232       makeChangeNoReadonly(doc, change, selUpdate);
2233     }
2234   }
2235
2236   function makeChangeNoReadonly(doc, change, selUpdate) {
2237     var selAfter = computeSelAfterChange(doc, change, selUpdate);
2238     addToHistory(doc, change, selAfter, doc.cm ? doc.cm.curOp.id : NaN);
2239
2240     makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change));
2241     var rebased = [];
2242
2243     linkedDocs(doc, function(doc, sharedHist) {
2244       if (!sharedHist && indexOf(rebased, doc.history) == -1) {
2245         rebaseHist(doc.history, change);
2246         rebased.push(doc.history);
2247       }
2248       makeChangeSingleDoc(doc, change, null, stretchSpansOverChange(doc, change));
2249     });
2250   }
2251
2252   function makeChangeFromHistory(doc, type) {
2253     if (doc.cm && doc.cm.state.suppressEdits) return;
2254
2255     var hist = doc.history;
2256     var event = (type == "undo" ? hist.done : hist.undone).pop();
2257     if (!event) return;
2258     hist.dirtyCounter += type == "undo" ? -1 : 1;
2259
2260     var anti = {changes: [], anchorBefore: event.anchorAfter, headBefore: event.headAfter,
2261                 anchorAfter: event.anchorBefore, headAfter: event.headBefore};
2262     (type == "undo" ? hist.undone : hist.done).push(anti);
2263
2264     for (var i = event.changes.length - 1; i >= 0; --i) {
2265       var change = event.changes[i];
2266       change.origin = type;
2267       anti.changes.push(historyChangeFromChange(doc, change));
2268
2269       var after = i ? computeSelAfterChange(doc, change, null)
2270                     : {anchor: event.anchorBefore, head: event.headBefore};
2271       makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change));
2272       var rebased = [];
2273
2274       linkedDocs(doc, function(doc, sharedHist) {
2275         if (!sharedHist && indexOf(rebased, doc.history) == -1) {
2276           rebaseHist(doc.history, change);
2277           rebased.push(doc.history);
2278         }
2279         makeChangeSingleDoc(doc, change, null, mergeOldSpans(doc, change));
2280       });
2281     }
2282   }
2283
2284   function shiftDoc(doc, distance) {
2285     function shiftPos(pos) {return Pos(pos.line + distance, pos.ch);}
2286     doc.first += distance;
2287     if (doc.cm) regChange(doc.cm, doc.first, doc.first, distance);
2288     doc.sel.head = shiftPos(doc.sel.head); doc.sel.anchor = shiftPos(doc.sel.anchor);
2289     doc.sel.from = shiftPos(doc.sel.from); doc.sel.to = shiftPos(doc.sel.to);
2290   }
2291
2292   function makeChangeSingleDoc(doc, change, selAfter, spans) {
2293     if (doc.cm && !doc.cm.curOp)
2294       return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans);
2295
2296     if (change.to.line < doc.first) {
2297       shiftDoc(doc, change.text.length - 1 - (change.to.line - change.from.line));
2298       return;
2299     }
2300     if (change.from.line > doc.lastLine()) return;
2301
2302     // Clip the change to the size of this doc
2303     if (change.from.line < doc.first) {
2304       var shift = change.text.length - 1 - (doc.first - change.from.line);
2305       shiftDoc(doc, shift);
2306       change = {from: Pos(doc.first, 0), to: Pos(change.to.line + shift, change.to.ch),
2307                 text: [lst(change.text)], origin: change.origin};
2308     }
2309     var last = doc.lastLine();
2310     if (change.to.line > last) {
2311       change = {from: change.from, to: Pos(last, getLine(doc, last).text.length),
2312                 text: [change.text[0]], origin: change.origin};
2313     }
2314
2315     change.removed = getBetween(doc, change.from, change.to);
2316
2317     if (!selAfter) selAfter = computeSelAfterChange(doc, change, null);
2318     if (doc.cm) makeChangeSingleDocInEditor(doc.cm, change, spans, selAfter);
2319     else updateDoc(doc, change, spans, selAfter);
2320   }
2321
2322   function makeChangeSingleDocInEditor(cm, change, spans, selAfter) {
2323     var doc = cm.doc, display = cm.display, from = change.from, to = change.to;
2324
2325     var recomputeMaxLength = false, checkWidthStart = from.line;
2326     if (!cm.options.lineWrapping) {
2327       checkWidthStart = lineNo(visualLine(doc, getLine(doc, from.line)));
2328       doc.iter(checkWidthStart, to.line + 1, function(line) {
2329         if (line == display.maxLine) {
2330           recomputeMaxLength = true;
2331           return true;
2332         }
2333       });
2334     }
2335
2336     if (!posLess(doc.sel.head, change.from) && !posLess(change.to, doc.sel.head))
2337       cm.curOp.cursorActivity = true;
2338
2339     updateDoc(doc, change, spans, selAfter, estimateHeight(cm));
2340
2341     if (!cm.options.lineWrapping) {
2342       doc.iter(checkWidthStart, from.line + change.text.length, function(line) {
2343         var len = lineLength(doc, line);
2344         if (len > display.maxLineLength) {
2345           display.maxLine = line;
2346           display.maxLineLength = len;
2347           display.maxLineChanged = true;
2348           recomputeMaxLength = false;
2349         }
2350       });
2351       if (recomputeMaxLength) cm.curOp.updateMaxLine = true;
2352     }
2353
2354     // Adjust frontier, schedule worker
2355     doc.frontier = Math.min(doc.frontier, from.line);
2356     startWorker(cm, 400);
2357
2358     var lendiff = change.text.length - (to.line - from.line) - 1;
2359     // Remember that these lines changed, for updating the display
2360     regChange(cm, from.line, to.line + 1, lendiff);
2361
2362     if (hasHandler(cm, "change")) {
2363       var changeObj = {from: from, to: to,
2364                        text: change.text,
2365                        removed: change.removed,
2366                        origin: change.origin};
2367       if (cm.curOp.textChanged) {
2368         for (var cur = cm.curOp.textChanged; cur.next; cur = cur.next) {}
2369         cur.next = changeObj;
2370       } else cm.curOp.textChanged = changeObj;
2371     }
2372   }
2373
2374   function replaceRange(doc, code, from, to, origin) {
2375     if (!to) to = from;
2376     if (posLess(to, from)) { var tmp = to; to = from; from = tmp; }
2377     if (typeof code == "string") code = splitLines(code);
2378     makeChange(doc, {from: from, to: to, text: code, origin: origin}, null);
2379   }
2380
2381   // POSITION OBJECT
2382
2383   function Pos(line, ch) {
2384     if (!(this instanceof Pos)) return new Pos(line, ch);
2385     this.line = line; this.ch = ch;
2386   }
2387   CodeMirror.Pos = Pos;
2388
2389   function posEq(a, b) {return a.line == b.line && a.ch == b.ch;}
2390   function posLess(a, b) {return a.line < b.line || (a.line == b.line && a.ch < b.ch);}
2391   function copyPos(x) {return Pos(x.line, x.ch);}
2392
2393   // SELECTION
2394
2395   function clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1));}
2396   function clipPos(doc, pos) {
2397     if (pos.line < doc.first) return Pos(doc.first, 0);
2398     var last = doc.first + doc.size - 1;
2399     if (pos.line > last) return Pos(last, getLine(doc, last).text.length);
2400     return clipToLen(pos, getLine(doc, pos.line).text.length);
2401   }
2402   function clipToLen(pos, linelen) {
2403     var ch = pos.ch;
2404     if (ch == null || ch > linelen) return Pos(pos.line, linelen);
2405     else if (ch < 0) return Pos(pos.line, 0);
2406     else return pos;
2407   }
2408   function isLine(doc, l) {return l >= doc.first && l < doc.first + doc.size;}
2409
2410   // If shift is held, this will move the selection anchor. Otherwise,
2411   // it'll set the whole selection.
2412   function extendSelection(doc, pos, other, bias) {
2413     if (doc.sel.shift || doc.sel.extend) {
2414       var anchor = doc.sel.anchor;
2415       if (other) {
2416         var posBefore = posLess(pos, anchor);
2417         if (posBefore != posLess(other, anchor)) {
2418           anchor = pos;
2419           pos = other;
2420         } else if (posBefore != posLess(pos, other)) {
2421           pos = other;
2422         }
2423       }
2424       setSelection(doc, anchor, pos, bias);
2425     } else {
2426       setSelection(doc, pos, other || pos, bias);
2427     }
2428     if (doc.cm) doc.cm.curOp.userSelChange = true;
2429   }
2430
2431   function filterSelectionChange(doc, anchor, head) {
2432     var obj = {anchor: anchor, head: head};
2433     signal(doc, "beforeSelectionChange", doc, obj);
2434     if (doc.cm) signal(doc.cm, "beforeSelectionChange", doc.cm, obj);
2435     obj.anchor = clipPos(doc, obj.anchor); obj.head = clipPos(doc, obj.head);
2436     return obj;
2437   }
2438
2439   // Update the selection. Last two args are only used by
2440   // updateDoc, since they have to be expressed in the line
2441   // numbers before the update.
2442   function setSelection(doc, anchor, head, bias, checkAtomic) {
2443     if (!checkAtomic && hasHandler(doc, "beforeSelectionChange") || doc.cm && hasHandler(doc.cm, "beforeSelectionChange")) {
2444       var filtered = filterSelectionChange(doc, anchor, head);
2445       head = filtered.head;
2446       anchor = filtered.anchor;
2447     }
2448
2449     var sel = doc.sel;
2450     sel.goalColumn = null;
2451     // Skip over atomic spans.
2452     if (checkAtomic || !posEq(anchor, sel.anchor))
2453       anchor = skipAtomic(doc, anchor, bias, checkAtomic != "push");
2454     if (checkAtomic || !posEq(head, sel.head))
2455       head = skipAtomic(doc, head, bias, checkAtomic != "push");
2456
2457     if (posEq(sel.anchor, anchor) && posEq(sel.head, head)) return;
2458
2459     sel.anchor = anchor; sel.head = head;
2460     var inv = posLess(head, anchor);
2461     sel.from = inv ? head : anchor;
2462     sel.to = inv ? anchor : head;
2463
2464     if (doc.cm)
2465       doc.cm.curOp.updateInput = doc.cm.curOp.selectionChanged =
2466         doc.cm.curOp.cursorActivity = true;
2467
2468     signalLater(doc, "cursorActivity", doc);
2469   }
2470
2471   function reCheckSelection(cm) {
2472     setSelection(cm.doc, cm.doc.sel.from, cm.doc.sel.to, null, "push");
2473   }
2474
2475   function skipAtomic(doc, pos, bias, mayClear) {
2476     var flipped = false, curPos = pos;
2477     var dir = bias || 1;
2478     doc.cantEdit = false;
2479     search: for (;;) {
2480       var line = getLine(doc, curPos.line);
2481       if (line.markedSpans) {
2482         for (var i = 0; i < line.markedSpans.length; ++i) {
2483           var sp = line.markedSpans[i], m = sp.marker;
2484           if ((sp.from == null || (m.inclusiveLeft ? sp.from <= curPos.ch : sp.from < curPos.ch)) &&
2485               (sp.to == null || (m.inclusiveRight ? sp.to >= curPos.ch : sp.to > curPos.ch))) {
2486             if (mayClear) {
2487               signal(m, "beforeCursorEnter");
2488               if (m.explicitlyCleared) {
2489                 if (!line.markedSpans) break;
2490                 else {--i; continue;}
2491               }
2492             }
2493             if (!m.atomic) continue;
2494             var newPos = m.find()[dir < 0 ? "from" : "to"];
2495             if (posEq(newPos, curPos)) {
2496               newPos.ch += dir;
2497               if (newPos.ch < 0) {
2498                 if (newPos.line > doc.first) newPos = clipPos(doc, Pos(newPos.line - 1));
2499                 else newPos = null;
2500               } else if (newPos.ch > line.text.length) {
2501                 if (newPos.line < doc.first + doc.size - 1) newPos = Pos(newPos.line + 1, 0);
2502                 else newPos = null;
2503               }
2504               if (!newPos) {
2505                 if (flipped) {
2506                   // Driven in a corner -- no valid cursor position found at all
2507                   // -- try again *with* clearing, if we didn't already
2508                   if (!mayClear) return skipAtomic(doc, pos, bias, true);
2509                   // Otherwise, turn off editing until further notice, and return the start of the doc
2510                   doc.cantEdit = true;
2511                   return Pos(doc.first, 0);
2512                 }
2513                 flipped = true; newPos = pos; dir = -dir;
2514               }
2515             }
2516             curPos = newPos;
2517             continue search;
2518           }
2519         }
2520       }
2521       return curPos;
2522     }
2523   }
2524
2525   // SCROLLING
2526
2527   function scrollCursorIntoView(cm) {
2528     var coords = scrollPosIntoView(cm, cm.doc.sel.head, cm.options.cursorScrollMargin);
2529     if (!cm.state.focused) return;
2530     var display = cm.display, box = getRect(display.sizer), doScroll = null, pTop = paddingTop(cm.display);
2531     if (coords.top + pTop + box.top < 0) doScroll = true;
2532     else if (coords.bottom + pTop + box.top > (window.innerHeight || document.documentElement.clientHeight)) doScroll = false;
2533     if (doScroll != null && !phantom) {
2534       var hidden = display.cursor.style.display == "none";
2535       if (hidden) {
2536         display.cursor.style.display = "";
2537         display.cursor.style.left = coords.left + "px";
2538         display.cursor.style.top = (coords.top - display.viewOffset) + "px";
2539       }
2540       display.cursor.scrollIntoView(doScroll);
2541       if (hidden) display.cursor.style.display = "none";
2542     }
2543   }
2544
2545   function scrollPosIntoView(cm, pos, margin) {
2546     if (margin == null) margin = 0;
2547     for (;;) {
2548       var changed = false, coords = cursorCoords(cm, pos);
2549       var scrollPos = calculateScrollPos(cm, coords.left, coords.top - margin, coords.left, coords.bottom + margin);
2550       var startTop = cm.doc.scrollTop, startLeft = cm.doc.scrollLeft;
2551       if (scrollPos.scrollTop != null) {
2552         setScrollTop(cm, scrollPos.scrollTop);
2553         if (Math.abs(cm.doc.scrollTop - startTop) > 1) changed = true;
2554       }
2555       if (scrollPos.scrollLeft != null) {
2556         setScrollLeft(cm, scrollPos.scrollLeft);
2557         if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) changed = true;
2558       }
2559       if (!changed) return coords;
2560     }
2561   }
2562
2563   function scrollIntoView(cm, x1, y1, x2, y2) {
2564     var scrollPos = calculateScrollPos(cm, x1, y1, x2, y2);
2565     if (scrollPos.scrollTop != null) setScrollTop(cm, scrollPos.scrollTop);
2566     if (scrollPos.scrollLeft != null) setScrollLeft(cm, scrollPos.scrollLeft);
2567   }
2568
2569   function calculateScrollPos(cm, x1, y1, x2, y2) {
2570     var display = cm.display, pt = paddingTop(display);
2571     y1 += pt; y2 += pt;
2572     if (y1 < 0) y1 = 0;
2573     var screen = display.scroller.clientHeight - scrollerCutOff, screentop = display.scroller.scrollTop, result = {};
2574     var docBottom = cm.doc.height + paddingVert(display);
2575     var atTop = y1 < pt + 10, atBottom = y2 + pt > docBottom - 10;
2576     if (y1 < screentop) {
2577       result.scrollTop = atTop ? 0 : y1;
2578     } else if (y2 > screentop + screen) {
2579       var newTop = Math.min(y1, (atBottom ? docBottom : y2) - screen);
2580       if (newTop != screentop) result.scrollTop = newTop;
2581     }
2582
2583     var screenw = display.scroller.clientWidth - scrollerCutOff, screenleft = display.scroller.scrollLeft;
2584     x1 += display.gutters.offsetWidth; x2 += display.gutters.offsetWidth;
2585     var gutterw = display.gutters.offsetWidth;
2586     var atLeft = x1 < gutterw + 10;
2587     if (x1 < screenleft + gutterw || atLeft) {
2588       if (atLeft) x1 = 0;
2589       result.scrollLeft = Math.max(0, x1 - 10 - gutterw);
2590     } else if (x2 > screenw + screenleft - 3) {
2591       result.scrollLeft = x2 + 10 - screenw;
2592     }
2593     return result;
2594   }
2595
2596   function updateScrollPos(cm, left, top) {
2597     cm.curOp.updateScrollPos = {scrollLeft: left == null ? cm.doc.scrollLeft : left,
2598                                 scrollTop: top == null ? cm.doc.scrollTop : top};
2599   }
2600
2601   function addToScrollPos(cm, left, top) {
2602     var pos = cm.curOp.updateScrollPos || (cm.curOp.updateScrollPos = {scrollLeft: cm.doc.scrollLeft, scrollTop: cm.doc.scrollTop});
2603     var scroll = cm.display.scroller;
2604     pos.scrollTop = Math.max(0, Math.min(scroll.scrollHeight - scroll.clientHeight, pos.scrollTop + top));
2605     pos.scrollLeft = Math.max(0, Math.min(scroll.scrollWidth - scroll.clientWidth, pos.scrollLeft + left));
2606   }
2607
2608   // API UTILITIES
2609
2610   function indentLine(cm, n, how, aggressive) {
2611     var doc = cm.doc;
2612     if (!how) how = "add";
2613     if (how == "smart") {
2614       if (!cm.doc.mode.indent) how = "prev";
2615       else var state = getStateBefore(cm, n);
2616     }
2617
2618     var tabSize = cm.options.tabSize;
2619     var line = getLine(doc, n), curSpace = countColumn(line.text, null, tabSize);
2620     var curSpaceString = line.text.match(/^\s*/)[0], indentation;
2621     if (how == "smart") {
2622       indentation = cm.doc.mode.indent(state, line.text.slice(curSpaceString.length), line.text);
2623       if (indentation == Pass) {
2624         if (!aggressive) return;
2625         how = "prev";
2626       }
2627     }
2628     if (how == "prev") {
2629       if (n > doc.first) indentation = countColumn(getLine(doc, n-1).text, null, tabSize);
2630       else indentation = 0;
2631     } else if (how == "add") {
2632       indentation = curSpace + cm.options.indentUnit;
2633     } else if (how == "subtract") {
2634       indentation = curSpace - cm.options.indentUnit;
2635     }
2636     indentation = Math.max(0, indentation);
2637
2638     var indentString = "", pos = 0;
2639     if (cm.options.indentWithTabs)
2640       for (var i = Math.floor(indentation / tabSize); i; --i) {pos += tabSize; indentString += "\t";}
2641     if (pos < indentation) indentString += spaceStr(indentation - pos);
2642
2643     if (indentString != curSpaceString)
2644       replaceRange(cm.doc, indentString, Pos(n, 0), Pos(n, curSpaceString.length), "+input");
2645     line.stateAfter = null;
2646   }
2647
2648   function changeLine(cm, handle, op) {
2649     var no = handle, line = handle, doc = cm.doc;
2650     if (typeof handle == "number") line = getLine(doc, clipLine(doc, handle));
2651     else no = lineNo(handle);
2652     if (no == null) return null;
2653     if (op(line, no)) regChange(cm, no, no + 1);
2654     else return null;
2655     return line;
2656   }
2657
2658   function findPosH(doc, pos, dir, unit, visually) {
2659     var line = pos.line, ch = pos.ch, origDir = dir;
2660     var lineObj = getLine(doc, line);
2661     var possible = true;
2662     function findNextLine() {
2663       var l = line + dir;
2664       if (l < doc.first || l >= doc.first + doc.size) return (possible = false);
2665       line = l;
2666       return lineObj = getLine(doc, l);
2667     }
2668     function moveOnce(boundToLine) {
2669       var next = (visually ? moveVisually : moveLogically)(lineObj, ch, dir, true);
2670       if (next == null) {
2671         if (!boundToLine && findNextLine()) {
2672           if (visually) ch = (dir < 0 ? lineRight : lineLeft)(lineObj);
2673           else ch = dir < 0 ? lineObj.text.length : 0;
2674         } else return (possible = false);
2675       } else ch = next;
2676       return true;
2677     }
2678
2679     if (unit == "char") moveOnce();
2680     else if (unit == "column") moveOnce(true);
2681     else if (unit == "word" || unit == "group") {
2682       var sawType = null, group = unit == "group";
2683       for (var first = true;; first = false) {
2684         if (dir < 0 && !moveOnce(!first)) break;
2685         var cur = lineObj.text.charAt(ch) || "\n";
2686         var type = isWordChar(cur) ? "w"
2687           : !group ? null
2688           : /\s/.test(cur) ? null
2689           : "p";
2690         if (sawType && sawType != type) {
2691           if (dir < 0) {dir = 1; moveOnce();}
2692           break;
2693         }
2694         if (type) sawType = type;
2695         if (dir > 0 && !moveOnce(!first)) break;
2696       }
2697     }
2698     var result = skipAtomic(doc, Pos(line, ch), origDir, true);
2699     if (!possible) result.hitSide = true;
2700     return result;
2701   }
2702
2703   function findPosV(cm, pos, dir, unit) {
2704     var doc = cm.doc, x = pos.left, y;
2705     if (unit == "page") {
2706       var pageSize = Math.min(cm.display.wrapper.clientHeight, window.innerHeight || document.documentElement.clientHeight);
2707       y = pos.top + dir * (pageSize - (dir < 0 ? 1.5 : .5) * textHeight(cm.display));
2708     } else if (unit == "line") {
2709       y = dir > 0 ? pos.bottom + 3 : pos.top - 3;
2710     }
2711     for (;;) {
2712       var target = coordsChar(cm, x, y);
2713       if (!target.outside) break;
2714       if (dir < 0 ? y <= 0 : y >= doc.height) { target.hitSide = true; break; }
2715       y += dir * 5;
2716     }
2717     return target;
2718   }
2719
2720   function findWordAt(line, pos) {
2721     var start = pos.ch, end = pos.ch;
2722     if (line) {
2723       if (pos.after === false || end == line.length) --start; else ++end;
2724       var startChar = line.charAt(start);
2725       var check = isWordChar(startChar) ? isWordChar
2726         : /\s/.test(startChar) ? function(ch) {return /\s/.test(ch);}
2727         : function(ch) {return !/\s/.test(ch) && !isWordChar(ch);};
2728       while (start > 0 && check(line.charAt(start - 1))) --start;
2729       while (end < line.length && check(line.charAt(end))) ++end;
2730     }
2731     return {from: Pos(pos.line, start), to: Pos(pos.line, end)};
2732   }
2733
2734   function selectLine(cm, line) {
2735     extendSelection(cm.doc, Pos(line, 0), clipPos(cm.doc, Pos(line + 1, 0)));
2736   }
2737
2738   // PROTOTYPE
2739
2740   // The publicly visible API. Note that operation(null, f) means
2741   // 'wrap f in an operation, performed on its `this` parameter'
2742
2743   CodeMirror.prototype = {
2744     constructor: CodeMirror,
2745     focus: function(){window.focus(); focusInput(this); onFocus(this); fastPoll(this);},
2746
2747     setOption: function(option, value) {
2748       var options = this.options, old = options[option];
2749       if (options[option] == value && option != "mode") return;
2750       options[option] = value;
2751       if (optionHandlers.hasOwnProperty(option))
2752         operation(this, optionHandlers[option])(this, value, old);
2753     },
2754
2755     getOption: function(option) {return this.options[option];},
2756     getDoc: function() {return this.doc;},
2757
2758     addKeyMap: function(map, bottom) {
2759       this.state.keyMaps[bottom ? "push" : "unshift"](map);
2760     },
2761     removeKeyMap: function(map) {
2762       var maps = this.state.keyMaps;
2763       for (var i = 0; i < maps.length; ++i)
2764         if ((typeof map == "string" ? maps[i].name : maps[i]) == map) {
2765           maps.splice(i, 1);
2766           return true;
2767         }
2768     },
2769
2770     addOverlay: operation(null, function(spec, options) {
2771       var mode = spec.token ? spec : CodeMirror.getMode(this.options, spec);
2772       if (mode.startState) throw new Error("Overlays may not be stateful.");
2773       this.state.overlays.push({mode: mode, modeSpec: spec, opaque: options && options.opaque});
2774       this.state.modeGen++;
2775       regChange(this);
2776     }),
2777     removeOverlay: operation(null, function(spec) {
2778       var overlays = this.state.overlays;
2779       for (var i = 0; i < overlays.length; ++i) {
2780         if (overlays[i].modeSpec == spec) {
2781           overlays.splice(i, 1);
2782           this.state.modeGen++;
2783           regChange(this);
2784           return;
2785         }
2786       }
2787     }),
2788
2789     indentLine: operation(null, function(n, dir, aggressive) {
2790       if (typeof dir != "string") {
2791         if (dir == null) dir = this.options.smartIndent ? "smart" : "prev";
2792         else dir = dir ? "add" : "subtract";
2793       }
2794       if (isLine(this.doc, n)) indentLine(this, n, dir, aggressive);
2795     }),
2796     indentSelection: operation(null, function(how) {
2797       var sel = this.doc.sel;
2798       if (posEq(sel.from, sel.to)) return indentLine(this, sel.from.line, how);
2799       var e = sel.to.line - (sel.to.ch ? 0 : 1);
2800       for (var i = sel.from.line; i <= e; ++i) indentLine(this, i, how);
2801     }),
2802
2803     // Fetch the parser token for a given character. Useful for hacks
2804     // that want to inspect the mode state (say, for completion).
2805     getTokenAt: function(pos) {
2806       var doc = this.doc;
2807       pos = clipPos(doc, pos);
2808       var state = getStateBefore(this, pos.line), mode = this.doc.mode;
2809       var line = getLine(doc, pos.line);
2810       var stream = new StringStream(line.text, this.options.tabSize);
2811       while (stream.pos < pos.ch && !stream.eol()) {
2812         stream.start = stream.pos;
2813         var style = mode.token(stream, state);
2814       }
2815       return {start: stream.start,
2816               end: stream.pos,
2817               string: stream.current(),
2818               className: style || null, // Deprecated, use 'type' instead
2819               type: style || null,
2820               state: state};
2821     },
2822
2823     getStateAfter: function(line) {
2824       var doc = this.doc;
2825       line = clipLine(doc, line == null ? doc.first + doc.size - 1: line);
2826       return getStateBefore(this, line + 1);
2827     },
2828
2829     cursorCoords: function(start, mode) {
2830       var pos, sel = this.doc.sel;
2831       if (start == null) pos = sel.head;
2832       else if (typeof start == "object") pos = clipPos(this.doc, start);
2833       else pos = start ? sel.from : sel.to;
2834       return cursorCoords(this, pos, mode || "page");
2835     },
2836
2837     charCoords: function(pos, mode) {
2838       return charCoords(this, clipPos(this.doc, pos), mode || "page");
2839     },
2840
2841     coordsChar: function(coords, mode) {
2842       coords = fromCoordSystem(this, coords, mode || "page");
2843       return coordsChar(this, coords.left, coords.top);
2844     },
2845
2846     defaultTextHeight: function() { return textHeight(this.display); },
2847     defaultCharWidth: function() { return charWidth(this.display); },
2848
2849     setGutterMarker: operation(null, function(line, gutterID, value) {
2850       return changeLine(this, line, function(line) {
2851         var markers = line.gutterMarkers || (line.gutterMarkers = {});
2852         markers[gutterID] = value;
2853         if (!value && isEmpty(markers)) line.gutterMarkers = null;
2854         return true;
2855       });
2856     }),
2857
2858     clearGutter: operation(null, function(gutterID) {
2859       var cm = this, doc = cm.doc, i = doc.first;
2860       doc.iter(function(line) {
2861         if (line.gutterMarkers && line.gutterMarkers[gutterID]) {
2862           line.gutterMarkers[gutterID] = null;
2863           regChange(cm, i, i + 1);
2864           if (isEmpty(line.gutterMarkers)) line.gutterMarkers = null;
2865         }
2866         ++i;
2867       });
2868     }),
2869
2870     addLineClass: operation(null, function(handle, where, cls) {
2871       return changeLine(this, handle, function(line) {
2872         var prop = where == "text" ? "textClass" : where == "background" ? "bgClass" : "wrapClass";
2873         if (!line[prop]) line[prop] = cls;
2874         else if (new RegExp("\\b" + cls + "\\b").test(line[prop])) return false;
2875         else line[prop] += " " + cls;
2876         return true;
2877       });
2878     }),
2879
2880     removeLineClass: operation(null, function(handle, where, cls) {
2881       return changeLine(this, handle, function(line) {
2882         var prop = where == "text" ? "textClass" : where == "background" ? "bgClass" : "wrapClass";
2883         var cur = line[prop];
2884         if (!cur) return false;
2885         else if (cls == null) line[prop] = null;
2886         else {
2887           var upd = cur.replace(new RegExp("^" + cls + "\\b\\s*|\\s*\\b" + cls + "\\b"), "");
2888           if (upd == cur) return false;
2889           line[prop] = upd || null;
2890         }
2891         return true;
2892       });
2893     }),
2894
2895     addLineWidget: operation(null, function(handle, node, options) {
2896       return addLineWidget(this, handle, node, options);
2897     }),
2898
2899     removeLineWidget: function(widget) { widget.clear(); },
2900
2901     lineInfo: function(line) {
2902       if (typeof line == "number") {
2903         if (!isLine(this.doc, line)) return null;
2904         var n = line;
2905         line = getLine(this.doc, line);
2906         if (!line) return null;
2907       } else {
2908         var n = lineNo(line);
2909         if (n == null) return null;
2910       }
2911       return {line: n, handle: line, text: line.text, gutterMarkers: line.gutterMarkers,
2912               textClass: line.textClass, bgClass: line.bgClass, wrapClass: line.wrapClass,
2913               widgets: line.widgets};
2914     },
2915
2916     getViewport: function() { return {from: this.display.showingFrom, to: this.display.showingTo};},
2917
2918     addWidget: function(pos, node, scroll, vert, horiz) {
2919       var display = this.display;
2920       pos = cursorCoords(this, clipPos(this.doc, pos));
2921       var top = pos.bottom, left = pos.left;
2922       node.style.position = "absolute";
2923       display.sizer.appendChild(node);
2924       if (vert == "over") {
2925         top = pos.top;
2926       } else if (vert == "above" || vert == "near") {
2927         var vspace = Math.max(display.wrapper.clientHeight, this.doc.height),
2928         hspace = Math.max(display.sizer.clientWidth, display.lineSpace.clientWidth);
2929         // Default to positioning above (if specified and possible); otherwise default to positioning below
2930         if ((vert == 'above' || pos.bottom + node.offsetHeight > vspace) && pos.top > node.offsetHeight)
2931           top = pos.top - node.offsetHeight;
2932         else if (pos.bottom + node.offsetHeight <= vspace)
2933           top = pos.bottom;
2934         if (left + node.offsetWidth > hspace)
2935           left = hspace - node.offsetWidth;
2936       }
2937       node.style.top = (top + paddingTop(display)) + "px";
2938       node.style.left = node.style.right = "";
2939       if (horiz == "right") {
2940         left = display.sizer.clientWidth - node.offsetWidth;
2941         node.style.right = "0px";
2942       } else {
2943         if (horiz == "left") left = 0;
2944         else if (horiz == "middle") left = (display.sizer.clientWidth - node.offsetWidth) / 2;
2945         node.style.left = left + "px";
2946       }
2947       if (scroll)
2948         scrollIntoView(this, left, top, left + node.offsetWidth, top + node.offsetHeight);
2949     },
2950
2951     triggerOnKeyDown: operation(null, onKeyDown),
2952
2953     execCommand: function(cmd) {return commands[cmd](this);},
2954
2955     findPosH: function(from, amount, unit, visually) {
2956       var dir = 1;
2957       if (amount < 0) { dir = -1; amount = -amount; }
2958       for (var i = 0, cur = clipPos(this.doc, from); i < amount; ++i) {
2959         cur = findPosH(this.doc, cur, dir, unit, visually);
2960         if (cur.hitSide) break;
2961       }
2962       return cur;
2963     },
2964
2965     moveH: operation(null, function(dir, unit) {
2966       var sel = this.doc.sel, pos;
2967       if (sel.shift || sel.extend || posEq(sel.from, sel.to))
2968         pos = findPosH(this.doc, sel.head, dir, unit, this.options.rtlMoveVisually);
2969       else
2970         pos = dir < 0 ? sel.from : sel.to;
2971       extendSelection(this.doc, pos, pos, dir);
2972     }),
2973
2974     deleteH: operation(null, function(dir, unit) {
2975       var sel = this.doc.sel;
2976       if (!posEq(sel.from, sel.to)) replaceRange(this.doc, "", sel.from, sel.to, "+delete");
2977       else replaceRange(this.doc, "", sel.from, findPosH(this.doc, sel.head, dir, unit, false), "+delete");
2978       this.curOp.userSelChange = true;
2979     }),
2980
2981     findPosV: function(from, amount, unit, goalColumn) {
2982       var dir = 1, x = goalColumn;
2983       if (amount < 0) { dir = -1; amount = -amount; }
2984       for (var i = 0, cur = clipPos(this.doc, from); i < amount; ++i) {
2985         var coords = cursorCoords(this, cur, "div");
2986         if (x == null) x = coords.left;
2987         else coords.left = x;
2988         cur = findPosV(this, coords, dir, unit);
2989         if (cur.hitSide) break;
2990       }
2991       return cur;
2992     },
2993
2994     moveV: operation(null, function(dir, unit) {
2995       var sel = this.doc.sel;
2996       var pos = cursorCoords(this, sel.head, "div");
2997       if (sel.goalColumn != null) pos.left = sel.goalColumn;
2998       var target = findPosV(this, pos, dir, unit);
2999
3000       if (unit == "page") addToScrollPos(this, 0, charCoords(this, target, "div").top - pos.top);
3001       extendSelection(this.doc, target, target, dir);
3002       sel.goalColumn = pos.left;
3003     }),
3004
3005     toggleOverwrite: function(value) {
3006       if (value != null && value == this.state.overwrite) return;
3007       if (this.state.overwrite = !this.state.overwrite)
3008         this.display.cursor.className += " CodeMirror-overwrite";
3009       else
3010         this.display.cursor.className = this.display.cursor.className.replace(" CodeMirror-overwrite", "");
3011     },
3012     hasFocus: function() { return this.state.focused; },
3013
3014     scrollTo: operation(null, function(x, y) {
3015       updateScrollPos(this, x, y);
3016     }),
3017     getScrollInfo: function() {
3018       var scroller = this.display.scroller, co = scrollerCutOff;
3019       return {left: scroller.scrollLeft, top: scroller.scrollTop,
3020               height: scroller.scrollHeight - co, width: scroller.scrollWidth - co,
3021               clientHeight: scroller.clientHeight - co, clientWidth: scroller.clientWidth - co};
3022     },
3023
3024     scrollIntoView: operation(null, function(pos, margin) {
3025       if (typeof pos == "number") pos = Pos(pos, 0);
3026       if (!margin) margin = 0;
3027       var coords = pos;
3028
3029       if (!pos || pos.line != null) {
3030         this.curOp.scrollToPos = pos ? clipPos(this.doc, pos) : this.doc.sel.head;
3031         this.curOp.scrollToPosMargin = margin;
3032         coords = cursorCoords(this, this.curOp.scrollToPos);
3033       }
3034       var sPos = calculateScrollPos(this, coords.left, coords.top - margin, coords.right, coords.bottom + margin);
3035       updateScrollPos(this, sPos.scrollLeft, sPos.scrollTop);
3036     }),
3037
3038     setSize: function(width, height) {
3039       function interpret(val) {
3040         return typeof val == "number" || /^\d+$/.test(String(val)) ? val + "px" : val;
3041       }
3042       if (width != null) this.display.wrapper.style.width = interpret(width);
3043       if (height != null) this.display.wrapper.style.height = interpret(height);
3044       this.refresh();
3045     },
3046
3047     on: function(type, f) {on(this, type, f);},
3048     off: function(type, f) {off(this, type, f);},
3049
3050     operation: function(f){return runInOp(this, f);},
3051
3052     refresh: operation(null, function() {
3053       clearCaches(this);
3054       updateScrollPos(this, this.doc.scrollLeft, this.doc.scrollTop);
3055       regChange(this);
3056     }),
3057
3058     swapDoc: operation(null, function(doc) {
3059       var old = this.doc;
3060       old.cm = null;
3061       attachDoc(this, doc);
3062       clearCaches(this);
3063       resetInput(this, true);
3064       updateScrollPos(this, doc.scrollLeft, doc.scrollTop);
3065       return old;
3066     }),
3067
3068     getInputField: function(){return this.display.input;},
3069     getWrapperElement: function(){return this.display.wrapper;},
3070     getScrollerElement: function(){return this.display.scroller;},
3071     getGutterElement: function(){return this.display.gutters;}
3072   };
3073
3074   // OPTION DEFAULTS
3075
3076   var optionHandlers = CodeMirror.optionHandlers = {};
3077
3078   // The default configuration options.
3079   var defaults = CodeMirror.defaults = {};
3080
3081   function option(name, deflt, handle, notOnInit) {
3082     CodeMirror.defaults[name] = deflt;
3083     if (handle) optionHandlers[name] =
3084       notOnInit ? function(cm, val, old) {if (old != Init) handle(cm, val, old);} : handle;
3085   }
3086
3087   var Init = CodeMirror.Init = {toString: function(){return "CodeMirror.Init";}};
3088
3089   // These two are, on init, called from the constructor because they
3090   // have to be initialized before the editor can start at all.
3091   option("value", "", function(cm, val) {
3092     cm.setValue(val);
3093   }, true);
3094   option("mode", null, function(cm, val) {
3095     cm.doc.modeOption = val;
3096     loadMode(cm);
3097   }, true);
3098
3099   option("indentUnit", 2, loadMode, true);
3100   option("indentWithTabs", false);
3101   option("smartIndent", true);
3102   option("tabSize", 4, function(cm) {
3103     loadMode(cm);
3104     clearCaches(cm);
3105     regChange(cm);
3106   }, true);
3107   option("electricChars", true);
3108   option("rtlMoveVisually", !windows);
3109
3110   option("theme", "default", function(cm) {
3111     themeChanged(cm);
3112     guttersChanged(cm);
3113   }, true);
3114   option("keyMap", "default", keyMapChanged);
3115   option("extraKeys", null);
3116
3117   option("onKeyEvent", null);
3118   option("onDragEvent", null);
3119
3120   option("lineWrapping", false, wrappingChanged, true);
3121   option("gutters", [], function(cm) {
3122     setGuttersForLineNumbers(cm.options);
3123     guttersChanged(cm);
3124   }, true);
3125   option("fixedGutter", true, function(cm, val) {
3126     cm.display.gutters.style.left = val ? compensateForHScroll(cm.display) + "px" : "0";
3127     cm.refresh();
3128   }, true);
3129   option("coverGutterNextToScrollbar", false, updateScrollbars, true);
3130   option("lineNumbers", false, function(cm) {
3131     setGuttersForLineNumbers(cm.options);
3132     guttersChanged(cm);
3133   }, true);
3134   option("firstLineNumber", 1, guttersChanged, true);
3135   option("lineNumberFormatter", function(integer) {return integer;}, guttersChanged, true);
3136   option("showCursorWhenSelecting", false, updateSelection, true);
3137
3138   option("readOnly", false, function(cm, val) {
3139     if (val == "nocursor") {onBlur(cm); cm.display.input.blur();}
3140     else if (!val) resetInput(cm, true);
3141   });
3142   option("dragDrop", true);
3143
3144   option("cursorBlinkRate", 530);
3145   option("cursorScrollMargin", 0);
3146   option("cursorHeight", 1);
3147   option("workTime", 100);
3148   option("workDelay", 100);
3149   option("flattenSpans", true);
3150   option("pollInterval", 100);
3151   option("undoDepth", 40, function(cm, val){cm.doc.history.undoDepth = val;});
3152   option("historyEventDelay", 500);
3153   option("viewportMargin", 10, function(cm){cm.refresh();}, true);
3154   option("maxHighlightLength", 10000, function(cm){loadMode(cm); cm.refresh();}, true);
3155   option("moveInputWithCursor", true, function(cm, val) {
3156     if (!val) cm.display.inputDiv.style.top = cm.display.inputDiv.style.left = 0;
3157   });
3158
3159   option("tabindex", null, function(cm, val) {
3160     cm.display.input.tabIndex = val || "";
3161   });
3162   option("autofocus", null);
3163
3164   // MODE DEFINITION AND QUERYING
3165
3166   // Known modes, by name and by MIME
3167   var modes = CodeMirror.modes = {}, mimeModes = CodeMirror.mimeModes = {};
3168
3169   CodeMirror.defineMode = function(name, mode) {
3170     if (!CodeMirror.defaults.mode && name != "null") CodeMirror.defaults.mode = name;
3171     if (arguments.length > 2) {
3172       mode.dependencies = [];
3173       for (var i = 2; i < arguments.length; ++i) mode.dependencies.push(arguments[i]);
3174     }
3175     modes[name] = mode;
3176   };
3177
3178   CodeMirror.defineMIME = function(mime, spec) {
3179     mimeModes[mime] = spec;
3180   };
3181
3182   CodeMirror.resolveMode = function(spec) {
3183     if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) {
3184       spec = mimeModes[spec];
3185     } else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) {
3186       var found = mimeModes[spec.name];
3187       spec = createObj(found, spec);
3188       spec.name = found.name;
3189     } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+xml$/.test(spec)) {
3190       return CodeMirror.resolveMode("application/xml");
3191     }
3192     if (typeof spec == "string") return {name: spec};
3193     else return spec || {name: "null"};
3194   };
3195
3196   CodeMirror.getMode = function(options, spec) {
3197     spec = CodeMirror.resolveMode(spec);
3198     var mfactory = modes[spec.name];
3199     if (!mfactory) return CodeMirror.getMode(options, "text/plain");
3200     var modeObj = mfactory(options, spec);
3201     if (modeExtensions.hasOwnProperty(spec.name)) {
3202       var exts = modeExtensions[spec.name];
3203       for (var prop in exts) {
3204         if (!exts.hasOwnProperty(prop)) continue;
3205         if (modeObj.hasOwnProperty(prop)) modeObj["_" + prop] = modeObj[prop];
3206         modeObj[prop] = exts[prop];
3207       }
3208     }
3209     modeObj.name = spec.name;
3210     return modeObj;
3211   };
3212
3213   CodeMirror.defineMode("null", function() {
3214     return {token: function(stream) {stream.skipToEnd();}};
3215   });
3216   CodeMirror.defineMIME("text/plain", "null");
3217
3218   var modeExtensions = CodeMirror.modeExtensions = {};
3219   CodeMirror.extendMode = function(mode, properties) {
3220     var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {});
3221     copyObj(properties, exts);
3222   };
3223
3224   // EXTENSIONS
3225
3226   CodeMirror.defineExtension = function(name, func) {
3227     CodeMirror.prototype[name] = func;
3228   };
3229   CodeMirror.defineDocExtension = function(name, func) {
3230     Doc.prototype[name] = func;
3231   };
3232   CodeMirror.defineOption = option;
3233
3234   var initHooks = [];
3235   CodeMirror.defineInitHook = function(f) {initHooks.push(f);};
3236
3237   // MODE STATE HANDLING
3238
3239   // Utility functions for working with state. Exported because modes
3240   // sometimes need to do this.
3241   function copyState(mode, state) {
3242     if (state === true) return state;
3243     if (mode.copyState) return mode.copyState(state);
3244     var nstate = {};
3245     for (var n in state) {
3246       var val = state[n];
3247       if (val instanceof Array) val = val.concat([]);
3248       nstate[n] = val;
3249     }
3250     return nstate;
3251   }
3252   CodeMirror.copyState = copyState;
3253
3254   function startState(mode, a1, a2) {
3255     return mode.startState ? mode.startState(a1, a2) : true;
3256   }
3257   CodeMirror.startState = startState;
3258
3259   CodeMirror.innerMode = function(mode, state) {
3260     while (mode.innerMode) {
3261       var info = mode.innerMode(state);
3262       state = info.state;
3263       mode = info.mode;
3264     }
3265     return info || {mode: mode, state: state};
3266   };
3267
3268   // STANDARD COMMANDS
3269
3270   var commands = CodeMirror.commands = {
3271     selectAll: function(cm) {cm.setSelection(Pos(cm.firstLine(), 0), Pos(cm.lastLine()));},
3272     killLine: function(cm) {
3273       var from = cm.getCursor(true), to = cm.getCursor(false), sel = !posEq(from, to);
3274       if (!sel && cm.getLine(from.line).length == from.ch)
3275         cm.replaceRange("", from, Pos(from.line + 1, 0), "+delete");
3276       else cm.replaceRange("", from, sel ? to : Pos(from.line), "+delete");
3277     },
3278     deleteLine: function(cm) {
3279       var l = cm.getCursor().line;
3280       cm.replaceRange("", Pos(l, 0), Pos(l), "+delete");
3281     },
3282     undo: function(cm) {cm.undo();},
3283     redo: function(cm) {cm.redo();},
3284     goDocStart: function(cm) {cm.extendSelection(Pos(cm.firstLine(), 0));},
3285     goDocEnd: function(cm) {cm.extendSelection(Pos(cm.lastLine()));},
3286     goLineStart: function(cm) {
3287       cm.extendSelection(lineStart(cm, cm.getCursor().line));
3288     },
3289     goLineStartSmart: function(cm) {
3290       var cur = cm.getCursor(), start = lineStart(cm, cur.line);
3291       var line = cm.getLineHandle(start.line);
3292       var order = getOrder(line);
3293       if (!order || order[0].level == 0) {
3294         var firstNonWS = Math.max(0, line.text.search(/\S/));
3295         var inWS = cur.line == start.line && cur.ch <= firstNonWS && cur.ch;
3296         cm.extendSelection(Pos(start.line, inWS ? 0 : firstNonWS));
3297       } else cm.extendSelection(start);
3298     },
3299     goLineEnd: function(cm) {
3300       cm.extendSelection(lineEnd(cm, cm.getCursor().line));
3301     },
3302     goLineRight: function(cm) {
3303       var top = cm.charCoords(cm.getCursor(), "div").top + 5;
3304       cm.extendSelection(cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div"));
3305     },
3306     goLineLeft: function(cm) {
3307       var top = cm.charCoords(cm.getCursor(), "div").top + 5;
3308       cm.extendSelection(cm.coordsChar({left: 0, top: top}, "div"));
3309     },
3310     goLineUp: function(cm) {cm.moveV(-1, "line");},
3311     goLineDown: function(cm) {cm.moveV(1, "line");},
3312     goPageUp: function(cm) {cm.moveV(-1, "page");},
3313     goPageDown: function(cm) {cm.moveV(1, "page");},
3314     goCharLeft: function(cm) {cm.moveH(-1, "char");},
3315     goCharRight: function(cm) {cm.moveH(1, "char");},
3316     goColumnLeft: function(cm) {cm.moveH(-1, "column");},
3317     goColumnRight: function(cm) {cm.moveH(1, "column");},
3318     goWordLeft: function(cm) {cm.moveH(-1, "word");},
3319     goGroupRight: function(cm) {cm.moveH(1, "group");},
3320     goGroupLeft: function(cm) {cm.moveH(-1, "group");},
3321     goWordRight: function(cm) {cm.moveH(1, "word");},
3322     delCharBefore: function(cm) {cm.deleteH(-1, "char");},
3323     delCharAfter: function(cm) {cm.deleteH(1, "char");},
3324     delWordBefore: function(cm) {cm.deleteH(-1, "word");},
3325     delWordAfter: function(cm) {cm.deleteH(1, "word");},
3326     delGroupBefore: function(cm) {cm.deleteH(-1, "group");},
3327     delGroupAfter: function(cm) {cm.deleteH(1, "group");},
3328     indentAuto: function(cm) {cm.indentSelection("smart");},
3329     indentMore: function(cm) {cm.indentSelection("add");},
3330     indentLess: function(cm) {cm.indentSelection("subtract");},
3331     insertTab: function(cm) {cm.replaceSelection("\t", "end", "+input");},
3332     defaultTab: function(cm) {
3333       if (cm.somethingSelected()) cm.indentSelection("add");
3334       else cm.replaceSelection("\t", "end", "+input");
3335     },
3336     transposeChars: function(cm) {
3337       var cur = cm.getCursor(), line = cm.getLine(cur.line);
3338       if (cur.ch > 0 && cur.ch < line.length - 1)
3339         cm.replaceRange(line.charAt(cur.ch) + line.charAt(cur.ch - 1),
3340                         Pos(cur.line, cur.ch - 1), Pos(cur.line, cur.ch + 1));
3341     },
3342     newlineAndIndent: function(cm) {
3343       operation(cm, function() {
3344         cm.replaceSelection("\n", "end", "+input");
3345         cm.indentLine(cm.getCursor().line, null, true);
3346       })();
3347     },
3348     toggleOverwrite: function(cm) {cm.toggleOverwrite();}
3349   };
3350
3351   // STANDARD KEYMAPS
3352
3353   var keyMap = CodeMirror.keyMap = {};
3354   keyMap.basic = {
3355     "Left": "goCharLeft", "Right": "goCharRight", "Up": "goLineUp", "Down": "goLineDown",
3356     "End": "goLineEnd", "Home": "goLineStartSmart", "PageUp": "goPageUp", "PageDown": "goPageDown",
3357     "Delete": "delCharAfter", "Backspace": "delCharBefore", "Tab": "defaultTab", "Shift-Tab": "indentAuto",
3358     "Enter": "newlineAndIndent", "Insert": "toggleOverwrite"
3359   };
3360   // Note that the save and find-related commands aren't defined by
3361   // default. Unknown commands are simply ignored.
3362   keyMap.pcDefault = {
3363     "Ctrl-A": "selectAll", "Ctrl-D": "deleteLine", "Ctrl-Z": "undo", "Shift-Ctrl-Z": "redo", "Ctrl-Y": "redo",
3364     "Ctrl-Home": "goDocStart", "Alt-Up": "goDocStart", "Ctrl-End": "goDocEnd", "Ctrl-Down": "goDocEnd",
3365     "Ctrl-Left": "goGroupLeft", "Ctrl-Right": "goGroupRight", "Alt-Left": "goLineStart", "Alt-Right": "goLineEnd",
3366     "Ctrl-Backspace": "delGroupBefore", "Ctrl-Delete": "delGroupAfter", "Ctrl-S": "save", "Ctrl-F": "find",
3367     "Ctrl-G": "findNext", "Shift-Ctrl-G": "findPrev", "Shift-Ctrl-F": "replace", "Shift-Ctrl-R": "replaceAll",
3368     "Ctrl-[": "indentLess", "Ctrl-]": "indentMore",
3369     fallthrough: "basic"
3370   };
3371   keyMap.macDefault = {
3372     "Cmd-A": "selectAll", "Cmd-D": "deleteLine", "Cmd-Z": "undo", "Shift-Cmd-Z": "redo", "Cmd-Y": "redo",
3373     "Cmd-Up": "goDocStart", "Cmd-End": "goDocEnd", "Cmd-Down": "goDocEnd", "Alt-Left": "goGroupLeft",
3374     "Alt-Right": "goGroupRight", "Cmd-Left": "goLineStart", "Cmd-Right": "goLineEnd", "Alt-Backspace": "delGroupBefore",
3375     "Ctrl-Alt-Backspace": "delGroupAfter", "Alt-Delete": "delGroupAfter", "Cmd-S": "save", "Cmd-F": "find",
3376     "Cmd-G": "findNext", "Shift-Cmd-G": "findPrev", "Cmd-Alt-F": "replace", "Shift-Cmd-Alt-F": "replaceAll",
3377     "Cmd-[": "indentLess", "Cmd-]": "indentMore",
3378     fallthrough: ["basic", "emacsy"]
3379   };
3380   keyMap["default"] = mac ? keyMap.macDefault : keyMap.pcDefault;
3381   keyMap.emacsy = {
3382     "Ctrl-F": "goCharRight", "Ctrl-B": "goCharLeft", "Ctrl-P": "goLineUp", "Ctrl-N": "goLineDown",
3383     "Alt-F": "goWordRight", "Alt-B": "goWordLeft", "Ctrl-A": "goLineStart", "Ctrl-E": "goLineEnd",
3384     "Ctrl-V": "goPageDown", "Shift-Ctrl-V": "goPageUp", "Ctrl-D": "delCharAfter", "Ctrl-H": "delCharBefore",
3385     "Alt-D": "delWordAfter", "Alt-Backspace": "delWordBefore", "Ctrl-K": "killLine", "Ctrl-T": "transposeChars"
3386   };
3387
3388   // KEYMAP DISPATCH
3389
3390   function getKeyMap(val) {
3391     if (typeof val == "string") return keyMap[val];
3392     else return val;
3393   }
3394
3395   function lookupKey(name, maps, handle) {
3396     function lookup(map) {
3397       map = getKeyMap(map);
3398       var found = map[name];
3399       if (found === false) return "stop";
3400       if (found != null && handle(found)) return true;
3401       if (map.nofallthrough) return "stop";
3402
3403       var fallthrough = map.fallthrough;
3404       if (fallthrough == null) return false;
3405       if (Object.prototype.toString.call(fallthrough) != "[object Array]")
3406         return lookup(fallthrough);
3407       for (var i = 0, e = fallthrough.length; i < e; ++i) {
3408         var done = lookup(fallthrough[i]);
3409         if (done) return done;
3410       }
3411       return false;
3412     }
3413
3414     for (var i = 0; i < maps.length; ++i) {
3415       var done = lookup(maps[i]);
3416       if (done) return done;
3417     }
3418   }
3419   function isModifierKey(event) {
3420     var name = keyNames[event.keyCode];
3421     return name == "Ctrl" || name == "Alt" || name == "Shift" || name == "Mod";
3422   }
3423   function keyName(event, noShift) {
3424     if (opera && event.keyCode == 34 && event["char"]) return false;
3425     var name = keyNames[event.keyCode];
3426     if (name == null || event.altGraphKey) return false;
3427     if (event.altKey) name = "Alt-" + name;
3428     if (flipCtrlCmd ? event.metaKey : event.ctrlKey) name = "Ctrl-" + name;
3429     if (flipCtrlCmd ? event.ctrlKey : event.metaKey) name = "Cmd-" + name;
3430     if (!noShift && event.shiftKey) name = "Shift-" + name;
3431     return name;
3432   }
3433   CodeMirror.lookupKey = lookupKey;
3434   CodeMirror.isModifierKey = isModifierKey;
3435   CodeMirror.keyName = keyName;
3436
3437   // FROMTEXTAREA
3438
3439   CodeMirror.fromTextArea = function(textarea, options) {
3440     if (!options) options = {};
3441     options.value = textarea.value;
3442     if (!options.tabindex && textarea.tabindex)
3443       options.tabindex = textarea.tabindex;
3444     if (!options.placeholder && textarea.placeholder)
3445       options.placeholder = textarea.placeholder;
3446     // Set autofocus to true if this textarea is focused, or if it has
3447     // autofocus and no other element is focused.
3448     if (options.autofocus == null) {
3449       var hasFocus = document.body;
3450       // doc.activeElement occasionally throws on IE
3451       try { hasFocus = document.activeElement; } catch(e) {}
3452       options.autofocus = hasFocus == textarea ||
3453         textarea.getAttribute("autofocus") != null && hasFocus == document.body;
3454     }
3455
3456     function save() {textarea.value = cm.getValue();}
3457     if (textarea.form) {
3458       on(textarea.form, "submit", save);
3459       // Deplorable hack to make the submit method do the right thing.
3460       if (!options.leaveSubmitMethodAlone) {
3461         var form = textarea.form, realSubmit = form.submit;
3462         try {
3463           var wrappedSubmit = form.submit = function() {
3464             save();
3465             form.submit = realSubmit;
3466             form.submit();
3467             form.submit = wrappedSubmit;
3468           };
3469         } catch(e) {}
3470       }
3471     }
3472
3473     textarea.style.display = "none";
3474     var cm = CodeMirror(function(node) {