// CodeMirror version 3.0

 //

 // CodeMirror is the only global var we claim

 window.CodeMirror = (function() {

   "use strict";

   // BROWSER SNIFFING

   // Crude, but necessary to handle a number of hard-to-feature-detect

   // bugs and behavior differences.

   var gecko = /gecko\/\d/i.test(navigator.userAgent);

   var ie = /MSIE \d/.test(navigator.userAgent);

   var ie_lt8 = /MSIE [1-7]\b/.test(navigator.userAgent);

   var ie_lt9 = /MSIE [1-8]\b/.test(navigator.userAgent);

   var webkit = /WebKit\//.test(navigator.userAgent);

   var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(navigator.userAgent);

   var chrome = /Chrome\//.test(navigator.userAgent);

   var opera = /Opera\//.test(navigator.userAgent);

   var safari = /Apple Computer/.test(navigator.vendor);

   var khtml = /KHTML\//.test(navigator.userAgent);

   var mac_geLion = /Mac OS X 1\d\D([7-9]|\d\d)\D/.test(navigator.userAgent);

   var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(navigator.userAgent);

   var phantom = /PhantomJS/.test(navigator.userAgent);

   var ios = /AppleWebKit/.test(navigator.userAgent) && /Mobile\/\w+/.test(navigator.userAgent);

   // This is woefully incomplete. Suggestions for alternative methods welcome.

   var mobile = ios || /Android|webOS|BlackBerry|Opera Mini|IEMobile/i.test(navigator.userAgent);

   var mac = ios || /Mac/.test(navigator.platform);

   // Optimize some code when these features are not used

   var sawReadOnlySpans = false, sawCollapsedSpans = false;

   // CONSTRUCTOR

   function CodeMirror(place, options) {

     if (!(this instanceof CodeMirror)) return new CodeMirror(place, options);

     this.options = options = options || {};

     // Determine effective options based on given values and defaults.

     for (var opt in defaults) if (!options.hasOwnProperty(opt) && defaults.hasOwnProperty(opt))

       options[opt] = defaults[opt];

     setGuttersForLineNumbers(options);

     var display = this.display = makeDisplay(place);

     display.wrapper.CodeMirror = this;

     updateGutters(this);

     if (options.autofocus && !mobile) focusInput(this);

     this.view = makeView(new BranchChunk([new LeafChunk([makeLine("", null, textHeight(display))])]));

     this.nextOpId = 0;

     loadMode(this);

     themeChanged(this);

     if (options.lineWrapping)

       this.display.wrapper.className += " CodeMirror-wrap";

     // Initialize the content.

     this.setValue(options.value || "");

     // Override magic textarea content restore that IE sometimes does

     // on our hidden textarea on reload

     if (ie) setTimeout(bind(resetInput, this, true), 20);

     this.view.history = makeHistory();

     registerEventHandlers(this);

     // IE throws unspecified error in certain cases, when

     // trying to access activeElement before onload

     var hasFocus; try { hasFocus = (document.activeElement == display.input); } catch(e) { }

     if (hasFocus || (options.autofocus && !mobile)) setTimeout(bind(onFocus, this), 20);

     else onBlur(this);

     operation(this, function() {

       for (var opt in optionHandlers)

         if (optionHandlers.propertyIsEnumerable(opt))

           optionHandlers[opt](this, options[opt], Init);

       for (var i = 0; i < initHooks.length; ++i) initHooks[i](this);

     })();

   }

   // DISPLAY CONSTRUCTOR

   function makeDisplay(place) {

     var d = {};

     var input = d.input = elt("textarea", null, null, "position: absolute; padding: 0; width: 1px; height: 1em; outline: none;");

     input.setAttribute("wrap", "off"); input.setAttribute("autocorrect", "off"); input.setAttribute("autocapitalize", "off");

     // Wraps and hides input textarea

     d.inputDiv = elt("div", [input], null, "overflow: hidden; position: relative; width: 3px; height: 0px;");

     // The actual fake scrollbars.

     d.scrollbarH = elt("div", [elt("div", null, null, "height: 1px")], "CodeMirror-hscrollbar");

     d.scrollbarV = elt("div", [elt("div", null, null, "width: 1px")], "CodeMirror-vscrollbar");

     d.scrollbarFiller = elt("div", null, "CodeMirror-scrollbar-filler");

     // DIVs containing the selection and the actual code

     d.lineDiv = elt("div");

     d.selectionDiv = elt("div", null, null, "position: relative; z-index: 1");

     // Blinky cursor, and element used to ensure cursor fits at the end of a line

     d.cursor = elt("pre", "\u00a0", "CodeMirror-cursor");

     // Secondary cursor, shown when on a 'jump' in bi-directional text

     d.otherCursor = elt("pre", "\u00a0", "CodeMirror-cursor CodeMirror-secondarycursor");

     // Used to measure text size

     d.measure = elt("div", null, "CodeMirror-measure");

     // Wraps everything that needs to exist inside the vertically-padded coordinate system

     d.lineSpace = elt("div", [d.measure, d.selectionDiv, d.lineDiv, d.cursor, d.otherCursor],

                          null, "position: relative; outline: none");

     // Moved around its parent to cover visible view

     d.mover = elt("div", [elt("div", [d.lineSpace], "CodeMirror-lines")], null, "position: relative");

     // Set to the height of the text, causes scrolling

     d.sizer = elt("div", [d.mover], "CodeMirror-sizer");

     // D is needed because behavior of elts with overflow: auto and padding is inconsistent across browsers

     d.heightForcer = elt("div", "\u00a0", null, "position: absolute; height: " + scrollerCutOff + "px");

     // Will contain the gutters, if any

     d.gutters = elt("div", null, "CodeMirror-gutters");

     d.lineGutter = null;

     // Helper element to properly size the gutter backgrounds

     var scrollerInner = elt("div", [d.sizer, d.heightForcer, d.gutters], null, "position: relative; min-height: 100%");

     // Provides scrolling

     d.scroller = elt("div", [scrollerInner], "CodeMirror-scroll");

     d.scroller.setAttribute("tabIndex", "-1");

     // The element in which the editor lives.

     d.wrapper = elt("div", [d.inputDiv, d.scrollbarH, d.scrollbarV,

                             d.scrollbarFiller, d.scroller], "CodeMirror");

     // Work around IE7 z-index bug

     if (ie_lt8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0; }

     if (place.appendChild) place.appendChild(d.wrapper); else place(d.wrapper);

     // Needed to hide big blue blinking cursor on Mobile Safari

     if (ios) input.style.width = "0px";

     if (!webkit) d.scroller.draggable = true;

     // Needed to handle Tab key in KHTML

     if (khtml) { d.inputDiv.style.height = "1px"; d.inputDiv.style.position = "absolute"; }

     // Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8).

     else if (ie_lt8) d.scrollbarH.style.minWidth = d.scrollbarV.style.minWidth = "18px";

     // Current visible range (may be bigger than the view window).

     d.viewOffset = d.showingFrom = d.showingTo = d.lastSizeC = 0;

     // Used to only resize the line number gutter when necessary (when

     // the amount of lines crosses a boundary that makes its width change)

     d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null;

     // See readInput and resetInput

     d.prevInput = "";

     // Set to true when a non-horizontal-scrolling widget is added. As

     // an optimization, widget aligning is skipped when d is false.

     d.alignWidgets = false;

     // Flag that indicates whether we currently expect input to appear

     // (after some event like 'keypress' or 'input') and are polling

     // intensively.

     d.pollingFast = false;

     // Self-resetting timeout for the poller

     d.poll = new Delayed();

     // True when a drag from the editor is active

     d.draggingText = false;

     d.cachedCharWidth = d.cachedTextHeight = null;

     d.measureLineCache = [];

     d.measureLineCachePos = 0;

     // Tracks when resetInput has punted to just putting a short

     // string instead of the (large) selection.

     d.inaccurateSelection = false;

     // Used to adjust overwrite behaviour when a paste has been

     // detected

     d.pasteIncoming = false;

     return d;

   }

   // VIEW CONSTRUCTOR

   function makeView(doc) {

     var selPos = {line: 0, ch: 0};

     return {

       doc: doc,

       // frontier is the point up to which the content has been parsed,

       frontier: 0, highlight: new Delayed(),

       sel: {from: selPos, to: selPos, head: selPos, anchor: selPos, shift: false, extend: false},

       scrollTop: 0, scrollLeft: 0,

       overwrite: false, focused: false,

       // Tracks the maximum line length so that

       // the horizontal scrollbar can be kept

       // static when scrolling.

       maxLine: getLine(doc, 0),

       maxLineLength: 0,

       maxLineChanged: false,

       suppressEdits: false,

       goalColumn: null,

       cantEdit: false,

       keyMaps: []

     };

   }

   // STATE UPDATES

   // Used to get the editor into a consistent state again when options change.

   function loadMode(cm) {

     var doc = cm.view.doc;

     cm.view.mode = CodeMirror.getMode(cm.options, cm.options.mode);

     doc.iter(0, doc.size, function(line) { line.stateAfter = null; });

     cm.view.frontier = 0;

     startWorker(cm, 100);

   }

   function wrappingChanged(cm) {

     var doc = cm.view.doc, th = textHeight(cm.display);

     if (cm.options.lineWrapping) {

       cm.display.wrapper.className += " CodeMirror-wrap";

       var perLine = cm.display.scroller.clientWidth / charWidth(cm.display) - 3;

       doc.iter(0, doc.size, function(line) {

         if (line.height == 0) return;

         var guess = Math.ceil(line.text.length / perLine) || 1;

         if (guess != 1) updateLineHeight(line, guess * th);

       });

       cm.display.sizer.style.minWidth = "";

     } else {

       cm.display.wrapper.className = cm.display.wrapper.className.replace(" CodeMirror-wrap", "");

       computeMaxLength(cm.view);

       doc.iter(0, doc.size, function(line) {

         if (line.height != 0) updateLineHeight(line, th);

       });

     }

     regChange(cm, 0, doc.size);

     clearCaches(cm);

     setTimeout(function(){updateScrollbars(cm.display, cm.view.doc.height);}, 100);

   }

   function keyMapChanged(cm) {

     var style = keyMap[cm.options.keyMap].style;

     cm.display.wrapper.className = cm.display.wrapper.className.replace(/\s*cm-keymap-\S+/g, "") +

       (style ? " cm-keymap-" + style : "");

   }

   function themeChanged(cm) {

     cm.display.wrapper.className = cm.display.wrapper.className.replace(/\s*cm-s-\S+/g, "") +

       cm.options.theme.replace(/(^|\s)\s*/g, " cm-s-");

     clearCaches(cm);

   }

   function guttersChanged(cm) {

     updateGutters(cm);

     updateDisplay(cm, true);

   }

   function updateGutters(cm) {

     var gutters = cm.display.gutters, specs = cm.options.gutters;

     removeChildren(gutters);

     for (var i = 0; i < specs.length; ++i) {

       var gutterClass = specs[i];

       var gElt = gutters.appendChild(elt("div", null, "CodeMirror-gutter " + gutterClass));

       if (gutterClass == "CodeMirror-linenumbers") {

         cm.display.lineGutter = gElt;

         gElt.style.width = (cm.display.lineNumWidth || 1) + "px";

       }

     }

     gutters.style.display = i ? "" : "none";

   }

   function lineLength(doc, line) {

     if (line.height == 0) return 0;

     var len = line.text.length, merged, cur = line;

     while (merged = collapsedSpanAtStart(cur)) {

       var found = merged.find();

       cur = getLine(doc, found.from.line);

       len += found.from.ch - found.to.ch;

     }

     cur = line;

     while (merged = collapsedSpanAtEnd(cur)) {

       var found = merged.find();

       len -= cur.text.length - found.from.ch;

       cur = getLine(doc, found.to.line);

       len += cur.text.length - found.to.ch;

     }

     return len;

   }

   function computeMaxLength(view) {

     view.maxLine = getLine(view.doc, 0);

     view.maxLineLength = lineLength(view.doc, view.maxLine);

     view.maxLineChanged = true;

     view.doc.iter(1, view.doc.size, function(line) {

       var len = lineLength(view.doc, line);

       if (len > view.maxLineLength) {

         view.maxLineLength = len;

         view.maxLine = line;

       }

     });

   }

   // Make sure the gutters options contains the element

   // "CodeMirror-linenumbers" when the lineNumbers option is true.

   function setGuttersForLineNumbers(options) {

     var found = false;

     for (var i = 0; i < options.gutters.length; ++i) {

       if (options.gutters[i] == "CodeMirror-linenumbers") {

         if (options.lineNumbers) found = true;

         else options.gutters.splice(i--, 1);

       }

     }

     if (!found && options.lineNumbers)

       options.gutters.push("CodeMirror-linenumbers");

   }

   // SCROLLBARS

   // Re-synchronize the fake scrollbars with the actual size of the

   // content. Optionally force a scrollTop.

   function updateScrollbars(d /* display */, docHeight) {

     var totalHeight = docHeight + 2 * paddingTop(d);

     d.sizer.style.minHeight = d.heightForcer.style.top = totalHeight + "px";

     var scrollHeight = Math.max(totalHeight, d.scroller.scrollHeight);

     var needsH = d.scroller.scrollWidth > d.scroller.clientWidth;

     var needsV = scrollHeight > d.scroller.clientHeight;

     if (needsV) {

       d.scrollbarV.style.display = "block";

       d.scrollbarV.style.bottom = needsH ? scrollbarWidth(d.measure) + "px" : "0";

       d.scrollbarV.firstChild.style.height = 

         (scrollHeight - d.scroller.clientHeight + d.scrollbarV.clientHeight) + "px";

     } else d.scrollbarV.style.display = "";

     if (needsH) {

       d.scrollbarH.style.display = "block";

       d.scrollbarH.style.right = needsV ? scrollbarWidth(d.measure) + "px" : "0";

       d.scrollbarH.firstChild.style.width =

         (d.scroller.scrollWidth - d.scroller.clientWidth + d.scrollbarH.clientWidth) + "px";

     } else d.scrollbarH.style.display = "";

     if (needsH && needsV) {

       d.scrollbarFiller.style.display = "block";

       d.scrollbarFiller.style.height = d.scrollbarFiller.style.width = scrollbarWidth(d.measure) + "px";

     } else d.scrollbarFiller.style.display = "";

     if (mac_geLion && scrollbarWidth(d.measure) === 0)

       d.scrollbarV.style.minWidth = d.scrollbarH.style.minHeight = mac_geMountainLion ? "18px" : "12px";

   }

   function visibleLines(display, doc, viewPort) {

     var top = display.scroller.scrollTop, height = display.wrapper.clientHeight;

     if (typeof viewPort == "number") top = viewPort;

     else if (viewPort) {top = viewPort.top; height = viewPort.bottom - viewPort.top;}

     top = Math.floor(top - paddingTop(display));

     var bottom = Math.ceil(top + height);

     return {from: lineAtHeight(doc, top), to: lineAtHeight(doc, bottom)};

   }

   // LINE NUMBERS

   function alignHorizontally(cm) {

     var display = cm.display;

     if (!display.alignWidgets && !display.gutters.firstChild) return;

     var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.view.scrollLeft;

     var gutterW = display.gutters.offsetWidth, l = comp + "px";

     for (var n = display.lineDiv.firstChild; n; n = n.nextSibling) if (n.alignable) {

       for (var i = 0, a = n.alignable; i < a.length; ++i) a[i].style.left = l;

     }

     display.gutters.style.left = (comp + gutterW) + "px";

   }

   function maybeUpdateLineNumberWidth(cm) {

     if (!cm.options.lineNumbers) return false;

     var doc = cm.view.doc, last = lineNumberFor(cm.options, doc.size - 1), display = cm.display;

     if (last.length != display.lineNumChars) {

       var test = display.measure.appendChild(elt("div", [elt("div", last)],

                                                  "CodeMirror-linenumber CodeMirror-gutter-elt"));

       var innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW;

       display.lineGutter.style.width = "";

       display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding);

       display.lineNumWidth = display.lineNumInnerWidth + padding;

       display.lineNumChars = display.lineNumInnerWidth ? last.length : -1;

       display.lineGutter.style.width = display.lineNumWidth + "px";

       return true;

     }

     return false;

   }

   function lineNumberFor(options, i) {

     return String(options.lineNumberFormatter(i + options.firstLineNumber));

   }

   function compensateForHScroll(display) {

     return display.scroller.getBoundingClientRect().left - display.sizer.getBoundingClientRect().left;

   }

   // DISPLAY DRAWING

   function updateDisplay(cm, changes, viewPort) {

     var oldFrom = cm.display.showingFrom, oldTo = cm.display.showingTo;

     var updated = updateDisplayInner(cm, changes, viewPort);

     if (updated) {

       signalLater(cm, cm, "update", cm);

       if (cm.display.showingFrom != oldFrom || cm.display.showingTo != oldTo)

         signalLater(cm, cm, "viewportChange", cm, cm.display.showingFrom, cm.display.showingTo);

     }

     updateSelection(cm);

     updateScrollbars(cm.display, cm.view.doc.height);

     return updated;

   }

   // Uses a set of changes plus the current scroll position to

   // determine which DOM updates have to be made, and makes the

   // updates.

   function updateDisplayInner(cm, changes, viewPort) {

     var display = cm.display, doc = cm.view.doc;

     if (!display.wrapper.clientWidth) {

       display.showingFrom = display.showingTo = display.viewOffset = 0;

       return;

     }

     // Compute the new visible window

     // If scrollTop is specified, use that to determine which lines

     // to render instead of the current scrollbar position.

     var visible = visibleLines(display, doc, viewPort);

     // Bail out if the visible area is already rendered and nothing changed.

     if (changes !== true && changes.length == 0 &&

         visible.from > display.showingFrom && visible.to < display.showingTo)

       return;

     if (changes && maybeUpdateLineNumberWidth(cm))

       changes = true;

     display.sizer.style.marginLeft = display.scrollbarH.style.left = display.gutters.offsetWidth + "px";

     // When merged lines are present, the line that needs to be

     // redrawn might not be the one that was changed.

     if (changes !== true && sawCollapsedSpans)

       for (var i = 0; i < changes.length; ++i) {

         var ch = changes[i], merged;

         while (merged = collapsedSpanAtStart(getLine(doc, ch.from))) {

           var from = merged.find().from.line;

           if (ch.diff) ch.diff -= ch.from - from;

           ch.from = from;

         }

       }

     // Used to determine which lines need their line numbers updated

     var positionsChangedFrom = changes === true ? 0 : Infinity;

     if (cm.options.lineNumbers && changes && changes !== true)

       for (var i = 0; i < changes.length; ++i)

         if (changes[i].diff) { positionsChangedFrom = changes[i].from; break; }

     var from = Math.max(visible.from - cm.options.viewportMargin, 0);

     var to = Math.min(doc.size, visible.to + cm.options.viewportMargin);

     if (display.showingFrom < from && from - display.showingFrom < 20) from = display.showingFrom;

     if (display.showingTo > to && display.showingTo - to < 20) to = Math.min(doc.size, display.showingTo);

     if (sawCollapsedSpans) {

       from = lineNo(visualLine(doc, getLine(doc, from)));

       while (to < doc.size && lineIsHidden(getLine(doc, to))) ++to;

     }

     // Create a range of theoretically intact lines, and punch holes

     // in that using the change info.

     var intact = changes === true ? [] :

       computeIntact([{from: display.showingFrom, to: display.showingTo}], changes);

     // Clip off the parts that won't be visible

     var intactLines = 0;

     for (var i = 0; i < intact.length; ++i) {

       var range = intact[i];

       if (range.from < from) range.from = from;

       if (range.to > to) range.to = to;

       if (range.from >= range.to) intact.splice(i--, 1);

       else intactLines += range.to - range.from;

     }

     if (intactLines == to - from && from == display.showingFrom && to == display.showingTo)

       return;

     intact.sort(function(a, b) {return a.from - b.from;});

     if (intactLines < (to - from) * .7) display.lineDiv.style.display = "none";

     patchDisplay(cm, from, to, intact, positionsChangedFrom);

     display.lineDiv.style.display = "";

     var different = from != display.showingFrom || to != display.showingTo ||

       display.lastSizeC != display.wrapper.clientHeight;

     // This is just a bogus formula that detects when the editor is

     // resized or the font size changes.

     if (different) display.lastSizeC = display.wrapper.clientHeight;

     display.showingFrom = from; display.showingTo = to;

     startWorker(cm, 100);

     var prevBottom = display.lineDiv.offsetTop;

     for (var node = display.lineDiv.firstChild, height; node; node = node.nextSibling) if (node.lineObj) {

       if (ie_lt8) {

         var bot = node.offsetTop + node.offsetHeight;

         height = bot - prevBottom;

         prevBottom = bot;

       } else {

         var box = node.getBoundingClientRect();

         height = box.bottom - box.top;

       }

       var diff = node.lineObj.height - height;

       if (height < 2) height = textHeight(display);

       if (diff > .001 || diff < -.001)

         updateLineHeight(node.lineObj, height);

     }

     display.viewOffset = heightAtLine(cm, getLine(doc, from));

     // Position the mover div to align with the current virtual scroll position

     display.mover.style.top = display.viewOffset + "px";

     return true;

   }

   function computeIntact(intact, changes) {

     for (var i = 0, l = changes.length || 0; i < l; ++i) {

       var change = changes[i], intact2 = [], diff = change.diff || 0;

       for (var j = 0, l2 = intact.length; j < l2; ++j) {

         var range = intact[j];

         if (change.to <= range.from && change.diff) {

           intact2.push({from: range.from + diff, to: range.to + diff});

         } else if (change.to <= range.from || change.from >= range.to) {

           intact2.push(range);

         } else {

           if (change.from > range.from)

             intact2.push({from: range.from, to: change.from});

           if (change.to < range.to)

             intact2.push({from: change.to + diff, to: range.to + diff});

         }

       }

       intact = intact2;

     }

     return intact;

   }

   function getDimensions(cm) {

     var d = cm.display, left = {}, width = {};

     for (var n = d.gutters.firstChild, i = 0; n; n = n.nextSibling, ++i) {

       left[cm.options.gutters[i]] = n.offsetLeft;

       width[cm.options.gutters[i]] = n.offsetWidth;

     }

     return {fixedPos: compensateForHScroll(d),

             gutterTotalWidth: d.gutters.offsetWidth,

             gutterLeft: left,

             gutterWidth: width,

             wrapperWidth: d.wrapper.clientWidth};

   }

   function patchDisplay(cm, from, to, intact, updateNumbersFrom) {

     var dims = getDimensions(cm);

     var display = cm.display, lineNumbers = cm.options.lineNumbers;

     // IE does bad things to nodes when .innerHTML = "" is used on a parent

     // we still need widgets and markers intact to add back to the new content later

     if (!intact.length && !ie && (!webkit || !cm.display.currentWheelTarget))

       removeChildren(display.lineDiv);

     var container = display.lineDiv, cur = container.firstChild;

     function rm(node) {

       var next = node.nextSibling;

       if (webkit && mac && cm.display.currentWheelTarget == node) {

         node.style.display = "none";

         node.lineObj = null;

       } else {

         container.removeChild(node);

       }

       return next;

     }

     var nextIntact = intact.shift(), lineNo = from;

     cm.view.doc.iter(from, to, function(line) {

       if (nextIntact && nextIntact.to == lineNo) nextIntact = intact.shift();

       if (lineIsHidden(line)) {

         if (line.height != 0) updateLineHeight(line, 0);

       } else if (nextIntact && nextIntact.from <= lineNo && nextIntact.to > lineNo) {

         // This line is intact. Skip to the actual node. Update its

         // line number if needed.

         while (cur.lineObj != line) cur = rm(cur);

         if (lineNumbers && updateNumbersFrom <= lineNo && cur.lineNumber)

           setTextContent(cur.lineNumber, lineNumberFor(cm.options, lineNo));

         cur = cur.nextSibling;

       } else {

         // This line needs to be generated.

         var lineNode = buildLineElement(cm, line, lineNo, dims);

         container.insertBefore(lineNode, cur);

         lineNode.lineObj = line;

       }

       ++lineNo;

     });

     while (cur) cur = rm(cur);

   }

   function buildLineElement(cm, line, lineNo, dims) {

     var lineElement = lineContent(cm, line);

     var markers = line.gutterMarkers, display = cm.display;

     if (!cm.options.lineNumbers && !markers && !line.bgClass && !line.wrapClass &&

         (!line.widgets || !line.widgets.length)) return lineElement;

     // Lines with gutter elements or a background class need

     // to be wrapped again, and have the extra elements added

     // to the wrapper div

     var wrap = elt("div", null, line.wrapClass, "position: relative");

     if (cm.options.lineNumbers || markers) {

       var gutterWrap = wrap.appendChild(elt("div", null, null, "position: absolute; left: " +

                                             dims.fixedPos + "px"));

       wrap.alignable = [gutterWrap];

       if (cm.options.lineNumbers && (!markers || !markers["CodeMirror-linenumbers"]))

         wrap.lineNumber = gutterWrap.appendChild(

           elt("div", lineNumberFor(cm.options, lineNo),

               "CodeMirror-linenumber CodeMirror-gutter-elt",

               "left: " + dims.gutterLeft["CodeMirror-linenumbers"] + "px; width: "

               + display.lineNumInnerWidth + "px"));

       if (markers)

         for (var k = 0; k < cm.options.gutters.length; ++k) {

           var id = cm.options.gutters[k], found = markers.hasOwnProperty(id) && markers[id];

           if (found)

             gutterWrap.appendChild(elt("div", [found], "CodeMirror-gutter-elt", "left: " +

                                        dims.gutterLeft[id] + "px; width: " + dims.gutterWidth[id] + "px"));

         }

     }

     // Kludge to make sure the styled element lies behind the selection (by z-index)

     if (line.bgClass)

       wrap.appendChild(elt("div", "\u00a0", line.bgClass + " CodeMirror-linebackground"));

     wrap.appendChild(lineElement);

     if (line.widgets)

       for (var i = 0, ws = line.widgets; i < ws.length; ++i) {

         var widget = ws[i], node = elt("div", [widget.node], "CodeMirror-linewidget");

         node.widget = widget;

         if (widget.noHScroll) {

           (wrap.alignable || (wrap.alignable = [])).push(node);

           var width = dims.wrapperWidth;

           node.style.left = dims.fixedPos + "px";

           if (!widget.coverGutter) {

             width -= dims.gutterTotalWidth;

             node.style.paddingLeft = dims.gutterTotalWidth + "px";

           }

           node.style.width = width + "px";

         }

         if (widget.coverGutter) {

           node.style.zIndex = 5;

           node.style.position = "relative";

           if (!widget.noHScroll) node.style.marginLeft = -dims.gutterTotalWidth + "px";

         }

         if (widget.above)

           wrap.insertBefore(node, cm.options.lineNumbers && line.height != 0 ? gutterWrap : lineElement);

         else

           wrap.appendChild(node);

       }

     if (ie_lt8) wrap.style.zIndex = 2;

     return wrap;

   }

   // SELECTION / CURSOR

   function updateSelection(cm) {

     var display = cm.display;

     var collapsed = posEq(cm.view.sel.from, cm.view.sel.to);

     if (collapsed || cm.options.showCursorWhenSelecting)

       updateSelectionCursor(cm);

     else

       display.cursor.style.display = display.otherCursor.style.display = "none";

     if (!collapsed)

       updateSelectionRange(cm);

     else

       display.selectionDiv.style.display = "none";

     // Move the hidden textarea near the cursor to prevent scrolling artifacts

     var headPos = cursorCoords(cm, cm.view.sel.head, "div");

     var wrapOff = display.wrapper.getBoundingClientRect(), lineOff = display.lineDiv.getBoundingClientRect();

     display.inputDiv.style.top = Math.max(0, Math.min(display.wrapper.clientHeight - 10,

                                                       headPos.top + lineOff.top - wrapOff.top)) + "px";

     display.inputDiv.style.left = Math.max(0, Math.min(display.wrapper.clientWidth - 10,

                                                        headPos.left + lineOff.left - wrapOff.left)) + "px";

   }

   // No selection, plain cursor

   function updateSelectionCursor(cm) {

     var display = cm.display, pos = cursorCoords(cm, cm.view.sel.head, "div");

     display.cursor.style.left = pos.left + "px";

     display.cursor.style.top = pos.top + "px";

     display.cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + "px";

     display.cursor.style.display = "";

     if (pos.other) {

       display.otherCursor.style.display = "";

       display.otherCursor.style.left = pos.other.left + "px";

       display.otherCursor.style.top = pos.other.top + "px";

       display.otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + "px";

     } else { display.otherCursor.style.display = "none"; }

   }

   // Highlight selection

   function updateSelectionRange(cm) {

     var display = cm.display, doc = cm.view.doc, sel = cm.view.sel;

     var fragment = document.createDocumentFragment();

     var clientWidth = display.lineSpace.offsetWidth, pl = paddingLeft(cm.display);

     function add(left, top, width, bottom) {

       if (top < 0) top = 0;

       fragment.appendChild(elt("div", null, "CodeMirror-selected", "position: absolute; left: " + left +

                                "px; top: " + top + "px; width: " + (width == null ? clientWidth - left : width) +

                                "px; height: " + (bottom - top) + "px"));

     }

     function drawForLine(line, fromArg, toArg, retTop) {

       var lineObj = getLine(doc, line);

       var lineLen = lineObj.text.length, rVal = retTop ? Infinity : -Infinity;

       function coords(ch) {

         return charCoords(cm, {line: line, ch: ch}, "div", lineObj);

       }

       iterateBidiSections(getOrder(lineObj), fromArg || 0, toArg == null ? lineLen : toArg, function(from, to, dir) {

         var leftPos = coords(dir == "rtl" ? to - 1 : from);

         var rightPos = coords(dir == "rtl" ? from : to - 1);

         var left = leftPos.left, right = rightPos.right;

         if (rightPos.top - leftPos.top > 3) { // Different lines, draw top part

           add(left, leftPos.top, null, leftPos.bottom);

           left = pl;

           if (leftPos.bottom < rightPos.top) add(left, leftPos.bottom, null, rightPos.top);

         }

         if (toArg == null && to == lineLen) right = clientWidth;

         if (fromArg == null && from == 0) left = pl;

         rVal = retTop ? Math.min(rightPos.top, rVal) : Math.max(rightPos.bottom, rVal);

         if (left < pl + 1) left = pl;

         add(left, rightPos.top, right - left, rightPos.bottom);

       });

       return rVal;

     }

     if (sel.from.line == sel.to.line) {

       drawForLine(sel.from.line, sel.from.ch, sel.to.ch);

     } else {

       var fromObj = getLine(doc, sel.from.line);

       var cur = fromObj, merged, path = [sel.from.line, sel.from.ch], singleLine;

       while (merged = collapsedSpanAtEnd(cur)) {

         var found = merged.find();

         path.push(found.from.ch, found.to.line, found.to.ch);

         if (found.to.line == sel.to.line) {

           path.push(sel.to.ch);

           singleLine = true;

           break;

         }

         cur = getLine(doc, found.to.line);

       }

       // This is a single, merged line

       if (singleLine) {

         for (var i = 0; i < path.length; i += 3)

           drawForLine(path[i], path[i+1], path[i+2]);

       } else {

         var middleTop, middleBot, toObj = getLine(doc, sel.to.line);

         if (sel.from.ch)

           // Draw the first line of selection.

           middleTop = drawForLine(sel.from.line, sel.from.ch, null, false);

         else

           // Simply include it in the middle block.

           middleTop = heightAtLine(cm, fromObj) - display.viewOffset;

         if (!sel.to.ch)

           middleBot = heightAtLine(cm, toObj) - display.viewOffset;

         else

           middleBot = drawForLine(sel.to.line, collapsedSpanAtStart(toObj) ? null : 0, sel.to.ch, true);

         if (middleTop < middleBot) add(pl, middleTop, null, middleBot);

       }

     }

     removeChildrenAndAdd(display.selectionDiv, fragment);

     display.selectionDiv.style.display = "";

   }

   // Cursor-blinking

   function restartBlink(cm) {

     var display = cm.display;

     clearInterval(display.blinker);

     var on = true;

     display.cursor.style.visibility = display.otherCursor.style.visibility = "";

     display.blinker = setInterval(function() {

       if (!display.cursor.offsetHeight) return;

       display.cursor.style.visibility = display.otherCursor.style.visibility = (on = !on) ? "" : "hidden";

     }, cm.options.cursorBlinkRate);

   }

   // HIGHLIGHT WORKER

   function startWorker(cm, time) {

     if (cm.view.frontier < cm.display.showingTo)

       cm.view.highlight.set(time, bind(highlightWorker, cm));

   }

   function highlightWorker(cm) {

     var view = cm.view, doc = view.doc;

     if (view.frontier >= cm.display.showingTo) return;

     var end = +new Date + cm.options.workTime;

     var state = copyState(view.mode, getStateBefore(cm, view.frontier));

     var changed = [], prevChange;

     doc.iter(view.frontier, Math.min(doc.size, cm.display.showingTo + 500), function(line) {

       if (view.frontier >= cm.display.showingFrom) { // Visible

         if (highlightLine(cm, line, state) && view.frontier >= cm.display.showingFrom) {

           if (prevChange && prevChange.end == view.frontier) prevChange.end++;

           else changed.push(prevChange = {start: view.frontier, end: view.frontier + 1});

         }

         line.stateAfter = copyState(view.mode, state);

       } else {

         processLine(cm, line, state);

         line.stateAfter = view.frontier % 5 == 0 ? copyState(view.mode, state) : null;

       }

       ++view.frontier;

       if (+new Date > end) {

         startWorker(cm, cm.options.workDelay);

         return true;

       }

     });

     if (changed.length)

       operation(cm, function() {

         for (var i = 0; i < changed.length; ++i)

           regChange(this, changed[i].start, changed[i].end);

       })();

   }

   // Finds the line to start with when starting a parse. Tries to

   // find a line with a stateAfter, so that it can start with a

   // valid state. If that fails, it returns the line with the

   // smallest indentation, which tends to need the least context to

   // parse correctly.

   function findStartLine(cm, n) {

     var minindent, minline, doc = cm.view.doc;

     for (var search = n, lim = n - 100; search > lim; --search) {

       if (search == 0) return 0;

       var line = getLine(doc, search-1);

       if (line.stateAfter) return search;

       var indented = countColumn(line.text, null, cm.options.tabSize);

       if (minline == null || minindent > indented) {

         minline = search - 1;

         minindent = indented;

       }

     }

     return minline;

   }

   function getStateBefore(cm, n) {

     var view = cm.view;

     var pos = findStartLine(cm, n), state = pos && getLine(view.doc, pos-1).stateAfter;

     if (!state) state = startState(view.mode);

     else state = copyState(view.mode, state);

     view.doc.iter(pos, n, function(line) {

       processLine(cm, line, state);

       var save = pos == n - 1 || pos % 5 == 0 || pos >= view.showingFrom && pos < view.showingTo;

       line.stateAfter = save ? copyState(view.mode, state) : null;

       ++pos;

     });

     return state;

   }

   // POSITION MEASUREMENT

   function paddingTop(display) {return display.lineSpace.offsetTop;}

   function paddingLeft(display) {

     var e = removeChildrenAndAdd(display.measure, elt("pre")).appendChild(elt("span", "x"));

     return e.offsetLeft;

   }

   function measureChar(cm, line, ch, data) {

     var data = data || measureLine(cm, line), dir = -1;

     for (var pos = ch;; pos += dir) {

       var r = data[pos];

       if (r) break;

       if (dir < 0 && pos == 0) dir = 1;

     }

     return {left: pos < ch ? r.right : r.left,

             right: pos > ch ? r.left : r.right,

             top: r.top, bottom: r.bottom};

   }

   function measureLine(cm, line) {

     // First look in the cache

     var display = cm.display, cache = cm.display.measureLineCache;

     for (var i = 0; i < cache.length; ++i) {

       var memo = cache[i];

       if (memo.text == line.text && memo.markedSpans == line.markedSpans &&

           display.scroller.clientWidth == memo.width)

         return memo.measure;

     }

     var measure = measureLineInner(cm, line);

     // Store result in the cache

     var memo = {text: line.text, width: display.scroller.clientWidth,

                 markedSpans: line.markedSpans, measure: measure};

     if (cache.length == 16) cache[++display.measureLineCachePos % 16] = memo;

     else cache.push(memo);

     return measure;

   }

   function measureLineInner(cm, line) {

     var display = cm.display, measure = emptyArray(line.text.length);

     var pre = lineContent(cm, line, measure);

     // IE does not cache element positions of inline elements between

     // calls to getBoundingClientRect. This makes the loop below,

     // which gathers the positions of all the characters on the line,

     // do an amount of layout work quadratic to the number of

     // characters. When line wrapping is off, we try to improve things

     // by first subdividing the line into a bunch of inline blocks, so

     // that IE can reuse most of the layout information from caches

     // for those blocks. This does interfere with line wrapping, so it

     // doesn't work when wrapping is on, but in that case the

     // situation is slightly better, since IE does cache line-wrapping

     // information and only recomputes per-line.

     if (ie && !ie_lt8 && !cm.options.lineWrapping && pre.childNodes.length > 100) {

       var fragment = document.createDocumentFragment();

       var chunk = 10, n = pre.childNodes.length;

       for (var i = 0, chunks = Math.ceil(n / chunk); i < chunks; ++i) {

         var wrap = elt("div", null, null, "display: inline-block");

         for (var j = 0; j < chunk && n; ++j) {

           wrap.appendChild(pre.firstChild);

           --n;

         }

         fragment.appendChild(wrap);

       }

       pre.appendChild(fragment);

     }

     removeChildrenAndAdd(display.measure, pre);

     var outer = display.lineDiv.getBoundingClientRect();

     var vranges = [], data = emptyArray(line.text.length), maxBot = pre.offsetHeight;

     for (var i = 0, cur; i < measure.length; ++i) if (cur = measure[i]) {

       var size = cur.getBoundingClientRect();

       var top = Math.max(0, size.top - outer.top), bot = Math.min(size.bottom - outer.top, maxBot);

       for (var j = 0; j < vranges.length; j += 2) {

         var rtop = vranges[j], rbot = vranges[j+1];

         if (rtop > bot || rbot < top) continue;

         if (rtop <= top && rbot >= bot ||

             top <= rtop && bot >= rbot ||

             Math.min(bot, rbot) - Math.max(top, rtop) >= (bot - top) >> 1) {

           vranges[j] = Math.min(top, rtop);

           vranges[j+1] = Math.max(bot, rbot);

           break;

         }

       }

       if (j == vranges.length) vranges.push(top, bot);

       data[i] = {left: size.left - outer.left, right: size.right - outer.left, top: j};

     }

     for (var i = 0, cur; i < data.length; ++i) if (cur = data[i]) {

       var vr = cur.top;

       cur.top = vranges[vr]; cur.bottom = vranges[vr+1];

     }

     return data;

   }

   function clearCaches(cm) {

     cm.display.measureLineCache.length = cm.display.measureLineCachePos = 0;

     cm.display.cachedCharWidth = cm.display.cachedTextHeight = null;

     cm.view.maxLineChanged = true;

   }

   // Context is one of "line", "div" (display.lineDiv), "local"/null (editor), or "page"

   function intoCoordSystem(cm, lineObj, rect, context) {

     if (lineObj.widgets) for (var i = 0; i < lineObj.widgets.length; ++i) if (lineObj.widgets[i].above) {

       var size = lineObj.widgets[i].node.offsetHeight;

       rect.top += size; rect.bottom += size;

     }

     if (context == "line") return rect;

     if (!context) context = "local";

     var yOff = heightAtLine(cm, lineObj);

     if (context != "local") yOff -= cm.display.viewOffset;

     if (context == "page") {

       var lOff = cm.display.lineSpace.getBoundingClientRect();

       yOff += lOff.top + (window.pageYOffset || (document.documentElement || document.body).scrollTop);

       var xOff = lOff.left + (window.pageXOffset || (document.documentElement || document.body).scrollLeft);

       rect.left += xOff; rect.right += xOff;

     }

     rect.top += yOff; rect.bottom += yOff;

     return rect;

   }

   function charCoords(cm, pos, context, lineObj) {

     if (!lineObj) lineObj = getLine(cm.view.doc, pos.line);

     return intoCoordSystem(cm, lineObj, measureChar(cm, lineObj, pos.ch), context);

   }

   function cursorCoords(cm, pos, context, lineObj, measurement) {

     lineObj = lineObj || getLine(cm.view.doc, pos.line);

     if (!measurement) measurement = measureLine(cm, lineObj);

     function get(ch, right) {

       var m = measureChar(cm, lineObj, ch, measurement);

       if (right) m.left = m.right; else m.right = m.left;

       return intoCoordSystem(cm, lineObj, m, context);

     }

     var order = getOrder(lineObj), ch = pos.ch;

     if (!order) return get(ch);

     var main, other, linedir = order[0].level;

     for (var i = 0; i < order.length; ++i) {

       var part = order[i], rtl = part.level % 2, nb, here;

       if (part.from < ch && part.to > ch) return get(ch, rtl);

       var left = rtl ? part.to : part.from, right = rtl ? part.from : part.to;

       if (left == ch) {

         // Opera and IE return bogus offsets and widths for edges

         // where the direction flips, but only for the side with the

         // lower level. So we try to use the side with the higher

         // level.

         if (i && part.level < (nb = order[i-1]).level) here = get(nb.level % 2 ? nb.from : nb.to - 1, true);

         else here = get(rtl && part.from != part.to ? ch - 1 : ch);

         if (rtl == linedir) main = here; else other = here;

       } else if (right == ch) {

         var nb = i < order.length - 1 && order[i+1];

         if (!rtl && nb && nb.from == nb.to) continue;

         if (nb && part.level < nb.level) here = get(nb.level % 2 ? nb.to - 1 : nb.from);

         else here = get(rtl ? ch : ch - 1, true);

         if (rtl == linedir) main = here; else other = here;

       }

     }

     if (linedir && !ch) other = get(order[0].to - 1);

     if (!main) return other;

     if (other) main.other = other;

     return main;

   }

   // Coords must be lineSpace-local

   function coordsChar(cm, x, y) {

     var doc = cm.view.doc;

     y += cm.display.viewOffset;

     if (y < 0) return {line: 0, ch: 0, outside: true};

     var lineNo = lineAtHeight(doc, y);

     if (lineNo >= doc.size) return {line: doc.size - 1, ch: getLine(doc, doc.size - 1).text.length};

     if (x < 0) x = 0;

     for (;;) {

       var lineObj = getLine(doc, lineNo);

       var found = coordsCharInner(cm, lineObj, lineNo, x, y);

       var merged = collapsedSpanAtEnd(lineObj);

       if (merged && found.ch == lineRight(lineObj))

         lineNo = merged.find().to.line;

       else

         return found;

     }

   }

   function coordsCharInner(cm, lineObj, lineNo, x, y) {

     var innerOff = y - heightAtLine(cm, lineObj);

     var wrongLine = false, cWidth = cm.display.wrapper.clientWidth;

     var measurement = measureLine(cm, lineObj);

     function getX(ch) {

       var sp = cursorCoords(cm, {line: lineNo, ch: ch}, "line",

                             lineObj, measurement);

       wrongLine = true;

       if (innerOff > sp.bottom) return Math.max(0, sp.left - cWidth);

       else if (innerOff < sp.top) return sp.left + cWidth;

       else wrongLine = false;

       return sp.left;

     }

     var bidi = getOrder(lineObj), dist = lineObj.text.length;

     var from = lineLeft(lineObj), to = lineRight(lineObj);

     var fromX = paddingLeft(cm.display), toX = getX(to);

     if (x > toX) return {line: lineNo, ch: to, outside: wrongLine};

     // Do a binary search between these bounds.

     for (;;) {

       if (bidi ? to == from || to == moveVisually(lineObj, from, 1) : to - from <= 1) {

         var after = x - fromX < toX - x, ch = after ? from : to;

         while (isExtendingChar.test(lineObj.text.charAt(ch))) ++ch;

         return {line: lineNo, ch: ch, after: after, outside: wrongLine};

       }

       var step = Math.ceil(dist / 2), middle = from + step;

       if (bidi) {

         middle = from;

         for (var i = 0; i < step; ++i) middle = moveVisually(lineObj, middle, 1);

       }

       var middleX = getX(middle);

       if (middleX > x) {to = middle; toX = middleX; if (wrongLine) toX += 1000; dist -= step;}

       else {from = middle; fromX = middleX; dist = step;}

     }

   }

   var measureText;

   function textHeight(display) {

     if (display.cachedTextHeight != null) return display.cachedTextHeight;

     if (measureText == null) {

       measureText = elt("pre");

       // Measure a bunch of lines, for browsers that compute

       // fractional heights.

       for (var i = 0; i < 49; ++i) {

         measureText.appendChild(document.createTextNode("x"));

         measureText.appendChild(elt("br"));

       }

       measureText.appendChild(document.createTextNode("x"));

     }

     removeChildrenAndAdd(display.measure, measureText);

     var height = measureText.offsetHeight / 50;

     if (height > 3) display.cachedTextHeight = height;

     removeChildren(display.measure);

     return height || 1;

   }

   function charWidth(display) {

     if (display.cachedCharWidth != null) return display.cachedCharWidth;

     var anchor = elt("span", "x");

     var pre = elt("pre", [anchor]);

     removeChildrenAndAdd(display.measure, pre);

     var width = anchor.offsetWidth;

     if (width > 2) display.cachedCharWidth = width;

     return width || 10;

   }

   // OPERATIONS

   // Operations are used to wrap changes in such a way that each

   // change won't have to update the cursor and display (which would

   // be awkward, slow, and error-prone), but instead updates are

   // batched and then all combined and executed at once.

   function startOperation(cm) {

     if (cm.curOp) ++cm.curOp.depth;

     else cm.curOp = {

       // Nested operations delay update until the outermost one

       // finishes.

       depth: 1,

       // An array of ranges of lines that have to be updated. See

       // updateDisplay.

       changes: [],

       delayedCallbacks: [],

       updateInput: null,

       userSelChange: null,

       textChanged: null,

       selectionChanged: false,

       updateMaxLine: false,

       id: ++cm.nextOpId

     };

   }

   function endOperation(cm) {

     var op = cm.curOp;

     if (--op.depth) return;

     cm.curOp = null;

     var view = cm.view, display = cm.display;

     if (op.updateMaxLine) computeMaxLength(view);

     if (view.maxLineChanged && !cm.options.lineWrapping) {

       var width = measureChar(cm, view.maxLine, view.maxLine.text.length).right;

       display.sizer.style.minWidth = (width + 3 + scrollerCutOff) + "px";

       view.maxLineChanged = false;

     }

     var newScrollPos, updated;

     if (op.selectionChanged) {

       var coords = cursorCoords(cm, view.sel.head);

       newScrollPos = calculateScrollPos(cm, coords.left, coords.top, coords.left, coords.bottom);

     }

     if (op.changes.length || newScrollPos && newScrollPos.scrollTop != null)

       updated = updateDisplay(cm, op.changes, newScrollPos && newScrollPos.scrollTop);

     if (!updated && op.selectionChanged) updateSelection(cm);

     if (newScrollPos) scrollCursorIntoView(cm);

     if (op.selectionChanged) restartBlink(cm);

     if (view.focused && op.updateInput)

       resetInput(cm, op.userSelChange);

     if (op.textChanged)

       signal(cm, "change", cm, op.textChanged);

     if (op.selectionChanged) signal(cm, "cursorActivity", cm);

     for (var i = 0; i < op.delayedCallbacks.length; ++i) op.delayedCallbacks[i](cm);

   }

   // Wraps a function in an operation. Returns the wrapped function.

   function operation(cm1, f) {

     return function() {

       var cm = cm1 || this;

       startOperation(cm);

       try {var result = f.apply(cm, arguments);}

       finally {endOperation(cm);}

       return result;

     };

   }

   function regChange(cm, from, to, lendiff) {

     cm.curOp.changes.push({from: from, to: to, diff: lendiff});

   }

   // INPUT HANDLING

   function slowPoll(cm) {

     if (cm.view.pollingFast) return;

     cm.display.poll.set(cm.options.pollInterval, function() {

       readInput(cm);

       if (cm.view.focused) slowPoll(cm);

     });

   }

   function fastPoll(cm) {

     var missed = false;

     cm.display.pollingFast = true;

     function p() {

       var changed = readInput(cm);

       if (!changed && !missed) {missed = true; cm.display.poll.set(60, p);}

       else {cm.display.pollingFast = false; slowPoll(cm);}

     }

     cm.display.poll.set(20, p);

   }

   // prevInput is a hack to work with IME. If we reset the textarea

   // on every change, that breaks IME. So we look for changes

   // compared to the previous content instead. (Modern browsers have

   // events that indicate IME taking place, but these are not widely

   // supported or compatible enough yet to rely on.)

   function readInput(cm) {

     var input = cm.display.input, prevInput = cm.display.prevInput, view = cm.view, sel = view.sel;

     if (!view.focused || hasSelection(input) || isReadOnly(cm)) return false;

     var text = input.value;

     if (text == prevInput && posEq(sel.from, sel.to)) return false;

     startOperation(cm);

     view.sel.shift = false;

     var same = 0, l = Math.min(prevInput.length, text.length);

     while (same < l && prevInput[same] == text[same]) ++same;

     var from = sel.from, to = sel.to;

     if (same < prevInput.length)

       from = {line: from.line, ch: from.ch - (prevInput.length - same)};

     else if (view.overwrite && posEq(from, to) && !cm.display.pasteIncoming)

       to = {line: to.line, ch: Math.min(getLine(cm.view.doc, to.line).text.length, to.ch + (text.length - same))};

     var updateInput = cm.curOp.updateInput;

     updateDoc(cm, from, to, splitLines(text.slice(same)), "end",

               cm.display.pasteIncoming ? "paste" : "input", {from: from, to: to});

     cm.curOp.updateInput = updateInput;

     if (text.length > 1000) input.value = cm.display.prevInput = "";

     else cm.display.prevInput = text;

     endOperation(cm);

     cm.display.pasteIncoming = false;

     return true;

   }

   function resetInput(cm, user) {

     var view = cm.view, minimal, selected;

     if (!posEq(view.sel.from, view.sel.to)) {

       cm.display.prevInput = "";

       minimal = hasCopyEvent &&

         (view.sel.to.line - view.sel.from.line > 100 || (selected = cm.getSelection()).length > 1000);

       if (minimal) cm.display.input.value = "-";

       else cm.display.input.value = selected || cm.getSelection();

       if (view.focused) selectInput(cm.display.input);

     } else if (user) cm.display.prevInput = cm.display.input.value = "";

     cm.display.inaccurateSelection = minimal;

   }

   function focusInput(cm) {

     if (cm.options.readOnly != "nocursor" && (ie || document.activeElement != cm.display.input))

       cm.display.input.focus();

   }

   function isReadOnly(cm) {

     return cm.options.readOnly || cm.view.cantEdit;

   }

   // EVENT HANDLERS

   function registerEventHandlers(cm) {

     var d = cm.display;

     on(d.scroller, "mousedown", operation(cm, onMouseDown));

     on(d.scroller, "dblclick", operation(cm, e_preventDefault));

     on(d.lineSpace, "selectstart", function(e) {

       if (!mouseEventInWidget(d, e)) e_preventDefault(e);

     });

     // Gecko browsers fire contextmenu *after* opening the menu, at

     // which point we can't mess with it anymore. Context menu is

     // handled in onMouseDown for Gecko.

     if (!gecko) on(d.scroller, "contextmenu", function(e) {onContextMenu(cm, e);});

     on(d.scroller, "scroll", function() {

       setScrollTop(cm, d.scroller.scrollTop);

       setScrollLeft(cm, d.scroller.scrollLeft, true);

       signal(cm, "scroll", cm);

     });

     on(d.scrollbarV, "scroll", function() {

       setScrollTop(cm, d.scrollbarV.scrollTop);

     });

     on(d.scrollbarH, "scroll", function() {

       setScrollLeft(cm, d.scrollbarH.scrollLeft);

     });

     on(d.scroller, "mousewheel", function(e){onScrollWheel(cm, e);});

     on(d.scroller, "DOMMouseScroll", function(e){onScrollWheel(cm, e);});

     function reFocus() { if (cm.view.focused) setTimeout(bind(focusInput, cm), 0); }

     on(d.scrollbarH, "mousedown", reFocus);

     on(d.scrollbarV, "mousedown", reFocus);

     // Prevent wrapper from ever scrolling

     on(d.wrapper, "scroll", function() { d.wrapper.scrollTop = d.wrapper.scrollLeft = 0; });

     on(window, "resize", function resizeHandler() {

       // Might be a text scaling operation, clear size caches.

       d.cachedCharWidth = d.cachedTextHeight = null;

       clearCaches(cm);

       if (d.wrapper.parentNode) updateDisplay(cm, true);

       else off(window, "resize", resizeHandler);

     });

     on(d.input, "keyup", operation(cm, function(e) {

       if (cm.options.onKeyEvent && cm.options.onKeyEvent(cm, addStop(e))) return;

       if (e_prop(e, "keyCode") == 16) cm.view.sel.shift = false;

     }));

     on(d.input, "input", bind(fastPoll, cm));

     on(d.input, "keydown", operation(cm, onKeyDown));

     on(d.input, "keypress", operation(cm, onKeyPress));

     on(d.input, "focus", bind(onFocus, cm));

     on(d.input, "blur", bind(onBlur, cm));

     function drag_(e) {

       if (cm.options.onDragEvent && cm.options.onDragEvent(cm, addStop(e))) return;

       e_stop(e);

     }

     if (cm.options.dragDrop) {

       on(d.scroller, "dragstart", function(e){onDragStart(cm, e);});

       on(d.scroller, "dragenter", drag_);

       on(d.scroller, "dragover", drag_);

       on(d.scroller, "drop", operation(cm, onDrop));

     }

     on(d.scroller, "paste", function(){focusInput(cm); fastPoll(cm);});

     on(d.input, "paste", function() {

       d.pasteIncoming = true;

       fastPoll(cm);

     });

     function prepareCopy() {

       if (d.inaccurateSelection) {

         d.prevInput = "";

         d.inaccurateSelection = false;

         d.input.value = cm.getSelection();

         selectInput(d.input);

       }

     }

     on(d.input, "cut", prepareCopy);

     on(d.input, "copy", prepareCopy);

     // Needed to handle Tab key in KHTML

     if (khtml) on(d.sizer, "mouseup", function() {

         if (document.activeElement == d.input) d.input.blur();

         focusInput(cm);

     });

   }

   function mouseEventInWidget(display, e) {

     for (var n = e_target(e); n != display.wrapper; n = n.parentNode)

       if (/\bCodeMirror-(?:line)?widget\b/.test(n.className) ||

           n.parentNode == display.sizer && n != display.mover) return true;

   }

   function posFromMouse(cm, e, liberal) {

     var display = cm.display;

     if (!liberal) {

       var target = e_target(e);

       if (target == display.scrollbarH || target == display.scrollbarH.firstChild ||

           target == display.scrollbarV || target == display.scrollbarV.firstChild ||

           target == display.scrollbarFiller) return null;

     }

     var x, y, space = display.lineSpace.getBoundingClientRect();

     // Fails unpredictably on IE[67] when mouse is dragged around quickly.

     try { x = e.clientX; y = e.clientY; } catch (e) { return null; }

     return coordsChar(cm, x - space.left, y - space.top);

   }

   var lastClick, lastDoubleClick;

   function onMouseDown(e) {

     var cm = this, display = cm.display, view = cm.view, sel = view.sel, doc = view.doc;

     sel.shift = e_prop(e, "shiftKey");

     if (mouseEventInWidget(display, e)) {

       if (!webkit) {

         display.scroller.draggable = false;

         setTimeout(function(){display.scroller.draggable = true;}, 100);

       }

       return;

     }

     if (clickInGutter(cm, e)) return;

     var start = posFromMouse(cm, e);

     switch (e_button(e)) {

     case 3:

       if (gecko) onContextMenu.call(cm, cm, e);

       return;

     case 2:

       if (start) extendSelection(cm, start);

       setTimeout(bind(focusInput, cm), 20);

       e_preventDefault(e);

       return;

     }

     // For button 1, if it was clicked inside the editor

     // (posFromMouse returning non-null), we have to adjust the

     // selection.

     if (!start) {if (e_target(e) == display.scroller) e_preventDefault(e); return;}

     if (!view.focused) onFocus(cm);

     var now = +new Date, type = "single";

     if (lastDoubleClick && lastDoubleClick.time > now - 400 && posEq(lastDoubleClick.pos, start)) {

       type = "triple";

       e_preventDefault(e);

       setTimeout(bind(focusInput, cm), 20);

       selectLine(cm, start.line);

     } else if (lastClick && lastClick.time > now - 400 && posEq(lastClick.pos, start)) {

       type = "double";

       lastDoubleClick = {time: now, pos: start};

       e_preventDefault(e);

       var word = findWordAt(getLine(doc, start.line).text, start);

       extendSelection(cm, word.from, word.to);

     } else { lastClick = {time: now, pos: start}; }

     var last = start;

     if (cm.options.dragDrop && dragAndDrop && !isReadOnly(cm) && !posEq(sel.from, sel.to) &&

         !posLess(start, sel.from) && !posLess(sel.to, start) && type == "single") {

       var dragEnd = operation(cm, function(e2) {

         if (webkit) display.scroller.draggable = false;

         view.draggingText = false;

         off(document, "mouseup", dragEnd);

         off(display.scroller, "drop", dragEnd);

         if (Math.abs(e.clientX - e2.clientX) + Math.abs(e.clientY - e2.clientY) < 10) {

           e_preventDefault(e2);

           extendSelection(cm, start);

           focusInput(cm);

         }

       });

       // Let the drag handler handle this.

       if (webkit) display.scroller.draggable = true;

       view.draggingText = dragEnd;

       // IE's approach to draggable

       if (display.scroller.dragDrop) display.scroller.dragDrop();

       on(document, "mouseup", dragEnd);

       on(display.scroller, "drop", dragEnd);

       return;

     }

     e_preventDefault(e);

     if (type == "single") extendSelection(cm, clipPos(doc, start));

     var startstart = sel.from, startend = sel.to;

     function doSelect(cur) {

       if (type == "single") {

         extendSelection(cm, clipPos(doc, start), cur);

         return;

       }

       startstart = clipPos(doc, startstart);

       startend = clipPos(doc, startend);

       if (type == "double") {

         var word = findWordAt(getLine(doc, cur.line).text, cur);

         if (posLess(cur, startstart)) extendSelection(cm, word.from, startend);

         else extendSelection(cm, startstart, word.to);

       } else if (type == "triple") {

         if (posLess(cur, startstart)) extendSelection(cm, startend, clipPos(doc, {line: cur.line, ch: 0}));

         else extendSelection(cm, startstart, clipPos(doc, {line: cur.line + 1, ch: 0}));

       }

     }

     var editorSize = display.wrapper.getBoundingClientRect();

     // Used to ensure timeout re-tries don't fire when another extend

     // happened in the meantime (clearTimeout isn't reliable -- at

     // least on Chrome, the timeouts still happen even when cleared,

     // if the clear happens after their scheduled firing time).

     var counter = 0;

     function extend(e) {

       var curCount = ++counter;

       var cur = posFromMouse(cm, e, true);

       if (!cur) return;

       if (!posEq(cur, last)) {

         if (!view.focused) onFocus(cm);

         last = cur;

         doSelect(cur);

         var visible = visibleLines(display, doc);

         if (cur.line >= visible.to || cur.line < visible.from)

           setTimeout(operation(cm, function(){if (counter == curCount) extend(e);}), 150);

       } else {

         var outside = e.clientY < editorSize.top ? -20 : e.clientY > editorSize.bottom ? 20 : 0;

         if (outside) setTimeout(operation(cm, function() {

           if (counter != curCount) return;

           display.scroller.scrollTop += outside;

           extend(e);

         }), 50);

       }

     }

     function done(e) {

       counter = Infinity;

       var cur = posFromMouse(cm, e);

       if (cur) doSelect(cur);

       e_preventDefault(e);

       focusInput(cm);

       off(document, "mousemove", move);

       off(document, "mouseup", up);

     }

     var move = operation(cm, function(e) {

       if (!ie && !e_button(e)) done(e);

       else extend(e);

     });

     var up = operation(cm, done);

     on(document, "mousemove", move);

     on(document, "mouseup", up);

   }

   function onDrop(e) {

     var cm = this;

     if (cm.options.onDragEvent && cm.options.onDragEvent(cm, addStop(e))) return;

     e_preventDefault(e);

     var pos = posFromMouse(cm, e, true), files = e.dataTransfer.files;

     if (!pos || isReadOnly(cm)) return;

     if (files && files.length && window.FileReader && window.File) {

       var n = files.length, text = Array(n), read = 0;

       var loadFile = function(file, i) {

         var reader = new FileReader;

         reader.onload = function() {

           text[i] = reader.result;

           if (++read == n) {

             pos = clipPos(cm.view.doc, pos);

             operation(cm, function() {

               var end = replaceRange(cm, text.join(""), pos, pos, "paste");

               setSelection(cm, pos, end);

             })();

           }

         };

         reader.readAsText(file);

       };

       for (var i = 0; i < n; ++i) loadFile(files[i], i);

     } else {

       // Don't do a replace if the drop happened inside of the selected text.

       if (cm.view.draggingText && !(posLess(pos, cm.view.sel.from) || posLess(cm.view.sel.to, pos))) {

         cm.view.draggingText(e);

         if (ie) setTimeout(bind(focusInput, cm), 50);

         return;

       }

       try {

         var text = e.dataTransfer.getData("Text");

         if (text) {

           var curFrom = cm.view.sel.from, curTo = cm.view.sel.to;

           setSelection(cm, pos, pos);

           if (cm.view.draggingText) replaceRange(cm, "", curFrom, curTo, "paste");

           cm.replaceSelection(text, null, "paste");

           focusInput(cm);

           onFocus(cm);

         }

       }

       catch(e){}

     }

   }

   function clickInGutter(cm, e) {

     var display = cm.display;

     try { var mX = e.clientX, mY = e.clientY; }

     catch(e) { return false; }

     if (mX >= Math.floor(display.gutters.getBoundingClientRect().right)) return false;

     e_preventDefault(e);

     if (!hasHandler(cm, "gutterClick")) return true;

     var lineBox = display.lineDiv.getBoundingClientRect();

     if (mY > lineBox.bottom) return true;

     mY -= lineBox.top - display.viewOffset;

     for (var i = 0; i < cm.options.gutters.length; ++i) {

       var g = display.gutters.childNodes[i];

       if (g && g.getBoundingClientRect().right >= mX) {

         var line = lineAtHeight(cm.view.doc, mY);

         var gutter = cm.options.gutters[i];

         signalLater(cm, cm, "gutterClick", cm, line, gutter, e);

         break;

       }

     }

     return true;

   }

   function onDragStart(cm, e) {

     var txt = cm.getSelection();

     e.dataTransfer.setData("Text", txt);

     // Use dummy image instead of default browsers image.

     // Recent Safari (~6.0.2) have a tendency to segfault when this happens, so we don't do it there.

     if (e.dataTransfer.setDragImage && !safari)

       e.dataTransfer.setDragImage(elt('img'), 0, 0);

   }

   function setScrollTop(cm, val) {

     if (Math.abs(cm.view.scrollTop - val) < 2) return;

     cm.view.scrollTop = val;

     if (!gecko) updateDisplay(cm, [], val);

     if (cm.display.scroller.scrollTop != val) cm.display.scroller.scrollTop = val;

     if (cm.display.scrollbarV.scrollTop != val) cm.display.scrollbarV.scrollTop = val;

     if (gecko) updateDisplay(cm, []);

   }

   function setScrollLeft(cm, val, isScroller) {

     if (isScroller ? val == cm.view.scrollLeft : Math.abs(cm.view.scrollLeft - val) < 2) return;

     cm.view.scrollLeft = val;

     alignHorizontally(cm);

     if (cm.display.scroller.scrollLeft != val) cm.display.scroller.scrollLeft = val;

     if (cm.display.scrollbarH.scrollLeft != val) cm.display.scrollbarH.scrollLeft = val;

   }

   // Since the delta values reported on mouse wheel events are

   // unstandardized between browsers and even browser versions, and

   // generally horribly unpredictable, this code starts by measuring

   // the scroll effect that the first few mouse wheel events have,

   // and, from that, detects the way it can convert deltas to pixel

   // offsets afterwards.

   //

   // The reason we want to know the amount a wheel event will scroll

   // is that it gives us a chance to update the display before the

   // actual scrolling happens, reducing flickering.

   var wheelSamples = 0, wheelDX, wheelDY, wheelStartX, wheelStartY, wheelPixelsPerUnit = null;

   // Fill in a browser-detected starting value on browsers where we

   // know one. These don't have to be accurate -- the result of them

   // being wrong would just be a slight flicker on the first wheel

   // scroll (if it is large enough).

   if (ie) wheelPixelsPerUnit = -.53;

   else if (gecko) wheelPixelsPerUnit = 15;

   else if (chrome) wheelPixelsPerUnit = -.7;

   else if (safari) wheelPixelsPerUnit = -1/3;

   function onScrollWheel(cm, e) {

     var dx = e.wheelDeltaX, dy = e.wheelDeltaY;

     if (dx == null && e.detail && e.axis == e.HORIZONTAL_AXIS) dx = e.detail;

     if (dy == null && e.detail && e.axis == e.VERTICAL_AXIS) dy = e.detail;

     else if (dy == null) dy = e.wheelDelta;

     // Webkit browsers on OS X abort momentum scrolls when the target

     // of the scroll event is removed from the scrollable element.

     // This hack (see related code in patchDisplay) makes sure the

     // element is kept around.

     if (dy && mac && webkit) {

       for (var cur = e.target; cur != scroll; cur = cur.parentNode) {

         if (cur.lineObj) {

           cm.display.currentWheelTarget = cur;

           break;

         }

       }

     }

     var scroll = cm.display.scroller;

     // On some browsers, horizontal scrolling will cause redraws to

     // happen before the gutter has been realigned, causing it to

     // wriggle around in a most unseemly way. When we have an

     // estimated pixels/delta value, we just handle horizontal

     // scrolling entirely here. It'll be slightly off from native, but

     // better than glitching out.

     if (dx && !gecko && !opera && wheelPixelsPerUnit != null) {

       if (dy)

         setScrollTop(cm, Math.max(0, Math.min(scroll.scrollTop + dy * wheelPixelsPerUnit, scroll.scrollHeight - scroll.clientHeight)));

       setScrollLeft(cm, Math.max(0, Math.min(scroll.scrollLeft + dx * wheelPixelsPerUnit, scroll.scrollWidth - scroll.clientWidth)));

       e_preventDefault(e);

       wheelStartX = null; // Abort measurement, if in progress

       return;

     }

     if (dy && wheelPixelsPerUnit != null) {

       var pixels = dy * wheelPixelsPerUnit;

       var top = cm.view.scrollTop, bot = top + cm.display.wrapper.clientHeight;

       if (pixels < 0) top = Math.max(0, top + pixels - 50);

       else bot = Math.min(cm.view.doc.height, bot + pixels + 50);

       updateDisplay(cm, [], {top: top, bottom: bot});

     }

     if (wheelSamples < 20) {

       if (wheelStartX == null) {

         wheelStartX = scroll.scrollLeft; wheelStartY = scroll.scrollTop;

         wheelDX = dx; wheelDY = dy;

         setTimeout(function() {

           if (wheelStartX == null) return;

           var movedX = scroll.scrollLeft - wheelStartX;

           var movedY = scroll.scrollTop - wheelStartY;

           var sample = (movedY && wheelDY && movedY / wheelDY) ||

             (movedX && wheelDX && movedX / wheelDX);

           wheelStartX = wheelStartY = null;

           if (!sample) return;

           wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1);

           ++wheelSamples;

         }, 200);

       } else {

         wheelDX += dx; wheelDY += dy;

       }

     }

   }

   function doHandleBinding(cm, bound, dropShift) {

     if (typeof bound == "string") {

       bound = commands[bound];

       if (!bound) return false;

     }

     // Ensure previous input has been read, so that the handler sees a

     // consistent view of the document

     if (cm.display.pollingFast && readInput(cm)) cm.display.pollingFast = false;

     var view = cm.view, prevShift = view.sel.shift;

     try {

       if (isReadOnly(cm)) view.suppressEdits = true;

       if (dropShift) view.sel.shift = false;

       bound(cm);

     } catch(e) {

       if (e != Pass) throw e;

       return false;

     } finally {

       view.sel.shift = prevShift;

       view.suppressEdits = false;

     }

     return true;

   }

   function allKeyMaps(cm) {

     var maps = cm.view.keyMaps.slice(0);

     maps.push(cm.options.keyMap);

     if (cm.options.extraKeys) maps.unshift(cm.options.extraKeys);

     return maps;

   }

   var maybeTransition;

   function handleKeyBinding(cm, e) {

     // Handle auto keymap transitions

     var startMap = getKeyMap(cm.options.keyMap), next = startMap.auto;

     clearTimeout(maybeTransition);

     if (next && !isModifierKey(e)) maybeTransition = setTimeout(function() {

       if (getKeyMap(cm.options.keyMap) == startMap)

         cm.options.keyMap = (next.call ? next.call(null, cm) : next);

     }, 50);

     var name = keyNames[e_prop(e, "keyCode")], handled = false;

     var flipCtrlCmd = mac && (opera || qtwebkit);

     if (name == null || e.altGraphKey) return false;

     if (e_prop(e, "altKey")) name = "Alt-" + name;

     if (e_prop(e, flipCtrlCmd ? "metaKey" : "ctrlKey")) name = "Ctrl-" + name;

     if (e_prop(e, flipCtrlCmd ? "ctrlKey" : "metaKey")) name = "Cmd-" + name;

     var stopped = false;

     function stop() { stopped = true; }

     var keymaps = allKeyMaps(cm);

     if (e_prop(e, "shiftKey")) {

       handled = lookupKey("Shift-" + name, keymaps,

                           function(b) {return doHandleBinding(cm, b, true);}, stop)

         || lookupKey(name, keymaps, function(b) {

           if (typeof b == "string" && /^go[A-Z]/.test(b)) return doHandleBinding(cm, b);

         }, stop);

     } else {

       handled = lookupKey(name, keymaps,

                           function(b) { return doHandleBinding(cm, b); }, stop);

     }

     if (stopped) handled = false;

     if (handled) {

       e_preventDefault(e);

       restartBlink(cm);

       if (ie_lt9) { e.oldKeyCode = e.keyCode; e.keyCode = 0; }

     }

     return handled;

   }

   function handleCharBinding(cm, e, ch) {

     var handled = lookupKey("'" + ch + "'", allKeyMaps(cm),

                             function(b) { return doHandleBinding(cm, b, true); });

     if (handled) {

       e_preventDefault(e);

       restartBlink(cm);

     }

     return handled;

   }

   var lastStoppedKey = null;

   function onKeyDown(e) {

     var cm = this;

     if (!cm.view.focused) onFocus(cm);

     if (ie && e.keyCode == 27) { e.returnValue = false; }

     if (cm.options.onKeyEvent && cm.options.onKeyEvent(cm, addStop(e))) return;

     var code = e_prop(e, "keyCode");

     // IE does strange things with escape.

     cm.view.sel.shift = code == 16 || e_prop(e, "shiftKey");

     // First give onKeyEvent option a chance to handle this.

     var handled = handleKeyBinding(cm, e);

     if (opera) {

       lastStoppedKey = handled ? code : null;

       // Opera has no cut event... we try to at least catch the key combo

       if (!handled && code == 88 && !hasCopyEvent && e_prop(e, mac ? "metaKey" : "ctrlKey"))

         cm.replaceSelection("");

     }

   }

   function onKeyPress(e) {

     var cm = this;

     if (cm.options.onKeyEvent && cm.options.onKeyEvent(cm, addStop(e))) return;

     var keyCode = e_prop(e, "keyCode"), charCode = e_prop(e, "charCode");

     if (opera && keyCode == lastStoppedKey) {lastStoppedKey = null; e_preventDefault(e); return;}

     if (((opera && (!e.which || e.which < 10)) || khtml) && handleKeyBinding(cm, e)) return;

     var ch = String.fromCharCode(charCode == null ? keyCode : charCode);

     if (this.options.electricChars && this.view.mode.electricChars &&

         this.options.smartIndent && !isReadOnly(this) &&

         this.view.mode.electricChars.indexOf(ch) > -1)

       setTimeout(operation(cm, function() {indentLine(cm, cm.view.sel.to.line, "smart");}), 75);

     if (handleCharBinding(cm, e, ch)) return;

     fastPoll(cm);

   }

   function onFocus(cm) {

     if (cm.options.readOnly == "nocursor") return;

     if (!cm.view.focused) {

       signal(cm, "focus", cm);

       cm.view.focused = true;

       if (cm.display.scroller.className.search(/\bCodeMirror-focused\b/) == -1)

         cm.display.scroller.className += " CodeMirror-focused";

       resetInput(cm, true);

     }

     slowPoll(cm);

     restartBlink(cm);

   }

   function onBlur(cm) {

     if (cm.view.focused) {

       signal(cm, "blur", cm);

       cm.view.focused = false;

       cm.display.scroller.className = cm.display.scroller.className.replace(" CodeMirror-focused", "");

     }

     clearInterval(cm.display.blinker);

     setTimeout(function() {if (!cm.view.focused) cm.view.sel.shift = false;}, 150);

   }

   var detectingSelectAll;

   function onContextMenu(cm, e) {

     var display = cm.display, sel = cm.view.sel;

     var pos = posFromMouse(cm, e), scrollPos = display.scroller.scrollTop;

     if (!pos || opera) return; // Opera is difficult.

     if (posEq(sel.from, sel.to) || posLess(pos, sel.from) || !posLess(pos, sel.to))

       operation(cm, setSelection)(cm, pos, pos);

     var oldCSS = display.input.style.cssText;

     display.inputDiv.style.position = "absolute";

     display.input.style.cssText = "position: fixed; width: 30px; height: 30px; top: " + (e.clientY - 5) +

       "px; left: " + (e.clientX - 5) + "px; z-index: 1000; background: white; outline: none;" +

       "border-width: 0; outline: none; overflow: hidden; opacity: .05; filter: alpha(opacity=5);";

     focusInput(cm);

     resetInput(cm, true);

     // Adds "Select all" to context menu in FF

     if (posEq(sel.from, sel.to)) display.input.value = display.prevInput = " ";

     function rehide() {

       display.inputDiv.style.position = "relative";

       display.input.style.cssText = oldCSS;

       if (ie_lt9) display.scrollbarV.scrollTop = display.scroller.scrollTop = scrollPos;

       slowPoll(cm);

       // Try to detect the user choosing select-all 

       if (display.input.selectionStart != null) {

         clearTimeout(detectingSelectAll);

         var extval = display.input.value = " " + (posEq(sel.from, sel.to) ? "" : display.input.value), i = 0;

         display.prevInput = " ";

         display.input.selectionStart = 1; display.input.selectionEnd = extval.length;

         detectingSelectAll = setTimeout(function poll(){

           if (display.prevInput == " " && display.input.selectionStart == 0)

             operation(cm, commands.selectAll)(cm);

           else if (i++ < 10) detectingSelectAll = setTimeout(poll, 500);

           else resetInput(cm);

         }, 200);

       }

     }

     if (gecko) {

       e_stop(e);

       on(window, "mouseup", function mouseup() {

         off(window, "mouseup", mouseup);

         setTimeout(rehide, 20);

       });

     } else {

       setTimeout(rehide, 50);

     }

   }

   // UPDATING

   // Replace the range from from to to by the strings in newText.

   // Afterwards, set the selection to selFrom, selTo.

   function updateDoc(cm, from, to, newText, selUpdate, origin) {

     // Possibly split or suppress the update based on the presence

     // of read-only spans in its range.

     var split = sawReadOnlySpans &&

       removeReadOnlyRanges(cm.view.doc, from, to);

     if (split) {

       for (var i = split.length - 1; i >= 1; --i)

         updateDocInner(cm, split[i].from, split[i].to, [""], origin);

       if (split.length)

         return updateDocInner(cm, split[0].from, split[0].to, newText, selUpdate, origin);

     } else {

       return updateDocInner(cm, from, to, newText, selUpdate, origin);

     }

   }

   function updateDocInner(cm, from, to, newText, selUpdate, origin) {

     if (cm.view.suppressEdits) return;

     var view = cm.view, doc = view.doc, old = [];

     doc.iter(from.line, to.line + 1, function(line) {

       old.push(newHL(line.text, line.markedSpans));

     });

     var startSelFrom = view.sel.from, startSelTo = view.sel.to;

     var lines = updateMarkedSpans(hlSpans(old[0]), hlSpans(lst(old)), from.ch, to.ch, newText);

     var retval = updateDocNoUndo(cm, from, to, lines, selUpdate, origin);

     if (view.history) addChange(cm, from.line, newText.length, old, origin,

                                 startSelFrom, startSelTo, view.sel.from, view.sel.to);

     return retval;

   }

   function unredoHelper(cm, type) {

     var doc = cm.view.doc, hist = cm.view.history;

     var set = (type == "undo" ? hist.done : hist.undone).pop();

     if (!set) return;

     var anti = {events: [], fromBefore: set.fromAfter, toBefore: set.toAfter,

                 fromAfter: set.fromBefore, toAfter: set.toBefore};

     for (var i = set.events.length - 1; i >= 0; i -= 1) {

       hist.dirtyCounter += type == "undo" ? -1 : 1;

       var change = set.events[i];

       var replaced = [], end = change.start + change.added;

       doc.iter(change.start, end, function(line) { replaced.push(newHL(line.text, line.markedSpans)); });

       anti.events.push({start: change.start, added: change.old.length, old: replaced});

       var selPos = i ? null : {from: set.fromBefore, to: set.toBefore};

       updateDocNoUndo(cm, {line: change.start, ch: 0}, {line: end - 1, ch: getLine(doc, end-1).text.length},

                       change.old, selPos, type);

     }

     (type == "undo" ? hist.undone : hist.done).push(anti);

   }

   function updateDocNoUndo(cm, from, to, lines, selUpdate, origin) {

     var view = cm.view, doc = view.doc, display = cm.display;

     if (view.suppressEdits) return;

     var nlines = to.line - from.line, firstLine = getLine(doc, from.line), lastLine = getLine(doc, to.line);

     var recomputeMaxLength = false, checkWidthStart = from.line;

     if (!cm.options.lineWrapping) {

       checkWidthStart = lineNo(visualLine(doc, firstLine));

       doc.iter(checkWidthStart, to.line + 1, function(line) {

         if (lineLength(doc, line) == view.maxLineLength) {

           recomputeMaxLength = true;

           return true;

         }

       });

     }

     var lastHL = lst(lines), th = textHeight(display);

     // First adjust the line structure

     if (from.ch == 0 && to.ch == 0 && hlText(lastHL) == "") {

       // This is a whole-line replace. Treated specially to make

       // sure line objects move the way they are supposed to.

       var added = [];

       for (var i = 0, e = lines.length - 1; i < e; ++i)

         added.push(makeLine(hlText(lines[i]), hlSpans(lines[i]), th));

       updateLine(cm, lastLine, lastLine.text, hlSpans(lastHL));

       if (nlines) doc.remove(from.line, nlines, cm);

       if (added.length) doc.insert(from.line, added);

     } else if (firstLine == lastLine) {

       if (lines.length == 1) {

         updateLine(cm, firstLine, firstLine.text.slice(0, from.ch) + hlText(lines[0]) +

                    firstLine.text.slice(to.ch), hlSpans(lines[0]));

       } else {

         for (var added = [], i = 1, e = lines.length - 1; i < e; ++i)

           added.push(makeLine(hlText(lines[i]), hlSpans(lines[i]), th));

         added.push(makeLine(hlText(lastHL) + firstLine.text.slice(to.ch), hlSpans(lastHL), th));

         updateLine(cm, firstLine, firstLine.text.slice(0, from.ch) + hlText(lines[0]), hlSpans(lines[0]));

         doc.insert(from.line + 1, added);

       }

     } else if (lines.length == 1) {

       updateLine(cm, firstLine, firstLine.text.slice(0, from.ch) + hlText(lines[0]) +

                  lastLine.text.slice(to.ch), hlSpans(lines[0]));

       doc.remove(from.line + 1, nlines, cm);

     } else {

       var added = [];

       updateLine(cm, firstLine, firstLine.text.slice(0, from.ch) + hlText(lines[0]), hlSpans(lines[0]));

       updateLine(cm, lastLine, hlText(lastHL) + lastLine.text.slice(to.ch), hlSpans(lastHL));

       for (var i = 1, e = lines.length - 1; i < e; ++i)

         added.push(makeLine(hlText(lines[i]), hlSpans(lines[i]), th));

       if (nlines > 1) doc.remove(from.line + 1, nlines - 1, cm);

       doc.insert(from.line + 1, added);

     }

     if (cm.options.lineWrapping) {

       var perLine = Math.max(5, display.scroller.clientWidth / charWidth(display) - 3);

       doc.iter(from.line, from.line + lines.length, function(line) {

         if (line.height == 0) return;

         var guess = (Math.ceil(line.text.length / perLine) || 1) * th;

         if (guess != line.height) updateLineHeight(line, guess);

       });

     } else {

       doc.iter(checkWidthStart, from.line + lines.length, function(line) {

         var len = lineLength(doc, line);

         if (len > view.maxLineLength) {

           view.maxLine = line;

           view.maxLineLength = len;

           view.maxLineChanged = true;

           recomputeMaxLength = false;

         }

       });

       if (recomputeMaxLength) cm.curOp.updateMaxLine = true;

     }

     // Adjust frontier, schedule worker

     view.frontier = Math.min(view.frontier, from.line);

     startWorker(cm, 400);

     var lendiff = lines.length - nlines - 1;

     // Remember that these lines changed, for updating the display

     regChange(cm, from.line, to.line + 1, lendiff);

     if (hasHandler(cm, "change")) {

       // Normalize lines to contain only strings, since that's what

       // the change event handler expects

       for (var i = 0; i < lines.length; ++i)

         if (typeof lines[i] != "string") lines[i] = lines[i].text;

       var changeObj = {from: from, to: to, text: lines, origin: origin};

       if (cm.curOp.textChanged) {

         for (var cur = cm.curOp.textChanged; cur.next; cur = cur.next) {}

         cur.next = changeObj;

       } else cm.curOp.textChanged = changeObj;

     }

     // Update the selection

     var newSelFrom, newSelTo, end = {line: from.line + lines.length - 1,

                                      ch: hlText(lastHL).length  + (lines.length == 1 ? from.ch : 0)};

     if (selUpdate && typeof selUpdate != "string") {

       if (selUpdate.from) { newSelFrom = selUpdate.from; newSelTo = selUpdate.to; }

       else newSelFrom = newSelTo = selUpdate;

     } else if (selUpdate == "end") {

       newSelFrom = newSelTo = end;

     } else if (selUpdate == "start") {

       newSelFrom = newSelTo = from;

     } else if (selUpdate == "around") {

       newSelFrom = from; newSelTo = end;

     } else {

       var adjustPos = function(pos) {

         if (posLess(pos, from)) return pos;

         if (!posLess(to, pos)) return end;

         var line = pos.line + lendiff;

         var ch = pos.ch;

         if (pos.line == to.line)

           ch += hlText(lastHL).length - (to.ch - (to.line == from.line ? from.ch : 0));

         return {line: line, ch: ch};

       };

       newSelFrom = adjustPos(view.sel.from);

       newSelTo = adjustPos(view.sel.to);

     }

     setSelection(cm, newSelFrom, newSelTo, null, true);

     return end;

   }

   function replaceRange(cm, code, from, to, origin) {

     if (!to) to = from;

     if (posLess(to, from)) { var tmp = to; to = from; from = tmp; }

     return updateDoc(cm, from, to, splitLines(code), null, origin);

   }

   // SELECTION

   function posEq(a, b) {return a.line == b.line && a.ch == b.ch;}

   function posLess(a, b) {return a.line < b.line || (a.line == b.line && a.ch < b.ch);}

   function copyPos(x) {return {line: x.line, ch: x.ch};}

   function clipLine(doc, n) {return Math.max(0, Math.min(n, doc.size-1));}

   function clipPos(doc, pos) {

     if (pos.line < 0) return {line: 0, ch: 0};

     if (pos.line >= doc.size) return {line: doc.size-1, ch: getLine(doc, doc.size-1).text.length};

     var ch = pos.ch, linelen = getLine(doc, pos.line).text.length;

     if (ch == null || ch > linelen) return {line: pos.line, ch: linelen};

     else if (ch < 0) return {line: pos.line, ch: 0};

     else return pos;

   }

   function isLine(doc, l) {return l >= 0 && l < doc.size;}

   // If shift is held, this will move the selection anchor. Otherwise,

   // it'll set the whole selection.

   function extendSelection(cm, pos, other, bias) {

     var sel = cm.view.sel;

     if (sel.shift || sel.extend) {

       var anchor = sel.anchor;

       if (other) {

         var posBefore = posLess(pos, anchor);

         if (posBefore != posLess(other, anchor)) {

           anchor = pos;

           pos = other;

         } else if (posBefore != posLess(pos, other)) {

           pos = other;

         }

       }

       setSelection(cm, anchor, pos, bias);

     } else {

       setSelection(cm, pos, other || pos, bias);

     }

     cm.curOp.userSelChange = true;

   }

   // Update the selection. Last two args are only used by

   // updateDoc, since they have to be expressed in the line

   // numbers before the update.

   function setSelection(cm, anchor, head, bias, checkAtomic) {

     cm.view.goalColumn = null;

     var sel = cm.view.sel;

     // Skip over atomic spans.

     if (checkAtomic || !posEq(anchor, sel.anchor))

       anchor = skipAtomic(cm, anchor, bias, checkAtomic != "push");

     if (checkAtomic || !posEq(head, sel.head))

       head = skipAtomic(cm, head, bias, checkAtomic != "push");

     if (posEq(sel.anchor, anchor) && posEq(sel.head, head)) return;

     sel.anchor = anchor; sel.head = head;

     var inv = posLess(head, anchor);

     sel.from = inv ? head : anchor;

     sel.to = inv ? anchor : head;

     cm.curOp.updateInput = true;

     cm.curOp.selectionChanged = true;

   }

   function reCheckSelection(cm) {

     setSelection(cm, cm.view.sel.from, cm.view.sel.to, null, "push");

   }

   function skipAtomic(cm, pos, bias, mayClear) {

     var doc = cm.view.doc, flipped = false, curPos = pos;

     var dir = bias || 1;

     cm.view.cantEdit = false;

     search: for (;;) {

       var line = getLine(doc, curPos.line), toClear;

       if (line.markedSpans) {

         for (var i = 0; i < line.markedSpans.length; ++i) {

           var sp = line.markedSpans[i], m = sp.marker;

           if ((sp.from == null || (m.inclusiveLeft ? sp.from <= curPos.ch : sp.from < curPos.ch)) &&

               (sp.to == null || (m.inclusiveRight ? sp.to >= curPos.ch : sp.to > curPos.ch))) {

             if (mayClear && m.clearOnEnter) {

               (toClear || (toClear = [])).push(m);

               continue;

             } else if (!m.atomic) continue;

             var newPos = m.find()[dir < 0 ? "from" : "to"];

             if (posEq(newPos, curPos)) {

               newPos.ch += dir;

               if (newPos.ch < 0) {

                 if (newPos.line) newPos = clipPos(doc, {line: newPos.line - 1});

                 else newPos = null;

               } else if (newPos.ch > line.text.length) {

                 if (newPos.line < doc.size - 1) newPos = {line: newPos.line + 1, ch: 0};

                 else newPos = null;

               }

               if (!newPos) {

                 if (flipped) {

                   // Driven in a corner -- no valid cursor position found at all

                   // -- try again *with* clearing, if we didn't already

                   if (!mayClear) return skipAtomic(cm, pos, bias, true);

                   // Otherwise, turn off editing until further notice, and return the start of the doc

                   cm.view.cantEdit = true;

                   return {line: 0, ch: 0};

                 }

                 flipped = true; newPos = pos; dir = -dir;

               }

             }

             curPos = newPos;

             continue search;

           }

         }

         if (toClear) for (var i = 0; i < toClear.length; ++i) toClear[i].clear();

       }

       return curPos;

     }

   }

   // SCROLLING

   function scrollCursorIntoView(cm) {

     var view = cm.view;

     var coords = scrollPosIntoView(cm, view.sel.head);

     if (!view.focused) return;

     var display = cm.display, box = display.sizer.getBoundingClientRect(), doScroll = null;

     if (coords.top + box.top < 0) doScroll = true;

     else if (coords.bottom + box.top > (window.innerHeight || document.documentElement.clientHeight)) doScroll = false;

     if (doScroll != null && !phantom) {

       var hidden = display.cursor.style.display == "none";

       if (hidden) {

         display.cursor.style.display = "";

         display.cursor.style.left = coords.left + "px";

         display.cursor.style.top = (coords.top - display.viewOffset) + "px";

       }

       display.cursor.scrollIntoView(doScroll);

       if (hidden) display.cursor.style.display = "none";

     }

   }

   function scrollPosIntoView(cm, pos) {

     for (;;) {

       var changed = false, coords = cursorCoords(cm, pos);

       var scrollPos = calculateScrollPos(cm, coords.left, coords.top, coords.left, coords.bottom);

       var startTop = cm.view.scrollTop, startLeft = cm.view.scrollLeft;

       if (scrollPos.scrollTop != null) {

         setScrollTop(cm, scrollPos.scrollTop);

         if (Math.abs(cm.view.scrollTop - startTop) > 1) changed = true;

       }

       if (scrollPos.scrollLeft != null) {

         setScrollLeft(cm, scrollPos.scrollLeft);

         if (Math.abs(cm.view.scrollLeft - startLeft) > 1) changed = true;

       }

       if (!changed) return coords;

     }

   }

   function scrollIntoView(cm, x1, y1, x2, y2) {

     var scrollPos = calculateScrollPos(cm, x1, y1, x2, y2);

     if (scrollPos.scrollTop != null) setScrollTop(cm, scrollPos.scrollTop);

     if (scrollPos.scrollLeft != null) setScrollLeft(cm, scrollPos.scrollLeft);

   }

   function calculateScrollPos(cm, x1, y1, x2, y2) {

     var display = cm.display, pt = paddingTop(display);

     y1 += pt; y2 += pt;

     var screen = display.scroller.clientHeight - scrollerCutOff, screentop = display.scroller.scrollTop, result = {};

     var docBottom = cm.view.doc.height + 2 * pt;

     var atTop = y1 < pt + 10, atBottom = y2 + pt > docBottom - 10;

     if (y1 < screentop) result.scrollTop = atTop ? 0 : Math.max(0, y1);

     else if (y2 > screentop + screen) result.scrollTop = (atBottom ? docBottom : y2) - screen;

     var screenw = display.scroller.clientWidth - scrollerCutOff, screenleft = display.scroller.scrollLeft;

     x1 += display.gutters.offsetWidth; x2 += display.gutters.offsetWidth;

     var gutterw = display.gutters.offsetWidth;

     var atLeft = x1 < gutterw + 10;

     if (x1 < screenleft + gutterw || atLeft) {

       if (atLeft) x1 = 0;

       result.scrollLeft = Math.max(0, x1 - 10 - gutterw);

     } else if (x2 > screenw + screenleft - 3) {

       result.scrollLeft = x2 + 10 - screenw;

     }

     return result;

   }

   // API UTILITIES

   function indentLine(cm, n, how, aggressive) {

     var doc = cm.view.doc;

     if (!how) how = "add";

     if (how == "smart") {

       if (!cm.view.mode.indent) how = "prev";

       else var state = getStateBefore(cm, n);

     }

     var tabSize = cm.options.tabSize;

     var line = getLine(doc, n), curSpace = countColumn(line.text, null, tabSize);

     var curSpaceString = line.text.match(/^\s*/)[0], indentation;

     if (how == "smart") {

       indentation = cm.view.mode.indent(state, line.text.slice(curSpaceString.length), line.text);

       if (indentation == Pass) {

         if (!aggressive) return;

         how = "prev";

       }

     }

     if (how == "prev") {

       if (n) indentation = countColumn(getLine(doc, n-1).text, null, tabSize);

       else indentation = 0;

     }

     else if (how == "add") indentation = curSpace + cm.options.indentUnit;

     else if (how == "subtract") indentation = curSpace - cm.options.indentUnit;

     indentation = Math.max(0, indentation);

     var indentString = "", pos = 0;

     if (cm.options.indentWithTabs)

       for (var i = Math.floor(indentation / tabSize); i; --i) {pos += tabSize; indentString += "\t";}

     if (pos < indentation) indentString += spaceStr(indentation - pos);

     if (indentString != curSpaceString)

       replaceRange(cm, indentString, {line: n, ch: 0}, {line: n, ch: curSpaceString.length}, "input");

     line.stateAfter = null;

   }

   function changeLine(cm, handle, op) {

     var no = handle, line = handle, doc = cm.view.doc;

     if (typeof handle == "number") line = getLine(doc, clipLine(doc, handle));

     else no = lineNo(handle);

     if (no == null) return null;

     if (op(line, no)) regChange(cm, no, no + 1);

     else return null;

     return line;

   }

   function findPosH(cm, dir, unit, visually) {

     var doc = cm.view.doc, end = cm.view.sel.head, line = end.line, ch = end.ch;

     var lineObj = getLine(doc, line);

     function findNextLine() {

       var l = line + dir;

       if (l < 0 || l == doc.size) return false;

       line = l;

       return lineObj = getLine(doc, l);

     }

     function moveOnce(boundToLine) {

       var next = (visually ? moveVisually : moveLogically)(lineObj, ch, dir, true);

       if (next == null) {

         if (!boundToLine && findNextLine()) {

           if (visually) ch = (dir < 0 ? lineRight : lineLeft)(lineObj);

           else ch = dir < 0 ? lineObj.text.length : 0;

         } else return false;

       } else ch = next;

       return true;

     }

     if (unit == "char") moveOnce();

     else if (unit == "column") moveOnce(true);

     else if (unit == "word") {

       var sawWord = false;

       for (;;) {

         if (dir < 0) if (!moveOnce()) break;

         if (isWordChar(lineObj.text.charAt(ch))) sawWord = true;

         else if (sawWord) {if (dir < 0) {dir = 1; moveOnce();} break;}

         if (dir > 0) if (!moveOnce()) break;

       }

     }

     return skipAtomic(cm, {line: line, ch: ch}, dir, true);

   }

   function findWordAt(line, pos) {

     var start = pos.ch, end = pos.ch;

     if (line) {

       if (pos.after === false || end == line.length) --start; else ++end;

       var startChar = line.charAt(start);

       var check = isWordChar(startChar) ? isWordChar :

         /\s/.test(startChar) ? function(ch) {return /\s/.test(ch);} :

       function(ch) {return !/\s/.test(ch) && !isWordChar(ch);};

       while (start > 0 && check(line.charAt(start - 1))) --start;

       while (end < line.length && check(line.charAt(end))) ++end;

     }

     return {from: {line: pos.line, ch: start}, to: {line: pos.line, ch: end}};

   }

   function selectLine(cm, line) {

     extendSelection(cm, {line: line, ch: 0}, clipPos(cm.view.doc, {line: line + 1, ch: 0}));

   }

   // PROTOTYPE

   // The publicly visible API. Note that operation(null, f) means

   // 'wrap f in an operation, performed on its `this` parameter'

   CodeMirror.prototype = {

     getValue: function(lineSep) {

       var text = [], doc = this.view.doc;

       doc.iter(0, doc.size, function(line) { text.push(line.text); });

       return text.join(lineSep || "\n");

     },

     setValue: operation(null, function(code) {

       var doc = this.view.doc, top = {line: 0, ch: 0}, lastLen = getLine(doc, doc.size-1).text.length;

       updateDocInner(this, top, {line: doc.size - 1, ch: lastLen}, splitLines(code), top, top, "setValue");

     }),

     getSelection: function(lineSep) { return this.getRange(this.view.sel.from, this.view.sel.to, lineSep); },

     replaceSelection: operation(null, function(code, collapse, origin) {

       var sel = this.view.sel;

       updateDoc(this, sel.from, sel.to, splitLines(code), collapse || "around", origin);

     }),

     focus: function(){window.focus(); focusInput(this); onFocus(this); fastPoll(this);},

     setOption: function(option, value) {

       var options = this.options, old = options[option];

       if (options[option] == value && option != "mode") return;

       options[option] = value;

       if (optionHandlers.hasOwnProperty(option))

         operation(this, optionHandlers[option])(this, value, old);

     },

     getOption: function(option) {return this.options[option];},

     getMode: function() {return this.view.mode;},

     addKeyMap: function(map) {

       this.view.keyMaps.push(map);

     },

     removeKeyMap: function(map) {

       var maps = this.view.keyMaps;

       for (var i = 0; i < maps.length; ++i)

         if ((typeof map == "string" ? maps[i].name : maps[i]) == map) {

           maps.splice(i, 1);

           return true;

         }

     },

     undo: operation(null, function() {unredoHelper(this, "undo");}),

     redo: operation(null, function() {unredoHelper(this, "redo");}),

     indentLine: operation(null, function(n, dir, aggressive) {

       if (typeof dir != "string") {

         if (dir == null) dir = this.options.smartIndent ? "smart" : "prev";

         else dir = dir ? "add" : "subtract";

       }

       if (isLine(this.view.doc, n)) indentLine(this, n, dir, aggressive);

     }),

     indentSelection: operation(null, function(how) {

       var sel = this.view.sel;

       if (posEq(sel.from, sel.to)) return indentLine(this, sel.from.line, how);

       var e = sel.to.line - (sel.to.ch ? 0 : 1);

       for (var i = sel.from.line; i <= e; ++i) indentLine(this, i, how);

     }),

     historySize: function() {

       var hist = this.view.history;

       return {undo: hist.done.length, redo: hist.undone.length};

     },

     clearHistory: function() {this.view.history = makeHistory();},

     markClean: function() {

       this.view.history.dirtyCounter = 0;

       this.view.history.lastOp = this.view.history.lastOrigin = null;

     },

     isClean: function () {return this.view.history.dirtyCounter == 0;},

     getHistory: function() {

       var hist = this.view.history;

       function cp(arr) {

         for (var i = 0, nw = [], nwelt; i < arr.length; ++i) {

           var set = arr[i];

           nw.push({events: nwelt = [], fromBefore: set.fromBefore, toBefore: set.toBefore,

                    fromAfter: set.fromAfter, toAfter: set.toAfter});

           for (var j = 0, elt = set.events; j < elt.length; ++j) {

             var old = [], cur = elt[j];

             nwelt.push({start: cur.start, added: cur.added, old: old});

             for (var k = 0; k < cur.old.length; ++k) old.push(hlText(cur.old[k]));

           }

         }

         return nw;

       }

       return {done: cp(hist.done), undone: cp(hist.undone)};

     },

     setHistory: function(histData) {

       var hist = this.view.history = makeHistory();

       hist.done = histData.done;

       hist.undone = histData.undone;

     },

     // Fetch the parser token for a given character. Useful for hacks

     // that want to inspect the mode state (say, for completion).

     getTokenAt: function(pos) {

       var doc = this.view.doc;

       pos = clipPos(doc, pos);

       var state = getStateBefore(this, pos.line), mode = this.view.mode;

       var line = getLine(doc, pos.line);

       var stream = new StringStream(line.text, this.options.tabSize);

       while (stream.pos < pos.ch && !stream.eol()) {

         stream.start = stream.pos;

         var style = mode.token(stream, state);

       }

       return {start: stream.start,

               end: stream.pos,

               string: stream.current(),

               className: style || null, // Deprecated, use 'type' instead

               type: style || null,

               state: state};

     },

     getStateAfter: function(line) {

       var doc = this.view.doc;

       line = clipLine(doc, line == null ? doc.size - 1: line);

       return getStateBefore(this, line + 1);

     },

     cursorCoords: function(start, mode) {

       var pos, sel = this.view.sel;

       if (start == null) pos = sel.head;

       else if (typeof start == "object") pos = clipPos(this.view.doc, start);

       else pos = start ? sel.from : sel.to;

       return cursorCoords(this, pos, mode || "page");

     },

     charCoords: function(pos, mode) {

       return charCoords(this, clipPos(this.view.doc, pos), mode || "page");

     },

     coordsChar: function(coords) {

       var off = this.display.lineSpace.getBoundingClientRect();

       return coordsChar(this, coords.left - off.left, coords.top - off.top);

     },

     defaultTextHeight: function() { return textHeight(this.display); },

     markText: operation(null, function(from, to, options) {

       return markText(this, clipPos(this.view.doc, from), clipPos(this.view.doc, to),

                       options, "range");

     }),

     setBookmark: operation(null, function(pos, widget) {

       pos = clipPos(this.view.doc, pos);

       return markText(this, pos, pos, widget ? {replacedWith: widget} : {}, "bookmark");

     }),

     findMarksAt: function(pos) {

       var doc = this.view.doc;

       pos = clipPos(doc, pos);

       var markers = [], spans = getLine(doc, pos.line).markedSpans;

       if (spans) for (var i = 0; i < spans.length; ++i) {

         var span = spans[i];

         if ((span.from == null || span.from <= pos.ch) &&

             (span.to == null || span.to >= pos.ch))

           markers.push(span.marker);

       }

       return markers;

     },

     setGutterMarker: operation(null, function(line, gutterID, value) {

       return changeLine(this, line, function(line) {

         var markers = line.gutterMarkers || (line.gutterMarkers = {});

         markers[gutterID] = value;

         if (!value && isEmpty(markers)) line.gutterMarkers = null;

         return true;

       });

     }),

     clearGutter: operation(null, function(gutterID) {

       var i = 0, cm = this, doc = cm.view.doc;

       doc.iter(0, doc.size, function(line) {

         if (line.gutterMarkers && line.gutterMarkers[gutterID]) {

           line.gutterMarkers[gutterID] = null;

           regChange(cm, i, i + 1);

           if (isEmpty(line.gutterMarkers)) line.gutterMarkers = null;

         }

         ++i;

       });

     }),

     addLineClass: operation(null, function(handle, where, cls) {

       return changeLine(this, handle, function(line) {

         var prop = where == "text" ? "textClass" : where == "background" ? "bgClass" : "wrapClass";

         if (!line[prop]) line[prop] = cls;

         else if (new RegExp("\\b" + cls + "\\b").test(line[prop])) return false;

         else line[prop] += " " + cls;

         return true;

       });

     }),

     removeLineClass: operation(null, function(handle, where, cls) {

       return changeLine(this, handle, function(line) {

         var prop = where == "text" ? "textClass" : where == "background" ? "bgClass" : "wrapClass";

         var cur = line[prop];

         if (!cur) return false;

         else if (cls == null) line[prop] = null;

         else {

           var upd = cur.replace(new RegExp("^" + cls + "\\b\\s*|\\s*\\b" + cls + "\\b"), "");

           if (upd == cur) return false;

           line[prop] = upd || null;

         }

         return true;

       });

     }),

     addLineWidget: operation(null, function(handle, node, options) {

       var widget = options || {};

       widget.node = node;

       if (widget.noHScroll) this.display.alignWidgets = true;

       changeLine(this, handle, function(line) {

         (line.widgets || (line.widgets = [])).push(widget);

         widget.line = line;

         return true;

       });

       return widget;

     }),

     removeLineWidget: operation(null, function(widget) {

       var ws = widget.line.widgets, no = lineNo(widget.line);

       if (no == null) return;

       for (var i = 0; i < ws.length; ++i) if (ws[i] == widget) ws.splice(i--, 1);

       regChange(this, no, no + 1);

     }),

     lineInfo: function(line) {

       if (typeof line == "number") {

         if (!isLine(this.view.doc, line)) return null;

         var n = line;

         line = getLine(this.view.doc, line);

         if (!line) return null;

       } else {

         var n = lineNo(line);

         if (n == null) return null;

       }

       return {line: n, handle: line, text: line.text, gutterMarkers: line.gutterMarkers,

               textClass: line.textClass, bgClass: line.bgClass, wrapClass: line.wrapClass,

               widgets: line.widgets};

     },

     getViewport: function() { return {from: this.display.showingFrom, to: this.display.showingTo};},

     addWidget: function(pos, node, scroll, vert, horiz) {

       var display = this.display;

       pos = cursorCoords(this, clipPos(this.view.doc, pos));

       var top = pos.top, left = pos.left;

       node.style.position = "absolute";

       display.sizer.appendChild(node);

       if (vert == "over") top = pos.top;

       else if (vert == "near") {

         var vspace = Math.max(display.wrapper.clientHeight, this.view.doc.height),

         hspace = Math.max(display.sizer.clientWidth, display.lineSpace.clientWidth);

         if (pos.bottom + node.offsetHeight > vspace && pos.top > node.offsetHeight)

           top = pos.top - node.offsetHeight;

         if (left + node.offsetWidth > hspace)

           left = hspace - node.offsetWidth;

       }

       node.style.top = (top + paddingTop(display)) + "px";

       node.style.left = node.style.right = "";

       if (horiz == "right") {

         left = display.sizer.clientWidth - node.offsetWidth;

         node.style.right = "0px";

       } else {

         if (horiz == "left") left = 0;

         else if (horiz == "middle") left = (display.sizer.clientWidth - node.offsetWidth) / 2;

         node.style.left = left + "px";

       }

       if (scroll)

         scrollIntoView(this, left, top, left + node.offsetWidth, top + node.offsetHeight);

     },

     lineCount: function() {return this.view.doc.size;},

     clipPos: function(pos) {return clipPos(this.view.doc, pos);},

     getCursor: function(start) {

       var sel = this.view.sel, pos;

       if (start == null || start == "head") pos = sel.head;

       else if (start == "anchor") pos = sel.anchor;

       else if (start == "end" || start === false) pos = sel.to;

       else pos = sel.from;

       return copyPos(pos);

     },

     somethingSelected: function() {return !posEq(this.view.sel.from, this.view.sel.to);},

     setCursor: operation(null, function(line, ch, extend) {

       var pos = clipPos(this.view.doc, typeof line == "number" ? {line: line, ch: ch || 0} : line);

       if (extend) extendSelection(this, pos);

       else setSelection(this, pos, pos);

     }),

     setSelection: operation(null, function(anchor, head) {

       var doc = this.view.doc;

       setSelection(this, clipPos(doc, anchor), clipPos(doc, head || anchor));

     }),

     extendSelection: operation(null, function(from, to) {

       var doc = this.view.doc;

       extendSelection(this, clipPos(doc, from), to && clipPos(doc, to));

     }),

     setExtending: function(val) {this.view.sel.extend = val;},

     getLine: function(line) {var l = this.getLineHandle(line); return l && l.text;},

     getLineHandle: function(line) {

       var doc = this.view.doc;

       if (isLine(doc, line)) return getLine(doc, line);

     },

     getLineNumber: function(line) {return lineNo(line);},

     setLine: operation(null, function(line, text) {

       if (isLine(this.view.doc, line))

         replaceRange(this, text, {line: line, ch: 0}, {line: line, ch: getLine(this.view.doc, line).text.length});

     }),

     removeLine: operation(null, function(line) {

       if (isLine(this.view.doc, line))

         replaceRange(this, "", {line: line, ch: 0}, clipPos(this.view.doc, {line: line+1, ch: 0}));

     }),

     replaceRange: operation(null, function(code, from, to) {

       var doc = this.view.doc;

       from = clipPos(doc, from);

       to = to ? clipPos(doc, to) : from;

       return replaceRange(this, code, from, to);

     }),

     getRange: function(from, to, lineSep) {

       var doc = this.view.doc;

       from = clipPos(doc, from); to = clipPos(doc, to);

       var l1 = from.line, l2 = to.line;