/* STOP */

/* The rest of this file contains styles related to the mechanics of

   the editor. You probably shouldn't touch them. */

.CodeMirror {

  line-height: 1;

  position: relative;

  overflow: hidden;

  background: white;

  color: black;

}

.CodeMirror-scroll {

  /* 30px is the magic margin used to hide the element's real scrollbars */

  /* See overflow: hidden in .CodeMirror */

  margin-bottom: -30px; margin-right: -30px;

  padding-bottom: 30px; padding-right: 30px;

  height: 100%;

  outline: none; /* Prevent dragging from highlighting the element */

  position: relative;

}

.CodeMirror-sizer {

  position: relative;

}

/* The fake, visible scrollbars. Used to force redraw during scrolling

   before actuall scrolling happens, thus preventing shaking and

   flickering artifacts. */

.CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {

  position: absolute;

  z-index: 6;

  display: none;

}

.CodeMirror-vscrollbar {

  right: 0; top: 0;

  overflow-x: hidden;

  overflow-y: scroll;

}

.CodeMirror-hscrollbar {

  bottom: 0; left: 0;

  overflow-y: hidden;

  overflow-x: scroll;

}

.CodeMirror-scrollbar-filler {

  right: 0; bottom: 0;

}

.CodeMirror-gutter-filler {

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

@media print {

  /* Hide the cursor when printing */

  .CodeMirror div.CodeMirror-cursor {

    visibility: hidden;

  }

}

//

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

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

    var d = {};

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

    if (webkit) input.style.width = "1000px";

    else input.setAttribute("wrap", "off");

    // if border: 0; -- iOS fails to open keyboard (issue #1287)

    if (ios) input.style.border = "1px solid black";

    input.setAttribute("autocorrect", "off"); input.setAttribute("autocapitalize", "off"); input.setAttribute("spellcheck", "false");

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

    d.gutterFiller = elt("div", null, "CodeMirror-gutter-filler");

    // DIVs containing the selection and the actual code

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

    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("div", "\u00a0", "CodeMirror-cursor");

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

    d.otherCursor = elt("div", "\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", null, null, "position: absolute; height: " + scrollerCutOff + "px; width: 1px;");

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

    var d = cm.display, docHeight = cm.doc.height;

    var totalHeight = docHeight + paddingVert(d);

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

    d.gutters.style.height = Math.max(totalHeight, d.scroller.clientHeight - scrollerCutOff) + "px";

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

    var needsH = d.scroller.scrollWidth > (d.scroller.clientWidth + 1);

    var needsV = scrollHeight > (d.scroller.clientHeight + 1);

    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 (needsH && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) {

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

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

      d.gutterFiller.style.width = d.gutters.offsetWidth + "px";

    } else d.gutterFiller.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 || !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;

    function rm(node) {

      var next = node.nextSibling;

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

        node.style.display = "none";

        node.lineObj = null;

      } else {

        node.parentNode.removeChild(node);

      }

      return next;

    }

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

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

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

      if (lineIsHidden(cm.doc, line)) {

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

        if (line.widgets && cur.previousSibling) for (var i = 0; i < line.widgets.length; ++i) {

          var w = line.widgets[i];

          if (w.showIfHidden) {

            var prev = cur.previousSibling;

            if (/pre/i.test(prev.nodeName)) {

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

              prev.parentNode.replaceChild(wrap, prev);

              wrap.appendChild(prev);

              prev = wrap;

            }

            var wnode = prev.appendChild(elt("div", [w.node], "CodeMirror-linewidget"));

            if (!w.handleMouseEvents) wnode.ignoreEvents = true;

            positionLineWidget(w, wnode, prev, dims);

          }

        }

      } 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

        wrap.appendChild(node);

      signalLater(widget, "redraw");

    }

    return wrap;

  }

  function positionLineWidget(widget, node, wrap, dims) {

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

    }

  }

  // SELECTION / CURSOR

  function updateSelection(cm) {

    var display = cm.display;

    var collapsed = posEq(cm.doc.sel.from, cm.doc.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

    if (cm.options.moveInputWithCursor) {

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

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

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

    }

  }

  // HIGHLIGHT WORKER

  function startWorker(cm, time) {

    if (cm.doc.mode.startState && cm.doc.frontier < cm.display.showingTo)

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

  }

  function highlightWorker(cm) {

    var doc = cm.doc;

    if (doc.frontier < doc.first) doc.frontier = doc.first;

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

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

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

    var changed = [], prevChange;

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

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

        var oldStyles = line.styles;

        line.styles = highlightLine(cm, line, state);

        var ischange = !oldStyles || oldStyles.length != line.styles.length;

        for (var i = 0; !ischange && i < oldStyles.length; ++i) ischange = oldStyles[i] != line.styles[i];

        if (ischange) {

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

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

        }

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

      } else {

        processLine(cm, line, state);

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

      }

      ++doc.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, 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;