white-space: pre-wrap;

  word-break: normal;

}

.CodeMirror-linebackground {

  position: absolute;

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

//

// CodeMirror is the only global var we claim

window.CodeMirror = (function() {

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

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

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

    }

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

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

      return;

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

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

    }

      updateViewOffset(cm);

      return;

    }

    }

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

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

      }

    }

  }

  function updateViewOffset(cm) {

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

  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,

    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;

  }

    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;

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

      // updateDisplay.

      changes: [],

      updateInput: null,

      userSelChange: null,

      textChanged: null,

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

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

    }

      if (cm.display.scroller.offsetHeight) cm.doc.scrollTop = cm.display.scroller.scrollTop;

    }

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

  var detectingSelectAll;

  function onContextMenu(cm, e) {

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

    if (eventInWidget(display, e)) return;

  function findWordAt(line, pos) {

    var start = pos.ch, end = pos.ch;

    if (line) {

      var startChar = line.charAt(start);

      var check = isWordChar(startChar) ? isWordChar

        : /\s/.test(startChar) ? function(ch) {return /\s/.test(ch);}

    removeKeyMap: function(map) {

      var maps = this.state.keyMaps;

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

          maps.splice(i, 1);

          return true;

        }

      pos = clipPos(this.doc, pos);

      var styles = getLineStyles(this, getLine(this.doc, pos.line));

      var before = 0, after = (styles.length - 1) / 2, ch = pos.ch;

      for (;;) {

        var mid = (before + after) >> 1;

        if ((mid ? styles[mid * 2 - 1] : 0) >= ch) after = mid;

      }

    },

    getStateAfter: function(line, precise) {

      var doc = this.doc;

      line = clipLine(doc, line == null ? doc.first + doc.size - 1: line);

      updateScrollPos(this, sPos.scrollLeft, sPos.scrollTop);

    }),

      function interpret(val) {

        return typeof val == "number" || /^\d+$/.test(String(val)) ? val + "px" : val;

      }

      if (width != null) this.display.wrapper.style.width = interpret(width);

      if (height != null) this.display.wrapper.style.height = interpret(height);

    operation: function(f){return runInOp(this, f);},

    getScrollerElement: function(){return this.display.scroller;},

    getGutterElement: function(){return this.display.gutters;}

  };

  // OPTION DEFAULTS

  };

  CodeMirror.getMode = function(options, spec) {

    var mfactory = modes[spec.name];

    if (!mfactory) return CodeMirror.getMode(options, "text/plain");

    var modeObj = mfactory(options, spec);

      }

    }

    modeObj.name = spec.name;

    return modeObj;

  };

  var initHooks = [];

  CodeMirror.defineInitHook = function(f) {initHooks.push(f);};

  // MODE STATE HANDLING

  // Utility functions for working with state. Exported because modes

  CodeMirror.innerMode = function(mode, state) {

    while (mode.innerMode) {

      var info = mode.innerMode(state);

      state = info.state;

      mode = info.mode;

    }

    this.doc = doc;

  }

  CodeMirror.TextMarker = TextMarker;

  TextMarker.prototype.clear = function() {

    if (this.explicitlyCleared) return;

    var cm = this.doc.cm, withOp = cm && !cm.curOp;

    if (withOp) startOperation(cm);

    var min = null, max = null;

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

      var line = this.lines[i];

      if (cm) reCheckSelection(cm);

    }

    if (withOp) endOperation(cm);

  };

  TextMarker.prototype.find = function() {

        if (node.offsetHeight != line.height) updateLineHeight(line, node.offsetHeight);

        break;

      }

    }

  };

    }

    if (cm) {

      if (updateMaxLine) cm.curOp.updateMaxLine = true;

        regChange(cm, from.line, to.line + 1);

      if (marker.atomic) reCheckSelection(cm);

    }

    }

  }

  CodeMirror.SharedTextMarker = SharedTextMarker;

  SharedTextMarker.prototype.clear = function() {

    if (this.explicitlyCleared) return;

  // LINE WIDGETS

  var LineWidget = CodeMirror.LineWidget = function(cm, node, options) {

      this[opt] = options[opt];

    this.cm = cm;

    this.node = node;

  };

  function widgetOperation(f) {

    return function() {

      var withOp = !this.cm.curOp;

    if (no == null || !ws) return;

    for (var i = 0; i < ws.length; ++i) if (ws[i] == this) ws.splice(i--, 1);

    if (!ws.length) this.line.widgets = null;

    updateLineHeight(this.line, Math.max(0, this.line.height - widgetHeight(this)));

    regChange(this.cm, no, no + 1);

  });

  LineWidget.prototype.changed = widgetOperation(function() {

    var widget = new LineWidget(cm, node, options);

    if (widget.noHScroll) cm.display.alignWidgets = true;

    changeLine(cm, handle, function(line) {

      widget.line = line;

      if (!lineIsHidden(cm.doc, line) || widget.showIfHidden) {

        updateLineHeight(line, line.height + widgetHeight(widget));

        if (aboveVisible) addToScrollPos(cm, 0, widget.height);

      }

  // Line objects. These hold state related to a line, including

  // highlighting info (the styles array).

  function updateLine(line, text, markedSpans, estimateHeight) {

    line.text = text;

      (styleToClassCache[style] = "cm-" + style.replace(/ +/g, " cm-"));

  }

    var merged, line = realLine, empty = true;

    while (merged = collapsedSpanAtStart(line))

      line = getLine(cm.doc, merged.find().from.line);

    if (line.textClass) builder.pre.className = line.textClass;

    do {

  }

  var tokenSpecialChars = /[\t\u0000-\u0019\u00ad\u200b\u2028\u2029\uFEFF]/g;

    if (!text) return;

    if (!tokenSpecialChars.test(text)) {

      builder.col += text.length;

      var fullStyle = style || "";

      if (startStyle) fullStyle += startStyle;

      if (endStyle) fullStyle += endStyle;

    }

    builder.pre.appendChild(content);

  }

      } else if (i && wrapping && spanAffectsWrapping(text, i)) {

        builder.pre.appendChild(elt("wbr"));

      }

      var span = builder.measure[builder.pos] =

        buildToken(builder, ch, style,

                   start && startStyle, i == text.length - 1 && endStyle);

      // In IE single-space nodes wrap differently than spaces

      // embedded in larger text nodes, except when set to

      // white-space: normal (issue #1268).

      out += " ";

      return out;

    }

    };

  }

    if (widget) {

      if (builder.measure) {

        builder.measuredSomething = true;

      }

    }

    builder.pos += size;

  }

    }

    var len = allText.length, pos = 0, i = 1, text = "", style;

    for (;;) {

      if (nextChange == pos) { // Update current marker set

        collapsed = null; nextChange = Infinity;

        var foundBookmark = null;

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

            if (m.className) spanStyle += " " + m.className;

            if (m.startStyle && sp.from == pos) spanStartStyle += " " + m.startStyle;

            if (m.endStyle && sp.to == nextChange) spanEndStyle += " " + m.endStyle;

            if (m.collapsed && (!collapsed || collapsed.marker.size < m.size))

              collapsed = sp;

          } else if (sp.from > pos && nextChange > sp.from) {

            nextChange = sp.from;

          }

        }

        if (collapsed && (collapsed.from || 0) == pos) {

          buildCollapsedSpan(builder, (collapsed.to == null ? len : collapsed.to) - pos,

          if (collapsed.to == null) return collapsed.marker.find();

        }

        if (foundBookmark && !collapsed) buildCollapsedSpan(builder, 0, foundBookmark);

          if (!collapsed) {

            var tokenText = end > upto ? text.slice(0, upto - pos) : text;

            builder.addToken(builder, tokenText, style ? style + spanStyle : spanStyle,

          }

          if (end >= upto) {text = text.slice(upto - pos); pos = upto; break;}

          pos = end;

      // This is a whole-line replace. Treated specially to make

      // sure line objects move the way they are supposed to.

      for (var i = 0, e = text.length - 1, added = []; i < e; ++i)

      update(lastLine, lastLine.text, lastSpans);

      if (nlines) doc.remove(from.line, nlines);

      if (added.length) doc.insert(from.line, added);

        update(firstLine, firstLine.text.slice(0, from.ch) + lastText + firstLine.text.slice(to.ch), lastSpans);

      } else {

        for (var added = [], i = 1, e = text.length - 1; i < e; ++i)

        update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0));

        doc.insert(from.line + 1, added);

      }

      update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0));

      update(lastLine, lastText + lastLine.text.slice(to.ch), lastSpans);

      for (var i = 1, e = text.length - 1, added = []; i < e; ++i)

      if (nlines > 1) doc.remove(from.line + 1, nlines - 1);

      doc.insert(from.line + 1, added);

    }

    if (!(this instanceof Doc)) return new Doc(text, mode, firstLine);

    if (firstLine == null) firstLine = 0;

    this.first = firstLine;

    this.scrollTop = this.scrollLeft = 0;

    this.cantEdit = false;

    getLineHandle: function(line) {if (isLine(this, line)) return getLine(this, line);},

    getLineNumber: function(line) {return lineNo(line);},

    lineCount: function() {return this.size;},

    firstLine: function() {return this.first;},

    lastLine: function() {return this.first + this.size - 1;},

      return function() {return method.apply(this.doc, arguments);};

    })(Doc.prototype[prop]);

  function linkedDocs(doc, f, sharedHistOnly) {

    function propagate(doc, skip, sharedHist) {

      if (doc.linked) for (var i = 0; i < doc.linked.length; ++i) {

  }

  function historyChangeFromChange(doc, change) {

    attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1);

    linkedDocs(doc, function(doc) {attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1);}, true);

    return histChange;

      delayedCallbacks.push(bnd(arr[i]));

  }

  }

  function fireDelayed() {

  CodeMirror.on = on; CodeMirror.off = off; CodeMirror.signal = signal;

  // MISC UTILITIES

  // Number of pixels added to scroller and sizer to hide scrollbar

    spanAffectsWrapping = function(str, i) {

      return /\-[^ \-?]|\?[^ !\'\"\),.\-\/:;\?\]\}]/.test(str.slice(i - 1, i + 1));

    };

    spanAffectsWrapping = function(str, i) {

      return /[~!#%&*)=+}\]|\"\.>,:;][({[<]|-[^\-?\.\u2010-\u201f\u2026]|\?[\w~`@#$%\^&*(_=+{[|><]|…[\w~`@#$%\^&*(_=+{[><]/.test(str.slice(i - 1, i + 1));

    };

  function iterateBidiSections(order, from, to, f) {

    if (!order) return f(from, to, "ltr");

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

      var part = order[i];

        f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1 ? "rtl" : "ltr");

  }

  function bidiLeft(part) { return part.level % 2 ? part.to : part.from; }

  // THE END

  return CodeMirror;

})();

    electricChars: "{}",

    blockCommentStart: "/*",

    blockCommentEnd: "*/",

  };

});

            return state.scopes[0].offset;

        },

    };

    return external;

});

    startState: function(base) {

      return {tokenize: tokenBase,

              baseIndent: base || 0,

    },

    token: function(stream, state) {

      var context = state.stack[state.stack.length-1];

      if (style == "variable") {

        if (type == "variable-definition") state.stack.push("propertyValue");

      } else if (style == "property") {

        var word = stream.current().toLowerCase();

        if (context == "propertyValue") {

      // Push/pop context stack

      if (type == "{") {

        if (context == "@media" || context == "@mediaType") {

          state.stack[state.stack.length-1] = "@media{";

        }

        else {

        }

      }

      else if (type == "}") {

        state.stack.pop();

        if (context == "propertyValue") state.stack.pop();

      }

      else if (type == "@media") state.stack.push("@media");

      else if (type == "@import") state.stack.push("@import");

      else if (context == "@media" && /\b(keyword|attribute)\b/.test(style))

      else if (context == "propertyValue" && type == ";") state.stack.pop();

      else if (context == "@import" && type == ";") state.stack.pop();

    },

    indent: function(state, textAfter) {

      var n = state.stack.length;

      if (/^\}/.test(textAfter))

      return state.baseIndent + n * indentUnit;

    },

    electricChars: "}",

    blockCommentStart: "/*",

  };