left: 0; bottom: 0;

}

.CodeMirror-gutters {

  position: absolute; left: 0; top: 0;

  padding-bottom: 30px;

  z-index: 3;

}

.CodeMirror-gutter {

  white-space: normal;

  height: 100%;

  padding-bottom: 30px;

  margin-bottom: -32px;

  display: inline-block;

  /* Hack to make IE7 behave */

  *zoom:1;

  *display:inline;

}

.CodeMirror-gutter-elt {

  position: absolute;

  cursor: default;

  z-index: 4;

}

.CodeMirror-lines {

  cursor: text;

}

.CodeMirror pre {

  /* Reset some styles that the rest of the page might have set */

  -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;

  border-width: 0;

  background: transparent;

  font-family: inherit;

  font-size: inherit;

  margin: 0;

  white-space: pre;

  word-wrap: normal;

  line-height: inherit;

  color: inherit;

  z-index: 2;

  position: relative;

  overflow: visible;

}

.CodeMirror-wrap pre {

  word-wrap: break-word;

  white-space: pre-wrap;

  word-break: normal;

}

.CodeMirror-linebackground {

  position: absolute;

  left: 0; right: 0; top: 0; bottom: 0;

  z-index: 0;

}

.CodeMirror-linewidget {

  position: relative;

  z-index: 2;

  overflow: auto;

}

.CodeMirror-widget {

}

.CodeMirror-wrap .CodeMirror-scroll {

  overflow-x: hidden;

}

.CodeMirror-measure {

  position: absolute;

  width: 100%; height: 0px;

  overflow: hidden;

  visibility: hidden;

}

.CodeMirror-measure pre { position: static; }

.CodeMirror div.CodeMirror-cursor {

  position: absolute;

  visibility: hidden;

  border-right: none;

  width: 0;

}

.CodeMirror-focused div.CodeMirror-cursor {

  visibility: visible;

}

.CodeMirror-selected { background: #d9d9d9; }

.CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }

.cm-searching {

  background: #ffa;

  background: rgba(255, 255, 0, .4);

}

/* IE7 hack to prevent it from returning funny offsetTops on the spans */

.CodeMirror span { *vertical-align: text-bottom; }

//

// 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 = ie && (document.documentMode == null || document.documentMode < 8);

  var ie_lt9 = ie && (document.documentMode == null || document.documentMode < 9);

  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|Opera Mobi|IEMobile/i.test(navigator.userAgent);

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

  var windows = /windows/i.test(navigator.platform);

  var opera_version = opera && navigator.userAgent.match(/Version\/(\d*\.\d*)/);

  if (opera_version) opera_version = Number(opera_version[1]);

  // Some browsers use the wrong event properties to signal cmd/ctrl on OS X

  var flipCtrlCmd = mac && (qtwebkit || opera && (opera_version == null || opera_version < 12.11));

  var captureMiddleClick = gecko || (ie && !ie_lt9);

  // 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 docStart = typeof options.value == "string" ? 0 : options.value.first;

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

    display.wrapper.CodeMirror = this;

    updateGutters(this);

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

    this.state = {keyMaps: [],

                  overlays: [],

                  modeGen: 0,

                  overwrite: false, focused: false,

                  suppressEdits: false, pasteIncoming: false,

                  draggingText: false,

                  highlight: new Delayed()};

    themeChanged(this);

    if (options.lineWrapping)

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

    var doc = options.value;

    if (typeof doc == "string") doc = new Doc(options.value, options.mode);

    operation(this, attachDoc)(this, doc);

    // Override magic textarea content restore that IE sometimes does

    // on our hidden textarea on reload

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

    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) { }

    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 || !cm.options.fixedGutter)) return;

    var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.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;

    }

    if (cm.options.fixedGutter)

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

  }

  function maybeUpdateLineNumberWidth(cm) {

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

    var doc = cm.doc, last = lineNumberFor(cm.options, doc.first + 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 getRect(display.scroller).left - getRect(display.sizer).left;

  }

  // DISPLAY DRAWING

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

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

    for (;;) {

      updated = true;

      updateSelection(cm);

      updateScrollbars(cm);

      // Clip forced viewport to actual scrollable area

      if (viewPort)

        viewPort = Math.min(cm.display.scroller.scrollHeight - cm.display.scroller.clientHeight,

                            typeof viewPort == "number" ? viewPort : viewPort.top);

      visible = visibleLines(cm.display, cm.doc, viewPort);

      if (visible.from >= cm.display.showingFrom && visible.to <= cm.display.showingTo)

        break;

      changes = [];

    }

    if (updated) {

      signalLater(cm, "update", cm);

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

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

    }

    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.

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

    if (!display.wrapper.clientWidth) {

      display.showingFrom = display.showingTo = doc.first;

      display.viewOffset = 0;

      return;

    }

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

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

      return;

    if (maybeUpdateLineNumberWidth(cm))

      changes = [{from: doc.first, to: doc.first + doc.size}];

    var gutterW = display.sizer.style.marginLeft = display.gutters.offsetWidth + "px";

    display.scrollbarH.style.left = cm.options.fixedGutter ? gutterW : "0";

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

    var positionsChangedFrom = Infinity;

    if (cm.options.lineNumbers)

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

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

    var end = doc.first + doc.size;

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

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

    if (display.showingFrom < from && from - display.showingFrom < 20) from = Math.max(doc.first, display.showingFrom);

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

    if (sawCollapsedSpans) {

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

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

    }

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

    // in that using the change info.

    var intact = [{from: Math.max(display.showingFrom, doc.first),

                   to: Math.min(display.showingTo, end)}];

    if (intact[0].from >= intact[0].to) intact = [];

    else intact = computeIntact(intact, changes);

    // When merged lines are present, we might have to reduce the

    // intact ranges because changes in continued fragments of the

    // intact lines do require the lines to be redrawn.

    if (sawCollapsedSpans)

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

        var range = intact[i], merged;

        while (merged = collapsedSpanAtEnd(getLine(doc, range.to - 1))) {

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

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

          else { intact.splice(i--, 1); break; }

        }

      }

    // 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;

    }

      updateViewOffset(cm);

      return;

    }

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

    // Avoid crashing on IE's "unspecified error" when in iframes

    try {

      var focused = document.activeElement;

    } catch(e) {}

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

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

    display.lineDiv.style.display = "";

    if (focused && document.activeElement != focused && focused.offsetHeight) focused.focus();

    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;

      startWorker(cm, 400);

    }

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

    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 = getRect(node);

        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);

        var widgets = node.lineObj.widgets;

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

          widgets[i].height = widgets[i].node.offsetHeight;

      }

    }

  }

  function updateViewOffset(cm) {

    var off = cm.display.viewOffset = heightAtLine(cm, getLine(cm.doc, cm.display.showingFrom));

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

    cm.display.mover.style.top = off + "px";

  }

  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;

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

      removeChildren(display.lineDiv);

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

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

        // 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 <= lineN && cur.lineNumber)

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

        cur = cur.nextSibling;

      } else {

        // For lines with widgets, make an attempt to find and reuse

        // the existing element, so that widgets aren't needlessly

        // removed and re-inserted into the dom

        if (line.widgets) for (var j = 0, search = cur, reuse; search && j < 20; ++j, search = search.nextSibling)

          if (search.lineObj == line && /div/i.test(search.nodeName)) { reuse = search; break; }

        // This line needs to be generated.

        var lineNode = buildLineElement(cm, line, lineN, dims, reuse);

        if (lineNode != reuse) {

          container.insertBefore(lineNode, cur);

        } else {

          while (cur != reuse) cur = rm(cur);

          cur = cur.nextSibling;

        }

        lineNode.lineObj = line;

      }

      ++lineN;

    });

    while (cur) cur = rm(cur);

  }

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

    var lineElement = lineContent(cm, line);

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

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

      return lineElement;

    // Lines with gutter elements, widgets or a background class need

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

    // wrapper div

    if (reuse) {

      reuse.alignable = null;

      var isOk = true, widgetsSeen = 0, insertBefore = null;

      for (var n = reuse.firstChild, next; n; n = next) {

        next = n.nextSibling;

        if (!/\bCodeMirror-linewidget\b/.test(n.className)) {

          reuse.removeChild(n);

        } else {

            var widget = line.widgets[i];

            if (widget.node == n.firstChild) {

              positionLineWidget(widget, n, reuse, dims);

              ++widgetsSeen;

              break;

            }

          }

          if (i == line.widgets.length) { isOk = false; break; }

        }

      }

      reuse.insertBefore(lineElement, insertBefore);

      if (isOk && widgetsSeen == line.widgets.length) {

        wrap = reuse;

        reuse.className = line.wrapClass || "";

      }

    }

    if (!wrap) {

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

      wrap.appendChild(lineElement);

    }

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

    if (line.bgClass)

      wrap.insertBefore(elt("div", null, line.bgClass + " CodeMirror-linebackground"), wrap.firstChild);

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

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

                                             (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + "px"),

                                         wrap.firstChild);

      if (cm.options.fixedGutter) (wrap.alignable || (wrap.alignable = [])).push(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"));

        }

    }

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

    if (line.widgets && wrap != reuse) for (var i = 0, ws = line.widgets; i < ws.length; ++i) {

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

      if (!widget.handleMouseEvents) node.ignoreEvents = true;

      positionLineWidget(widget, node, wrap, dims);

      if (widget.above)

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

      else

  function findStartLine(cm, n, precise) {

    var minindent, minline, doc = cm.doc;

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

      if (search <= doc.first) return doc.first;

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

      if (line.stateAfter && (!precise || search <= doc.frontier)) 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, precise) {

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

      if (!doc.mode.startState) return true;

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

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

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

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

      processLine(cm, line, state);

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

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

      ++pos;

    });

    return state;

  }

  // POSITION MEASUREMENT

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

  function paddingVert(display) {return display.mover.offsetHeight - display.lineSpace.offsetHeight;}

  function paddingLeft(display) {

    var e = removeChildrenAndAdd(display.measure, elt("pre", null, null, "text-align: left")).appendChild(elt("span", "x"));

    return e.offsetLeft;

  }

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

    var dir = -1;

    data = data || measureLine(cm, line);

    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,

  }

  function findCachedMeasurement(cm, line) {

    var 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 &&

          cm.display.scroller.clientWidth == memo.width &&

          memo.classes == line.textClass + "|" + line.bgClass + "|" + line.wrapClass)

        return memo;

    }

  }

  function clearCachedMeasurement(cm, line) {

    var exists = findCachedMeasurement(cm, line);

    if (exists) exists.text = exists.measure = exists.markedSpans = null;

  }

  function measureLine(cm, line) {

    // First look in the cache

    var cached = findCachedMeasurement(cm, line);

    if (cached) return cached.measure;

    // Failing that, recompute and store result in cache

    var measure = measureLineInner(cm, line);

    var cache = cm.display.measureLineCache;

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

                markedSpans: line.markedSpans, measure: measure,

                classes: line.textClass + "|" + line.bgClass + "|" + line.wrapClass};

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

    else cache.push(memo);

    return measure;

  }

  function measureLineInner(cm, line) {

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

    // 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 = getRect(display.lineDiv);

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

    // Work around an IE7/8 bug where it will sometimes have randomly

    // replaced our pre with a clone at this point.

    if (ie_lt9 && display.measure.first != pre)

      removeChildrenAndAdd(display.measure, pre);

      if (bot > maxBot) bot = maxBot;

      if (top < 0) top = 0;

        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) {

        }

      }

    }

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

      // A widget might wrap, needs special care

      if (/\bCodeMirror-widget\b/.test(cur.className) && cur.getClientRects) {

        if (cur.firstChild.nodeType == 1) node = cur.firstChild;

        if (rects.length > 1) {

        }

      }

    }

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

    }

    return data;

  }

  function measureLineWidth(cm, line) {

    var hasBadSpan = false;

    if (line.markedSpans) for (var i = 0; i < line.markedSpans; ++i) {

      var sp = line.markedSpans[i];

      if (sp.collapsed && (sp.to == null || sp.to == line.text.length)) hasBadSpan = true;

    }

    var cached = !hasBadSpan && findCachedMeasurement(cm, line);

    if (cached) return measureChar(cm, line, line.text.length, cached.measure, "right").right;

    var end = pre.appendChild(zeroWidthElement(cm.display.measure));

    removeChildrenAndAdd(cm.display.measure, pre);

    return getRect(end).right - getRect(cm.display.lineDiv).left;

  }

  function clearCaches(cm) {

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

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

    if (!cm.options.lineWrapping) cm.display.maxLineChanged = true;

    cm.display.lineNumChars = null;

  }

  function pageScrollX() { return window.pageXOffset || (document.documentElement || document.body).scrollLeft; }

  function pageScrollY() { return window.pageYOffset || (document.documentElement || document.body).scrollTop; }

  // 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 = widgetHeight(lineObj.widgets[i]);

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

    }

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

    if (!context) context = "local";

    var yOff = heightAtLine(cm, lineObj);

    if (context == "local") yOff += paddingTop(cm.display);

    else yOff -= cm.display.viewOffset;

    if (context == "page" || context == "window") {

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

      yOff += lOff.top + (context == "window" ? 0 : pageScrollY());

      var xOff = lOff.left + (context == "window" ? 0 : pageScrollX());

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

    }

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

    return rect;

  }

  // Context may be "window", "page", "div", or "local"/null

  // Result is in "div" coords

  function fromCoordSystem(cm, coords, context) {

    if (context == "div") return coords;

    var left = coords.left, top = coords.top;

    // First move into "page" coordinate system

    if (context == "page") {

      left -= pageScrollX();

      top -= pageScrollY();

    } else if (context == "local" || !context) {

      var localBox = getRect(cm.display.sizer);

      left += localBox.left;

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

      else {from = middle; fromX = middleX; fromOutside = wrongLine; 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.

  var nextOpId = 0;

  function startOperation(cm) {

    cm.curOp = {

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

      // updateDisplay.