Updating to CodeMirror 2.2, latest stable release.

IPython/frontend/html/notebook/static/codemirror/lib/util/dialog.css

@@ -0,0 +1,23 b''
+.CodeMirror-dialog {
+  position: relative;
+}
+
+.CodeMirror-dialog > div {
+  position: absolute;
+  top: 0; left: 0; right: 0;
+  background: white;
+  border-bottom: 1px solid #eee;
+  z-index: 15;
+  padding: .1em .8em;
+  overflow: hidden;
+  color: #333;
+}
+
+.CodeMirror-dialog input {
+  border: none;
+  outline: none;
+  background: transparent;
+  width: 20em;
+  color: inherit;
+  font-family: monospace;
+}

IPython/frontend/html/notebook/static/codemirror/lib/util/dialog.js

@@ -0,0 +1,63 b''
+// Open simple dialogs on top of an editor. Relies on dialog.css.
+
+(function() {
+  function dialogDiv(cm, template) {
+    var wrap = cm.getWrapperElement();
+    var dialog = wrap.insertBefore(document.createElement("div"), wrap.firstChild);
+    dialog.className = "CodeMirror-dialog";
+    dialog.innerHTML = '<div>' + template + '</div>';
+    return dialog;
+  }
+
+  CodeMirror.defineExtension("openDialog", function(template, callback) {
+    var dialog = dialogDiv(this, template);
+    var closed = false, me = this;
+    function close() {
+      if (closed) return;
+      closed = true;
+      dialog.parentNode.removeChild(dialog);
+    }
+    var inp = dialog.getElementsByTagName("input")[0];
+    if (inp) {
+      CodeMirror.connect(inp, "keydown", function(e) {
+        if (e.keyCode == 13 || e.keyCode == 27) {
+          CodeMirror.e_stop(e);
+          close();
+          me.focus();
+          if (e.keyCode == 13) callback(inp.value);
+        }
+      });
+      inp.focus();
+      CodeMirror.connect(inp, "blur", close);
+    }
+    return close;
+  });
+
+  CodeMirror.defineExtension("openConfirm", function(template, callbacks) {
+    var dialog = dialogDiv(this, template);
+    var buttons = dialog.getElementsByTagName("button");
+    var closed = false, me = this, blurring = 1;
+    function close() {
+      if (closed) return;
+      closed = true;
+      dialog.parentNode.removeChild(dialog);
+      me.focus();
+    }
+    buttons[0].focus();
+    for (var i = 0; i < buttons.length; ++i) {
+      var b = buttons[i];
+      (function(callback) {
+        CodeMirror.connect(b, "click", function(e) {
+          CodeMirror.e_preventDefault(e);
+          close();
+          if (callback) callback(me);
+        });
+      })(callbacks[i]);
+      CodeMirror.connect(b, "blur", function() {
+        --blurring;
+        setTimeout(function() { if (blurring <= 0) close(); }, 200);
+      });
+      CodeMirror.connect(b, "focus", function() { ++blurring; });
+    }
+  });
+})();
  No newline at end of file

IPython/frontend/html/notebook/static/codemirror/lib/util/foldcode.js

@@ -0,0 +1,66 b''
+CodeMirror.braceRangeFinder = function(cm, line) {
+  var lineText = cm.getLine(line);
+  var startChar = lineText.lastIndexOf("{");
+  if (startChar < 0 || lineText.lastIndexOf("}") > startChar) return;
+  var tokenType = cm.getTokenAt({line: line, ch: startChar}).className;
+  var count = 1, lastLine = cm.lineCount(), end;
+  outer: for (var i = line + 1; i < lastLine; ++i) {
+    var text = cm.getLine(i), pos = 0;
+    for (;;) {
+      var nextOpen = text.indexOf("{", pos), nextClose = text.indexOf("}", pos);
+      if (nextOpen < 0) nextOpen = text.length;
+      if (nextClose < 0) nextClose = text.length;
+      pos = Math.min(nextOpen, nextClose);
+      if (pos == text.length) break;
+      if (cm.getTokenAt({line: i, ch: pos + 1}).className == tokenType) {
+        if (pos == nextOpen) ++count;
+        else if (!--count) { end = i; break outer; }
+      }
+      ++pos;
+    }
+  }
+  if (end == null || end == line + 1) return;
+  return end;
+};
+
+
+CodeMirror.newFoldFunction = function(rangeFinder, markText) {
+  var folded = [];
+  if (markText == null) markText = '<div style="position: absolute; left: 2px; color:#600">&#x25bc;</div>%N%';
+
+  function isFolded(cm, n) {
+    for (var i = 0; i < folded.length; ++i) {
+      var start = cm.lineInfo(folded[i].start);
+      if (!start) folded.splice(i--, 1);
+      else if (start.line == n) return {pos: i, region: folded[i]};
+    }
+  }
+
+  function expand(cm, region) {
+    cm.clearMarker(region.start);
+    for (var i = 0; i < region.hidden.length; ++i)
+      cm.showLine(region.hidden[i]);
+  }
+
+  return function(cm, line) {
+    cm.operation(function() {
+      var known = isFolded(cm, line);
+      if (known) {
+        folded.splice(known.pos, 1);
+        expand(cm, known.region);
+      } else {
+        var end = rangeFinder(cm, line);
+        if (end == null) return;
+        var hidden = [];
+        for (var i = line + 1; i < end; ++i) {
+          var handle = cm.hideLine(i);
+          if (handle) hidden.push(handle);
+        }
+        var first = cm.setMarker(line, markText);
+        var region = {start: first, hidden: hidden};
+        cm.onDeleteLine(first, function() { expand(cm, region); });
+        folded.push(region);
+      }
+    });
+  };
+};

IPython/frontend/html/notebook/static/codemirror/lib/util/formatting.js

@@ -0,0 +1,291 b''
+// ============== Formatting extensions ============================
+// A common storage for all mode-specific formatting features
+if (!CodeMirror.modeExtensions) CodeMirror.modeExtensions = {};
+
+// Returns the extension of the editor's current mode
+CodeMirror.defineExtension("getModeExt", function () {
+  return CodeMirror.modeExtensions[this.getOption("mode")];
+});
+
+// If the current mode is 'htmlmixed', returns the extension of a mode located at
+// the specified position (can be htmlmixed, css or javascript). Otherwise, simply
+// returns the extension of the editor's current mode.
+CodeMirror.defineExtension("getModeExtAtPos", function (pos) {
+  var token = this.getTokenAt(pos);
+  if (token && token.state && token.state.mode)
+    return CodeMirror.modeExtensions[token.state.mode == "html" ? "htmlmixed" : token.state.mode];
+  else
+    return this.getModeExt();
+});
+
+// Comment/uncomment the specified range
+CodeMirror.defineExtension("commentRange", function (isComment, from, to) {
+  var curMode = this.getModeExtAtPos(this.getCursor());
+  if (isComment) { // Comment range
+    var commentedText = this.getRange(from, to);
+    this.replaceRange(curMode.commentStart + this.getRange(from, to) + curMode.commentEnd
+      , from, to);
+    if (from.line == to.line && from.ch == to.ch) { // An empty comment inserted - put cursor inside
+      this.setCursor(from.line, from.ch + curMode.commentStart.length);
+    }
+  }
+  else { // Uncomment range
+    var selText = this.getRange(from, to);
+    var startIndex = selText.indexOf(curMode.commentStart);
+    var endIndex = selText.lastIndexOf(curMode.commentEnd);
+    if (startIndex > -1 && endIndex > -1 && endIndex > startIndex) {
+      // Take string till comment start
+      selText = selText.substr(0, startIndex)
+      // From comment start till comment end
+        + selText.substring(startIndex + curMode.commentStart.length, endIndex)
+      // From comment end till string end
+        + selText.substr(endIndex + curMode.commentEnd.length);
+    }
+    this.replaceRange(selText, from, to);
+  }
+});
+
+// Applies automatic mode-aware indentation to the specified range
+CodeMirror.defineExtension("autoIndentRange", function (from, to) {
+  var cmInstance = this;
+  this.operation(function () {
+    for (var i = from.line; i <= to.line; i++) {
+      cmInstance.indentLine(i);
+    }
+  });
+});
+
+// Applies automatic formatting to the specified range
+CodeMirror.defineExtension("autoFormatRange", function (from, to) {
+  var absStart = this.indexFromPos(from);
+  var absEnd = this.indexFromPos(to);
+  // Insert additional line breaks where necessary according to the
+  // mode's syntax
+  var res = this.getModeExt().autoFormatLineBreaks(this.getValue(), absStart, absEnd);
+  var cmInstance = this;
+
+  // Replace and auto-indent the range
+  this.operation(function () {
+    cmInstance.replaceRange(res, from, to);
+    var startLine = cmInstance.posFromIndex(absStart).line;
+    var endLine = cmInstance.posFromIndex(absStart + res.length).line;
+    for (var i = startLine; i <= endLine; i++) {
+      cmInstance.indentLine(i);
+    }
+  });
+});
+
+// Define extensions for a few modes
+
+CodeMirror.modeExtensions["css"] = {
+  commentStart: "/*",
+  commentEnd: "*/",
+  wordWrapChars: [";", "\\{", "\\}"],
+  autoFormatLineBreaks: function (text) {
+    return text.replace(new RegExp("(;|\\{|\\})([^\r\n])", "g"), "$1\n$2");
+  }
+};
+
+CodeMirror.modeExtensions["javascript"] = {
+  commentStart: "/*",
+  commentEnd: "*/",
+  wordWrapChars: [";", "\\{", "\\}"],
+
+  getNonBreakableBlocks: function (text) {
+    var nonBreakableRegexes = [
+        new RegExp("for\\s*?\\(([\\s\\S]*?)\\)"),
+        new RegExp("'([\\s\\S]*?)('|$)"),
+        new RegExp("\"([\\s\\S]*?)(\"|$)"),
+        new RegExp("//.*([\r\n]|$)")
+      ];
+    var nonBreakableBlocks = new Array();
+    for (var i = 0; i < nonBreakableRegexes.length; i++) {
+      var curPos = 0;
+      while (curPos < text.length) {
+        var m = text.substr(curPos).match(nonBreakableRegexes[i]);
+        if (m != null) {
+          nonBreakableBlocks.push({
+            start: curPos + m.index,
+            end: curPos + m.index + m[0].length
+          });
+          curPos += m.index + Math.max(1, m[0].length);
+        }
+        else { // No more matches
+          break;
+        }
+      }
+    }
+    nonBreakableBlocks.sort(function (a, b) {
+      return a.start - b.start;
+    });
+
+    return nonBreakableBlocks;
+  },
+
+  autoFormatLineBreaks: function (text) {
+    var curPos = 0;
+    var reLinesSplitter = new RegExp("(;|\\{|\\})([^\r\n])", "g");
+    var nonBreakableBlocks = this.getNonBreakableBlocks(text);
+    if (nonBreakableBlocks != null) {
+      var res = "";
+      for (var i = 0; i < nonBreakableBlocks.length; i++) {
+        if (nonBreakableBlocks[i].start > curPos) { // Break lines till the block
+          res += text.substring(curPos, nonBreakableBlocks[i].start).replace(reLinesSplitter, "$1\n$2");
+          curPos = nonBreakableBlocks[i].start;
+        }
+        if (nonBreakableBlocks[i].start <= curPos
+          && nonBreakableBlocks[i].end >= curPos) { // Skip non-breakable block
+          res += text.substring(curPos, nonBreakableBlocks[i].end);
+          curPos = nonBreakableBlocks[i].end;
+        }
+      }
+      if (curPos < text.length - 1) {
+        res += text.substr(curPos).replace(reLinesSplitter, "$1\n$2");
+      }
+      return res;
+    }
+    else {
+      return text.replace(reLinesSplitter, "$1\n$2");
+    }
+  }
+};
+
+CodeMirror.modeExtensions["xml"] = {
+  commentStart: "<!--",
+  commentEnd: "-->",
+  wordWrapChars: [">"],
+
+  autoFormatLineBreaks: function (text) {
+    var lines = text.split("\n");
+    var reProcessedPortion = new RegExp("(^\\s*?<|^[^<]*?)(.+)(>\\s*?$|[^>]*?$)");
+    var reOpenBrackets = new RegExp("<", "g");
+    var reCloseBrackets = new RegExp("(>)([^\r\n])", "g");
+    for (var i = 0; i < lines.length; i++) {
+      var mToProcess = lines[i].match(reProcessedPortion);
+      if (mToProcess != null && mToProcess.length > 3) { // The line starts with whitespaces and ends with whitespaces
+        lines[i] = mToProcess[1]
+            + mToProcess[2].replace(reOpenBrackets, "\n$&").replace(reCloseBrackets, "$1\n$2")
+            + mToProcess[3];
+        continue;
+      }
+    }
+
+    return lines.join("\n");
+  }
+};
+
+CodeMirror.modeExtensions["htmlmixed"] = {
+  commentStart: "<!--",
+  commentEnd: "-->",
+  wordWrapChars: [">", ";", "\\{", "\\}"],
+
+  getModeInfos: function (text, absPos) {
+    var modeInfos = new Array();
+    modeInfos[0] =
+      {
+        pos: 0,
+        modeExt: CodeMirror.modeExtensions["xml"],
+        modeName: "xml"
+      };
+
+    var modeMatchers = new Array();
+    modeMatchers[0] =
+      {
+        regex: new RegExp("<style[^>]*>([\\s\\S]*?)(</style[^>]*>|$)", "i"),
+        modeExt: CodeMirror.modeExtensions["css"],
+        modeName: "css"
+      };
+    modeMatchers[1] =
+      {
+        regex: new RegExp("<script[^>]*>([\\s\\S]*?)(</script[^>]*>|$)", "i"),
+        modeExt: CodeMirror.modeExtensions["javascript"],
+        modeName: "javascript"
+      };
+
+    var lastCharPos = (typeof (absPos) !== "undefined" ? absPos : text.length - 1);
+    // Detect modes for the entire text
+    for (var i = 0; i < modeMatchers.length; i++) {
+      var curPos = 0;
+      while (curPos <= lastCharPos) {
+        var m = text.substr(curPos).match(modeMatchers[i].regex);
+        if (m != null) {
+          if (m.length > 1 && m[1].length > 0) {
+            // Push block begin pos
+            var blockBegin = curPos + m.index + m[0].indexOf(m[1]);
+            modeInfos.push(
+              {
+                pos: blockBegin,
+                modeExt: modeMatchers[i].modeExt,
+                modeName: modeMatchers[i].modeName
+              });
+            // Push block end pos
+            modeInfos.push(
+              {
+                pos: blockBegin + m[1].length,
+                modeExt: modeInfos[0].modeExt,
+                modeName: modeInfos[0].modeName
+              });
+            curPos += m.index + m[0].length;
+            continue;
+          }
+          else {
+            curPos += m.index + Math.max(m[0].length, 1);
+          }
+        }
+        else { // No more matches
+          break;
+        }
+      }
+    }
+    // Sort mode infos
+    modeInfos.sort(function sortModeInfo(a, b) {
+      return a.pos - b.pos;
+    });
+
+    return modeInfos;
+  },
+
+  autoFormatLineBreaks: function (text, startPos, endPos) {
+    var modeInfos = this.getModeInfos(text);
+    var reBlockStartsWithNewline = new RegExp("^\\s*?\n");
+    var reBlockEndsWithNewline = new RegExp("\n\\s*?$");
+    var res = "";
+    // Use modes info to break lines correspondingly
+    if (modeInfos.length > 1) { // Deal with multi-mode text
+      for (var i = 1; i <= modeInfos.length; i++) {
+        var selStart = modeInfos[i - 1].pos;
+        var selEnd = (i < modeInfos.length ? modeInfos[i].pos : endPos);
+
+        if (selStart >= endPos) { // The block starts later than the needed fragment
+          break;
+        }
+        if (selStart < startPos) {
+          if (selEnd <= startPos) { // The block starts earlier than the needed fragment
+            continue;
+          }
+          selStart = startPos;
+        }
+        if (selEnd > endPos) {
+          selEnd = endPos;
+        }
+        var textPortion = text.substring(selStart, selEnd);
+        if (modeInfos[i - 1].modeName != "xml") { // Starting a CSS or JavaScript block
+          if (!reBlockStartsWithNewline.test(textPortion)
+              && selStart > 0) { // The block does not start with a line break
+            textPortion = "\n" + textPortion;
+          }
+          if (!reBlockEndsWithNewline.test(textPortion)
+              && selEnd < text.length - 1) { // The block does not end with a line break
+            textPortion += "\n";
+          }
+        }
+        res += modeInfos[i - 1].modeExt.autoFormatLineBreaks(textPortion);
+      }
+    }
+    else { // Single-mode text
+      res = modeInfos[0].modeExt.autoFormatLineBreaks(text.substring(startPos, endPos));
+    }
+
+    return res;
+  }
+};

IPython/frontend/html/notebook/static/codemirror/lib/util/javascript-hint.js

@@ -0,0 +1,83 b''
+(function () {
+  function forEach(arr, f) {
+    for (var i = 0, e = arr.length; i < e; ++i) f(arr[i]);
+  }
+  
+  function arrayContains(arr, item) {
+    if (!Array.prototype.indexOf) {
+      var i = arr.length;
+      while (i--) {
+        if (arr[i] === item) {
+          return true;
+        }
+      }
+      return false;
+    }
+    return arr.indexOf(item) != -1;
+  }
+  
+  CodeMirror.javascriptHint = function(editor) {
+    // Find the token at the cursor
+    var cur = editor.getCursor(), token = editor.getTokenAt(cur), tprop = token;
+    // If it's not a 'word-style' token, ignore the token.
+    if (!/^[\w$_]*$/.test(token.string)) {
+      token = tprop = {start: cur.ch, end: cur.ch, string: "", state: token.state,
+                       className: token.string == "." ? "property" : null};
+    }
+    // If it is a property, find out what it is a property of.
+    while (tprop.className == "property") {
+      tprop = editor.getTokenAt({line: cur.line, ch: tprop.start});
+      if (tprop.string != ".") return;
+      tprop = editor.getTokenAt({line: cur.line, ch: tprop.start});
+      if (!context) var context = [];
+      context.push(tprop);
+    }
+    return {list: getCompletions(token, context),
+            from: {line: cur.line, ch: token.start},
+            to: {line: cur.line, ch: token.end}};
+  }
+
+  var stringProps = ("charAt charCodeAt indexOf lastIndexOf substring substr slice trim trimLeft trimRight " +
+                     "toUpperCase toLowerCase split concat match replace search").split(" ");
+  var arrayProps = ("length concat join splice push pop shift unshift slice reverse sort indexOf " +
+                    "lastIndexOf every some filter forEach map reduce reduceRight ").split(" ");
+  var funcProps = "prototype apply call bind".split(" ");
+  var keywords = ("break case catch continue debugger default delete do else false finally for function " +
+                  "if in instanceof new null return switch throw true try typeof var void while with").split(" ");
+
+  function getCompletions(token, context) {
+    var found = [], start = token.string;
+    function maybeAdd(str) {
+      if (str.indexOf(start) == 0 && !arrayContains(found, str)) found.push(str);
+    }
+    function gatherCompletions(obj) {
+      if (typeof obj == "string") forEach(stringProps, maybeAdd);
+      else if (obj instanceof Array) forEach(arrayProps, maybeAdd);
+      else if (obj instanceof Function) forEach(funcProps, maybeAdd);
+      for (var name in obj) maybeAdd(name);
+    }
+
+    if (context) {
+      // If this is a property, see if it belongs to some object we can
+      // find in the current environment.
+      var obj = context.pop(), base;
+      if (obj.className == "variable")
+        base = window[obj.string];
+      else if (obj.className == "string")
+        base = "";
+      else if (obj.className == "atom")
+        base = 1;
+      while (base != null && context.length)
+        base = base[context.pop().string];
+      if (base != null) gatherCompletions(base);
+    }
+    else {
+      // If not, just look in the window object and any local scope
+      // (reading into JS mode internals to get at the local variables)
+      for (var v = token.state.localVars; v; v = v.next) maybeAdd(v.name);
+      gatherCompletions(window);
+      forEach(keywords, maybeAdd);
+    }
+    return found;
+  }
+})();

IPython/frontend/html/notebook/static/codemirror/lib/util/search.js

@@ -0,0 +1,114 b''
+// Define search commands. Depends on dialog.js or another
+// implementation of the openDialog method.
+
+// Replace works a little oddly -- it will do the replace on the next
+// Ctrl-G (or whatever is bound to findNext) press. You prevent a
+// replace by making sure the match is no longer selected when hitting
+// Ctrl-G.
+
+(function() {
+  function SearchState() {
+    this.posFrom = this.posTo = this.query = null;
+    this.marked = [];
+  }
+  function getSearchState(cm) {
+    return cm._searchState || (cm._searchState = new SearchState());
+  }
+  function dialog(cm, text, shortText, f) {
+    if (cm.openDialog) cm.openDialog(text, f);
+    else f(prompt(shortText, ""));
+  }
+  function confirmDialog(cm, text, shortText, fs) {
+    if (cm.openConfirm) cm.openConfirm(text, fs);
+    else if (confirm(shortText)) fs[0]();
+  }
+  function parseQuery(query) {
+    var isRE = query.match(/^\/(.*)\/$/);
+    return isRE ? new RegExp(isRE[1]) : query;
+  }
+  var queryDialog =
+    'Search: <input type="text" style="width: 10em"> <span style="color: #888">(Use /re/ syntax for regexp search)</span>';
+  function doSearch(cm, rev) {
+    var state = getSearchState(cm);
+    if (state.query) return findNext(cm, rev);
+    dialog(cm, queryDialog, "Search for:", function(query) {
+      cm.operation(function() {
+        if (!query || state.query) return;
+        state.query = parseQuery(query);
+        if (cm.lineCount() < 2000) { // This is too expensive on big documents.
+          for (var cursor = cm.getSearchCursor(query); cursor.findNext();)
+            state.marked.push(cm.markText(cursor.from(), cursor.to(), "CodeMirror-searching"));
+        }
+        state.posFrom = state.posTo = cm.getCursor();
+        findNext(cm, rev);
+      });
+    });
+  }
+  function findNext(cm, rev) {cm.operation(function() {
+    var state = getSearchState(cm);
+    var cursor = cm.getSearchCursor(state.query, rev ? state.posFrom : state.posTo);
+    if (!cursor.find(rev)) {
+      cursor = cm.getSearchCursor(state.query, rev ? {line: cm.lineCount() - 1} : {line: 0, ch: 0});
+      if (!cursor.find(rev)) return;
+    }
+    cm.setSelection(cursor.from(), cursor.to());
+    state.posFrom = cursor.from(); state.posTo = cursor.to();
+  })}
+  function clearSearch(cm) {cm.operation(function() {
+    var state = getSearchState(cm);
+    if (!state.query) return;
+    state.query = null;
+    for (var i = 0; i < state.marked.length; ++i) state.marked[i].clear();
+    state.marked.length = 0;
+  })}
+
+  var replaceQueryDialog =
+    'Replace: <input type="text" style="width: 10em"> <span style="color: #888">(Use /re/ syntax for regexp search)</span>';
+  var replacementQueryDialog = 'With: <input type="text" style="width: 10em">';
+  var doReplaceConfirm = "Replace? <button>Yes</button> <button>No</button> <button>Stop</button>";
+  function replace(cm, all) {
+    dialog(cm, replaceQueryDialog, "Replace:", function(query) {
+      if (!query) return;
+      query = parseQuery(query);
+      dialog(cm, replacementQueryDialog, "Replace with:", function(text) {
+        if (all) {
+          cm.operation(function() {
+            for (var cursor = cm.getSearchCursor(query); cursor.findNext();) {
+              if (typeof query != "string") {
+                var match = cm.getRange(cursor.from(), cursor.to()).match(query);
+                cursor.replace(text.replace(/\$(\d)/, function(w, i) {return match[i];}));
+              } else cursor.replace(text);
+            }
+          });
+        } else {
+          clearSearch(cm);
+          var cursor = cm.getSearchCursor(query, cm.getCursor());
+          function advance() {
+            var start = cursor.from(), match;
+            if (!(match = cursor.findNext())) {
+              cursor = cm.getSearchCursor(query);
+              if (!(match = cursor.findNext()) ||
+                  (cursor.from().line == start.line && cursor.from().ch == start.ch)) return;
+            }
+            cm.setSelection(cursor.from(), cursor.to());
+            confirmDialog(cm, doReplaceConfirm, "Replace?",
+                          [function() {doReplace(match);}, advance]);
+          }
+          function doReplace(match) {
+            cursor.replace(typeof query == "string" ? text :
+                           text.replace(/\$(\d)/, function(w, i) {return match[i];}));
+            advance();
+          }
+          advance();
+        }
+      });
+    });
+  }
+
+  CodeMirror.commands.find = function(cm) {clearSearch(cm); doSearch(cm);};
+  CodeMirror.commands.findNext = doSearch;
+  CodeMirror.commands.findPrev = function(cm) {doSearch(cm, true);};
+  CodeMirror.commands.clearSearch = clearSearch;
+  CodeMirror.commands.replace = replace;
+  CodeMirror.commands.replaceAll = function(cm) {replace(cm, true);};
+})();

IPython/frontend/html/notebook/static/codemirror/lib/util/searchcursor.js

@@ -0,0 +1,117 b''
+(function(){
+  function SearchCursor(cm, query, pos, caseFold) {
+    this.atOccurrence = false; this.cm = cm;
+    if (caseFold == null) caseFold = typeof query == "string" && query == query.toLowerCase();
+
+    pos = pos ? cm.clipPos(pos) : {line: 0, ch: 0};
+    this.pos = {from: pos, to: pos};
+
+    // The matches method is filled in based on the type of query.
+    // It takes a position and a direction, and returns an object
+    // describing the next occurrence of the query, or null if no
+    // more matches were found.
+    if (typeof query != "string") // Regexp match
+      this.matches = function(reverse, pos) {
+        if (reverse) {
+          var line = cm.getLine(pos.line).slice(0, pos.ch), match = line.match(query), start = 0;
+          while (match) {
+            var ind = line.indexOf(match[0]);
+            start += ind;
+            line = line.slice(ind + 1);
+            var newmatch = line.match(query);
+            if (newmatch) match = newmatch;
+            else break;
+            start++;
+          }
+        }
+        else {
+          var line = cm.getLine(pos.line).slice(pos.ch), match = line.match(query),
+          start = match && pos.ch + line.indexOf(match[0]);
+        }
+        if (match)
+          return {from: {line: pos.line, ch: start},
+                  to: {line: pos.line, ch: start + match[0].length},
+                  match: match};
+      };
+    else { // String query
+      if (caseFold) query = query.toLowerCase();
+      var fold = caseFold ? function(str){return str.toLowerCase();} : function(str){return str;};
+      var target = query.split("\n");
+      // Different methods for single-line and multi-line queries
+      if (target.length == 1)
+        this.matches = function(reverse, pos) {
+          var line = fold(cm.getLine(pos.line)), len = query.length, match;
+          if (reverse ? (pos.ch >= len && (match = line.lastIndexOf(query, pos.ch - len)) != -1)
+              : (match = line.indexOf(query, pos.ch)) != -1)
+            return {from: {line: pos.line, ch: match},
+                    to: {line: pos.line, ch: match + len}};
+        };
+      else
+        this.matches = function(reverse, pos) {
+          var ln = pos.line, idx = (reverse ? target.length - 1 : 0), match = target[idx], line = fold(cm.getLine(ln));
+          var offsetA = (reverse ? line.indexOf(match) + match.length : line.lastIndexOf(match));
+          if (reverse ? offsetA >= pos.ch || offsetA != match.length
+              : offsetA <= pos.ch || offsetA != line.length - match.length)
+            return;
+          for (;;) {
+            if (reverse ? !ln : ln == cm.lineCount() - 1) return;
+            line = fold(cm.getLine(ln += reverse ? -1 : 1));
+            match = target[reverse ? --idx : ++idx];
+            if (idx > 0 && idx < target.length - 1) {
+              if (line != match) return;
+              else continue;
+            }
+            var offsetB = (reverse ? line.lastIndexOf(match) : line.indexOf(match) + match.length);
+            if (reverse ? offsetB != line.length - match.length : offsetB != match.length)
+              return;
+            var start = {line: pos.line, ch: offsetA}, end = {line: ln, ch: offsetB};
+            return {from: reverse ? end : start, to: reverse ? start : end};
+          }
+        };
+    }
+  }
+
+  SearchCursor.prototype = {
+    findNext: function() {return this.find(false);},
+    findPrevious: function() {return this.find(true);},
+
+    find: function(reverse) {
+      var self = this, pos = this.cm.clipPos(reverse ? this.pos.from : this.pos.to);
+      function savePosAndFail(line) {
+        var pos = {line: line, ch: 0};
+        self.pos = {from: pos, to: pos};
+        self.atOccurrence = false;
+        return false;
+      }
+
+      for (;;) {
+        if (this.pos = this.matches(reverse, pos)) {
+          this.atOccurrence = true;
+          return this.pos.match || true;
+        }
+        if (reverse) {
+          if (!pos.line) return savePosAndFail(0);
+          pos = {line: pos.line-1, ch: this.cm.getLine(pos.line-1).length};
+        }
+        else {
+          var maxLine = this.cm.lineCount();
+          if (pos.line == maxLine - 1) return savePosAndFail(maxLine);
+          pos = {line: pos.line+1, ch: 0};
+        }
+      }
+    },
+
+    from: function() {if (this.atOccurrence) return this.pos.from;},
+    to: function() {if (this.atOccurrence) return this.pos.to;},
+
+    replace: function(newText) {
+      var self = this;
+      if (this.atOccurrence)
+        self.pos.to = this.cm.replaceRange(newText, self.pos.from, self.pos.to);
+    }
+  };
+
+  CodeMirror.defineExtension("getSearchCursor", function(query, pos, caseFold) {
+    return new SearchCursor(this, query, pos, caseFold);
+  });
+})();

IPython/frontend/html/notebook/static/codemirror/lib/util/simple-hint.css

@@ -0,0 +1,16 b''
+.CodeMirror-completions {
+  position: absolute;
+  z-index: 10;
+  overflow: hidden;
+  -webkit-box-shadow: 2px 3px 5px rgba(0,0,0,.2);
+  -moz-box-shadow: 2px 3px 5px rgba(0,0,0,.2);
+  box-shadow: 2px 3px 5px rgba(0,0,0,.2);
+}
+.CodeMirror-completions select {
+  background: #fafafa;
+  outline: none;
+  border: none;
+  padding: 0;
+  margin: 0;
+  font-family: monospace;
+}

IPython/frontend/html/notebook/static/codemirror/lib/util/simple-hint.js

@@ -0,0 +1,66 b''
+(function() {
+  CodeMirror.simpleHint = function(editor, getHints) {
+    // We want a single cursor position.
+    if (editor.somethingSelected()) return;
+    var result = getHints(editor);
+    if (!result || !result.list.length) return;
+    var completions = result.list;
+    function insert(str) {
+      editor.replaceRange(str, result.from, result.to);
+    }
+    // When there is only one completion, use it directly.
+    if (completions.length == 1) {insert(completions[0]); return true;}
+
+    // Build the select widget
+    var complete = document.createElement("div");
+    complete.className = "CodeMirror-completions";
+    var sel = complete.appendChild(document.createElement("select"));
+    // Opera doesn't move the selection when pressing up/down in a
+    // multi-select, but it does properly support the size property on
+    // single-selects, so no multi-select is necessary.
+    if (!window.opera) sel.multiple = true;
+    for (var i = 0; i < completions.length; ++i) {
+      var opt = sel.appendChild(document.createElement("option"));
+      opt.appendChild(document.createTextNode(completions[i]));
+    }
+    sel.firstChild.selected = true;
+    sel.size = Math.min(10, completions.length);
+    var pos = editor.cursorCoords();
+    complete.style.left = pos.x + "px";
+    complete.style.top = pos.yBot + "px";
+    document.body.appendChild(complete);
+    // Hack to hide the scrollbar.
+    if (completions.length <= 10)
+      complete.style.width = (sel.clientWidth - 1) + "px";
+
+    var done = false;
+    function close() {
+      if (done) return;
+      done = true;
+      complete.parentNode.removeChild(complete);
+    }
+    function pick() {
+      insert(completions[sel.selectedIndex]);
+      close();
+      setTimeout(function(){editor.focus();}, 50);
+    }
+    CodeMirror.connect(sel, "blur", close);
+    CodeMirror.connect(sel, "keydown", function(event) {
+      var code = event.keyCode;
+      // Enter
+      if (code == 13) {CodeMirror.e_stop(event); pick();}
+      // Escape
+      else if (code == 27) {CodeMirror.e_stop(event); close(); editor.focus();}
+      else if (code != 38 && code != 40) {
+        close(); editor.focus();
+        setTimeout(function(){CodeMirror.simpleHint(editor, getHints);}, 50);
+      }
+    });
+    CodeMirror.connect(sel, "dblclick", pick);
+
+    sel.focus();
+    // Opera sometimes ignores focusing a freshly created node
+    if (window.opera) setTimeout(function(){if (!done) sel.focus();}, 100);
+    return true;
+  };
+})();

IPython/frontend/html/notebook/static/codemirror/theme/cobalt.css

@@ -0,0 +1,18 b''
+.cm-s-cobalt { background: #002240; color: white; }
+.cm-s-cobalt span.CodeMirror-selected { background: #b36539 !important; }
+.cm-s-cobalt .CodeMirror-gutter { background: #002240; border-right: 1px solid #aaa; }
+.cm-s-cobalt .CodeMirror-gutter-text { color: #d0d0d0; }
+.cm-s-cobalt .CodeMirror-cursor { border-left: 1px solid white !important; }
+
+.cm-s-cobalt span.cm-comment { color: #08f; }
+.cm-s-cobalt span.cm-atom { color: #845dc4; }
+.cm-s-cobalt span.cm-number, .cm-s-cobalt span.cm-attribute { color: #ff80e1; }
+.cm-s-cobalt span.cm-keyword { color: #ffee80; }
+.cm-s-cobalt span.cm-string { color: #3ad900; }
+.cm-s-cobalt span.cm-meta { color: #ff9d00; }
+.cm-s-cobalt span.cm-variable-2, .cm-s-cobalt span.cm-tag { color: #9effff; }
+.cm-s-cobalt span.cm-variable-3, .cm-s-cobalt span.cm-def { color: white; }
+.cm-s-cobalt span.cm-error { color: #9d1e15; }
+.cm-s-cobalt span.cm-bracket { color: #d8d8d8; }
+.cm-s-cobalt span.cm-builtin, .cm-s-cobalt span.cm-special { color: #ff9e59; }
+.cm-s-cobalt span.cm-link { color: #845dc4; }

IPython/frontend/html/notebook/static/codemirror/theme/eclipse.css

@@ -0,0 +1,25 b''
+.cm-s-eclipse span.cm-meta {color: #FF1717;}
+.cm-s-eclipse span.cm-keyword { font-weight: bold; color: #7F0055; }
+.cm-s-eclipse span.cm-atom {color: #219;}
+.cm-s-eclipse span.cm-number {color: #164;}
+.cm-s-eclipse span.cm-def {color: #00f;}
+.cm-s-eclipse span.cm-variable {color: black;}
+.cm-s-eclipse span.cm-variable-2 {color: #0000C0;}
+.cm-s-eclipse span.cm-variable-3 {color: #0000C0;}
+.cm-s-eclipse span.cm-property {color: black;}
+.cm-s-eclipse span.cm-operator {color: black;}
+.cm-s-eclipse span.cm-comment {color: #3F7F5F;}
+.cm-s-eclipse span.cm-string {color: #2A00FF;}
+.cm-s-eclipse span.cm-string-2 {color: #f50;}
+.cm-s-eclipse span.cm-error {color: #f00;}
+.cm-s-eclipse span.cm-qualifier {color: #555;}
+.cm-s-eclipse span.cm-builtin {color: #30a;}
+.cm-s-eclipse span.cm-bracket {color: #cc7;}
+.cm-s-eclipse span.cm-tag {color: #170;}
+.cm-s-eclipse span.cm-attribute {color: #00c;}
+.cm-s-eclipse span.cm-link {color: #219;}
+
+.cm-s-eclipse .CodeMirror-matchingbracket {
+	border:1px solid grey;
+	color:black !important;;
+}

IPython/frontend/html/notebook/static/codemirror/theme/monokai.css

@@ -0,0 +1,28 b''
+/* Based on Sublime Text's Monokai theme */
+
+.cm-s-monokai {background: #272822; color: #f8f8f2;}
+.cm-s-monokai span.CodeMirror-selected {background: #ffe792 !important;}
+.cm-s-monokai .CodeMirror-gutter {background: #272822; border-right: 0px;}
+.cm-s-monokai .CodeMirror-gutter-text {color: #d0d0d0;}
+.cm-s-monokai .CodeMirror-cursor {border-left: 1px solid #f8f8f0 !important;}
+
+.cm-s-monokai span.cm-comment {color: #75715e;}
+.cm-s-monokai span.cm-atom {color: #ae81ff;}
+.cm-s-monokai span.cm-number {color: #ae81ff;}
+
+.cm-s-monokai span.cm-property, .cm-s-monokai span.cm-attribute {color: #a6e22e;}
+.cm-s-monokai span.cm-keyword {color: #f92672;}
+.cm-s-monokai span.cm-string {color: #e6db74;}
+
+.cm-s-monokai span.cm-variable {color: #a6e22e;}
+.cm-s-monokai span.cm-variable-2 {color: #9effff;}
+.cm-s-monokai span.cm-def {color: #fd971f;}
+.cm-s-monokai span.cm-error {background: #f92672; color: #f8f8f0;}
+.cm-s-monokai span.cm-bracket {color: #f8f8f2;}
+.cm-s-monokai span.cm-tag {color: #f92672;}
+.cm-s-monokai span.cm-link {color: #ae81ff;}
+
+.cm-s-monokai .CodeMirror-matchingbracket {
+  text-decoration: underline;
+  color: white !important;
+}

IPython/frontend/html/notebook/static/codemirror/theme/rubyblue.css

@@ -0,0 +1,21 b''
+.cm-s-rubyblue { font:13px/1.4em Trebuchet, Verdana, sans-serif; }	/* - customized editor font - */
+
+.cm-s-rubyblue { background: #112435; color: white; }
+.cm-s-rubyblue span.CodeMirror-selected { background: #0000FF !important; }
+.cm-s-rubyblue .CodeMirror-gutter { background: #1F4661; border-right: 7px solid #3E7087; min-width:2.5em; }
+.cm-s-rubyblue .CodeMirror-gutter-text { color: white; }
+.cm-s-rubyblue .CodeMirror-cursor { border-left: 1px solid white !important; }
+
+.cm-s-rubyblue span.cm-comment { color: #999; font-style:italic; }
+.cm-s-rubyblue span.cm-atom { color: #F4C20B; }
+.cm-s-rubyblue span.cm-number, .cm-s-rubyblue span.cm-attribute { color: #82C6E0; }
+.cm-s-rubyblue span.cm-keyword { color: #F0F; }
+.cm-s-rubyblue span.cm-string { color: #F08047; }
+.cm-s-rubyblue span.cm-meta { color: #F0F; }
+.cm-s-rubyblue span.cm-variable-2, .cm-s-rubyblue span.cm-tag { color: #7BD827; }
+.cm-s-rubyblue span.cm-variable-3, .cm-s-rubyblue span.cm-def { color: white; }
+.cm-s-rubyblue span.cm-error { color: #AF2018; }
+.cm-s-rubyblue span.cm-bracket { color: #F0F; }
+.cm-s-rubyblue span.cm-link { color: #F4C20B; }
+.cm-s-rubyblue span.CodeMirror-matchingbracket { color:#F0F !important; }
+.cm-s-rubyblue span.cm-builtin, .cm-s-rubyblue span.cm-special { color: #FF9D00; }

IPython/frontend/html/notebook/static/codemirror/README-IPython.rst

@@ -1,33 +1,33 b''
 =======================
  CodeMirror in IPython
 =======================
 
 We carry a mostly unmodified copy of CodeMirror.  The current version we use
 is (*please update this information when updating versions*)::
 
-  CodeMirror 2.15
+  CodeMirror 2.2
 
 The only changes we've applied so far are these::
 
     diff --git a/IPython/frontend/html/notebook/static/codemirror/mode/python/python.js b/IPython/frontend/html/notebook/static/codemirror/mode/python/python.js
     index ca94e7a..fc9a503 100644
     --- a/IPython/frontend/html/notebook/static/codemirror/mode/python/python.js
     +++ b/IPython/frontend/html/notebook/static/codemirror/mode/python/python.js
     @@ -5,7 +5,11 @@ CodeMirror.defineMode("python", function(conf, parserConf) {
 	     return new RegExp("^((" + words.join(")|(") + "))\\b");
 	 }
 
     -    var singleOperators = new RegExp("^[\\+\\-\\*/%&|\\^~<>!]");
     +    // IPython-specific changes: add '?' as recognized character.
     +    //var singleOperators = new RegExp("^[\\+\\-\\*/%&|\\^~<>!]");
     +    var singleOperators = new RegExp("^[\\+\\-\\*/%&|\\^~<>!\\?]");
     +    // End IPython changes.
     +    
 	 var singleDelimiters = new RegExp('^[\\(\\)\\[\\]\\{\\}@,:`=;\\.]');
 	 var doubleOperators = new RegExp("^((==)|(!=)|(<=)|(>=)|(<>)|(<<)|(>>)|(//)|(\\*\\*))");
 	 var doubleDelimiters = new RegExp("^((\\+=)|(\\-=)|(\\*=)|(%=)|(/=)|(&=)|(\\|=)|(\\^=))");
 
 
 In practice it's just a one-line change, adding `\\?` to singleOperators,
 surrounded by a comment.  We'll turn this into a proper patchset if it ever
 gets more complicated than this, but for now this note should be enough.

IPython/frontend/html/notebook/static/codemirror/README.md

@@ -1,6 +1,6 b''
 # CodeMirror 2
 
 CodeMirror 2 is a rewrite of [CodeMirror
 1](http://github.com/marijnh/CodeMirror). The docs live
-[here](http://codemirror.net/manual.html), and the project page is
+[here](http://codemirror.net/doc/manual.html), and the project page is
 [http://codemirror.net/](http://codemirror.net/).

IPython/frontend/html/notebook/static/codemirror/lib/codemirror.css

@@ -1,68 +1,104 b''
 .CodeMirror {
   line-height: 1em;
   font-family: monospace;
 }
 
 .CodeMirror-scroll {
   overflow: auto;
   height: 300px;
   /* This is needed to prevent an IE[67] bug where the scrolled content
      is visible outside of the scrolling box. */
   position: relative;
 }
 
 .CodeMirror-gutter {
   position: absolute; left: 0; top: 0;
   z-index: 10;
   background-color: #f7f7f7;
   border-right: 1px solid #eee;
   min-width: 2em;
   height: 100%;
 }
 .CodeMirror-gutter-text {
   color: #aaa;
   text-align: right;
   padding: .4em .2em .4em .4em;
+  white-space: pre !important;
 }
 .CodeMirror-lines {
   padding: .4em;
 }
 
 .CodeMirror pre {
   -moz-border-radius: 0;
   -webkit-border-radius: 0;
   -o-border-radius: 0;
   border-radius: 0;
   border-width: 0; margin: 0; padding: 0; background: transparent;
   font-family: inherit;
   font-size: inherit;
   padding: 0; margin: 0;
   white-space: pre;
   word-wrap: normal;
 }
 
+.CodeMirror-wrap pre {
+  word-wrap: break-word;
+  white-space: pre-wrap;
+}
+.CodeMirror-wrap .CodeMirror-scroll {
+  overflow-x: hidden;
+}
+
 .CodeMirror textarea {
-  font-family: inherit !important;
-  font-size: inherit !important;
+  outline: none !important;
 }
 
-.CodeMirror-cursor {
+.CodeMirror pre.CodeMirror-cursor {
   z-index: 10;
   position: absolute;
   visibility: hidden;
-  border-left: 1px solid black !important;
+  border-left: 1px solid black;
 }
-.CodeMirror-focused .CodeMirror-cursor {
+.CodeMirror-focused pre.CodeMirror-cursor {
   visibility: visible;
 }
 
-span.CodeMirror-selected {
-  background: #ccc !important;
-  color: HighlightText !important;
-}
-.CodeMirror-focused span.CodeMirror-selected {
-  background: Highlight !important;
-}
+span.CodeMirror-selected { background: #d9d9d9; }
+.CodeMirror-focused span.CodeMirror-selected { background: #d2dcf8; }
+
+.CodeMirror-searching {background: #ffa;}
+
+/* Default theme */
+
+.cm-s-default span.cm-keyword {color: #708;}
+.cm-s-default span.cm-atom {color: #219;}
+.cm-s-default span.cm-number {color: #164;}
+.cm-s-default span.cm-def {color: #00f;}
+.cm-s-default span.cm-variable {color: black;}
+.cm-s-default span.cm-variable-2 {color: #05a;}
+.cm-s-default span.cm-variable-3 {color: #085;}
+.cm-s-default span.cm-property {color: black;}
+.cm-s-default span.cm-operator {color: black;}
+.cm-s-default span.cm-comment {color: #a50;}
+.cm-s-default span.cm-string {color: #a11;}
+.cm-s-default span.cm-string-2 {color: #f50;}
+.cm-s-default span.cm-meta {color: #555;}
+.cm-s-default span.cm-error {color: #f00;}
+.cm-s-default span.cm-qualifier {color: #555;}
+.cm-s-default span.cm-builtin {color: #30a;}
+.cm-s-default span.cm-bracket {color: #cc7;}
+.cm-s-default span.cm-tag {color: #170;}
+.cm-s-default span.cm-attribute {color: #00c;}
+.cm-s-default span.cm-header {color: #a0a;}
+.cm-s-default span.cm-quote {color: #090;}
+.cm-s-default span.cm-hr {color: #999;}
+.cm-s-default span.cm-link {color: #00c;}
+
+span.cm-header, span.cm-strong {font-weight: bold;}
+span.cm-em {font-style: italic;}
+span.cm-emstrong {font-style: italic; font-weight: bold;}
+span.cm-link {text-decoration: underline;}
 
-.CodeMirror-matchingbracket {color: #0f0 !important;}
-.CodeMirror-nonmatchingbracket {color: #f22 !important;}
+div.CodeMirror span.CodeMirror-matchingbracket {color: #0f0;}
+div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}

IPython/frontend/html/notebook/static/codemirror/lib/codemirror.js

@@ -1,2197 +1,2761 b''
+// CodeMirror version 2.2
+//
 // All functions that need access to the editor's state live inside
 // the CodeMirror function. Below that, at the bottom of the file,
 // some utilities are defined.
 
 // CodeMirror is the only global var we claim
 var CodeMirror = (function() {
   // This is the function that produces an editor instance. It's
   // closure is used to store the editor state.
   function CodeMirror(place, givenOptions) {
     // Determine effective options based on given values and defaults.
     var options = {}, defaults = CodeMirror.defaults;
     for (var opt in defaults)
       if (defaults.hasOwnProperty(opt))
         options[opt] = (givenOptions && givenOptions.hasOwnProperty(opt) ? givenOptions : defaults)[opt];
 
     var targetDocument = options["document"];
     // The element in which the editor lives.
     var wrapper = targetDocument.createElement("div");
-    wrapper.className = "CodeMirror";
+    wrapper.className = "CodeMirror" + (options.lineWrapping ? " CodeMirror-wrap" : "");
     // This mess creates the base DOM structure for the editor.
     wrapper.innerHTML =
-      '<div style="overflow: hidden; position: relative; width: 1px; height: 0px;">' + // Wraps and hides input textarea
-        '<textarea style="position: absolute; width: 2px;" wrap="off" ' +
+      '<div style="overflow: hidden; position: relative; width: 3px; height: 0px;">' + // Wraps and hides input textarea
+        '<textarea style="position: absolute; padding: 0; width: 1px;" wrap="off" ' +
           'autocorrect="off" autocapitalize="off"></textarea></div>' +
-      '<div class="CodeMirror-scroll cm-s-' + options.theme + '">' +
+      '<div class="CodeMirror-scroll" tabindex="-1">' +
         '<div style="position: relative">' + // Set to the height of the text, causes scrolling
-          '<div style="position: absolute; height: 0; width: 0; overflow: hidden;"></div>' +
           '<div style="position: relative">' + // Moved around its parent to cover visible view
             '<div class="CodeMirror-gutter"><div class="CodeMirror-gutter-text"></div></div>' +
             // Provides positioning relative to (visible) text origin
-            '<div class="CodeMirror-lines"><div style="position: relative" draggable="true">' +
+            '<div class="CodeMirror-lines"><div style="position: relative">' +
+              '<div style="position: absolute; width: 100%; height: 0; overflow: hidden; visibility: hidden"></div>' +
               '<pre class="CodeMirror-cursor">&#160;</pre>' + // Absolutely positioned blinky cursor
               '<div></div>' + // This DIV contains the actual code
             '</div></div></div></div></div>';
     if (place.appendChild) place.appendChild(wrapper); else place(wrapper);
     // I've never seen more elegant code in my life.
     var inputDiv = wrapper.firstChild, input = inputDiv.firstChild,
         scroller = wrapper.lastChild, code = scroller.firstChild,
-        measure = code.firstChild, mover = measure.nextSibling,
-        gutter = mover.firstChild, gutterText = gutter.firstChild,
-        lineSpace = gutter.nextSibling.firstChild,
-        cursor = lineSpace.firstChild, lineDiv = cursor.nextSibling;
-    if (options.tabindex != null) input.tabindex = options.tabindex;
+        mover = code.firstChild, gutter = mover.firstChild, gutterText = gutter.firstChild,
+        lineSpace = gutter.nextSibling.firstChild, measure = lineSpace.firstChild,
+        cursor = measure.nextSibling, lineDiv = cursor.nextSibling;
+    themeChanged();
+    // Needed to hide big blue blinking cursor on Mobile Safari
+    if (/AppleWebKit/.test(navigator.userAgent) && /Mobile\/\w+/.test(navigator.userAgent)) input.style.width = "0px";
+    if (!webkit) lineSpace.draggable = true;
+    if (options.tabindex != null) input.tabIndex = options.tabindex;
     if (!options.gutter && !options.lineNumbers) gutter.style.display = "none";
 
+    // Check for problem with IE innerHTML not working when we have a
+    // P (or similar) parent node.
+    try { stringWidth("x"); }
+    catch (e) {
+      if (e.message.match(/runtime/i))
+        e = new Error("A CodeMirror inside a P-style element does not work in Internet Explorer. (innerHTML bug)");
+      throw e;
+    }
+
     // Delayed object wrap timeouts, making sure only one is active. blinker holds an interval.
     var poll = new Delayed(), highlight = new Delayed(), blinker;
 
-    // mode holds a mode API object. lines an array of Line objects
-    // (see Line constructor), work an array of lines that should be
-    // parsed, and history the undo history (instance of History
-    // constructor).
-    var mode, lines = [new Line("")], work, history = new History(), focused;
+    // mode holds a mode API object. doc is the tree of Line objects,
+    // work an array of lines that should be parsed, and history the
+    // undo history (instance of History constructor).
+    var mode, doc = new BranchChunk([new LeafChunk([new Line("")])]), work, focused;
     loadMode();
     // The selection. These are always maintained to point at valid
     // positions. Inverted is used to remember that the user is
     // selecting bottom-to-top.
     var sel = {from: {line: 0, ch: 0}, to: {line: 0, ch: 0}, inverted: false};
     // Selection-related flags. shiftSelecting obviously tracks
-    // whether the user is holding shift. reducedSelection is a hack
-    // to get around the fact that we can't create inverted
-    // selections. See below.
-    var shiftSelecting, reducedSelection, lastClick, lastDoubleClick;
+    // whether the user is holding shift.
+    var shiftSelecting, lastClick, lastDoubleClick, draggingText, overwrite = false;
     // Variables used by startOperation/endOperation to track what
     // happened during the operation.
-    var updateInput, changes, textChanged, selectionChanged, leaveInputAlone, gutterDirty;
+    var updateInput, userSelChange, changes, textChanged, selectionChanged, leaveInputAlone,
+        gutterDirty, callbacks;
     // Current visible range (may be bigger than the view window).
-    var showingFrom = 0, showingTo = 0, lastHeight = 0, curKeyId = null;
-    // editing will hold an object describing the things we put in the
-    // textarea, to help figure out whether something changed.
+    var displayOffset = 0, showingFrom = 0, showingTo = 0, lastSizeC = 0;
     // bracketHighlighted is used to remember that a backet has been
     // marked.
-    var editing, bracketHighlighted;
+    var bracketHighlighted;
     // Tracks the maximum line length so that the horizontal scrollbar
     // can be kept static when scrolling.
-    var maxLine = "", maxWidth;
+    var maxLine = "", maxWidth, tabText = computeTabText();
 
     // Initialize the content.
     operation(function(){setValue(options.value || ""); updateInput = false;})();
+    var history = new History();
 
     // Register our event handlers.
     connect(scroller, "mousedown", operation(onMouseDown));
+    connect(scroller, "dblclick", operation(onDoubleClick));
     connect(lineSpace, "dragstart", onDragStart);
+    connect(lineSpace, "selectstart", e_preventDefault);
     // 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) connect(scroller, "contextmenu", onContextMenu);
     connect(scroller, "scroll", function() {
       updateDisplay([]);
       if (options.fixedGutter) gutter.style.left = scroller.scrollLeft + "px";
       if (options.onScroll) options.onScroll(instance);
     });
     connect(window, "resize", function() {updateDisplay(true);});
     connect(input, "keyup", operation(onKeyUp));
+    connect(input, "input", fastPoll);
     connect(input, "keydown", operation(onKeyDown));
     connect(input, "keypress", operation(onKeyPress));
     connect(input, "focus", onFocus);
     connect(input, "blur", onBlur);
 
     connect(scroller, "dragenter", e_stop);
     connect(scroller, "dragover", e_stop);
     connect(scroller, "drop", operation(onDrop));
     connect(scroller, "paste", function(){focusInput(); fastPoll();});
-    connect(input, "paste", function(){fastPoll();});
-    connect(input, "cut", function(){fastPoll();});
+    connect(input, "paste", fastPoll);
+    connect(input, "cut", operation(function(){replaceSelection("");}));
 
     // IE throws unspecified error in certain cases, when
     // trying to access activeElement before onload
     var hasFocus; try { hasFocus = (targetDocument.activeElement == input); } catch(e) { }
     if (hasFocus) setTimeout(onFocus, 20);
     else onBlur();
 
-    function isLine(l) {return l >= 0 && l < lines.length;}
+    function isLine(l) {return l >= 0 && l < doc.size;}
     // The instance object that we'll return. Mostly calls out to
     // local functions in the CodeMirror function. Some do some extra
     // range checking and/or clipping. operation is used to wrap the
     // call so that changes it makes are tracked, and the display is
     // updated afterwards.
     var instance = wrapper.CodeMirror = {
       getValue: getValue,
       setValue: operation(setValue),
       getSelection: getSelection,
       replaceSelection: operation(replaceSelection),
       focus: function(){focusInput(); onFocus(); fastPoll();},
       setOption: function(option, value) {
+        var oldVal = options[option];
         options[option] = value;
-        if (option == "lineNumbers" || option == "gutter" || option == "firstLineNumber")
+        if (option == "mode" || option == "indentUnit") loadMode();
+        else if (option == "readOnly" && value) {onBlur(); input.blur();}
+        else if (option == "theme") themeChanged();
+        else if (option == "lineWrapping" && oldVal != value) operation(wrappingChanged)();
+        else if (option == "tabSize") operation(tabsChanged)();
+        if (option == "lineNumbers" || option == "gutter" || option == "firstLineNumber" || option == "theme")
           operation(gutterChanged)();
-        else if (option == "mode" || option == "indentUnit") loadMode();
-        else if (option == "readOnly" && value == "nocursor") input.blur();
-        else if (option == "theme") scroller.className = scroller.className.replace(/cm-s-\w+/, "cm-s-" + value);
       },
       getOption: function(option) {return options[option];},
       undo: operation(undo),
       redo: operation(redo),
       indentLine: operation(function(n, dir) {
         if (isLine(n)) indentLine(n, dir == null ? "smart" : dir ? "add" : "subtract");
       }),
+      indentSelection: operation(indentSelected),
       historySize: function() {return {undo: history.done.length, redo: history.undone.length};},
+      clearHistory: function() {history = new History();},
       matchBrackets: operation(function(){matchBrackets(true);}),
-      getTokenAt: function(pos) {
+      getTokenAt: operation(function(pos) {
         pos = clipPos(pos);
-        return lines[pos.line].getTokenAt(mode, getStateBefore(pos.line), pos.ch);
-      },
+        return getLine(pos.line).getTokenAt(mode, getStateBefore(pos.line), pos.ch);
+      }),
       getStateAfter: function(line) {
-        line = clipLine(line == null ? lines.length - 1: line);
+        line = clipLine(line == null ? doc.size - 1: line);
         return getStateBefore(line + 1);
       },
       cursorCoords: function(start){
         if (start == null) start = sel.inverted;
         return pageCoords(start ? sel.from : sel.to);
       },
       charCoords: function(pos){return pageCoords(clipPos(pos));},
       coordsChar: function(coords) {
         var off = eltOffset(lineSpace);
-        var line = clipLine(Math.min(lines.length - 1, showingFrom + Math.floor((coords.y - off.top) / lineHeight())));
-        return clipPos({line: line, ch: charFromX(clipLine(line), coords.x - off.left)});
+        return coordsChar(coords.x - off.left, coords.y - off.top);
       },
-      getSearchCursor: function(query, pos, caseFold) {return new SearchCursor(query, pos, caseFold);},
-      markText: operation(function(a, b, c){return operation(markText(a, b, c));}),
+      markText: operation(markText),
+      setBookmark: setBookmark,
       setMarker: operation(addGutterMarker),
       clearMarker: operation(removeGutterMarker),
       setLineClass: operation(setLineClass),
+      hideLine: operation(function(h) {return setLineHidden(h, true);}),
+      showLine: operation(function(h) {return setLineHidden(h, false);}),
+      onDeleteLine: function(line, f) {
+        if (typeof line == "number") {
+          if (!isLine(line)) return null;
+          line = getLine(line);
+        }
+        (line.handlers || (line.handlers = [])).push(f);
+        return line;
+      },
       lineInfo: lineInfo,
       addWidget: function(pos, node, scroll, vert, horiz) {
         pos = localCoords(clipPos(pos));
         var top = pos.yBot, left = pos.x;
         node.style.position = "absolute";
         code.appendChild(node);
         if (vert == "over") top = pos.y;
         else if (vert == "near") {
-          var vspace = Math.max(scroller.offsetHeight, lines.length * lineHeight()),
+          var vspace = Math.max(scroller.offsetHeight, doc.height * textHeight()),
               hspace = Math.max(code.clientWidth, lineSpace.clientWidth) - paddingLeft();
           if (pos.yBot + node.offsetHeight > vspace && pos.y > node.offsetHeight)
             top = pos.y - node.offsetHeight;
           if (left + node.offsetWidth > hspace)
             left = hspace - node.offsetWidth;
         }
         node.style.top = (top + paddingTop()) + "px";
         node.style.left = node.style.right = "";
         if (horiz == "right") {
           left = code.clientWidth - node.offsetWidth;
           node.style.right = "0px";
         } else {
           if (horiz == "left") left = 0;
           else if (horiz == "middle") left = (code.clientWidth - node.offsetWidth) / 2;
           node.style.left = (left + paddingLeft()) + "px";
         }
         if (scroll)
           scrollIntoView(left, top, left + node.offsetWidth, top + node.offsetHeight);
       },
 
-      lineCount: function() {return lines.length;},
+      lineCount: function() {return doc.size;},
+      clipPos: clipPos,
       getCursor: function(start) {
         if (start == null) start = sel.inverted;
         return copyPos(start ? sel.from : sel.to);
       },
       somethingSelected: function() {return !posEq(sel.from, sel.to);},
-      setCursor: operation(function(line, ch) {
-        if (ch == null && typeof line.line == "number") setCursor(line.line, line.ch);
-        else setCursor(line, ch);
+      setCursor: operation(function(line, ch, user) {
+        if (ch == null && typeof line.line == "number") setCursor(line.line, line.ch, user);
+        else setCursor(line, ch, user);
+      }),
+      setSelection: operation(function(from, to, user) {
+        (user ? setSelectionUser : setSelection)(clipPos(from), clipPos(to || from));
       }),
-      setSelection: operation(function(from, to) {setSelection(clipPos(from), clipPos(to || from));}),
-      getLine: function(line) {if (isLine(line)) return lines[line].text;},
+      getLine: function(line) {if (isLine(line)) return getLine(line).text;},
+      getLineHandle: function(line) {if (isLine(line)) return getLine(line);},
       setLine: operation(function(line, text) {
-        if (isLine(line)) replaceRange(text, {line: line, ch: 0}, {line: line, ch: lines[line].text.length});
+        if (isLine(line)) replaceRange(text, {line: line, ch: 0}, {line: line, ch: getLine(line).text.length});
       }),
       removeLine: operation(function(line) {
         if (isLine(line)) replaceRange("", {line: line, ch: 0}, clipPos({line: line+1, ch: 0}));
       }),
       replaceRange: operation(replaceRange),
       getRange: function(from, to) {return getRange(clipPos(from), clipPos(to));},
 
+      execCommand: function(cmd) {return commands[cmd](instance);},
+      // Stuff used by commands, probably not much use to outside code.
+      moveH: operation(moveH),
+      deleteH: operation(deleteH),
+      moveV: operation(moveV),
+      toggleOverwrite: function() {overwrite = !overwrite;},
+
+      posFromIndex: function(off) {
+        var lineNo = 0, ch;
+        doc.iter(0, doc.size, function(line) {
+          var sz = line.text.length + 1;
+          if (sz > off) { ch = off; return true; }
+          off -= sz;
+          ++lineNo;
+        });
+        return clipPos({line: lineNo, ch: ch});
+      },
+      indexFromPos: function (coords) {
+        if (coords.line < 0 || coords.ch < 0) return 0;
+        var index = coords.ch;
+        doc.iter(0, coords.line, function (line) {
+          index += line.text.length + 1;
+        });
+        return index;
+      },
+
       operation: function(f){return operation(f)();},
       refresh: function(){updateDisplay(true);},
       getInputField: function(){return input;},
       getWrapperElement: function(){return wrapper;},
       getScrollerElement: function(){return scroller;},
       getGutterElement: function(){return gutter;}
     };
 
+    function getLine(n) { return getLineAt(doc, n); }
+    function updateLineHeight(line, height) {
+      gutterDirty = true;
+      var diff = height - line.height;
+      for (var n = line; n; n = n.parent) n.height += diff;
+    }
+
     function setValue(code) {
-      history = null;
       var top = {line: 0, ch: 0};
-      updateLines(top, {line: lines.length - 1, ch: lines[lines.length-1].text.length},
+      updateLines(top, {line: doc.size - 1, ch: getLine(doc.size-1).text.length},
                   splitLines(code), top, top);
-      history = new History();
       updateInput = true;
     }
     function getValue(code) {
       var text = [];
-      for (var i = 0, l = lines.length; i < l; ++i)
-        text.push(lines[i].text);
+      doc.iter(0, doc.size, function(line) { text.push(line.text); });
       return text.join("\n");
     }
 
     function onMouseDown(e) {
+      setShift(e.shiftKey);
       // Check whether this is a click in a widget
       for (var n = e_target(e); n != wrapper; n = n.parentNode)
         if (n.parentNode == code && n != mover) return;
 
-      // First, see if this is a click in the gutter
+      // See if this is a click in the gutter
       for (var n = e_target(e); n != wrapper; n = n.parentNode)
         if (n.parentNode == gutterText) {
           if (options.onGutterClick)
             options.onGutterClick(instance, indexOf(gutterText.childNodes, n) + showingFrom, e);
           return e_preventDefault(e);
         }
 
       var start = posFromMouse(e);
 
       switch (e_button(e)) {
       case 3:
         if (gecko && !mac) onContextMenu(e);
         return;
       case 2:
         if (start) setCursor(start.line, start.ch, true);
         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) == scroller) e_preventDefault(e); return;}
 
       if (!focused) onFocus();
 
       var now = +new Date;
-      if (lastDoubleClick > now - 400) {
+      if (lastDoubleClick && lastDoubleClick.time > now - 400 && posEq(lastDoubleClick.pos, start)) {
         e_preventDefault(e);
+        setTimeout(focusInput, 20);
         return selectLine(start.line);
-      } else if (lastClick > now - 400) {
-        lastDoubleClick = now;
+      } else if (lastClick && lastClick.time > now - 400 && posEq(lastClick.pos, start)) {
+        lastDoubleClick = {time: now, pos: start};
         e_preventDefault(e);
         return selectWordAt(start);
-      } else { lastClick = now; }
+      } else { lastClick = {time: now, pos: start}; }
 
       var last = start, going;
       if (dragAndDrop && !posEq(sel.from, sel.to) &&
           !posLess(start, sel.from) && !posLess(sel.to, start)) {
         // Let the drag handler handle this.
+        if (webkit) lineSpace.draggable = true;
+        var up = connect(targetDocument, "mouseup", operation(function(e2) {
+          if (webkit) lineSpace.draggable = false;
+          draggingText = false;
+          up();
+          if (Math.abs(e.clientX - e2.clientX) + Math.abs(e.clientY - e2.clientY) < 10) {
+            e_preventDefault(e2);
+            setCursor(start.line, start.ch, true);
+            focusInput();
+          }
+        }), true);
+        draggingText = true;
         return;
       }
       e_preventDefault(e);
       setCursor(start.line, start.ch, true);
 
       function extend(e) {
         var cur = posFromMouse(e, true);
         if (cur && !posEq(cur, last)) {
           if (!focused) onFocus();
           last = cur;
           setSelectionUser(start, cur);
           updateInput = false;
           var visible = visibleLines();
           if (cur.line >= visible.to || cur.line < visible.from)
             going = setTimeout(operation(function(){extend(e);}), 150);
         }
       }
 
       var move = connect(targetDocument, "mousemove", operation(function(e) {
         clearTimeout(going);
         e_preventDefault(e);
         extend(e);
       }), true);
       var up = connect(targetDocument, "mouseup", operation(function(e) {
         clearTimeout(going);
         var cur = posFromMouse(e);
         if (cur) setSelectionUser(start, cur);
         e_preventDefault(e);
         focusInput();
         updateInput = true;
         move(); up();
       }), true);
     }
+    function onDoubleClick(e) {
+      for (var n = e_target(e); n != wrapper; n = n.parentNode)
+        if (n.parentNode == gutterText) return e_preventDefault(e);
+      var start = posFromMouse(e);
+      if (!start) return;
+      lastDoubleClick = {time: +new Date, pos: start};
+      e_preventDefault(e);
+      selectWordAt(start);
+    }
     function onDrop(e) {
       e.preventDefault();
       var pos = posFromMouse(e, true), files = e.dataTransfer.files;
       if (!pos || options.readOnly) return;
       if (files && files.length && window.FileReader && window.File) {
         function loadFile(file, i) {
           var reader = new FileReader;
           reader.onload = function() {
             text[i] = reader.result;
-            if (++read == n) replaceRange(text.join(""), clipPos(pos), clipPos(pos));
+            if (++read == n) {
+	      pos = clipPos(pos);
+	      operation(function() {
+                var end = replaceRange(text.join(""), pos, pos);
+                setSelectionUser(pos, end);
+              })();
+	    }
           };
           reader.readAsText(file);
         }
         var n = files.length, text = Array(n), read = 0;
         for (var i = 0; i < n; ++i) loadFile(files[i], i);
       }
       else {
         try {
           var text = e.dataTransfer.getData("Text");
-          if (text) replaceRange(text, pos, pos);
+          if (text) {
+	    var end = replaceRange(text, pos, pos);
+	    var curFrom = sel.from, curTo = sel.to;
+	    setSelectionUser(pos, end);
+            if (draggingText) replaceRange("", curFrom, curTo);
+	    focusInput();
+	  }
         }
         catch(e){}
       }
     }
     function onDragStart(e) {
       var txt = getSelection();
       // This will reset escapeElement
       htmlEscape(txt);
       e.dataTransfer.setDragImage(escapeElement, 0, 0);
       e.dataTransfer.setData("Text", txt);
     }
+    function handleKeyBinding(e) {
+      var name = keyNames[e.keyCode], next = keyMap[options.keyMap].auto, bound, dropShift;
+      if (name == null || e.altGraphKey) {
+        if (next) options.keyMap = next;
+        return null;
+      }
+      if (e.altKey) name = "Alt-" + name;
+      if (e.ctrlKey) name = "Ctrl-" + name;
+      if (e.metaKey) name = "Cmd-" + name;
+      if (e.shiftKey && (bound = lookupKey("Shift-" + name, options.extraKeys, options.keyMap))) {
+        dropShift = true;
+      } else {
+        bound = lookupKey(name, options.extraKeys, options.keyMap);
+      }
+      if (typeof bound == "string") {
+        if (commands.propertyIsEnumerable(bound)) bound = commands[bound];
+        else bound = null;
+      }
+      if (next && (bound || !isModifierKey(e))) options.keyMap = next;
+      if (!bound) return false;
+      if (dropShift) {
+        var prevShift = shiftSelecting;
+        shiftSelecting = null;
+        bound(instance);
+        shiftSelecting = prevShift;
+      } else bound(instance);
+      e_preventDefault(e);
+      return true;
+    }
+    var lastStoppedKey = null;
     function onKeyDown(e) {
       if (!focused) onFocus();
-
       var code = e.keyCode;
       // IE does strange things with escape.
       if (ie && code == 27) { e.returnValue = false; }
-      // Tries to detect ctrl on non-mac, cmd on mac.
-      var mod = (mac ? e.metaKey : e.ctrlKey) && !e.altKey, anyMod = e.ctrlKey || e.altKey || e.metaKey;
-      if (code == 16 || e.shiftKey) shiftSelecting = shiftSelecting || (sel.inverted ? sel.to : sel.from);
-      else shiftSelecting = null;
+      setShift(code == 16 || e.shiftKey);
       // First give onKeyEvent option a chance to handle this.
       if (options.onKeyEvent && options.onKeyEvent(instance, addStop(e))) return;
-
-      if (code == 33 || code == 34) {scrollPage(code == 34); return e_preventDefault(e);} // page up/down
-      if (mod && ((code == 36 || code == 35) || // ctrl-home/end
-                  mac && (code == 38 || code == 40))) { // cmd-up/down
-        scrollEnd(code == 36 || code == 38); return e_preventDefault(e);
-      }
-      if (mod && code == 65) {selectAll(); return e_preventDefault(e);} // ctrl-a
-      if (!options.readOnly) {
-        if (!anyMod && code == 13) {return;} // enter
-        if (!anyMod && code == 9 && handleTab(e.shiftKey)) return e_preventDefault(e); // tab
-        if (mod && code == 90) {undo(); return e_preventDefault(e);} // ctrl-z
-        if (mod && ((e.shiftKey && code == 90) || code == 89)) {redo(); return e_preventDefault(e);} // ctrl-shift-z, ctrl-y
-      }
-      if (code == 36) { if (options.smartHome) { smartHome(); return e_preventDefault(e); } }
-
-      // Key id to use in the movementKeys map. We also pass it to
-      // fastPoll in order to 'self learn'. We need this because
-      // reducedSelection, the hack where we collapse the selection to
-      // its start when it is inverted and a movement key is pressed
-      // (and later restore it again), shouldn't be used for
-      // non-movement keys.
-      curKeyId = (mod ? "c" : "") + (e.altKey ? "a" : "") + code;
-      if (sel.inverted && movementKeys[curKeyId] === true) {
-        var range = selRange(input);
-        if (range) {
-          reducedSelection = {anchor: range.start};
-          setSelRange(input, range.start, range.start);
-        }
-      }
-      // Don't save the key as a movementkey unless it had a modifier
-      if (!mod && !e.altKey) curKeyId = null;
-      fastPoll(curKeyId);
+      var handled = handleKeyBinding(e);
+      if (window.opera) {
+        lastStoppedKey = handled ? e.keyCode : null;
+        // Opera has no cut event... we try to at least catch the key combo
+        if (!handled && (mac ? e.metaKey : e.ctrlKey) && e.keyCode == 88)
+          replaceSelection("");
     }
-    function onKeyUp(e) {
-      if (options.onKeyEvent && options.onKeyEvent(instance, addStop(e))) return;
-      if (reducedSelection) {
-        reducedSelection = null;
-        updateInput = true;
-      }
-      if (e.keyCode == 16) shiftSelecting = null;
     }
     function onKeyPress(e) {
+      if (window.opera && e.keyCode == lastStoppedKey) {lastStoppedKey = null; e_preventDefault(e); return;}
       if (options.onKeyEvent && options.onKeyEvent(instance, addStop(e))) return;
+      if (window.opera && !e.which && handleKeyBinding(e)) return;
       if (options.electricChars && mode.electricChars) {
         var ch = String.fromCharCode(e.charCode == null ? e.keyCode : e.charCode);
         if (mode.electricChars.indexOf(ch) > -1)
-          setTimeout(operation(function() {indentLine(sel.to.line, "smart");}), 50);
+          setTimeout(operation(function() {indentLine(sel.to.line, "smart");}), 75);
       }
-      var code = e.keyCode;
-      // Re-stop tab and enter. Necessary on some browsers.
-      if (code == 13) {if (!options.readOnly) handleEnter(); e_preventDefault(e);}
-      else if (!e.ctrlKey && !e.altKey && !e.metaKey && code == 9 && options.tabMode != "default") e_preventDefault(e);
-      else fastPoll(curKeyId);
+      fastPoll();
+    }
+    function onKeyUp(e) {
+      if (options.onKeyEvent && options.onKeyEvent(instance, addStop(e))) return;
+      if (e.keyCode == 16) shiftSelecting = null;
     }
 
     function onFocus() {
-      if (options.readOnly == "nocursor") return;
+      if (options.readOnly) return;
       if (!focused) {
         if (options.onFocus) options.onFocus(instance);
         focused = true;
         if (wrapper.className.search(/\bCodeMirror-focused\b/) == -1)
           wrapper.className += " CodeMirror-focused";
-        if (!leaveInputAlone) prepareInput();
+        if (!leaveInputAlone) resetInput(true);
       }
       slowPoll();
       restartBlink();
     }
     function onBlur() {
       if (focused) {
         if (options.onBlur) options.onBlur(instance);
         focused = false;
         wrapper.className = wrapper.className.replace(" CodeMirror-focused", "");
       }
       clearInterval(blinker);
       setTimeout(function() {if (!focused) shiftSelecting = null;}, 150);
     }
 
     // Replace the range from from to to by the strings in newText.
     // Afterwards, set the selection to selFrom, selTo.
     function updateLines(from, to, newText, selFrom, selTo) {
       if (history) {
         var old = [];
-        for (var i = from.line, e = to.line + 1; i < e; ++i) old.push(lines[i].text);
+        doc.iter(from.line, to.line + 1, function(line) { old.push(line.text); });
         history.addChange(from.line, newText.length, old);
         while (history.done.length > options.undoDepth) history.done.shift();
       }
       updateLinesNoUndo(from, to, newText, selFrom, selTo);
     }
     function unredoHelper(from, to) {
       var change = from.pop();
       if (change) {
         var replaced = [], end = change.start + change.added;
-        for (var i = change.start; i < end; ++i) replaced.push(lines[i].text);
+        doc.iter(change.start, end, function(line) { replaced.push(line.text); });
         to.push({start: change.start, added: change.old.length, old: replaced});
         var pos = clipPos({line: change.start + change.old.length - 1,
                            ch: editEnd(replaced[replaced.length-1], change.old[change.old.length-1])});
-        updateLinesNoUndo({line: change.start, ch: 0}, {line: end - 1, ch: lines[end-1].text.length}, change.old, pos, pos);
+        updateLinesNoUndo({line: change.start, ch: 0}, {line: end - 1, ch: getLine(end-1).text.length}, change.old, pos, pos);
         updateInput = true;
       }
     }
     function undo() {unredoHelper(history.done, history.undone);}
     function redo() {unredoHelper(history.undone, history.done);}
 
     function updateLinesNoUndo(from, to, newText, selFrom, selTo) {
       var recomputeMaxLength = false, maxLineLength = maxLine.length;
-      for (var i = from.line; i <= to.line; ++i) {
-        if (lines[i].text.length == maxLineLength) {recomputeMaxLength = true; break;}
-      }
+      if (!options.lineWrapping)
+        doc.iter(from.line, to.line, function(line) {
+          if (line.text.length == maxLineLength) {recomputeMaxLength = true; return true;}
+        });
+      if (from.line != to.line || newText.length > 1) gutterDirty = true;
 
-      var nlines = to.line - from.line, firstLine = lines[from.line], lastLine = lines[to.line];
+      var nlines = to.line - from.line, firstLine = getLine(from.line), lastLine = getLine(to.line);
       // First adjust the line structure, taking some care to leave highlighting intact.
-      if (firstLine == lastLine) {
+      if (from.ch == 0 && to.ch == 0 && newText[newText.length - 1] == "") {
+        // This is a whole-line replace. Treated specially to make
+        // sure line objects move the way they are supposed to.
+        var added = [], prevLine = null;
+        if (from.line) {
+          prevLine = getLine(from.line - 1);
+          prevLine.fixMarkEnds(lastLine);
+        } else lastLine.fixMarkStarts();
+        for (var i = 0, e = newText.length - 1; i < e; ++i)
+          added.push(Line.inheritMarks(newText[i], prevLine));
+        if (nlines) doc.remove(from.line, nlines, callbacks);
+        if (added.length) doc.insert(from.line, added);
+      } else if (firstLine == lastLine) {
         if (newText.length == 1)
           firstLine.replace(from.ch, to.ch, newText[0]);
         else {
           lastLine = firstLine.split(to.ch, newText[newText.length-1]);
-          var spliceargs = [from.line + 1, nlines];
-          firstLine.replace(from.ch, firstLine.text.length, newText[0]);
-          for (var i = 1, e = newText.length - 1; i < e; ++i) spliceargs.push(new Line(newText[i]));
-          spliceargs.push(lastLine);
-          lines.splice.apply(lines, spliceargs);
-        }
-      }
-      else if (newText.length == 1) {
-        firstLine.replace(from.ch, firstLine.text.length, newText[0] + lastLine.text.slice(to.ch));
-        lines.splice(from.line + 1, nlines);
-      }
-      else {
-        var spliceargs = [from.line + 1, nlines - 1];
-        firstLine.replace(from.ch, firstLine.text.length, newText[0]);
-        lastLine.replace(0, to.ch, newText[newText.length-1]);
-        for (var i = 1, e = newText.length - 1; i < e; ++i) spliceargs.push(new Line(newText[i]));
-        lines.splice.apply(lines, spliceargs);
-      }
-
-
-      for (var i = from.line, e = i + newText.length; i < e; ++i) {
-        var l = lines[i].text;
+          firstLine.replace(from.ch, null, newText[0]);
+          firstLine.fixMarkEnds(lastLine);
+          var added = [];
+          for (var i = 1, e = newText.length - 1; i < e; ++i)
+            added.push(Line.inheritMarks(newText[i], firstLine));
+          added.push(lastLine);
+          doc.insert(from.line + 1, added);
+        }
+      } else if (newText.length == 1) {
+        firstLine.replace(from.ch, null, newText[0]);
+        lastLine.replace(null, to.ch, "");
+        firstLine.append(lastLine);
+        doc.remove(from.line + 1, nlines, callbacks);
+      } else {
+        var added = [];
+        firstLine.replace(from.ch, null, newText[0]);
+        lastLine.replace(null, to.ch, newText[newText.length-1]);
+        firstLine.fixMarkEnds(lastLine);
+        for (var i = 1, e = newText.length - 1; i < e; ++i)
+          added.push(Line.inheritMarks(newText[i], firstLine));
+        if (nlines > 1) doc.remove(from.line + 1, nlines - 1, callbacks);
+        doc.insert(from.line + 1, added);
+      }
+      if (options.lineWrapping) {
+        var perLine = scroller.clientWidth / charWidth() - 3;
+        doc.iter(from.line, from.line + newText.length, function(line) {
+          if (line.hidden) return;
+          var guess = Math.ceil(line.text.length / perLine) || 1;
+          if (guess != line.height) updateLineHeight(line, guess);
+        });
+      } else {
+        doc.iter(from.line, i + newText.length, function(line) {
+          var l = line.text;
         if (l.length > maxLineLength) {
           maxLine = l; maxLineLength = l.length; maxWidth = null;
           recomputeMaxLength = false;
         }
-      }
+        });
       if (recomputeMaxLength) {
         maxLineLength = 0; maxLine = ""; maxWidth = null;
-        for (var i = 0, e = lines.length; i < e; ++i) {
-          var l = lines[i].text;
+          doc.iter(0, doc.size, function(line) {
+            var l = line.text;
           if (l.length > maxLineLength) {
             maxLineLength = l.length; maxLine = l;
           }
+          });
         }
       }
 
       // Add these lines to the work array, so that they will be
       // highlighted. Adjust work lines if lines were added/removed.
       var newWork = [], lendiff = newText.length - nlines - 1;
       for (var i = 0, l = work.length; i < l; ++i) {
         var task = work[i];
         if (task < from.line) newWork.push(task);
         else if (task > to.line) newWork.push(task + lendiff);
       }
-      if (newText.length < 5) {
-        highlightLines(from.line, from.line + newText.length);
-        newWork.push(from.line + newText.length);
-      } else {
-        newWork.push(from.line);
-      }
+      var hlEnd = from.line + Math.min(newText.length, 500);
+      highlightLines(from.line, hlEnd);
+      newWork.push(hlEnd);
       work = newWork;
       startWorker(100);
       // Remember that these lines changed, for updating the display
       changes.push({from: from.line, to: to.line + 1, diff: lendiff});
-      textChanged = {from: from, to: to, text: newText};
+      var changeObj = {from: from, to: to, text: newText};
+      if (textChanged) {
+        for (var cur = textChanged; cur.next; cur = cur.next) {}
+        cur.next = changeObj;
+      } else textChanged = changeObj;
 
       // Update the selection
       function updateLine(n) {return n <= Math.min(to.line, to.line + lendiff) ? n : n + lendiff;}
       setSelection(selFrom, selTo, updateLine(sel.from.line), updateLine(sel.to.line));
 
       // Make sure the scroll-size div has the correct height.
-      code.style.height = (lines.length * lineHeight() + 2 * paddingTop()) + "px";
+      code.style.height = (doc.height * textHeight() + 2 * paddingTop()) + "px";
     }
 
     function replaceRange(code, from, to) {
       from = clipPos(from);
       if (!to) to = from; else to = clipPos(to);
       code = splitLines(code);
       function adjustPos(pos) {
         if (posLess(pos, from)) return pos;
         if (!posLess(to, pos)) return end;
         var line = pos.line + code.length - (to.line - from.line) - 1;
         var ch = pos.ch;
         if (pos.line == to.line)
           ch += code[code.length-1].length - (to.ch - (to.line == from.line ? from.ch : 0));
         return {line: line, ch: ch};
       }
       var end;
       replaceRange1(code, from, to, function(end1) {
         end = end1;
         return {from: adjustPos(sel.from), to: adjustPos(sel.to)};
       });
       return end;
     }
     function replaceSelection(code, collapse) {
       replaceRange1(splitLines(code), sel.from, sel.to, function(end) {
         if (collapse == "end") return {from: end, to: end};
         else if (collapse == "start") return {from: sel.from, to: sel.from};
         else return {from: sel.from, to: end};
       });
     }
     function replaceRange1(code, from, to, computeSel) {
       var endch = code.length == 1 ? code[0].length + from.ch : code[code.length-1].length;
       var newSel = computeSel({line: from.line + code.length - 1, ch: endch});
       updateLines(from, to, code, newSel.from, newSel.to);
     }
 
     function getRange(from, to) {
       var l1 = from.line, l2 = to.line;
-      if (l1 == l2) return lines[l1].text.slice(from.ch, to.ch);
-      var code = [lines[l1].text.slice(from.ch)];
-      for (var i = l1 + 1; i < l2; ++i) code.push(lines[i].text);
-      code.push(lines[l2].text.slice(0, to.ch));
+      if (l1 == l2) return getLine(l1).text.slice(from.ch, to.ch);
+      var code = [getLine(l1).text.slice(from.ch)];
+      doc.iter(l1 + 1, l2, function(line) { code.push(line.text); });
+      code.push(getLine(l2).text.slice(0, to.ch));
       return code.join("\n");
     }
     function getSelection() {
       return getRange(sel.from, sel.to);
     }
 
     var pollingFast = false; // Ensures slowPoll doesn't cancel fastPoll
     function slowPoll() {
       if (pollingFast) return;
-      poll.set(2000, function() {
+      poll.set(options.pollInterval, function() {
         startOperation();
         readInput();
         if (focused) slowPoll();
         endOperation();
       });
     }
-    function fastPoll(keyId) {
+    function fastPoll() {
       var missed = false;
       pollingFast = true;
       function p() {
         startOperation();
         var changed = readInput();
-        if (changed && keyId) {
-          if (changed == "moved" && movementKeys[keyId] == null) movementKeys[keyId] = true;
-          if (changed == "changed") movementKeys[keyId] = false;
-        }
-        if (!changed && !missed) {missed = true; poll.set(80, p);}
+        if (!changed && !missed) {missed = true; poll.set(60, p);}
         else {pollingFast = false; slowPoll();}
         endOperation();
       }
       poll.set(20, p);
     }
 
-    // Inspects the textarea, compares its state (content, selection)
-    // to the data in the editing variable, and updates the editor
-    // content or cursor if something changed.
+    // 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.)
+    var prevInput = "";
     function readInput() {
-      if (leaveInputAlone || !focused) return;
-      var changed = false, text = input.value, sr = selRange(input);
-      if (!sr) return false;
-      var changed = editing.text != text, rs = reducedSelection;
-      var moved = changed || sr.start != editing.start || sr.end != (rs ? editing.start : editing.end);
-      if (!moved && !rs) return false;
-      if (changed) {
-        shiftSelecting = reducedSelection = null;
-        if (options.readOnly) {updateInput = true; return "changed";}
-      }
-
-      // Compute selection start and end based on start/end offsets in textarea
-      function computeOffset(n, startLine) {
-        var pos = 0;
-        for (;;) {
-          var found = text.indexOf("\n", pos);
-          if (found == -1 || (text.charAt(found-1) == "\r" ? found - 1 : found) >= n)
-            return {line: startLine, ch: n - pos};
-          ++startLine;
-          pos = found + 1;
-        }
-      }
-      var from = computeOffset(sr.start, editing.from),
-          to = computeOffset(sr.end, editing.from);
-      // Here we have to take the reducedSelection hack into account,
-      // so that you can, for example, press shift-up at the start of
-      // your selection and have the right thing happen.
-      if (rs) {
-        var head = sr.start == rs.anchor ? to : from;
-        var tail = shiftSelecting ? sel.to : sr.start == rs.anchor ? from : to;
-        if (sel.inverted = posLess(head, tail)) { from = head; to = tail; }
-        else { reducedSelection = null; from = tail; to = head; }
-      }
-
-      // In some cases (cursor on same line as before), we don't have
-      // to update the textarea content at all.
-      if (from.line == to.line && from.line == sel.from.line && from.line == sel.to.line && !shiftSelecting)
-        updateInput = false;
-
-      // Magic mess to extract precise edited range from the changed
-      // string.
-      if (changed) {
-        var start = 0, end = text.length, len = Math.min(end, editing.text.length);
-        var c, line = editing.from, nl = -1;
-        while (start < len && (c = text.charAt(start)) == editing.text.charAt(start)) {
-          ++start;
-          if (c == "\n") {line++; nl = start;}
-        }
-        var ch = nl > -1 ? start - nl : start, endline = editing.to - 1, edend = editing.text.length;
-        for (;;) {
-          c = editing.text.charAt(edend);
-          if (text.charAt(end) != c) {++end; ++edend; break;}
-          if (c == "\n") endline--;
-          if (edend <= start || end <= start) break;
-          --end; --edend;
-        }
-        var nl = editing.text.lastIndexOf("\n", edend - 1), endch = nl == -1 ? edend : edend - nl - 1;
-        updateLines({line: line, ch: ch}, {line: endline, ch: endch}, splitLines(text.slice(start, end)), from, to);
-        if (line != endline || from.line != line) updateInput = true;
+      if (leaveInputAlone || !focused || hasSelection(input)) return false;
+      var text = input.value;
+      if (text == prevInput) return false;
+      shiftSelecting = null;
+      var same = 0, l = Math.min(prevInput.length, text.length);
+      while (same < l && prevInput[same] == text[same]) ++same;
+      if (same < prevInput.length)
+        sel.from = {line: sel.from.line, ch: sel.from.ch - (prevInput.length - same)};
+      else if (overwrite && posEq(sel.from, sel.to))
+        sel.to = {line: sel.to.line, ch: Math.min(getLine(sel.to.line).text.length, sel.to.ch + (text.length - same))};
+      replaceSelection(text.slice(same), "end");
+      prevInput = text;
+      return true;
       }
-      else setSelection(from, to);
-
-      editing.text = text; editing.start = sr.start; editing.end = sr.end;
-      return changed ? "changed" : moved ? "moved" : false;
+    function resetInput(user) {
+      if (!posEq(sel.from, sel.to)) {
+        prevInput = "";
+        input.value = getSelection();
+        input.select();
+      } else if (user) prevInput = input.value = "";
     }
 
-    // Set the textarea content and selection range to match the
-    // editor state.
-    function prepareInput() {
-      var text = [];
-      var from = Math.max(0, sel.from.line - 1), to = Math.min(lines.length, sel.to.line + 2);
-      for (var i = from; i < to; ++i) text.push(lines[i].text);
-      text = input.value = text.join(lineSep);
-      var startch = sel.from.ch, endch = sel.to.ch;
-      for (var i = from; i < sel.from.line; ++i)
-        startch += lineSep.length + lines[i].text.length;
-      for (var i = from; i < sel.to.line; ++i)
-        endch += lineSep.length + lines[i].text.length;
-      editing = {text: text, from: from, to: to, start: startch, end: endch};
-      setSelRange(input, startch, reducedSelection ? startch : endch);
-    }
     function focusInput() {
-      if (options.readOnly != "nocursor") input.focus();
+      if (!options.readOnly) input.focus();
     }
 
     function scrollEditorIntoView() {
       if (!cursor.getBoundingClientRect) return;
       var rect = cursor.getBoundingClientRect();
-      var winH = window.innerHeight || document.body.offsetHeight || document.documentElement.offsetHeight;
+      // IE returns bogus coordinates when the instance sits inside of an iframe and the cursor is hidden
+      if (ie && rect.top == rect.bottom) return;
+      var winH = window.innerHeight || Math.max(document.body.offsetHeight, document.documentElement.offsetHeight);
       if (rect.top < 0 || rect.bottom > winH) cursor.scrollIntoView();
     }
     function scrollCursorIntoView() {
       var cursor = localCoords(sel.inverted ? sel.from : sel.to);
-      return scrollIntoView(cursor.x, cursor.y, cursor.x, cursor.yBot);
+      var x = options.lineWrapping ? Math.min(cursor.x, lineSpace.offsetWidth) : cursor.x;
+      return scrollIntoView(x, cursor.y, x, cursor.yBot);
     }
     function scrollIntoView(x1, y1, x2, y2) {
-      var pl = paddingLeft(), pt = paddingTop(), lh = lineHeight();
+      var pl = paddingLeft(), pt = paddingTop(), lh = textHeight();
       y1 += pt; y2 += pt; x1 += pl; x2 += pl;
       var screen = scroller.clientHeight, screentop = scroller.scrollTop, scrolled = false, result = true;
       if (y1 < screentop) {scroller.scrollTop = Math.max(0, y1 - 2*lh); scrolled = true;}
       else if (y2 > screentop + screen) {scroller.scrollTop = y2 + lh - screen; scrolled = true;}
 
       var screenw = scroller.clientWidth, screenleft = scroller.scrollLeft;
       var gutterw = options.fixedGutter ? gutter.clientWidth : 0;
       if (x1 < screenleft + gutterw) {
         if (x1 < 50) x1 = 0;
         scroller.scrollLeft = Math.max(0, x1 - 10 - gutterw);
         scrolled = true;
       }
-      else if (x2 > screenw + screenleft) {
+      else if (x2 > screenw + screenleft - 3) {
         scroller.scrollLeft = x2 + 10 - screenw;
         scrolled = true;
         if (x2 > code.clientWidth) result = false;
       }
       if (scrolled && options.onScroll) options.onScroll(instance);
       return result;
     }
 
     function visibleLines() {
-      var lh = lineHeight(), top = scroller.scrollTop - paddingTop();
-      return {from: Math.min(lines.length, Math.max(0, Math.floor(top / lh))),
-              to: Math.min(lines.length, Math.ceil((top + scroller.clientHeight) / lh))};
+      var lh = textHeight(), top = scroller.scrollTop - paddingTop();
+      var from_height = Math.max(0, Math.floor(top / lh));
+      var to_height = Math.ceil((top + scroller.clientHeight) / lh);
+      return {from: lineAtHeight(doc, from_height),
+              to: lineAtHeight(doc, to_height)};
     }
     // Uses a set of changes plus the current scroll position to
     // determine which DOM updates have to be made, and makes the
     // updates.
-    function updateDisplay(changes) {
+    function updateDisplay(changes, suppressCallback) {
       if (!scroller.clientWidth) {
-        showingFrom = showingTo = 0;
+        showingFrom = showingTo = displayOffset = 0;
         return;
       }
-      // First create a range of theoretically intact lines, and punch
-      // holes in that using the change info.
-      var intact = changes === true ? [] : [{from: showingFrom, to: showingTo, domStart: 0}];
-      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)
-            intact2.push({from: range.from + diff, to: range.to + diff, domStart: range.domStart});
-          else if (range.to <= change.from)
-            intact2.push(range);
-          else {
-            if (change.from > range.from)
-              intact2.push({from: range.from, to: change.from, domStart: range.domStart})
-            if (change.to < range.to)
-              intact2.push({from: change.to + diff, to: range.to + diff,
-                            domStart: range.domStart + (change.to - range.from)});
-          }
-        }
-        intact = intact2;
-      }
-
-      // Then, determine which lines we'd want to see, and which
-      // updates have to be made to get there.
+      // Compute the new visible window
       var visible = visibleLines();
-      var from = Math.min(showingFrom, Math.max(visible.from - 3, 0)),
-          to = Math.min(lines.length, Math.max(showingTo, visible.to + 3)),
-          updates = [], domPos = 0, domEnd = showingTo - showingFrom, pos = from, changedLines = 0;
-
-      for (var i = 0, l = intact.length; i < l; ++i) {
+      // Bail out if the visible area is already rendered and nothing changed.
+      if (changes !== true && changes.length == 0 && visible.from >= showingFrom && visible.to <= showingTo) return;
+      var from = Math.max(visible.from - 100, 0), to = Math.min(doc.size, visible.to + 100);
+      if (showingFrom < from && from - showingFrom < 20) from = showingFrom;
+      if (showingTo > to && showingTo - to < 20) to = Math.min(doc.size, showingTo);
+
+      // Create a range of theoretically intact lines, and punch holes
+      // in that using the change info.
+      var intact = changes === true ? [] :
+        computeIntact([{from: showingFrom, to: showingTo, domStart: 0}], 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.to <= from) continue;
-        if (range.from >= to) break;
-        if (range.domStart > domPos || range.from > pos) {
-          updates.push({from: pos, to: range.from, domSize: range.domStart - domPos, domStart: domPos});
-          changedLines += range.from - pos;
-        }
-        pos = range.to;
-        domPos = range.domStart + (range.to - range.from);
-      }
-      if (domPos != domEnd || pos != to) {
-        changedLines += Math.abs(to - pos);
-        updates.push({from: pos, to: to, domSize: domEnd - domPos, domStart: domPos});
-        if (to - pos != domEnd - domPos) gutterDirty = true;
-      }
-
-      if (!updates.length) return;
-      lineDiv.style.display = "none";
-      // If more than 30% of the screen needs update, just do a full
-      // redraw (which is quicker than patching)
-      if (changedLines > (visible.to - visible.from) * .3)
-        refreshDisplay(from = Math.max(visible.from - 10, 0), to = Math.min(visible.to + 7, lines.length));
-      // Otherwise, only update the stuff that needs updating.
-      else
-        patchDisplay(updates);
+        if (range.from < from) {range.domStart += (from - range.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) return;
+      intact.sort(function(a, b) {return a.domStart - b.domStart;});
+
+      var th = textHeight(), gutterDisplay = gutter.style.display;
+      lineDiv.style.display = gutter.style.display = "none";
+      patchDisplay(from, to, intact);
       lineDiv.style.display = "";
 
       // Position the mover div to align with the lines it's supposed
       // to be showing (which will cover the visible display)
-      var different = from != showingFrom || to != showingTo || lastHeight != scroller.clientHeight;
+      var different = from != showingFrom || to != showingTo || lastSizeC != scroller.clientHeight + th;
+      // This is just a bogus formula that detects when the editor is
+      // resized or the font size changes.
+      if (different) lastSizeC = scroller.clientHeight + th;
       showingFrom = from; showingTo = to;
-      mover.style.top = (from * lineHeight()) + "px";
-      if (different) {
-        lastHeight = scroller.clientHeight;
-        code.style.height = (lines.length * lineHeight() + 2 * paddingTop()) + "px";
-      }
-      if (different || gutterDirty) updateGutter();
+      displayOffset = heightAtLine(doc, from);
+      mover.style.top = (displayOffset * th) + "px";
+      code.style.height = (doc.height * th + 2 * paddingTop()) + "px";
 
+      // Since this is all rather error prone, it is honoured with the
+      // only assertion in the whole file.
+      if (lineDiv.childNodes.length != showingTo - showingFrom)
+        throw new Error("BAD PATCH! " + JSON.stringify(intact) + " size=" + (showingTo - showingFrom) +
+                        " nodes=" + lineDiv.childNodes.length);
+
+      if (options.lineWrapping) {
+        maxWidth = scroller.clientWidth;
+        var curNode = lineDiv.firstChild;
+        doc.iter(showingFrom, showingTo, function(line) {
+          if (!line.hidden) {
+            var height = Math.round(curNode.offsetHeight / th) || 1;
+            if (line.height != height) {updateLineHeight(line, height); gutterDirty = true;}
+          }
+          curNode = curNode.nextSibling;
+        });
+      } else {
       if (maxWidth == null) maxWidth = stringWidth(maxLine);
       if (maxWidth > scroller.clientWidth) {
         lineSpace.style.width = maxWidth + "px";
         // Needed to prevent odd wrapping/hiding of widgets placed in here.
         code.style.width = "";
         code.style.width = scroller.scrollWidth + "px";
       } else {
         lineSpace.style.width = code.style.width = "";
       }
-
-      // Since this is all rather error prone, it is honoured with the
-      // only assertion in the whole file.
-      if (lineDiv.childNodes.length != showingTo - showingFrom)
-        throw new Error("BAD PATCH! " + JSON.stringify(updates) + " size=" + (showingTo - showingFrom) +
-                        " nodes=" + lineDiv.childNodes.length);
+      }
+      gutter.style.display = gutterDisplay;
+      if (different || gutterDirty) updateGutter();
       updateCursor();
+      if (!suppressCallback && options.onUpdate) options.onUpdate(instance);
+      return true;
     }
 
-    function refreshDisplay(from, to) {
-      var html = [], start = {line: from, ch: 0}, inSel = posLess(sel.from, start) && !posLess(sel.to, start);
-      for (var i = from; i < to; ++i) {
-        var ch1 = null, ch2 = null;
-        if (inSel) {
-          ch1 = 0;
-          if (sel.to.line == i) {inSel = false; ch2 = sel.to.ch;}
+    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,
+                          domStart: range.domStart});
+          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, domStart: range.domStart});
+            if (change.to < range.to)
+              intact2.push({from: change.to + diff, to: range.to + diff,
+                            domStart: range.domStart + (change.to - range.from)});
         }
-        else if (sel.from.line == i) {
-          if (sel.to.line == i) {ch1 = sel.from.ch; ch2 = sel.to.ch;}
-          else {inSel = true; ch1 = sel.from.ch;}
         }
-        html.push(lines[i].getHTML(ch1, ch2, true));
-      }
-      lineDiv.innerHTML = html.join("");
-    }
-    function patchDisplay(updates) {
-      // Slightly different algorithm for IE (badInnerHTML), since
-      // there .innerHTML on PRE nodes is dumb, and discards
-      // whitespace.
-      var sfrom = sel.from.line, sto = sel.to.line, off = 0,
-          scratch = badInnerHTML && targetDocument.createElement("div");
-      for (var i = 0, e = updates.length; i < e; ++i) {
-        var rec = updates[i];
-        var extra = (rec.to - rec.from) - rec.domSize;
-        var nodeAfter = lineDiv.childNodes[rec.domStart + rec.domSize + off] || null;
-        if (badInnerHTML)
-          for (var j = Math.max(-extra, rec.domSize); j > 0; --j)
-            lineDiv.removeChild(nodeAfter ? nodeAfter.previousSibling : lineDiv.lastChild);
-        else if (extra) {
-          for (var j = Math.max(0, extra); j > 0; --j)
-            lineDiv.insertBefore(targetDocument.createElement("pre"), nodeAfter);
-          for (var j = Math.max(0, -extra); j > 0; --j)
-            lineDiv.removeChild(nodeAfter ? nodeAfter.previousSibling : lineDiv.lastChild);
-        }
-        var node = lineDiv.childNodes[rec.domStart + off], inSel = sfrom < rec.from && sto >= rec.from;
-        for (var j = rec.from; j < rec.to; ++j) {
+        intact = intact2;
+      }
+      return intact;
+    }
+
+    function patchDisplay(from, to, intact) {
+      // The first pass removes the DOM nodes that aren't intact.
+      if (!intact.length) lineDiv.innerHTML = "";
+      else {
+        function killNode(node) {
+          var tmp = node.nextSibling;
+          node.parentNode.removeChild(node);
+          return tmp;
+        }
+        var domPos = 0, curNode = lineDiv.firstChild, n;
+        for (var i = 0; i < intact.length; ++i) {
+          var cur = intact[i];
+          while (cur.domStart > domPos) {curNode = killNode(curNode); domPos++;}
+          for (var j = 0, e = cur.to - cur.from; j < e; ++j) {curNode = curNode.nextSibling; domPos++;}
+        }
+        while (curNode) curNode = killNode(curNode);
+      }
+      // This pass fills in the lines that actually changed.
+      var nextIntact = intact.shift(), curNode = lineDiv.firstChild, j = from;
+      var sfrom = sel.from.line, sto = sel.to.line, inSel = sfrom < from && sto >= from;
+      var scratch = targetDocument.createElement("div"), newElt;
+      doc.iter(from, to, function(line) {
           var ch1 = null, ch2 = null;
           if (inSel) {
             ch1 = 0;
             if (sto == j) {inSel = false; ch2 = sel.to.ch;}
-          }
-          else if (sfrom == j) {
+        } else if (sfrom == j) {
             if (sto == j) {ch1 = sel.from.ch; ch2 = sel.to.ch;}
             else {inSel = true; ch1 = sel.from.ch;}
           }
-          if (badInnerHTML) {
-            scratch.innerHTML = lines[j].getHTML(ch1, ch2, true);
-            lineDiv.insertBefore(scratch.firstChild, nodeAfter);
-          }
-          else {
-            node.innerHTML = lines[j].getHTML(ch1, ch2, false);
-            node.className = lines[j].className || "";
-            node = node.nextSibling;
-          }
-        }
-        off += extra;
+        if (nextIntact && nextIntact.to == j) nextIntact = intact.shift();
+        if (!nextIntact || nextIntact.from > j) {
+          if (line.hidden) scratch.innerHTML = "<pre></pre>";
+          else scratch.innerHTML = line.getHTML(ch1, ch2, true, tabText);
+          lineDiv.insertBefore(scratch.firstChild, curNode);
+        } else {
+          curNode = curNode.nextSibling;
       }
+        ++j;
+      });
     }
 
     function updateGutter() {
       if (!options.gutter && !options.lineNumbers) return;
       var hText = mover.offsetHeight, hEditor = scroller.clientHeight;
       gutter.style.height = (hText - hEditor < 2 ? hEditor : hText) + "px";
-      var html = [];
-      for (var i = showingFrom; i < Math.max(showingTo, showingFrom + 1); ++i) {
-        var marker = lines[i].gutterMarker;
+      var html = [], i = showingFrom;
+      doc.iter(showingFrom, Math.max(showingTo, showingFrom + 1), function(line) {
+        if (line.hidden) {
+          html.push("<pre></pre>");
+        } else {
+          var marker = line.gutterMarker;
         var text = options.lineNumbers ? i + options.firstLineNumber : null;
         if (marker && marker.text)
           text = marker.text.replace("%N%", text != null ? text : "");
         else if (text == null)
           text = "\u00a0";
-        html.push((marker && marker.style ? '<pre class="' + marker.style + '">' : "<pre>"), text, "</pre>");
+          html.push((marker && marker.style ? '<pre class="' + marker.style + '">' : "<pre>"), text);
+          for (var j = 1; j < line.height; ++j) html.push("<br/>&#160;");
+          html.push("</pre>");
       }
+        ++i;
+      });
       gutter.style.display = "none";
       gutterText.innerHTML = html.join("");
-      var minwidth = String(lines.length).length, firstNode = gutterText.firstChild, val = eltText(firstNode), pad = "";
+      var minwidth = String(doc.size).length, firstNode = gutterText.firstChild, val = eltText(firstNode), pad = "";
       while (val.length + pad.length < minwidth) pad += "\u00a0";
       if (pad) firstNode.insertBefore(targetDocument.createTextNode(pad), firstNode.firstChild);
       gutter.style.display = "";
       lineSpace.style.marginLeft = gutter.offsetWidth + "px";
       gutterDirty = false;
     }
     function updateCursor() {
-      var head = sel.inverted ? sel.from : sel.to, lh = lineHeight();
-      var x = charX(head.line, head.ch);
-      var top = head.line * lh - scroller.scrollTop;
-      inputDiv.style.top = Math.max(Math.min(top, scroller.offsetHeight), 0) + "px";
-      inputDiv.style.left = (x - scroller.scrollLeft) + "px";
+      var head = sel.inverted ? sel.from : sel.to, lh = textHeight();
+      var pos = localCoords(head, true);
+      var wrapOff = eltOffset(wrapper), lineOff = eltOffset(lineDiv);
+      inputDiv.style.top = (pos.y + lineOff.top - wrapOff.top) + "px";
+      inputDiv.style.left = (pos.x + lineOff.left - wrapOff.left) + "px";
       if (posEq(sel.from, sel.to)) {
-        cursor.style.top = (head.line - showingFrom) * lh + "px";
-        cursor.style.left = x + "px";
+        cursor.style.top = pos.y + "px";
+        cursor.style.left = (options.lineWrapping ? Math.min(pos.x, lineSpace.offsetWidth) : pos.x) + "px";
         cursor.style.display = "";
       }
       else cursor.style.display = "none";
     }
 
+    function setShift(val) {
+      if (val) shiftSelecting = shiftSelecting || (sel.inverted ? sel.to : sel.from);
+      else shiftSelecting = null;
+    }
     function setSelectionUser(from, to) {
       var sh = shiftSelecting && clipPos(shiftSelecting);
       if (sh) {
         if (posLess(sh, from)) from = sh;
         else if (posLess(to, sh)) to = sh;
       }
       setSelection(from, to);
+      userSelChange = true;
     }
     // Update the selection. Last two args are only used by
     // updateLines, since they have to be expressed in the line
     // numbers before the update.
     function setSelection(from, to, oldFrom, oldTo) {
+      goalColumn = null;
+      if (oldFrom == null) {oldFrom = sel.from.line; oldTo = sel.to.line;}
       if (posEq(sel.from, from) && posEq(sel.to, to)) return;
       if (posLess(to, from)) {var tmp = to; to = from; from = tmp;}
 
+      // Skip over hidden lines.
+      if (from.line != oldFrom) from = skipHidden(from, oldFrom, sel.from.ch);
+      if (to.line != oldTo) to = skipHidden(to, oldTo, sel.to.ch);
+
       if (posEq(from, to)) sel.inverted = false;
       else if (posEq(from, sel.to)) sel.inverted = false;
       else if (posEq(to, sel.from)) sel.inverted = true;
 
       // Some ugly logic used to only mark the lines that actually did
       // see a change in selection as changed, rather than the whole
       // selected range.
-      if (oldFrom == null) {oldFrom = sel.from.line; oldTo = sel.to.line;}
       if (posEq(from, to)) {
         if (!posEq(sel.from, sel.to))
           changes.push({from: oldFrom, to: oldTo + 1});
       }
       else if (posEq(sel.from, sel.to)) {
         changes.push({from: from.line, to: to.line + 1});
       }
       else {
         if (!posEq(from, sel.from)) {
           if (from.line < oldFrom)
             changes.push({from: from.line, to: Math.min(to.line, oldFrom) + 1});
           else
             changes.push({from: oldFrom, to: Math.min(oldTo, from.line) + 1});
         }
         if (!posEq(to, sel.to)) {
           if (to.line < oldTo)
             changes.push({from: Math.max(oldFrom, from.line), to: oldTo + 1});
           else
             changes.push({from: Math.max(from.line, oldTo), to: to.line + 1});
         }
       }
       sel.from = from; sel.to = to;
       selectionChanged = true;
     }
+    function skipHidden(pos, oldLine, oldCh) {
+      function getNonHidden(dir) {
+        var lNo = pos.line + dir, end = dir == 1 ? doc.size : -1;
+        while (lNo != end) {
+          var line = getLine(lNo);
+          if (!line.hidden) {
+            var ch = pos.ch;
+            if (ch > oldCh || ch > line.text.length) ch = line.text.length;
+            return {line: lNo, ch: ch};
+          }
+          lNo += dir;
+        }
+      }
+      var line = getLine(pos.line);
+      if (!line.hidden) return pos;
+      if (pos.line >= oldLine) return getNonHidden(1) || getNonHidden(-1);
+      else return getNonHidden(-1) || getNonHidden(1);
+    }
     function setCursor(line, ch, user) {
       var pos = clipPos({line: line, ch: ch || 0});
       (user ? setSelectionUser : setSelection)(pos, pos);
     }
 
-    function clipLine(n) {return Math.max(0, Math.min(n, lines.length-1));}
+    function clipLine(n) {return Math.max(0, Math.min(n, doc.size-1));}
     function clipPos(pos) {
       if (pos.line < 0) return {line: 0, ch: 0};
-      if (pos.line >= lines.length) return {line: lines.length-1, ch: lines[lines.length-1].text.length};
-      var ch = pos.ch, linelen = lines[pos.line].text.length;
+      if (pos.line >= doc.size) return {line: doc.size-1, ch: getLine(doc.size-1).text.length};
+      var ch = pos.ch, linelen = getLine(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 scrollPage(down) {
-      var linesPerPage = Math.floor(scroller.clientHeight / lineHeight()), head = sel.inverted ? sel.from : sel.to;
-      setCursor(head.line + (Math.max(linesPerPage - 1, 1) * (down ? 1 : -1)), head.ch, true);
+    function findPosH(dir, unit) {
+      var end = sel.inverted ? sel.from : sel.to, line = end.line, ch = end.ch;
+      var lineObj = getLine(line);
+      function findNextLine() {
+        for (var l = line + dir, e = dir < 0 ? -1 : doc.size; l != e; l += dir) {
+          var lo = getLine(l);
+          if (!lo.hidden) { line = l; lineObj = lo; return true; }
     }
-    function scrollEnd(top) {
-      var pos = top ? {line: 0, ch: 0} : {line: lines.length - 1, ch: lines[lines.length-1].text.length};
-      setSelectionUser(pos, pos);
     }
-    function selectAll() {
-      var endLine = lines.length - 1;
-      setSelection({line: 0, ch: 0}, {line: endLine, ch: lines[endLine].text.length});
+      function moveOnce(boundToLine) {
+        if (ch == (dir < 0 ? 0 : lineObj.text.length)) {
+          if (!boundToLine && findNextLine()) ch = dir < 0 ? lineObj.text.length : 0;
+          else return false;
+        } else ch += dir;
+        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 {line: line, ch: ch};
+    }
+    function moveH(dir, unit) {
+      var pos = dir < 0 ? sel.from : sel.to;
+      if (shiftSelecting || posEq(sel.from, sel.to)) pos = findPosH(dir, unit);
+      setCursor(pos.line, pos.ch, true);
+    }
+    function deleteH(dir, unit) {
+      if (!posEq(sel.from, sel.to)) replaceRange("", sel.from, sel.to);
+      else if (dir < 0) replaceRange("", findPosH(dir, unit), sel.to);
+      else replaceRange("", sel.from, findPosH(dir, unit));
+      userSelChange = true;
+    }
+    var goalColumn = null;
+    function moveV(dir, unit) {
+      var dist = 0, pos = localCoords(sel.inverted ? sel.from : sel.to, true);
+      if (goalColumn != null) pos.x = goalColumn;
+      if (unit == "page") dist = scroller.clientHeight;
+      else if (unit == "line") dist = textHeight();
+      var target = coordsChar(pos.x, pos.y + dist * dir + 2);
+      setCursor(target.line, target.ch, true);
+      goalColumn = pos.x;
+    }
+
     function selectWordAt(pos) {
-      var line = lines[pos.line].text;
+      var line = getLine(pos.line).text;
       var start = pos.ch, end = pos.ch;
-      while (start > 0 && /\w/.test(line.charAt(start - 1))) --start;
-      while (end < line.length && /\w/.test(line.charAt(end))) ++end;
+      while (start > 0 && isWordChar(line.charAt(start - 1))) --start;
+      while (end < line.length && isWordChar(line.charAt(end))) ++end;
       setSelectionUser({line: pos.line, ch: start}, {line: pos.line, ch: end});
     }
     function selectLine(line) {
-      setSelectionUser({line: line, ch: 0}, {line: line, ch: lines[line].text.length});
-    }
-    function handleEnter() {
-      replaceSelection("\n", "end");
-      if (options.enterMode != "flat")
-        indentLine(sel.from.line, options.enterMode == "keep" ? "prev" : "smart");
+      setSelectionUser({line: line, ch: 0}, {line: line, ch: getLine(line).text.length});
     }
-    function handleTab(shift) {
       function indentSelected(mode) {
         if (posEq(sel.from, sel.to)) return indentLine(sel.from.line, mode);
         var e = sel.to.line - (sel.to.ch ? 0 : 1);
         for (var i = sel.from.line; i <= e; ++i) indentLine(i, mode);
       }
-      shiftSelecting = null;
-      switch (options.tabMode) {
-      case "default":
-        return false;
-      case "indent":
-        indentSelected("smart");
-        break;
-      case "classic":
-        if (posEq(sel.from, sel.to)) {
-          if (shift) indentLine(sel.from.line, "smart");
-          else replaceSelection("\t", "end");
-          break;
-        }
-      case "shift":
-        indentSelected(shift ? "subtract" : "add");
-        break;
-      }
-      return true;
-    }
-    function smartHome() {
-      var firstNonWS = Math.max(0, lines[sel.from.line].text.search(/\S/));
-      setCursor(sel.from.line, sel.from.ch <= firstNonWS && sel.from.ch ? 0 : firstNonWS, true);
-    }
 
     function indentLine(n, how) {
+      if (!how) how = "add";
       if (how == "smart") {
         if (!mode.indent) how = "prev";
         else var state = getStateBefore(n);
       }
 
-      var line = lines[n], curSpace = line.indentation(), curSpaceString = line.text.match(/^\s*/)[0], indentation;
+      var line = getLine(n), curSpace = line.indentation(options.tabSize),
+          curSpaceString = line.text.match(/^\s*/)[0], indentation;
       if (how == "prev") {
-        if (n) indentation = lines[n-1].indentation();
+        if (n) indentation = getLine(n-1).indentation(options.tabSize);
         else indentation = 0;
       }
-      else if (how == "smart") indentation = mode.indent(state, line.text.slice(curSpaceString.length));
+      else if (how == "smart") indentation = mode.indent(state, line.text.slice(curSpaceString.length), line.text);
       else if (how == "add") indentation = curSpace + options.indentUnit;
       else if (how == "subtract") indentation = curSpace - options.indentUnit;
       indentation = Math.max(0, indentation);
       var diff = indentation - curSpace;
 
       if (!diff) {
         if (sel.from.line != n && sel.to.line != n) return;
         var indentString = curSpaceString;
       }
       else {
         var indentString = "", pos = 0;
         if (options.indentWithTabs)
-          for (var i = Math.floor(indentation / tabSize); i; --i) {pos += tabSize; indentString += "\t";}
+          for (var i = Math.floor(indentation / options.tabSize); i; --i) {pos += options.tabSize; indentString += "\t";}
         while (pos < indentation) {++pos; indentString += " ";}
       }
 
       replaceRange(indentString, {line: n, ch: 0}, {line: n, ch: curSpaceString.length});
     }
 
     function loadMode() {
       mode = CodeMirror.getMode(options, options.mode);
-      for (var i = 0, l = lines.length; i < l; ++i)
-        lines[i].stateAfter = null;
+      doc.iter(0, doc.size, function(line) { line.stateAfter = null; });
       work = [0];
       startWorker();
     }
     function gutterChanged() {
       var visible = options.gutter || options.lineNumbers;
       gutter.style.display = visible ? "" : "none";
       if (visible) gutterDirty = true;
       else lineDiv.parentNode.style.marginLeft = 0;
     }
+    function wrappingChanged(from, to) {
+      if (options.lineWrapping) {
+        wrapper.className += " CodeMirror-wrap";
+        var perLine = scroller.clientWidth / charWidth() - 3;
+        doc.iter(0, doc.size, function(line) {
+          if (line.hidden) return;
+          var guess = Math.ceil(line.text.length / perLine) || 1;
+          if (guess != 1) updateLineHeight(line, guess);
+        });
+        lineSpace.style.width = code.style.width = "";
+      } else {
+        wrapper.className = wrapper.className.replace(" CodeMirror-wrap", "");
+        maxWidth = null; maxLine = "";
+        doc.iter(0, doc.size, function(line) {
+          if (line.height != 1 && !line.hidden) updateLineHeight(line, 1);
+          if (line.text.length > maxLine.length) maxLine = line.text;
+        });
+      }
+      changes.push({from: 0, to: doc.size});
+    }
+    function computeTabText() {
+      for (var str = '<span class="cm-tab">', i = 0; i < options.tabSize; ++i) str += " ";
+      return str + "</span>";
+    }
+    function tabsChanged() {
+      tabText = computeTabText();
+      updateDisplay(true);
+    }
+    function themeChanged() {
+      scroller.className = scroller.className.replace(/\s*cm-s-\w+/g, "") +
+        options.theme.replace(/(^|\s)\s*/g, " cm-s-");
+    }
+
+    function TextMarker() { this.set = []; }
+    TextMarker.prototype.clear = operation(function() {
+      var min = Infinity, max = -Infinity;
+      for (var i = 0, e = this.set.length; i < e; ++i) {
+        var line = this.set[i], mk = line.marked;
+        if (!mk || !line.parent) continue;
+        var lineN = lineNo(line);
+        min = Math.min(min, lineN); max = Math.max(max, lineN);
+        for (var j = 0; j < mk.length; ++j)
+          if (mk[j].set == this.set) mk.splice(j--, 1);
+      }
+      if (min != Infinity)
+        changes.push({from: min, to: max + 1});
+    });
+    TextMarker.prototype.find = function() {
+      var from, to;
+      for (var i = 0, e = this.set.length; i < e; ++i) {
+        var line = this.set[i], mk = line.marked;
+        for (var j = 0; j < mk.length; ++j) {
+          var mark = mk[j];
+          if (mark.set == this.set) {
+            if (mark.from != null || mark.to != null) {
+              var found = lineNo(line);
+              if (found != null) {
+                if (mark.from != null) from = {line: found, ch: mark.from};
+                if (mark.to != null) to = {line: found, ch: mark.to};
+              }
+            }
+          }
+        }
+      }
+      return {from: from, to: to};
+    };
 
     function markText(from, to, className) {
       from = clipPos(from); to = clipPos(to);
-      var accum = [];
+      var tm = new TextMarker();
       function add(line, from, to, className) {
-        var line = lines[line], mark = line.addMark(from, to, className);
-        mark.line = line;
-        accum.push(mark);
+        getLine(line).addMark(new MarkedText(from, to, className, tm.set));
       }
       if (from.line == to.line) add(from.line, from.ch, to.ch, className);
       else {
         add(from.line, from.ch, null, className);
         for (var i = from.line + 1, e = to.line; i < e; ++i)
-          add(i, 0, null, className);
-        add(to.line, 0, to.ch, className);
+          add(i, null, null, className);
+        add(to.line, null, to.ch, className);
       }
       changes.push({from: from.line, to: to.line + 1});
-      return function() {
-        var start, end;
-        for (var i = 0; i < accum.length; ++i) {
-          var mark = accum[i], found = indexOf(lines, mark.line);
-          mark.line.removeMark(mark);
-          if (found > -1) {
-            if (start == null) start = found;
-            end = found;
+      return tm;
           }
-        }
-        if (start != null) changes.push({from: start, to: end + 1});
-      };
+
+    function setBookmark(pos) {
+      pos = clipPos(pos);
+      var bm = new Bookmark(pos.ch);
+      getLine(pos.line).addMark(bm);
+      return bm;
     }
 
     function addGutterMarker(line, text, className) {
-      if (typeof line == "number") line = lines[clipLine(line)];
+      if (typeof line == "number") line = getLine(clipLine(line));
       line.gutterMarker = {text: text, style: className};
       gutterDirty = true;
       return line;
     }
     function removeGutterMarker(line) {
-      if (typeof line == "number") line = lines[clipLine(line)];
+      if (typeof line == "number") line = getLine(clipLine(line));
       line.gutterMarker = null;
       gutterDirty = true;
     }
-    function setLineClass(line, className) {
-      if (typeof line == "number") {
-        var no = line;
-        line = lines[clipLine(line)];
-      }
-      else {
-        var no = indexOf(lines, line);
-        if (no == -1) return null;
+
+    function changeLine(handle, op) {
+      var no = handle, line = handle;
+      if (typeof handle == "number") line = getLine(clipLine(handle));
+      else no = lineNo(handle);
+      if (no == null) return null;
+      if (op(line, no)) changes.push({from: no, to: no + 1});
+      else return null;
+      return line;
       }
+    function setLineClass(handle, className) {
+      return changeLine(handle, function(line) {
       if (line.className != className) {
         line.className = className;
-        changes.push({from: no, to: no + 1});
+          return true;
       }
-      return line;
+      });
+    }
+    function setLineHidden(handle, hidden) {
+      return changeLine(handle, function(line, no) {
+        if (line.hidden != hidden) {
+          line.hidden = hidden;
+          updateLineHeight(line, hidden ? 0 : 1);
+          if (hidden && (sel.from.line == no || sel.to.line == no))
+            setSelection(skipHidden(sel.from, sel.from.line, sel.from.ch),
+                         skipHidden(sel.to, sel.to.line, sel.to.ch));
+          return (gutterDirty = true);
+        }
+      });
     }
 
     function lineInfo(line) {
       if (typeof line == "number") {
+        if (!isLine(line)) return null;
         var n = line;
-        line = lines[line];
+        line = getLine(line);
         if (!line) return null;
       }
       else {
-        var n = indexOf(lines, line);
-        if (n == -1) return null;
+        var n = lineNo(line);
+        if (n == null) return null;
       }
       var marker = line.gutterMarker;
-      return {line: n, text: line.text, markerText: marker && marker.text, markerClass: marker && marker.style};
+      return {line: n, handle: line, text: line.text, markerText: marker && marker.text,
+              markerClass: marker && marker.style, lineClass: line.className};
     }
 
     function stringWidth(str) {
       measure.innerHTML = "<pre><span>x</span></pre>";
       measure.firstChild.firstChild.firstChild.nodeValue = str;
       return measure.firstChild.firstChild.offsetWidth || 10;
     }
     // These are used to go from pixel positions to character
     // positions, taking varying character widths into account.
-    function charX(line, pos) {
-      if (pos == 0) return 0;
-      measure.innerHTML = "<pre><span>" + lines[line].getHTML(null, null, false, pos) + "</span></pre>";
-      return measure.firstChild.firstChild.offsetWidth;
-    }
     function charFromX(line, x) {
       if (x <= 0) return 0;
-      var lineObj = lines[line], text = lineObj.text;
+      var lineObj = getLine(line), text = lineObj.text;
       function getX(len) {
-        measure.innerHTML = "<pre><span>" + lineObj.getHTML(null, null, false, len) + "</span></pre>";
+        measure.innerHTML = "<pre><span>" + lineObj.getHTML(null, null, false, tabText, len) + "</span></pre>";
         return measure.firstChild.firstChild.offsetWidth;
       }
       var from = 0, fromX = 0, to = text.length, toX;
       // Guess a suitable upper bound for our search.
-      var estimated = Math.min(to, Math.ceil(x / stringWidth("x")));
+      var estimated = Math.min(to, Math.ceil(x / charWidth()));
       for (;;) {
         var estX = getX(estimated);
         if (estX <= x && estimated < to) estimated = Math.min(to, Math.ceil(estimated * 1.2));
         else {toX = estX; to = estimated; break;}
       }
       if (x > toX) return to;
       // Try to guess a suitable lower bound as well.
       estimated = Math.floor(to * 0.8); estX = getX(estimated);
       if (estX < x) {from = estimated; fromX = estX;}
       // Do a binary search between these bounds.
       for (;;) {
         if (to - from <= 1) return (toX - x > x - fromX) ? from : to;
         var middle = Math.ceil((from + to) / 2), middleX = getX(middle);
         if (middleX > x) {to = middle; toX = middleX;}
         else {from = middle; fromX = middleX;}
       }
     }
 
+    var tempId = Math.floor(Math.random() * 0xffffff).toString(16);
+    function measureLine(line, ch) {
+      var extra = "";
+      // Include extra text at the end to make sure the measured line is wrapped in the right way.
+      if (options.lineWrapping) {
+        var end = line.text.indexOf(" ", ch + 2);
+        extra = htmlEscape(line.text.slice(ch + 1, end < 0 ? line.text.length : end + (ie ? 5 : 0)));
+      }
+      measure.innerHTML = "<pre>" + line.getHTML(null, null, false, tabText, ch) +
+        '<span id="CodeMirror-temp-' + tempId + '">' + htmlEscape(line.text.charAt(ch) || " ") + "</span>" +
+        extra + "</pre>";
+      var elt = document.getElementById("CodeMirror-temp-" + tempId);
+      var top = elt.offsetTop, left = elt.offsetLeft;
+      // Older IEs report zero offsets for spans directly after a wrap
+      if (ie && ch && top == 0 && left == 0) {
+        var backup = document.createElement("span");
+        backup.innerHTML = "x";
+        elt.parentNode.insertBefore(backup, elt.nextSibling);
+        top = backup.offsetTop;
+      }
+      return {top: top, left: left};
+    }
     function localCoords(pos, inLineWrap) {
-      var lh = lineHeight(), line = pos.line - (inLineWrap ? showingFrom : 0);
-      return {x: charX(pos.line, pos.ch), y: line * lh, yBot: (line + 1) * lh};
+      var x, lh = textHeight(), y = lh * (heightAtLine(doc, pos.line) - (inLineWrap ? displayOffset : 0));
+      if (pos.ch == 0) x = 0;
+      else {
+        var sp = measureLine(getLine(pos.line), pos.ch);
+        x = sp.left;
+        if (options.lineWrapping) y += Math.max(0, sp.top);
+      }
+      return {x: x, y: y, yBot: y + lh};
+    }
+    // Coords must be lineSpace-local
+    function coordsChar(x, y) {
+      if (y < 0) y = 0;
+      var th = textHeight(), cw = charWidth(), heightPos = displayOffset + Math.floor(y / th);
+      var lineNo = lineAtHeight(doc, heightPos);
+      if (lineNo >= doc.size) return {line: doc.size - 1, ch: getLine(doc.size - 1).text.length};
+      var lineObj = getLine(lineNo), text = lineObj.text;
+      var tw = options.lineWrapping, innerOff = tw ? heightPos - heightAtLine(doc, lineNo) : 0;
+      if (x <= 0 && innerOff == 0) return {line: lineNo, ch: 0};
+      function getX(len) {
+        var sp = measureLine(lineObj, len);
+        if (tw) {
+          var off = Math.round(sp.top / th);
+          return Math.max(0, sp.left + (off - innerOff) * scroller.clientWidth);
+        }
+        return sp.left;
+      }
+      var from = 0, fromX = 0, to = text.length, toX;
+      // Guess a suitable upper bound for our search.
+      var estimated = Math.min(to, Math.ceil((x + innerOff * scroller.clientWidth * .9) / cw));
+      for (;;) {
+        var estX = getX(estimated);
+        if (estX <= x && estimated < to) estimated = Math.min(to, Math.ceil(estimated * 1.2));
+        else {toX = estX; to = estimated; break;}
+      }
+      if (x > toX) return {line: lineNo, ch: to};
+      // Try to guess a suitable lower bound as well.
+      estimated = Math.floor(to * 0.8); estX = getX(estimated);
+      if (estX < x) {from = estimated; fromX = estX;}
+      // Do a binary search between these bounds.
+      for (;;) {
+        if (to - from <= 1) return {line: lineNo, ch: (toX - x > x - fromX) ? from : to};
+        var middle = Math.ceil((from + to) / 2), middleX = getX(middle);
+        if (middleX > x) {to = middle; toX = middleX;}
+        else {from = middle; fromX = middleX;}
+      }
     }
     function pageCoords(pos) {
       var local = localCoords(pos, true), off = eltOffset(lineSpace);
       return {x: off.left + local.x, y: off.top + local.y, yBot: off.top + local.yBot};
     }
 
-    function lineHeight() {
-      var nlines = lineDiv.childNodes.length;
-      if (nlines) return (lineDiv.offsetHeight / nlines) || 1;
-      measure.innerHTML = "<pre>x</pre>";
-      return measure.firstChild.offsetHeight || 1;
+    var cachedHeight, cachedHeightFor, measureText;
+    function textHeight() {
+      if (measureText == null) {
+        measureText = "<pre>";
+        for (var i = 0; i < 49; ++i) measureText += "x<br/>";
+        measureText += "x</pre>";
+      }
+      var offsetHeight = lineDiv.clientHeight;
+      if (offsetHeight == cachedHeightFor) return cachedHeight;
+      cachedHeightFor = offsetHeight;
+      measure.innerHTML = measureText;
+      cachedHeight = measure.firstChild.offsetHeight / 50 || 1;
+      measure.innerHTML = "";
+      return cachedHeight;
+    }
+    var cachedWidth, cachedWidthFor = 0;
+    function charWidth() {
+      if (scroller.clientWidth == cachedWidthFor) return cachedWidth;
+      cachedWidthFor = scroller.clientWidth;
+      return (cachedWidth = stringWidth("x"));
     }
     function paddingTop() {return lineSpace.offsetTop;}
     function paddingLeft() {return lineSpace.offsetLeft;}
 
     function posFromMouse(e, liberal) {
       var offW = eltOffset(scroller, true), x, y;
       // Fails unpredictably on IE[67] when mouse is dragged around quickly.
       try { x = e.clientX; y = e.clientY; } catch (e) { return null; }
       // This is a mess of a heuristic to try and determine whether a
       // scroll-bar was clicked or not, and to return null if one was
       // (and !liberal).
       if (!liberal && (x - offW.left > scroller.clientWidth || y - offW.top > scroller.clientHeight))
         return null;
       var offL = eltOffset(lineSpace, true);
-      var line = showingFrom + Math.floor((y - offL.top) / lineHeight());
-      return clipPos({line: line, ch: charFromX(clipLine(line), x - offL.left)});
+      return coordsChar(x - offL.left, y - offL.top);
     }
     function onContextMenu(e) {
       var pos = posFromMouse(e);
       if (!pos || window.opera) return; // Opera is difficult.
       if (posEq(sel.from, sel.to) || posLess(pos, sel.from) || !posLess(pos, sel.to))
         operation(setCursor)(pos.line, pos.ch);
 
       var oldCSS = input.style.cssText;
       inputDiv.style.position = "absolute";
       input.style.cssText = "position: fixed; width: 30px; height: 30px; top: " + (e.clientY - 5) +
         "px; left: " + (e.clientX - 5) + "px; z-index: 1000; background: white; " +
         "border-width: 0; outline: none; overflow: hidden; opacity: .05; filter: alpha(opacity=5);";
       leaveInputAlone = true;
       var val = input.value = getSelection();
       focusInput();
-      setSelRange(input, 0, input.value.length);
+      input.select();
       function rehide() {
         var newVal = splitLines(input.value).join("\n");
         if (newVal != val) operation(replaceSelection)(newVal, "end");
         inputDiv.style.position = "relative";
         input.style.cssText = oldCSS;
         leaveInputAlone = false;
-        prepareInput();
+        resetInput(true);
         slowPoll();
       }
 
       if (gecko) {
         e_stop(e);
         var mouseup = connect(window, "mouseup", function() {
           mouseup();
           setTimeout(rehide, 20);
         }, true);
       }
       else {
         setTimeout(rehide, 50);
       }
     }
 
     // Cursor-blinking
     function restartBlink() {
       clearInterval(blinker);
       var on = true;
       cursor.style.visibility = "";
       blinker = setInterval(function() {
         cursor.style.visibility = (on = !on) ? "" : "hidden";
       }, 650);
     }
 
     var matching = {"(": ")>", ")": "(<", "[": "]>", "]": "[<", "{": "}>", "}": "{<"};
     function matchBrackets(autoclear) {
-      var head = sel.inverted ? sel.from : sel.to, line = lines[head.line], pos = head.ch - 1;
+      var head = sel.inverted ? sel.from : sel.to, line = getLine(head.line), pos = head.ch - 1;
       var match = (pos >= 0 && matching[line.text.charAt(pos)]) || matching[line.text.charAt(++pos)];
       if (!match) return;
       var ch = match.charAt(0), forward = match.charAt(1) == ">", d = forward ? 1 : -1, st = line.styles;
       for (var off = pos + 1, i = 0, e = st.length; i < e; i+=2)
         if ((off -= st[i].length) <= 0) {var style = st[i+1]; break;}
 
       var stack = [line.text.charAt(pos)], re = /[(){}[\]]/;
       function scan(line, from, to) {
         if (!line.text) return;
         var st = line.styles, pos = forward ? 0 : line.text.length - 1, cur;
         for (var i = forward ? 0 : st.length - 2, e = forward ? st.length : -2; i != e; i += 2*d) {
           var text = st[i];
           if (st[i+1] != null && st[i+1] != style) {pos += d * text.length; continue;}
           for (var j = forward ? 0 : text.length - 1, te = forward ? text.length : -1; j != te; j += d, pos+=d) {
             if (pos >= from && pos < to && re.test(cur = text.charAt(j))) {
               var match = matching[cur];
               if (match.charAt(1) == ">" == forward) stack.push(cur);
               else if (stack.pop() != match.charAt(0)) return {pos: pos, match: false};
               else if (!stack.length) return {pos: pos, match: true};
             }
           }
         }
       }
-      for (var i = head.line, e = forward ? Math.min(i + 100, lines.length) : Math.max(-1, i - 100); i != e; i+=d) {
-        var line = lines[i], first = i == head.line;
+      for (var i = head.line, e = forward ? Math.min(i + 100, doc.size) : Math.max(-1, i - 100); i != e; i+=d) {
+        var line = getLine(i), first = i == head.line;
         var found = scan(line, first && forward ? pos + 1 : 0, first && !forward ? pos : line.text.length);
         if (found) break;
       }
       if (!found) found = {pos: null, match: false};
       var style = found.match ? "CodeMirror-matchingbracket" : "CodeMirror-nonmatchingbracket";
       var one = markText({line: head.line, ch: pos}, {line: head.line, ch: pos+1}, style),
-          two = found.pos != null
-            ? markText({line: i, ch: found.pos}, {line: i, ch: found.pos + 1}, style)
-            : function() {};
-      var clear = operation(function(){one(); two();});
+          two = found.pos != null && markText({line: i, ch: found.pos}, {line: i, ch: found.pos + 1}, style);
+      var clear = operation(function(){one.clear(); two && two.clear();});
       if (autoclear) setTimeout(clear, 800);
       else bracketHighlighted = clear;
     }
 
     // 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(n) {
       var minindent, minline;
       for (var search = n, lim = n - 40; search > lim; --search) {
         if (search == 0) return 0;
-        var line = lines[search-1];
+        var line = getLine(search-1);
         if (line.stateAfter) return search;
-        var indented = line.indentation();
+        var indented = line.indentation(options.tabSize);
         if (minline == null || minindent > indented) {
           minline = search - 1;
           minindent = indented;
         }
       }
       return minline;
     }
     function getStateBefore(n) {
-      var start = findStartLine(n), state = start && lines[start-1].stateAfter;
+      var start = findStartLine(n), state = start && getLine(start-1).stateAfter;
       if (!state) state = startState(mode);
       else state = copyState(mode, state);
-      for (var i = start; i < n; ++i) {
-        var line = lines[i];
-        line.highlight(mode, state);
+      doc.iter(start, n, function(line) {
+        line.highlight(mode, state, options.tabSize);
         line.stateAfter = copyState(mode, state);
-      }
-      if (n < lines.length && !lines[n].stateAfter) work.push(n);
+      });
+      if (start < n) changes.push({from: start, to: n});
+      if (n < doc.size && !getLine(n).stateAfter) work.push(n);
       return state;
     }
     function highlightLines(start, end) {
       var state = getStateBefore(start);
-      for (var i = start; i < end; ++i) {
-        var line = lines[i];
-        line.highlight(mode, state);
+      doc.iter(start, end, function(line) {
+        line.highlight(mode, state, options.tabSize);
         line.stateAfter = copyState(mode, state);
-      }
+      });
     }
     function highlightWorker() {
       var end = +new Date + options.workTime;
       var foundWork = work.length;
       while (work.length) {
-        if (!lines[showingFrom].stateAfter) var task = showingFrom;
+        if (!getLine(showingFrom).stateAfter) var task = showingFrom;
         else var task = work.pop();
-        if (task >= lines.length) continue;
-        var start = findStartLine(task), state = start && lines[start-1].stateAfter;
+        if (task >= doc.size) continue;
+        var start = findStartLine(task), state = start && getLine(start-1).stateAfter;
         if (state) state = copyState(mode, state);
         else state = startState(mode);
 
-        var unchanged = 0, compare = mode.compareStates, realChange = false;
-        for (var i = start, l = lines.length; i < l; ++i) {
-          var line = lines[i], hadState = line.stateAfter;
+        var unchanged = 0, compare = mode.compareStates, realChange = false,
+            i = start, bail = false;
+        doc.iter(i, doc.size, function(line) {
+          var hadState = line.stateAfter;
           if (+new Date > end) {
             work.push(i);
             startWorker(options.workDelay);
             if (realChange) changes.push({from: task, to: i + 1});
-            return;
+            return (bail = true);
           }
-          var changed = line.highlight(mode, state);
+          var changed = line.highlight(mode, state, options.tabSize);
           if (changed) realChange = true;
           line.stateAfter = copyState(mode, state);
           if (compare) {
-            if (hadState && compare(hadState, state)) break;
+            if (hadState && compare(hadState, state)) return true;
           } else {
             if (changed !== false || !hadState) unchanged = 0;
-            else if (++unchanged > 3) break;
-          }
+            else if (++unchanged > 3 && (!mode.indent || mode.indent(hadState, "") == mode.indent(state, "")))
+              return true;
         }
+          ++i;
+        });
+        if (bail) return;
         if (realChange) changes.push({from: task, to: i + 1});
       }
       if (foundWork && options.onHighlightComplete)
         options.onHighlightComplete(instance);
     }
     function startWorker(time) {
       if (!work.length) return;
       highlight.set(time, operation(highlightWorker));
     }
 
     // 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() {
-      updateInput = null; changes = []; textChanged = selectionChanged = false;
+      updateInput = userSelChange = textChanged = null;
+      changes = []; selectionChanged = false; callbacks = [];
     }
     function endOperation() {
-      var reScroll = false;
+      var reScroll = false, updated;
       if (selectionChanged) reScroll = !scrollCursorIntoView();
-      if (changes.length) updateDisplay(changes);
+      if (changes.length) updated = updateDisplay(changes, true);
       else {
         if (selectionChanged) updateCursor();
         if (gutterDirty) updateGutter();
       }
       if (reScroll) scrollCursorIntoView();
       if (selectionChanged) {scrollEditorIntoView(); restartBlink();}
 
-      // updateInput can be set to a boolean value to force/prevent an
-      // update.
       if (focused && !leaveInputAlone &&
           (updateInput === true || (updateInput !== false && selectionChanged)))
-        prepareInput();
+        resetInput(userSelChange);
 
       if (selectionChanged && options.matchBrackets)
         setTimeout(operation(function() {
           if (bracketHighlighted) {bracketHighlighted(); bracketHighlighted = null;}
-          matchBrackets(false);
+          if (posEq(sel.from, sel.to)) matchBrackets(false);
         }), 20);
-      var tc = textChanged; // textChanged can be reset by cursoractivity callback
+      var tc = textChanged, cbs = callbacks; // these can be reset by callbacks
       if (selectionChanged && options.onCursorActivity)
         options.onCursorActivity(instance);
       if (tc && options.onChange && instance)
         options.onChange(instance, tc);
+      for (var i = 0; i < cbs.length; ++i) cbs[i](instance);
+      if (updated && options.onUpdate) options.onUpdate(instance);
     }
     var nestedOperation = 0;
     function operation(f) {
       return function() {
         if (!nestedOperation++) startOperation();
         try {var result = f.apply(this, arguments);}
         finally {if (!--nestedOperation) endOperation();}
         return result;
       };
     }
 
-    function SearchCursor(query, pos, caseFold) {
-      this.atOccurrence = false;
-      if (caseFold == null) caseFold = typeof query == "string" && query == query.toLowerCase();
-
-      if (pos && typeof pos == "object") pos = clipPos(pos);
-      else pos = {line: 0, ch: 0};
-      this.pos = {from: pos, to: pos};
-
-      // The matches method is filled in based on the type of query.
-      // It takes a position and a direction, and returns an object
-      // describing the next occurrence of the query, or null if no
-      // more matches were found.
-      if (typeof query != "string") // Regexp match
-        this.matches = function(reverse, pos) {
-          if (reverse) {
-            var line = lines[pos.line].text.slice(0, pos.ch), match = line.match(query), start = 0;
-            while (match) {
-              var ind = line.indexOf(match[0]);
-              start += ind;
-              line = line.slice(ind + 1);
-              var newmatch = line.match(query);
-              if (newmatch) match = newmatch;
-              else break;
-              start++;
-            }
-          }
-          else {
-            var line = lines[pos.line].text.slice(pos.ch), match = line.match(query),
-                start = match && pos.ch + line.indexOf(match[0]);
-          }
-          if (match)
-            return {from: {line: pos.line, ch: start},
-                    to: {line: pos.line, ch: start + match[0].length},
-                    match: match};
-        };
-      else { // String query
-        if (caseFold) query = query.toLowerCase();
-        var fold = caseFold ? function(str){return str.toLowerCase();} : function(str){return str;};
-        var target = query.split("\n");
-        // Different methods for single-line and multi-line queries
-        if (target.length == 1)
-          this.matches = function(reverse, pos) {
-            var line = fold(lines[pos.line].text), len = query.length, match;
-            if (reverse ? (pos.ch >= len && (match = line.lastIndexOf(query, pos.ch - len)) != -1)
-                        : (match = line.indexOf(query, pos.ch)) != -1)
-              return {from: {line: pos.line, ch: match},
-                      to: {line: pos.line, ch: match + len}};
-          };
-        else
-          this.matches = function(reverse, pos) {
-            var ln = pos.line, idx = (reverse ? target.length - 1 : 0), match = target[idx], line = fold(lines[ln].text);
-            var offsetA = (reverse ? line.indexOf(match) + match.length : line.lastIndexOf(match));
-            if (reverse ? offsetA >= pos.ch || offsetA != match.length
-                        : offsetA <= pos.ch || offsetA != line.length - match.length)
-              return;
-            for (;;) {
-              if (reverse ? !ln : ln == lines.length - 1) return;
-              line = fold(lines[ln += reverse ? -1 : 1].text);
-              match = target[reverse ? --idx : ++idx];
-              if (idx > 0 && idx < target.length - 1) {
-                if (line != match) return;
-                else continue;
-              }
-              var offsetB = (reverse ? line.lastIndexOf(match) : line.indexOf(match) + match.length);
-              if (reverse ? offsetB != line.length - match.length : offsetB != match.length)
-                return;
-              var start = {line: pos.line, ch: offsetA}, end = {line: ln, ch: offsetB};
-              return {from: reverse ? end : start, to: reverse ? start : end};
-            }
-          };
-      }
-    }
-
-    SearchCursor.prototype = {
-      findNext: function() {return this.find(false);},
-      findPrevious: function() {return this.find(true);},
-
-      find: function(reverse) {
-        var self = this, pos = clipPos(reverse ? this.pos.from : this.pos.to);
-        function savePosAndFail(line) {
-          var pos = {line: line, ch: 0};
-          self.pos = {from: pos, to: pos};
-          self.atOccurrence = false;
-          return false;
-        }
-
-        for (;;) {
-          if (this.pos = this.matches(reverse, pos)) {
-            this.atOccurrence = true;
-            return this.pos.match || true;
-          }
-          if (reverse) {
-            if (!pos.line) return savePosAndFail(0);
-            pos = {line: pos.line-1, ch: lines[pos.line-1].text.length};
-          }
-          else {
-            if (pos.line == lines.length - 1) return savePosAndFail(lines.length);
-            pos = {line: pos.line+1, ch: 0};
-          }
-        }
-      },
-
-      from: function() {if (this.atOccurrence) return copyPos(this.pos.from);},
-      to: function() {if (this.atOccurrence) return copyPos(this.pos.to);},
-
-      replace: function(newText) {
-        var self = this;
-        if (this.atOccurrence)
-          operation(function() {
-            self.pos.to = replaceRange(newText, self.pos.from, self.pos.to);
-          })();
-      }
-    };
-
     for (var ext in extensions)
       if (extensions.propertyIsEnumerable(ext) &&
           !instance.propertyIsEnumerable(ext))
         instance[ext] = extensions[ext];
     return instance;
   } // (end of function CodeMirror)
 
   // The default configuration options.
   CodeMirror.defaults = {
     value: "",
     mode: null,
     theme: "default",
     indentUnit: 2,
     indentWithTabs: false,
-    tabMode: "classic",
-    enterMode: "indent",
+    tabSize: 4,
+    keyMap: "default",
+    extraKeys: null,
     electricChars: true,
     onKeyEvent: null,
+    lineWrapping: false,
     lineNumbers: false,
     gutter: false,
     fixedGutter: false,
     firstLineNumber: 1,
     readOnly: false,
-    smartHome: true,
     onChange: null,
     onCursorActivity: null,
     onGutterClick: null,
     onHighlightComplete: null,
+    onUpdate: null,
     onFocus: null, onBlur: null, onScroll: null,
     matchBrackets: false,
     workTime: 100,
     workDelay: 200,
+    pollInterval: 100,
     undoDepth: 40,
     tabindex: null,
     document: window.document
   };
 
+  var mac = /Mac/.test(navigator.platform);
+  var win = /Win/.test(navigator.platform);
+
   // Known modes, by name and by MIME
   var modes = {}, mimeModes = {};
   CodeMirror.defineMode = function(name, mode) {
     if (!CodeMirror.defaults.mode && name != "null") CodeMirror.defaults.mode = name;
     modes[name] = mode;
   };
   CodeMirror.defineMIME = function(mime, spec) {
     mimeModes[mime] = spec;
   };
   CodeMirror.getMode = function(options, spec) {
     if (typeof spec == "string" && mimeModes.hasOwnProperty(spec))
       spec = mimeModes[spec];
     if (typeof spec == "string")
       var mname = spec, config = {};
     else if (spec != null)
       var mname = spec.name, config = spec;
     var mfactory = modes[mname];
     if (!mfactory) {
       if (window.console) console.warn("No mode " + mname + " found, falling back to plain text.");
       return CodeMirror.getMode(options, "text/plain");
     }
     return mfactory(options, config || {});
   };
   CodeMirror.listModes = function() {
     var list = [];
     for (var m in modes)
       if (modes.propertyIsEnumerable(m)) list.push(m);
     return list;
   };
   CodeMirror.listMIMEs = function() {
     var list = [];
     for (var m in mimeModes)
       if (mimeModes.propertyIsEnumerable(m)) list.push({mime: m, mode: mimeModes[m]});
     return list;
   };
 
-  var extensions = {};
+  var extensions = CodeMirror.extensions = {};
   CodeMirror.defineExtension = function(name, func) {
     extensions[name] = func;
   };
 
+  var commands = CodeMirror.commands = {
+    selectAll: function(cm) {cm.setSelection({line: 0, ch: 0}, {line: cm.lineCount() - 1});},
+    killLine: function(cm) {
+      var from = cm.getCursor(true), to = cm.getCursor(false), sel = !posEq(from, to);
+      if (!sel && cm.getLine(from.line).length == from.ch) cm.replaceRange("", from, {line: from.line + 1, ch: 0});
+      else cm.replaceRange("", from, sel ? to : {line: from.line});
+    },
+    deleteLine: function(cm) {var l = cm.getCursor().line; cm.replaceRange("", {line: l, ch: 0}, {line: l});},
+    undo: function(cm) {cm.undo();},
+    redo: function(cm) {cm.redo();},
+    goDocStart: function(cm) {cm.setCursor(0, 0, true);},
+    goDocEnd: function(cm) {cm.setSelection({line: cm.lineCount() - 1}, null, true);},
+    goLineStart: function(cm) {cm.setCursor(cm.getCursor().line, 0, true);},
+    goLineStartSmart: function(cm) {
+      var cur = cm.getCursor();
+      var text = cm.getLine(cur.line), firstNonWS = Math.max(0, text.search(/\S/));
+      cm.setCursor(cur.line, cur.ch <= firstNonWS && cur.ch ? 0 : firstNonWS, true);
+    },
+    goLineEnd: function(cm) {cm.setSelection({line: cm.getCursor().line}, null, true);},
+    goLineUp: function(cm) {cm.moveV(-1, "line");},
+    goLineDown: function(cm) {cm.moveV(1, "line");},
+    goPageUp: function(cm) {cm.moveV(-1, "page");},
+    goPageDown: function(cm) {cm.moveV(1, "page");},
+    goCharLeft: function(cm) {cm.moveH(-1, "char");},
+    goCharRight: function(cm) {cm.moveH(1, "char");},
+    goColumnLeft: function(cm) {cm.moveH(-1, "column");},
+    goColumnRight: function(cm) {cm.moveH(1, "column");},
+    goWordLeft: function(cm) {cm.moveH(-1, "word");},
+    goWordRight: function(cm) {cm.moveH(1, "word");},
+    delCharLeft: function(cm) {cm.deleteH(-1, "char");},
+    delCharRight: function(cm) {cm.deleteH(1, "char");},
+    delWordLeft: function(cm) {cm.deleteH(-1, "word");},
+    delWordRight: function(cm) {cm.deleteH(1, "word");},
+    indentAuto: function(cm) {cm.indentSelection("smart");},
+    indentMore: function(cm) {cm.indentSelection("add");},
+    indentLess: function(cm) {cm.indentSelection("subtract");},
+    insertTab: function(cm) {cm.replaceSelection("\t", "end");},
+    transposeChars: function(cm) {
+      var cur = cm.getCursor(), line = cm.getLine(cur.line);
+      if (cur.ch > 0 && cur.ch < line.length - 1)
+        cm.replaceRange(line.charAt(cur.ch) + line.charAt(cur.ch - 1),
+                        {line: cur.line, ch: cur.ch - 1}, {line: cur.line, ch: cur.ch + 1});
+    },
+    newlineAndIndent: function(cm) {
+      cm.replaceSelection("\n", "end");
+      cm.indentLine(cm.getCursor().line);
+    },
+    toggleOverwrite: function(cm) {cm.toggleOverwrite();}
+  };
+
+  var keyMap = CodeMirror.keyMap = {};
+  keyMap.basic = {
+    "Left": "goCharLeft", "Right": "goCharRight", "Up": "goLineUp", "Down": "goLineDown",
+    "End": "goLineEnd", "Home": "goLineStartSmart", "PageUp": "goPageUp", "PageDown": "goPageDown",
+    "Delete": "delCharRight", "Backspace": "delCharLeft", "Tab": "indentMore", "Shift-Tab": "indentLess",
+    "Enter": "newlineAndIndent", "Insert": "toggleOverwrite"
+  };
+  // Note that the save and find-related commands aren't defined by
+  // default. Unknown commands are simply ignored.
+  keyMap.pcDefault = {
+    "Ctrl-A": "selectAll", "Ctrl-D": "deleteLine", "Ctrl-Z": "undo", "Shift-Ctrl-Z": "redo", "Ctrl-Y": "redo",
+    "Ctrl-Home": "goDocStart", "Alt-Up": "goDocStart", "Ctrl-End": "goDocEnd", "Ctrl-Down": "goDocEnd",
+    "Ctrl-Left": "goWordLeft", "Ctrl-Right": "goWordRight", "Alt-Left": "goLineStart", "Alt-Right": "goLineEnd",
+    "Ctrl-Backspace": "delWordLeft", "Ctrl-Delete": "delWordRight", "Ctrl-S": "save", "Ctrl-F": "find",
+    "Ctrl-G": "findNext", "Shift-Ctrl-G": "findPrev", "Shift-Ctrl-F": "replace", "Shift-Ctrl-R": "replaceAll",
+    fallthrough: "basic"
+  };
+  keyMap.macDefault = {
+    "Cmd-A": "selectAll", "Cmd-D": "deleteLine", "Cmd-Z": "undo", "Shift-Cmd-Z": "redo", "Cmd-Y": "redo",
+    "Cmd-Up": "goDocStart", "Cmd-End": "goDocEnd", "Cmd-Down": "goDocEnd", "Alt-Left": "goWordLeft",
+    "Alt-Right": "goWordRight", "Cmd-Left": "goLineStart", "Cmd-Right": "goLineEnd", "Alt-Backspace": "delWordLeft",
+    "Ctrl-Alt-Backspace": "delWordRight", "Alt-Delete": "delWordRight", "Cmd-S": "save", "Cmd-F": "find",
+    "Cmd-G": "findNext", "Shift-Cmd-G": "findPrev", "Cmd-Alt-F": "replace", "Shift-Cmd-Alt-F": "replaceAll",
+    fallthrough: ["basic", "emacsy"]
+  };
+  keyMap["default"] = mac ? keyMap.macDefault : keyMap.pcDefault;
+  keyMap.emacsy = {
+    "Ctrl-F": "goCharRight", "Ctrl-B": "goCharLeft", "Ctrl-P": "goLineUp", "Ctrl-N": "goLineDown",
+    "Alt-F": "goWordRight", "Alt-B": "goWordLeft", "Ctrl-A": "goLineStart", "Ctrl-E": "goLineEnd",
+    "Ctrl-V": "goPageUp", "Shift-Ctrl-V": "goPageDown", "Ctrl-D": "delCharRight", "Ctrl-H": "delCharLeft",
+    "Alt-D": "delWordRight", "Alt-Backspace": "delWordLeft", "Ctrl-K": "killLine", "Ctrl-T": "transposeChars"
+  };
+
+  function lookupKey(name, extraMap, map) {
+    function lookup(name, map, ft) {
+      var found = map[name];
+      if (found != null) return found;
+      if (ft == null) ft = map.fallthrough;
+      if (ft == null) return map.catchall;
+      if (typeof ft == "string") return lookup(name, keyMap[ft]);
+      for (var i = 0, e = ft.length; i < e; ++i) {
+        found = lookup(name, keyMap[ft[i]]);
+        if (found != null) return found;
+      }
+      return null;
+    }
+    return extraMap ? lookup(name, extraMap, map) : lookup(name, keyMap[map]);
+  }
+  function isModifierKey(event) {
+    var name = keyNames[event.keyCode];
+    return name == "Ctrl" || name == "Alt" || name == "Shift" || name == "Mod";
+  }
+
   CodeMirror.fromTextArea = function(textarea, options) {
     if (!options) options = {};
     options.value = textarea.value;
     if (!options.tabindex && textarea.tabindex)
       options.tabindex = textarea.tabindex;
 
     function save() {textarea.value = instance.getValue();}
     if (textarea.form) {
       // Deplorable hack to make the submit method do the right thing.
       var rmSubmit = connect(textarea.form, "submit", save, true);
       if (typeof textarea.form.submit == "function") {
         var realSubmit = textarea.form.submit;
         function wrappedSubmit() {
           save();
           textarea.form.submit = realSubmit;
           textarea.form.submit();
           textarea.form.submit = wrappedSubmit;
         }
         textarea.form.submit = wrappedSubmit;
       }
     }
 
     textarea.style.display = "none";
     var instance = CodeMirror(function(node) {
       textarea.parentNode.insertBefore(node, textarea.nextSibling);
     }, options);
     instance.save = save;
+    instance.getTextArea = function() { return textarea; };
     instance.toTextArea = function() {
       save();
       textarea.parentNode.removeChild(instance.getWrapperElement());
       textarea.style.display = "";
       if (textarea.form) {
         rmSubmit();
         if (typeof textarea.form.submit == "function")
           textarea.form.submit = realSubmit;
       }
     };
     return instance;
   };
 
   // Utility functions for working with state. Exported because modes
   // sometimes need to do this.
   function copyState(mode, state) {
     if (state === true) return state;
     if (mode.copyState) return mode.copyState(state);
     var nstate = {};
     for (var n in state) {
       var val = state[n];
       if (val instanceof Array) val = val.concat([]);
       nstate[n] = val;
     }
     return nstate;
   }
-  CodeMirror.startState = startState;
+  CodeMirror.copyState = copyState;
   function startState(mode, a1, a2) {
     return mode.startState ? mode.startState(a1, a2) : true;
   }
-  CodeMirror.copyState = copyState;
+  CodeMirror.startState = startState;
 
   // The character stream used by a mode's parser.
-  function StringStream(string) {
+  function StringStream(string, tabSize) {
     this.pos = this.start = 0;
     this.string = string;
+    this.tabSize = tabSize || 8;
   }
   StringStream.prototype = {
     eol: function() {return this.pos >= this.string.length;},
     sol: function() {return this.pos == 0;},
     peek: function() {return this.string.charAt(this.pos);},
     next: function() {
       if (this.pos < this.string.length)
         return this.string.charAt(this.pos++);
     },
     eat: function(match) {
       var ch = this.string.charAt(this.pos);
       if (typeof match == "string") var ok = ch == match;
       else var ok = ch && (match.test ? match.test(ch) : match(ch));
       if (ok) {++this.pos; return ch;}
     },
     eatWhile: function(match) {
       var start = this.pos;
       while (this.eat(match)){}
       return this.pos > start;
     },
     eatSpace: function() {
       var start = this.pos;
       while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) ++this.pos;
       return this.pos > start;
     },
     skipToEnd: function() {this.pos = this.string.length;},
     skipTo: function(ch) {
       var found = this.string.indexOf(ch, this.pos);
       if (found > -1) {this.pos = found; return true;}
     },
     backUp: function(n) {this.pos -= n;},
-    column: function() {return countColumn(this.string, this.start);},
-    indentation: function() {return countColumn(this.string);},
+    column: function() {return countColumn(this.string, this.start, this.tabSize);},
+    indentation: function() {return countColumn(this.string, null, this.tabSize);},
     match: function(pattern, consume, caseInsensitive) {
       if (typeof pattern == "string") {
         function cased(str) {return caseInsensitive ? str.toLowerCase() : str;}
         if (cased(this.string).indexOf(cased(pattern), this.pos) == this.pos) {
           if (consume !== false) this.pos += pattern.length;
           return true;
         }
       }
       else {
         var match = this.string.slice(this.pos).match(pattern);
         if (match && consume !== false) this.pos += match[0].length;
         return match;
       }
     },
     current: function(){return this.string.slice(this.start, this.pos);}
   };
   CodeMirror.StringStream = StringStream;
 
+  function MarkedText(from, to, className, set) {
+    this.from = from; this.to = to; this.style = className; this.set = set;
+  }
+  MarkedText.prototype = {
+    attach: function(line) { this.set.push(line); },
+    detach: function(line) {
+      var ix = indexOf(this.set, line);
+      if (ix > -1) this.set.splice(ix, 1);
+    },
+    split: function(pos, lenBefore) {
+      if (this.to <= pos && this.to != null) return null;
+      var from = this.from < pos || this.from == null ? null : this.from - pos + lenBefore;
+      var to = this.to == null ? null : this.to - pos + lenBefore;
+      return new MarkedText(from, to, this.style, this.set);
+    },
+    dup: function() { return new MarkedText(null, null, this.style, this.set); },
+    clipTo: function(fromOpen, from, toOpen, to, diff) {
+      if (this.from != null && this.from >= from)
+        this.from = Math.max(to, this.from) + diff;
+      if (this.to != null && this.to > from)
+        this.to = to < this.to ? this.to + diff : from;
+      if (fromOpen && to > this.from && (to < this.to || this.to == null))
+        this.from = null;
+      if (toOpen && (from < this.to || this.to == null) && (from > this.from || this.from == null))
+        this.to = null;
+    },
+    isDead: function() { return this.from != null && this.to != null && this.from >= this.to; },
+    sameSet: function(x) { return this.set == x.set; }
+  };
+
+  function Bookmark(pos) {
+    this.from = pos; this.to = pos; this.line = null;
+  }
+  Bookmark.prototype = {
+    attach: function(line) { this.line = line; },
+    detach: function(line) { if (this.line == line) this.line = null; },
+    split: function(pos, lenBefore) {
+      if (pos < this.from) {
+        this.from = this.to = (this.from - pos) + lenBefore;
+        return this;
+      }
+    },
+    isDead: function() { return this.from > this.to; },
+    clipTo: function(fromOpen, from, toOpen, to, diff) {
+      if ((fromOpen || from < this.from) && (toOpen || to > this.to)) {
+        this.from = 0; this.to = -1;
+      } else if (this.from > from) {
+        this.from = this.to = Math.max(to, this.from) + diff;
+      }
+    },
+    sameSet: function(x) { return false; },
+    find: function() {
+      if (!this.line || !this.line.parent) return null;
+      return {line: lineNo(this.line), ch: this.from};
+    },
+    clear: function() {
+      if (this.line) {
+        var found = indexOf(this.line.marked, this);
+        if (found != -1) this.line.marked.splice(found, 1);
+        this.line = null;
+      }
+    }
+  };
+
   // Line objects. These hold state related to a line, including
   // highlighting info (the styles array).
   function Line(text, styles) {
     this.styles = styles || [text, null];
-    this.stateAfter = null;
     this.text = text;
-    this.marked = this.gutterMarker = this.className = null;
+    this.height = 1;
+    this.marked = this.gutterMarker = this.className = this.handlers = null;
+    this.stateAfter = this.parent = this.hidden = null;
+  }
+  Line.inheritMarks = function(text, orig) {
+    var ln = new Line(text), mk = orig && orig.marked;
+    if (mk) {
+      for (var i = 0; i < mk.length; ++i) {
+        if (mk[i].to == null && mk[i].style) {
+          var newmk = ln.marked || (ln.marked = []), mark = mk[i];
+          var nmark = mark.dup(); newmk.push(nmark); nmark.attach(ln);
+        }
+      }
+    }
+    return ln;
   }
   Line.prototype = {
     // Replace a piece of a line, keeping the styles around it intact.
-    replace: function(from, to, text) {
-      var st = [], mk = this.marked;
+    replace: function(from, to_, text) {
+      var st = [], mk = this.marked, to = to_ == null ? this.text.length : to_;
       copyStyles(0, from, this.styles, st);
       if (text) st.push(text, null);
       copyStyles(to, this.text.length, this.styles, st);
       this.styles = st;
       this.text = this.text.slice(0, from) + text + this.text.slice(to);
       this.stateAfter = null;
       if (mk) {
-        var diff = text.length - (to - from), end = this.text.length;
-        function fix(n) {return n <= Math.min(to, to + diff) ? n : n + diff;}
-        for (var i = 0; i < mk.length; ++i) {
-          var mark = mk[i], del = false;
-          if (mark.from >= end) del = true;
-          else {mark.from = fix(mark.from); if (mark.to != null) mark.to = fix(mark.to);}
-          if (del || mark.from >= mark.to) {mk.splice(i, 1); i--;}
+        var diff = text.length - (to - from);
+        for (var i = 0, mark = mk[i]; i < mk.length; ++i) {
+          mark.clipTo(from == null, from || 0, to_ == null, to, diff);
+          if (mark.isDead()) {mark.detach(this); mk.splice(i--, 1);}
         }
       }
     },
-    // Split a line in two, again keeping styles intact.
+    // Split a part off a line, keeping styles and markers intact.
     split: function(pos, textBefore) {
-      var st = [textBefore, null];
+      var st = [textBefore, null], mk = this.marked;
       copyStyles(pos, this.text.length, this.styles, st);
-      return new Line(textBefore + this.text.slice(pos), st);
+      var taken = new Line(textBefore + this.text.slice(pos), st);
+      if (mk) {
+        for (var i = 0; i < mk.length; ++i) {
+          var mark = mk[i];
+          var newmark = mark.split(pos, textBefore.length);
+          if (newmark) {
+            if (!taken.marked) taken.marked = [];
+            taken.marked.push(newmark); newmark.attach(taken);
+          }
+        }
+      }
+      return taken;
     },
-    addMark: function(from, to, style) {
-      var mk = this.marked, mark = {from: from, to: to, style: style};
-      if (this.marked == null) this.marked = [];
-      this.marked.push(mark);
-      this.marked.sort(function(a, b){return a.from - b.from;});
-      return mark;
+    append: function(line) {
+      var mylen = this.text.length, mk = line.marked, mymk = this.marked;
+      this.text += line.text;
+      copyStyles(0, line.text.length, line.styles, this.styles);
+      if (mymk) {
+        for (var i = 0; i < mymk.length; ++i)
+          if (mymk[i].to == null) mymk[i].to = mylen;
+      }
+      if (mk && mk.length) {
+        if (!mymk) this.marked = mymk = [];
+        outer: for (var i = 0; i < mk.length; ++i) {
+          var mark = mk[i];
+          if (!mark.from) {
+            for (var j = 0; j < mymk.length; ++j) {
+              var mymark = mymk[j];
+              if (mymark.to == mylen && mymark.sameSet(mark)) {
+                mymark.to = mark.to == null ? null : mark.to + mylen;
+                if (mymark.isDead()) {
+                  mymark.detach(this);
+                  mk.splice(i--, 1);
+                }
+                continue outer;
+              }
+            }
+          }
+          mymk.push(mark);
+          mark.attach(this);
+          mark.from += mylen;
+          if (mark.to != null) mark.to += mylen;
+        }
+      }
     },
-    removeMark: function(mark) {
+    fixMarkEnds: function(other) {
+      var mk = this.marked, omk = other.marked;
+      if (!mk) return;
+      for (var i = 0; i < mk.length; ++i) {
+        var mark = mk[i], close = mark.to == null;
+        if (close && omk) {
+          for (var j = 0; j < omk.length; ++j)
+            if (omk[j].sameSet(mark)) {close = false; break;}
+        }
+        if (close) mark.to = this.text.length;
+      }
+    },
+    fixMarkStarts: function() {
       var mk = this.marked;
       if (!mk) return;
       for (var i = 0; i < mk.length; ++i)
-        if (mk[i] == mark) {mk.splice(i, 1); break;}
+        if (mk[i].from == null) mk[i].from = 0;
+    },
+    addMark: function(mark) {
+      mark.attach(this);
+      if (this.marked == null) this.marked = [];
+      this.marked.push(mark);
+      this.marked.sort(function(a, b){return (a.from || 0) - (b.from || 0);});
     },
     // Run the given mode's parser over a line, update the styles
     // array, which contains alternating fragments of text and CSS
     // classes.
-    highlight: function(mode, state) {
-      var stream = new StringStream(this.text), st = this.styles, pos = 0;
+    highlight: function(mode, state, tabSize) {
+      var stream = new StringStream(this.text, tabSize), st = this.styles, pos = 0;
       var changed = false, curWord = st[0], prevWord;
       if (this.text == "" && mode.blankLine) mode.blankLine(state);
       while (!stream.eol()) {
         var style = mode.token(stream, state);
         var substr = this.text.slice(stream.start, stream.pos);
         stream.start = stream.pos;
         if (pos && st[pos-1] == style)
           st[pos-2] += substr;
         else if (substr) {
           if (!changed && (st[pos+1] != style || (pos && st[pos-2] != prevWord))) changed = true;
           st[pos++] = substr; st[pos++] = style;
           prevWord = curWord; curWord = st[pos];
         }
         // Give up when line is ridiculously long
         if (stream.pos > 5000) {
           st[pos++] = this.text.slice(stream.pos); st[pos++] = null;
           break;
         }
       }
       if (st.length != pos) {st.length = pos; changed = true;}
       if (pos && st[pos-2] != prevWord) changed = true;
       // Short lines with simple highlights return null, and are
       // counted as changed by the driver because they are likely to
       // highlight the same way in various contexts.
       return changed || (st.length < 5 && this.text.length < 10 ? null : false);
     },
     // Fetch the parser token for a given character. Useful for hacks
     // that want to inspect the mode state (say, for completion).
     getTokenAt: function(mode, state, ch) {
       var txt = this.text, stream = new StringStream(txt);
       while (stream.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,
               state: state};
     },
-    indentation: function() {return countColumn(this.text);},
+    indentation: function(tabSize) {return countColumn(this.text, null, tabSize);},
     // Produces an HTML fragment for the line, taking selection,
     // marking, and highlighting into account.
-    getHTML: function(sfrom, sto, includePre, endAt) {
-      var html = [];
+    getHTML: function(sfrom, sto, includePre, tabText, endAt) {
+      var html = [], first = true;
       if (includePre)
         html.push(this.className ? '<pre class="' + this.className + '">': "<pre>");
       function span(text, style) {
         if (!text) return;
-        if (style) html.push('<span class="', style, '">', htmlEscape(text), "</span>");
-        else html.push(htmlEscape(text));
+        // Work around a bug where, in some compat modes, IE ignores leading spaces
+        if (first && ie && text.charAt(0) == " ") text = "\u00a0" + text.slice(1);
+        first = false;
+        if (style) html.push('<span class="', style, '">', htmlEscape(text).replace(/\t/g, tabText), "</span>");
+        else html.push(htmlEscape(text).replace(/\t/g, tabText));
       }
       var st = this.styles, allText = this.text, marked = this.marked;
       if (sfrom == sto) sfrom = null;
       var len = allText.length;
       if (endAt != null) len = Math.min(endAt, len);
 
       if (!allText && endAt == null)
         span(" ", sfrom != null && sto == null ? "CodeMirror-selected" : null);
       else if (!marked && sfrom == null)
         for (var i = 0, ch = 0; ch < len; i+=2) {
-          var str = st[i], l = str.length;
+          var str = st[i], style = st[i+1], l = str.length;
           if (ch + l > len) str = str.slice(0, len - ch);
           ch += l;
-          span(str, "cm-" + st[i+1]);
+          span(str, style && "cm-" + style);
         }
       else {
         var pos = 0, i = 0, text = "", style, sg = 0;
         var markpos = -1, mark = null;
         function nextMark() {
           if (marked) {
             markpos += 1;
             mark = (markpos < marked.length) ? marked[markpos] : null;
           }
         }
         nextMark();
         while (pos < len) {
           var upto = len;
           var extraStyle = "";
           if (sfrom != null) {
             if (sfrom > pos) upto = sfrom;
             else if (sto == null || sto > pos) {
               extraStyle = " CodeMirror-selected";
               if (sto != null) upto = Math.min(upto, sto);
             }
           }
           while (mark && mark.to != null && mark.to <= pos) nextMark();
           if (mark) {
             if (mark.from > pos) upto = Math.min(upto, mark.from);
             else {
               extraStyle += " " + mark.style;
               if (mark.to != null) upto = Math.min(upto, mark.to);
             }
           }
           for (;;) {
             var end = pos + text.length;
             var appliedStyle = style;
             if (extraStyle) appliedStyle = style ? style + extraStyle : extraStyle;
             span(end > upto ? text.slice(0, upto - pos) : text, appliedStyle);
             if (end >= upto) {text = text.slice(upto - pos); pos = upto; break;}
             pos = end;
             text = st[i++]; style = "cm-" + st[i++];
           }
         }
         if (sfrom != null && sto == null) span(" ", "CodeMirror-selected");
       }
       if (includePre) html.push("</pre>");
       return html.join("");
+    },
+    cleanUp: function() {
+      this.parent = null;
+      if (this.marked)
+        for (var i = 0, e = this.marked.length; i < e; ++i) this.marked[i].detach(this);
     }
   };
   // Utility used by replace and split above
   function copyStyles(from, to, source, dest) {
     for (var i = 0, pos = 0, state = 0; pos < to; i+=2) {
       var part = source[i], end = pos + part.length;
       if (state == 0) {
         if (end > from) dest.push(part.slice(from - pos, Math.min(part.length, to - pos)), source[i+1]);
         if (end >= from) state = 1;
       }
       else if (state == 1) {
         if (end > to) dest.push(part.slice(0, to - pos), source[i+1]);
         else dest.push(part, source[i+1]);
       }
       pos = end;
     }
   }
 
+  // Data structure that holds the sequence of lines.
+  function LeafChunk(lines) {
+    this.lines = lines;
+    this.parent = null;
+    for (var i = 0, e = lines.length, height = 0; i < e; ++i) {
+      lines[i].parent = this;
+      height += lines[i].height;
+    }
+    this.height = height;
+  }
+  LeafChunk.prototype = {
+    chunkSize: function() { return this.lines.length; },
+    remove: function(at, n, callbacks) {
+      for (var i = at, e = at + n; i < e; ++i) {
+        var line = this.lines[i];
+        this.height -= line.height;
+        line.cleanUp();
+        if (line.handlers)
+          for (var j = 0; j < line.handlers.length; ++j) callbacks.push(line.handlers[j]);
+      }
+      this.lines.splice(at, n);
+    },
+    collapse: function(lines) {
+      lines.splice.apply(lines, [lines.length, 0].concat(this.lines));
+    },
+    insertHeight: function(at, lines, height) {
+      this.height += height;
+      this.lines.splice.apply(this.lines, [at, 0].concat(lines));
+      for (var i = 0, e = lines.length; i < e; ++i) lines[i].parent = this;
+    },
+    iterN: function(at, n, op) {
+      for (var e = at + n; at < e; ++at)
+        if (op(this.lines[at])) return true;
+    }
+  };
+  function BranchChunk(children) {
+    this.children = children;
+    var size = 0, height = 0;
+    for (var i = 0, e = children.length; i < e; ++i) {
+      var ch = children[i];
+      size += ch.chunkSize(); height += ch.height;
+      ch.parent = this;
+    }
+    this.size = size;
+    this.height = height;
+    this.parent = null;
+  }
+  BranchChunk.prototype = {
+    chunkSize: function() { return this.size; },
+    remove: function(at, n, callbacks) {
+      this.size -= n;
+      for (var i = 0; i < this.children.length; ++i) {
+        var child = this.children[i], sz = child.chunkSize();
+        if (at < sz) {
+          var rm = Math.min(n, sz - at), oldHeight = child.height;
+          child.remove(at, rm, callbacks);
+          this.height -= oldHeight - child.height;
+          if (sz == rm) { this.children.splice(i--, 1); child.parent = null; }
+          if ((n -= rm) == 0) break;
+          at = 0;
+        } else at -= sz;
+      }
+      if (this.size - n < 25) {
+        var lines = [];
+        this.collapse(lines);
+        this.children = [new LeafChunk(lines)];
+      }
+    },
+    collapse: function(lines) {
+      for (var i = 0, e = this.children.length; i < e; ++i) this.children[i].collapse(lines);
+    },
+    insert: function(at, lines) {
+      var height = 0;
+      for (var i = 0, e = lines.length; i < e; ++i) height += lines[i].height;
+      this.insertHeight(at, lines, height);
+    },
+    insertHeight: function(at, lines, height) {
+      this.size += lines.length;
+      this.height += height;
+      for (var i = 0, e = this.children.length; i < e; ++i) {
+        var child = this.children[i], sz = child.chunkSize();
+        if (at <= sz) {
+          child.insertHeight(at, lines, height);
+          if (child.lines && child.lines.length > 50) {
+            while (child.lines.length > 50) {
+              var spilled = child.lines.splice(child.lines.length - 25, 25);
+              var newleaf = new LeafChunk(spilled);
+              child.height -= newleaf.height;
+              this.children.splice(i + 1, 0, newleaf);
+              newleaf.parent = this;
+            }
+            this.maybeSpill();
+          }
+          break;
+        }
+        at -= sz;
+      }
+    },
+    maybeSpill: function() {
+      if (this.children.length <= 10) return;
+      var me = this;
+      do {
+        var spilled = me.children.splice(me.children.length - 5, 5);
+        var sibling = new BranchChunk(spilled);
+        if (!me.parent) { // Become the parent node
+          var copy = new BranchChunk(me.children);
+          copy.parent = me;
+          me.children = [copy, sibling];
+          me = copy;
+        } else {
+          me.size -= sibling.size;
+          me.height -= sibling.height;
+          var myIndex = indexOf(me.parent.children, me);
+          me.parent.children.splice(myIndex + 1, 0, sibling);
+        }
+        sibling.parent = me.parent;
+      } while (me.children.length > 10);
+      me.parent.maybeSpill();
+    },
+    iter: function(from, to, op) { this.iterN(from, to - from, op); },
+    iterN: function(at, n, op) {
+      for (var i = 0, e = this.children.length; i < e; ++i) {
+        var child = this.children[i], sz = child.chunkSize();
+        if (at < sz) {
+          var used = Math.min(n, sz - at);
+          if (child.iterN(at, used, op)) return true;
+          if ((n -= used) == 0) break;
+          at = 0;
+        } else at -= sz;
+      }
+    }
+  };
+
+  function getLineAt(chunk, n) {
+    while (!chunk.lines) {
+      for (var i = 0;; ++i) {
+        var child = chunk.children[i], sz = child.chunkSize();
+        if (n < sz) { chunk = child; break; }
+        n -= sz;
+      }
+    }
+    return chunk.lines[n];
+  }
+  function lineNo(line) {
+    if (line.parent == null) return null;
+    var cur = line.parent, no = indexOf(cur.lines, line);
+    for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) {
+      for (var i = 0, e = chunk.children.length; ; ++i) {
+        if (chunk.children[i] == cur) break;
+        no += chunk.children[i].chunkSize();
+      }
+    }
+    return no;
+  }
+  function lineAtHeight(chunk, h) {
+    var n = 0;
+    outer: do {
+      for (var i = 0, e = chunk.children.length; i < e; ++i) {
+        var child = chunk.children[i], ch = child.height;
+        if (h < ch) { chunk = child; continue outer; }
+        h -= ch;
+        n += child.chunkSize();
+      }
+      return n;
+    } while (!chunk.lines);
+    for (var i = 0, e = chunk.lines.length; i < e; ++i) {
+      var line = chunk.lines[i], lh = line.height;
+      if (h < lh) break;
+      h -= lh;
+    }
+    return n + i;
+  }
+  function heightAtLine(chunk, n) {
+    var h = 0;
+    outer: do {
+      for (var i = 0, e = chunk.children.length; i < e; ++i) {
+        var child = chunk.children[i], sz = child.chunkSize();
+        if (n < sz) { chunk = child; continue outer; }
+        n -= sz;
+        h += child.height;
+      }
+      return h;
+    } while (!chunk.lines);
+    for (var i = 0; i < n; ++i) h += chunk.lines[i].height;
+    return h;
+  }
+
   // The history object 'chunks' changes that are made close together
   // and at almost the same time into bigger undoable units.
   function History() {
     this.time = 0;
     this.done = []; this.undone = [];
   }
   History.prototype = {
     addChange: function(start, added, old) {
       this.undone.length = 0;
       var time = +new Date, last = this.done[this.done.length - 1];
       if (time - this.time > 400 || !last ||
           last.start > start + added || last.start + last.added < start - last.added + last.old.length)
         this.done.push({start: start, added: added, old: old});
       else {
         var oldoff = 0;
         if (start < last.start) {
           for (var i = last.start - start - 1; i >= 0; --i)
             last.old.unshift(old[i]);
           last.added += last.start - start;
           last.start = start;
         }
         else if (last.start < start) {
           oldoff = start - last.start;
           added += oldoff;
         }
         for (var i = last.added - oldoff, e = old.length; i < e; ++i)
           last.old.push(old[i]);
         if (last.added < added) last.added = added;
       }
       this.time = time;
     }
   };
 
   function stopMethod() {e_stop(this);}
   // Ensure an event has a stop method.
   function addStop(event) {
     if (!event.stop) event.stop = stopMethod;
     return event;
   }
 
   function e_preventDefault(e) {
     if (e.preventDefault) e.preventDefault();
     else e.returnValue = false;
   }
   function e_stopPropagation(e) {
     if (e.stopPropagation) e.stopPropagation();
     else e.cancelBubble = true;
   }
   function e_stop(e) {e_preventDefault(e); e_stopPropagation(e);}
+  CodeMirror.e_stop = e_stop;
+  CodeMirror.e_preventDefault = e_preventDefault;
+  CodeMirror.e_stopPropagation = e_stopPropagation;
+
   function e_target(e) {return e.target || e.srcElement;}
   function e_button(e) {
     if (e.which) return e.which;
     else if (e.button & 1) return 1;
     else if (e.button & 2) return 3;
     else if (e.button & 4) return 2;
   }
 
   // Event handler registration. If disconnect is true, it'll return a
   // function that unregisters the handler.
   function connect(node, type, handler, disconnect) {
-    function wrapHandler(event) {handler(event || window.event);}
     if (typeof node.addEventListener == "function") {
-      node.addEventListener(type, wrapHandler, false);
-      if (disconnect) return function() {node.removeEventListener(type, wrapHandler, false);};
+      node.addEventListener(type, handler, false);
+      if (disconnect) return function() {node.removeEventListener(type, handler, false);};
     }
     else {
+      var wrapHandler = function(event) {handler(event || window.event);};
       node.attachEvent("on" + type, wrapHandler);
       if (disconnect) return function() {node.detachEvent("on" + type, wrapHandler);};
     }
   }
+  CodeMirror.connect = connect;
 
   function Delayed() {this.id = null;}
   Delayed.prototype = {set: function(ms, f) {clearTimeout(this.id); this.id = setTimeout(f, ms);}};
 
-  // Some IE versions don't preserve whitespace when setting the
-  // innerHTML of a PRE tag.
-  var badInnerHTML = (function() {
-    var pre = document.createElement("pre");
-    pre.innerHTML = " "; return !pre.innerHTML;
-  })();
-
   // Detect drag-and-drop
-  var dragAndDrop = (function() {
+  var dragAndDrop = function() {
     // IE8 has ondragstart and ondrop properties, but doesn't seem to
     // actually support ondragstart the way it's supposed to work.
     if (/MSIE [1-8]\b/.test(navigator.userAgent)) return false;
     var div = document.createElement('div');
-    return "ondragstart" in div && "ondrop" in div;
-  })();
+    return "draggable" in div;
+  }();
 
   var gecko = /gecko\/\d{7}/i.test(navigator.userAgent);
   var ie = /MSIE \d/.test(navigator.userAgent);
-  var safari = /Apple Computer/.test(navigator.vendor);
+  var webkit = /WebKit\//.test(navigator.userAgent);
 
   var lineSep = "\n";
   // Feature-detect whether newlines in textareas are converted to \r\n
   (function () {
     var te = document.createElement("textarea");
     te.value = "foo\nbar";
     if (te.value.indexOf("\r") > -1) lineSep = "\r\n";
   }());
 
-  var tabSize = 8;
-  var mac = /Mac/.test(navigator.platform);
-  var movementKeys = {};
-  for (var i = 35; i <= 40; ++i)
-    movementKeys[i] = movementKeys["c" + i] = true;
-
   // Counts the column offset in a string, taking tabs into account.
   // Used mostly to find indentation.
-  function countColumn(string, end) {
+  function countColumn(string, end, tabSize) {
     if (end == null) {
       end = string.search(/[^\s\u00a0]/);
       if (end == -1) end = string.length;
     }
     for (var i = 0, n = 0; i < end; ++i) {
       if (string.charAt(i) == "\t") n += tabSize - (n % tabSize);
       else ++n;
     }
     return n;
   }
 
   function computedStyle(elt) {
     if (elt.currentStyle) return elt.currentStyle;
     return window.getComputedStyle(elt, null);
   }
+
   // Find the position of an element by following the offsetParent chain.
   // If screen==true, it returns screen (rather than page) coordinates.
   function eltOffset(node, screen) {
-    var doc = node.ownerDocument.body;
-    var x = 0, y = 0, skipDoc = false;
+    var bod = node.ownerDocument.body;
+    var x = 0, y = 0, skipBody = false;
     for (var n = node; n; n = n.offsetParent) {
-      x += n.offsetLeft; y += n.offsetTop;
+      var ol = n.offsetLeft, ot = n.offsetTop;
+      // Firefox reports weird inverted offsets when the body has a border.
+      if (n == bod) { x += Math.abs(ol); y += Math.abs(ot); }
+      else { x += ol, y += ot; }
       if (screen && computedStyle(n).position == "fixed")
-        skipDoc = true;
+        skipBody = true;
     }
-    var e = screen && !skipDoc ? null : doc;
+    var e = screen && !skipBody ? null : bod;
     for (var n = node.parentNode; n != e; n = n.parentNode)
       if (n.scrollLeft != null) { x -= n.scrollLeft; y -= n.scrollTop;}
     return {left: x, top: y};
   }
+  // Use the faster and saner getBoundingClientRect method when possible.
+  if (document.documentElement.getBoundingClientRect != null) eltOffset = function(node, screen) {
+    // Take the parts of bounding client rect that we are interested in so we are able to edit if need be,
+    // since the returned value cannot be changed externally (they are kept in sync as the element moves within the page)
+    try { var box = node.getBoundingClientRect(); box = { top: box.top, left: box.left }; }
+    catch(e) { box = {top: 0, left: 0}; }
+    if (!screen) {
+      // Get the toplevel scroll, working around browser differences.
+      if (window.pageYOffset == null) {
+        var t = document.documentElement || document.body.parentNode;
+        if (t.scrollTop == null) t = document.body;
+        box.top += t.scrollTop; box.left += t.scrollLeft;
+      } else {
+        box.top += window.pageYOffset; box.left += window.pageXOffset;
+      }
+    }
+    return box;
+  };
+
   // Get a node's text content.
   function eltText(node) {
     return node.textContent || node.innerText || node.nodeValue || "";
   }
 
   // Operations on {line, ch} objects.
   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};}
 
-  var escapeElement = document.createElement("div");
+  var escapeElement = document.createElement("pre");
   function htmlEscape(str) {
-    escapeElement.innerText = escapeElement.textContent = str;
+    escapeElement.textContent = str;
     return escapeElement.innerHTML;
   }
+  // Recent (late 2011) Opera betas insert bogus newlines at the start
+  // of the textContent, so we strip those.
+  if (htmlEscape("a") == "\na")
+    htmlEscape = function(str) {
+      escapeElement.textContent = str;
+      return escapeElement.innerHTML.slice(1);
+    };
+  // Some IEs don't preserve tabs through innerHTML
+  else if (htmlEscape("\t") != "\t")
+    htmlEscape = function(str) {
+      escapeElement.innerHTML = "";
+      escapeElement.appendChild(document.createTextNode(str));
+      return escapeElement.innerHTML;
+    };
   CodeMirror.htmlEscape = htmlEscape;
 
   // Used to position the cursor after an undo/redo by finding the
   // last edited character.
   function editEnd(from, to) {
     if (!to) return from ? from.length : 0;
     if (!from) return to.length;
     for (var i = from.length, j = to.length; i >= 0 && j >= 0; --i, --j)
       if (from.charAt(i) != to.charAt(j)) break;
     return j + 1;
   }
 
   function indexOf(collection, elt) {
     if (collection.indexOf) return collection.indexOf(elt);
     for (var i = 0, e = collection.length; i < e; ++i)
       if (collection[i] == elt) return i;
     return -1;
   }
+  function isWordChar(ch) {
+    return /\w/.test(ch) || ch.toUpperCase() != ch.toLowerCase();
+  }
 
   // See if "".split is the broken IE version, if so, provide an
   // alternative way to split lines.
-  var splitLines, selRange, setSelRange;
-  if ("\n\nb".split(/\n/).length != 3)
-    splitLines = function(string) {
+  var splitLines = "\n\nb".split(/\n/).length != 3 ? function(string) {
       var pos = 0, nl, result = [];
       while ((nl = string.indexOf("\n", pos)) > -1) {
         result.push(string.slice(pos, string.charAt(nl-1) == "\r" ? nl - 1 : nl));
         pos = nl + 1;
       }
       result.push(string.slice(pos));
       return result;
-    };
-  else
-    splitLines = function(string){return string.split(/\r?\n/);};
+  } : function(string){return string.split(/\r?\n/);};
   CodeMirror.splitLines = splitLines;
 
-  // Sane model of finding and setting the selection in a textarea
-  if (window.getSelection) {
-    selRange = function(te) {
-      try {return {start: te.selectionStart, end: te.selectionEnd};}
-      catch(e) {return null;}
-    };
-    if (safari)
-      // On Safari, selection set with setSelectionRange are in a sort
-      // of limbo wrt their anchor. If you press shift-left in them,
-      // the anchor is put at the end, and the selection expanded to
-      // the left. If you press shift-right, the anchor ends up at the
-      // front. This is not what CodeMirror wants, so it does a
-      // spurious modify() call to get out of limbo.
-      setSelRange = function(te, start, end) {
-        if (start == end)
-          te.setSelectionRange(start, end);
-        else {
-          te.setSelectionRange(start, end - 1);
-          window.getSelection().modify("extend", "forward", "character");
-        }
-      };
-    else
-      setSelRange = function(te, start, end) {
-        try {te.setSelectionRange(start, end);}
-        catch(e) {} // Fails on Firefox when textarea isn't part of the document
-      };
-  }
-  // IE model. Don't ask.
-  else {
-    selRange = function(te) {
+  var hasSelection = window.getSelection ? function(te) {
+    try { return te.selectionStart != te.selectionEnd; }
+    catch(e) { return false; }
+  } : function(te) {
       try {var range = te.ownerDocument.selection.createRange();}
-      catch(e) {return null;}
-      if (!range || range.parentElement() != te) return null;
-      var val = te.value, len = val.length, localRange = te.createTextRange();
-      localRange.moveToBookmark(range.getBookmark());
-      var endRange = te.createTextRange();
-      endRange.collapse(false);
-
-      if (localRange.compareEndPoints("StartToEnd", endRange) > -1)
-        return {start: len, end: len};
-
-      var start = -localRange.moveStart("character", -len);
-      for (var i = val.indexOf("\r"); i > -1 && i < start; i = val.indexOf("\r", i+1), start++) {}
-
-      if (localRange.compareEndPoints("EndToEnd", endRange) > -1)
-        return {start: start, end: len};
-
-      var end = -localRange.moveEnd("character", -len);
-      for (var i = val.indexOf("\r"); i > -1 && i < end; i = val.indexOf("\r", i+1), end++) {}
-      return {start: start, end: end};
-    };
-    setSelRange = function(te, start, end) {
-      var range = te.createTextRange();
-      range.collapse(true);
-      var endrange = range.duplicate();
-      var newlines = 0, txt = te.value;
-      for (var pos = txt.indexOf("\n"); pos > -1 && pos < start; pos = txt.indexOf("\n", pos + 1))
-        ++newlines;
-      range.move("character", start - newlines);
-      for (; pos > -1 && pos < end; pos = txt.indexOf("\n", pos + 1))
-        ++newlines;
-      endrange.move("character", end - newlines);
-      range.setEndPoint("EndToEnd", endrange);
-      range.select();
+    catch(e) {}
+    if (!range || range.parentElement() != te) return false;
+    return range.compareEndPoints("StartToEnd", range) != 0;
     };
-  }
 
   CodeMirror.defineMode("null", function() {
     return {token: function(stream) {stream.skipToEnd();}};
   });
   CodeMirror.defineMIME("text/plain", "null");
 
+  var keyNames = {3: "Enter", 8: "Backspace", 9: "Tab", 13: "Enter", 16: "Shift", 17: "Ctrl", 18: "Alt",
+                  19: "Pause", 20: "CapsLock", 27: "Esc", 32: "Space", 33: "PageUp", 34: "PageDown", 35: "End",
+                  36: "Home", 37: "Left", 38: "Up", 39: "Right", 40: "Down", 44: "PrintScrn", 45: "Insert",
+                  46: "Delete", 59: ";", 91: "Mod", 92: "Mod", 93: "Mod", 186: ";", 187: "=", 188: ",",
+                  189: "-", 190: ".", 191: "/", 192: "`", 219: "[", 220: "\\", 221: "]", 222: "'", 63276: "PageUp",
+                  63277: "PageDown", 63275: "End", 63273: "Home", 63234: "Left", 63232: "Up", 63235: "Right",
+                  63233: "Down", 63302: "Insert", 63272: "Delete"};
+  CodeMirror.keyNames = keyNames;
+  (function() {
+    // Number keys
+    for (var i = 0; i < 10; i++) keyNames[i + 48] = String(i);
+    // Alphabetic keys
+    for (var i = 65; i <= 90; i++) keyNames[i] = String.fromCharCode(i);
+    // Function keys
+    for (var i = 1; i <= 12; i++) keyNames[i + 111] = keyNames[i + 63235] = "F" + i;
+  })();
+
   return CodeMirror;
 })();

IPython/frontend/html/notebook/static/codemirror/lib/util/runmode.js

@@ -1,27 +1,27 b''
 CodeMirror.runMode = function(string, modespec, callback) {
   var mode = CodeMirror.getMode({indentUnit: 2}, modespec);
   var isNode = callback.nodeType == 1;
   if (isNode) {
     var node = callback, accum = [];
     callback = function(string, style) {
       if (string == "\n")
         accum.push("<br>");
       else if (style)
         accum.push("<span class=\"cm-" + CodeMirror.htmlEscape(style) + "\">" + CodeMirror.htmlEscape(string) + "</span>");
       else
         accum.push(CodeMirror.htmlEscape(string));
     }
   }
   var lines = CodeMirror.splitLines(string), state = CodeMirror.startState(mode);
   for (var i = 0, e = lines.length; i < e; ++i) {
     if (i) callback("\n");
     var stream = new CodeMirror.StringStream(lines[i]);
     while (!stream.eol()) {
       var style = mode.token(stream, state);
-      callback(stream.current(), style);
+      callback(stream.current(), style, i, stream.start);
       stream.start = stream.pos;
     }
   }
   if (isNode)
     node.innerHTML = accum.join("");
 };

IPython/frontend/html/notebook/static/codemirror/mode/css/index.html

@@ -1,56 +1,55 b''
 <!doctype html>
 <html>
   <head>
-    <title>CodeMirror 2: CSS mode</title>
+    <title>CodeMirror: CSS mode</title>
     <link rel="stylesheet" href="../../lib/codemirror.css">
     <script src="../../lib/codemirror.js"></script>
     <script src="css.js"></script>
-    <link rel="stylesheet" href="../../theme/default.css">
     <style>.CodeMirror {background: #f8f8f8;}</style>
-    <link rel="stylesheet" href="../../css/docs.css">
+    <link rel="stylesheet" href="../../doc/docs.css">
   </head>
   <body>
-    <h1>CodeMirror 2: CSS mode</h1>
+    <h1>CodeMirror: CSS mode</h1>
     <form><textarea id="code" name="code">
 /* Some example CSS */
 
 @import url("something.css");
 
 body {
   margin: 0;
   padding: 3em 6em;
   font-family: tahoma, arial, sans-serif;
   color: #000;
 }
 
 #navigation a {
   font-weight: bold;
   text-decoration: none !important;
 }
 
 h1 {
   font-size: 2.5em;
 }
 
 h2 {
   font-size: 1.7em;
 }
 
 h1:before, h2:before {
   content: "::";
 }
 
 code {
   font-family: courier, monospace;
   font-size: 80%;
   color: #418A8A;
 }
 </textarea></form>
     <script>
       var editor = CodeMirror.fromTextArea(document.getElementById("code"), {});
     </script>
 
     <p><strong>MIME types defined:</strong> <code>text/css</code>.</p>
 
   </body>
 </html>

IPython/frontend/html/notebook/static/codemirror/mode/htmlmixed/htmlmixed.js

@@ -1,79 +1,83 b''
 CodeMirror.defineMode("htmlmixed", function(config, parserConfig) {
   var htmlMode = CodeMirror.getMode(config, {name: "xml", htmlMode: true});
   var jsMode = CodeMirror.getMode(config, "javascript");
   var cssMode = CodeMirror.getMode(config, "css");
 
   function html(stream, state) {
     var style = htmlMode.token(stream, state.htmlState);
     if (style == "tag" && stream.current() == ">" && state.htmlState.context) {
       if (/^script$/i.test(state.htmlState.context.tagName)) {
         state.token = javascript;
         state.localState = jsMode.startState(htmlMode.indent(state.htmlState, ""));
         state.mode = "javascript";
       }
       else if (/^style$/i.test(state.htmlState.context.tagName)) {
         state.token = css;
         state.localState = cssMode.startState(htmlMode.indent(state.htmlState, ""));
         state.mode = "css";
       }
     }
     return style;
   }
   function maybeBackup(stream, pat, style) {
     var cur = stream.current();
     var close = cur.search(pat);
     if (close > -1) stream.backUp(cur.length - close);
     return style;
   }
   function javascript(stream, state) {
     if (stream.match(/^<\/\s*script\s*>/i, false)) {
       state.token = html;
       state.curState = null;
       state.mode = "html";
       return html(stream, state);
     }
     return maybeBackup(stream, /<\/\s*script\s*>/,
                        jsMode.token(stream, state.localState));
   }
   function css(stream, state) {
     if (stream.match(/^<\/\s*style\s*>/i, false)) {
       state.token = html;
       state.localState = null;
       state.mode = "html";
       return html(stream, state);
     }
     return maybeBackup(stream, /<\/\s*style\s*>/,
                        cssMode.token(stream, state.localState));
   }
 
   return {
     startState: function() {
       var state = htmlMode.startState();
       return {token: html, localState: null, mode: "html", htmlState: state};
     },
 
     copyState: function(state) {
       if (state.localState)
         var local = CodeMirror.copyState(state.token == css ? cssMode : jsMode, state.localState);
       return {token: state.token, localState: local, mode: state.mode,
               htmlState: CodeMirror.copyState(htmlMode, state.htmlState)};
     },
 
     token: function(stream, state) {
       return state.token(stream, state);
     },
 
     indent: function(state, textAfter) {
       if (state.token == html || /^\s*<\//.test(textAfter))
         return htmlMode.indent(state.htmlState, textAfter);
       else if (state.token == javascript)
         return jsMode.indent(state.localState, textAfter);
       else
         return cssMode.indent(state.localState, textAfter);
     },
 
+    compareStates: function(a, b) {
+      return htmlMode.compareStates(a.htmlState, b.htmlState);
+    },
+
     electricChars: "/{}:"
   }
 });
 
 CodeMirror.defineMIME("text/html", "htmlmixed");

IPython/frontend/html/notebook/static/codemirror/mode/htmlmixed/index.html

@@ -1,52 +1,51 b''
 <!doctype html>
 <html>
   <head>
-    <title>CodeMirror 2: HTML mixed mode</title>
+    <title>CodeMirror: HTML mixed mode</title>
     <link rel="stylesheet" href="../../lib/codemirror.css">
     <script src="../../lib/codemirror.js"></script>
     <script src="../xml/xml.js"></script>
     <script src="../javascript/javascript.js"></script>
     <script src="../css/css.js"></script>
-    <link rel="stylesheet" href="../../theme/default.css">
     <script src="htmlmixed.js"></script>
-    <link rel="stylesheet" href="../../css/docs.css">
+    <link rel="stylesheet" href="../../doc/docs.css">
     <style>.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
   </head>
   <body>
-    <h1>CodeMirror 2: HTML mixed mode</h1>
+    <h1>CodeMirror: HTML mixed mode</h1>
     <form><textarea id="code" name="code">
 <html style="color: green">
   <!-- this is a comment -->
   <head>
     <title>Mixed HTML Example</title>
     <style type="text/css">
       h1 {font-family: comic sans; color: #f0f;}
       div {background: yellow !important;}
       body {
         max-width: 50em;
         margin: 1em 2em 1em 5em;
       }
     </style>
   </head>
   <body>
     <h1>Mixed HTML Example</h1>
     <script>
       function jsFunc(arg1, arg2) {
         if (arg1 && arg2) document.body.innerHTML = "achoo";
       }
     </script>
   </body>
 </html>
 </textarea></form>
     <script>
       var editor = CodeMirror.fromTextArea(document.getElementById("code"), {mode: "text/html", tabMode: "indent"});
     </script>
 
     <p>The HTML mixed mode depends on the XML, JavaScript, and CSS modes.</p>
 
     <p><strong>MIME types defined:</strong> <code>text/html</code>
     (redefined, only takes effect if you load this parser after the
     XML parser).</p>
 
   </body>
 </html>

IPython/frontend/html/notebook/static/codemirror/mode/javascript/index.html

@@ -1,78 +1,77 b''
 <!doctype html>
 <html>
   <head>
-    <title>CodeMirror 2: JavaScript mode</title>
+    <title>CodeMirror: JavaScript mode</title>
     <link rel="stylesheet" href="../../lib/codemirror.css">
     <script src="../../lib/codemirror.js"></script>
     <script src="javascript.js"></script>
-    <link rel="stylesheet" href="../../theme/default.css">
-    <link rel="stylesheet" href="../../css/docs.css">
+    <link rel="stylesheet" href="../../doc/docs.css">
     <style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
   </head>
   <body>
-    <h1>CodeMirror 2: JavaScript mode</h1>
+    <h1>CodeMirror: JavaScript mode</h1>
 
 <div><textarea id="code" name="code">
 // Demo code (the actual new parser character stream implementation)
 
 function StringStream(string) {
   this.pos = 0;
   this.string = string;
 }
 
 StringStream.prototype = {
   done: function() {return this.pos >= this.string.length;},
   peek: function() {return this.string.charAt(this.pos);},
   next: function() {
     if (this.pos &lt; this.string.length)
       return this.string.charAt(this.pos++);
   },
   eat: function(match) {
     var ch = this.string.charAt(this.pos);
     if (typeof match == "string") var ok = ch == match;
     else var ok = ch &amp;&amp; match.test ? match.test(ch) : match(ch);
     if (ok) {this.pos++; return ch;}
   },
   eatWhile: function(match) {
     var start = this.pos;
     while (this.eat(match));
     if (this.pos > start) return this.string.slice(start, this.pos);
   },
   backUp: function(n) {this.pos -= n;},
   column: function() {return this.pos;},
   eatSpace: function() {
     var start = this.pos;
     while (/\s/.test(this.string.charAt(this.pos))) this.pos++;
     return this.pos - start;
   },
   match: function(pattern, consume, caseInsensitive) {
     if (typeof pattern == "string") {
       function cased(str) {return caseInsensitive ? str.toLowerCase() : str;}
       if (cased(this.string).indexOf(cased(pattern), this.pos) == this.pos) {
         if (consume !== false) this.pos += str.length;
         return true;
       }
     }
     else {
       var match = this.string.slice(this.pos).match(pattern);
       if (match &amp;&amp; consume !== false) this.pos += match[0].length;
       return match;
     }
   }
 };
 </textarea></div>
 
     <script>
       var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
         lineNumbers: true,
         matchBrackets: true
       });
     </script>
 
     <p>JavaScript mode supports a single configuration
     option, <code>json</code>, which will set the mode to expect JSON
     data rather than a JavaScript program.</p>
 
     <p><strong>MIME types defined:</strong> <code>text/javascript</code>, <code>application/json</code>.</p>
   </body>
 </html>

IPython/frontend/html/notebook/static/codemirror/mode/javascript/javascript.js

@@ -1,352 +1,360 b''
 CodeMirror.defineMode("javascript", function(config, parserConfig) {
   var indentUnit = config.indentUnit;
   var jsonMode = parserConfig.json;
 
   // Tokenizer
 
   var keywords = function(){
     function kw(type) {return {type: type, style: "keyword"};}
     var A = kw("keyword a"), B = kw("keyword b"), C = kw("keyword c");
     var operator = kw("operator"), atom = {type: "atom", style: "atom"};
     return {
       "if": A, "while": A, "with": A, "else": B, "do": B, "try": B, "finally": B,
       "return": C, "break": C, "continue": C, "new": C, "delete": C, "throw": C,
-      "var": kw("var"), "function": kw("function"), "catch": kw("catch"),
+      "var": kw("var"), "const": kw("var"), "let": kw("var"),
+      "function": kw("function"), "catch": kw("catch"),
       "for": kw("for"), "switch": kw("switch"), "case": kw("case"), "default": kw("default"),
       "in": operator, "typeof": operator, "instanceof": operator,
       "true": atom, "false": atom, "null": atom, "undefined": atom, "NaN": atom, "Infinity": atom
     };
   }();
 
   var isOperatorChar = /[+\-*&%=<>!?|]/;
 
   function chain(stream, state, f) {
     state.tokenize = f;
     return f(stream, state);
   }
 
   function nextUntilUnescaped(stream, end) {
     var escaped = false, next;
     while ((next = stream.next()) != null) {
       if (next == end && !escaped)
         return false;
       escaped = !escaped && next == "\\";
     }
     return escaped;
   }
 
   // Used as scratch variables to communicate multiple values without
   // consing up tons of objects.
   var type, content;
   function ret(tp, style, cont) {
     type = tp; content = cont;
     return style;
   }
 
   function jsTokenBase(stream, state) {
     var ch = stream.next();
     if (ch == '"' || ch == "'")
       return chain(stream, state, jsTokenString(ch));
     else if (/[\[\]{}\(\),;\:\.]/.test(ch))
       return ret(ch);
     else if (ch == "0" && stream.eat(/x/i)) {
       stream.eatWhile(/[\da-f]/i);
       return ret("number", "number");
     }
     else if (/\d/.test(ch)) {
-      stream.match(/^\d*(?:\.\d*)?(?:e[+\-]?\d+)?/);
+      stream.match(/^\d*(?:\.\d*)?(?:[eE][+\-]?\d+)?/);
       return ret("number", "number");
     }
     else if (ch == "/") {
       if (stream.eat("*")) {
         return chain(stream, state, jsTokenComment);
       }
       else if (stream.eat("/")) {
         stream.skipToEnd();
         return ret("comment", "comment");
       }
       else if (state.reAllowed) {
         nextUntilUnescaped(stream, "/");
         stream.eatWhile(/[gimy]/); // 'y' is "sticky" option in Mozilla
         return ret("regexp", "string");
       }
       else {
         stream.eatWhile(isOperatorChar);
         return ret("operator", null, stream.current());
       }
     }
     else if (ch == "#") {
         stream.skipToEnd();
         return ret("error", "error");
     }
     else if (isOperatorChar.test(ch)) {
       stream.eatWhile(isOperatorChar);
       return ret("operator", null, stream.current());
     }
     else {
       stream.eatWhile(/[\w\$_]/);
       var word = stream.current(), known = keywords.propertyIsEnumerable(word) && keywords[word];
-      return known ? ret(known.type, known.style, word) :
+      return (known && state.kwAllowed) ? ret(known.type, known.style, word) :
                      ret("variable", "variable", word);
     }
   }
 
   function jsTokenString(quote) {
     return function(stream, state) {
       if (!nextUntilUnescaped(stream, quote))
         state.tokenize = jsTokenBase;
       return ret("string", "string");
     };
   }
 
   function jsTokenComment(stream, state) {
     var maybeEnd = false, ch;
     while (ch = stream.next()) {
       if (ch == "/" && maybeEnd) {
         state.tokenize = jsTokenBase;
         break;
       }
       maybeEnd = (ch == "*");
     }
     return ret("comment", "comment");
   }
 
   // Parser
 
   var atomicTypes = {"atom": true, "number": true, "variable": true, "string": true, "regexp": true};
 
   function JSLexical(indented, column, type, align, prev, info) {
     this.indented = indented;
     this.column = column;
     this.type = type;
     this.prev = prev;
     this.info = info;
     if (align != null) this.align = align;
   }
 
   function inScope(state, varname) {
     for (var v = state.localVars; v; v = v.next)
       if (v.name == varname) return true;
   }
 
   function parseJS(state, style, type, content, stream) {
     var cc = state.cc;
     // Communicate our context to the combinators.
     // (Less wasteful than consing up a hundred closures on every call.)
     cx.state = state; cx.stream = stream; cx.marked = null, cx.cc = cc;
 
     if (!state.lexical.hasOwnProperty("align"))
       state.lexical.align = true;
 
     while(true) {
       var combinator = cc.length ? cc.pop() : jsonMode ? expression : statement;
       if (combinator(type, content)) {
         while(cc.length && cc[cc.length - 1].lex)
           cc.pop()();
         if (cx.marked) return cx.marked;
         if (type == "variable" && inScope(state, content)) return "variable-2";
         return style;
       }
     }
   }
 
   // Combinator utils
 
   var cx = {state: null, column: null, marked: null, cc: null};
   function pass() {
     for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]);
   }
   function cont() {
     pass.apply(null, arguments);
     return true;
   }
   function register(varname) {
     var state = cx.state;
     if (state.context) {
       cx.marked = "def";
       for (var v = state.localVars; v; v = v.next)
         if (v.name == varname) return;
       state.localVars = {name: varname, next: state.localVars};
     }
   }
 
   // Combinators
 
   var defaultVars = {name: "this", next: {name: "arguments"}};
   function pushcontext() {
     if (!cx.state.context) cx.state.localVars = defaultVars;
     cx.state.context = {prev: cx.state.context, vars: cx.state.localVars};
   }
   function popcontext() {
     cx.state.localVars = cx.state.context.vars;
     cx.state.context = cx.state.context.prev;
   }
   function pushlex(type, info) {
     var result = function() {
       var state = cx.state;
       state.lexical = new JSLexical(state.indented, cx.stream.column(), type, null, state.lexical, info)
     };
     result.lex = true;
     return result;
   }
   function poplex() {
     var state = cx.state;
     if (state.lexical.prev) {
       if (state.lexical.type == ")")
         state.indented = state.lexical.indented;
       state.lexical = state.lexical.prev;
     }
   }
   poplex.lex = true;
 
   function expect(wanted) {
     return function expecting(type) {
       if (type == wanted) return cont();
       else if (wanted == ";") return pass();
       else return cont(arguments.callee);
     };
   }
 
   function statement(type) {
     if (type == "var") return cont(pushlex("vardef"), vardef1, expect(";"), poplex);
     if (type == "keyword a") return cont(pushlex("form"), expression, statement, poplex);
     if (type == "keyword b") return cont(pushlex("form"), statement, poplex);
     if (type == "{") return cont(pushlex("}"), block, poplex);
     if (type == ";") return cont();
     if (type == "function") return cont(functiondef);
     if (type == "for") return cont(pushlex("form"), expect("("), pushlex(")"), forspec1, expect(")"),
                                       poplex, statement, poplex);
     if (type == "variable") return cont(pushlex("stat"), maybelabel);
     if (type == "switch") return cont(pushlex("form"), expression, pushlex("}", "switch"), expect("{"),
                                          block, poplex, poplex);
     if (type == "case") return cont(expression, expect(":"));
     if (type == "default") return cont(expect(":"));
     if (type == "catch") return cont(pushlex("form"), pushcontext, expect("("), funarg, expect(")"),
                                         statement, poplex, popcontext);
     return pass(pushlex("stat"), expression, expect(";"), poplex);
   }
   function expression(type) {
     if (atomicTypes.hasOwnProperty(type)) return cont(maybeoperator);
     if (type == "function") return cont(functiondef);
-    if (type == "keyword c") return cont(expression);
+    if (type == "keyword c") return cont(maybeexpression);
     if (type == "(") return cont(pushlex(")"), expression, expect(")"), poplex, maybeoperator);
     if (type == "operator") return cont(expression);
     if (type == "[") return cont(pushlex("]"), commasep(expression, "]"), poplex, maybeoperator);
     if (type == "{") return cont(pushlex("}"), commasep(objprop, "}"), poplex, maybeoperator);
     return cont();
   }
+  function maybeexpression(type) {
+    if (type.match(/[;\}\)\],]/)) return pass();
+    return pass(expression);
+  }
+    
   function maybeoperator(type, value) {
     if (type == "operator" && /\+\+|--/.test(value)) return cont(maybeoperator);
     if (type == "operator") return cont(expression);
     if (type == ";") return;
     if (type == "(") return cont(pushlex(")"), commasep(expression, ")"), poplex, maybeoperator);
     if (type == ".") return cont(property, maybeoperator);
     if (type == "[") return cont(pushlex("]"), expression, expect("]"), poplex, maybeoperator);
   }
   function maybelabel(type) {
     if (type == ":") return cont(poplex, statement);
     return pass(maybeoperator, expect(";"), poplex);
   }
   function property(type) {
     if (type == "variable") {cx.marked = "property"; return cont();}
   }
   function objprop(type) {
     if (type == "variable") cx.marked = "property";
     if (atomicTypes.hasOwnProperty(type)) return cont(expect(":"), expression);
   }
   function commasep(what, end) {
     function proceed(type) {
       if (type == ",") return cont(what, proceed);
       if (type == end) return cont();
       return cont(expect(end));
     }
     return function commaSeparated(type) {
       if (type == end) return cont();
       else return pass(what, proceed);
     };
   }
   function block(type) {
     if (type == "}") return cont();
     return pass(statement, block);
   }
   function vardef1(type, value) {
     if (type == "variable"){register(value); return cont(vardef2);}
     return cont();
   }
   function vardef2(type, value) {
     if (value == "=") return cont(expression, vardef2);
     if (type == ",") return cont(vardef1);
   }
   function forspec1(type) {
     if (type == "var") return cont(vardef1, forspec2);
     if (type == ";") return pass(forspec2);
     if (type == "variable") return cont(formaybein);
     return pass(forspec2);
   }
   function formaybein(type, value) {
     if (value == "in") return cont(expression);
     return cont(maybeoperator, forspec2);
   }
   function forspec2(type, value) {
     if (type == ";") return cont(forspec3);
     if (value == "in") return cont(expression);
     return cont(expression, expect(";"), forspec3);
   }
   function forspec3(type) {
     if (type != ")") cont(expression);
   }
   function functiondef(type, value) {
     if (type == "variable") {register(value); return cont(functiondef);}
     if (type == "(") return cont(pushlex(")"), pushcontext, commasep(funarg, ")"), poplex, statement, popcontext);
   }
   function funarg(type, value) {
     if (type == "variable") {register(value); return cont();}
   }
 
   // Interface
 
   return {
     startState: function(basecolumn) {
       return {
         tokenize: jsTokenBase,
         reAllowed: true,
+        kwAllowed: true,
         cc: [],
         lexical: new JSLexical((basecolumn || 0) - indentUnit, 0, "block", false),
         localVars: null,
         context: null,
         indented: 0
       };
     },
 
     token: function(stream, state) {
       if (stream.sol()) {
         if (!state.lexical.hasOwnProperty("align"))
           state.lexical.align = false;
         state.indented = stream.indentation();
       }
       if (stream.eatSpace()) return null;
       var style = state.tokenize(stream, state);
       if (type == "comment") return style;
       state.reAllowed = type == "operator" || type == "keyword c" || type.match(/^[\[{}\(,;:]$/);
+      state.kwAllowed = type != '.';
       return parseJS(state, style, type, content, stream);
     },
 
     indent: function(state, textAfter) {
       if (state.tokenize != jsTokenBase) return 0;
       var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical,
           type = lexical.type, closing = firstChar == type;
       if (type == "vardef") return lexical.indented + 4;
       else if (type == "form" && firstChar == "{") return lexical.indented;
       else if (type == "stat" || type == "form") return lexical.indented + indentUnit;
       else if (lexical.info == "switch" && !closing)
         return lexical.indented + (/^(?:case|default)\b/.test(textAfter) ? indentUnit : 2 * indentUnit);
       else if (lexical.align) return lexical.column + (closing ? 0 : 1);
       else return lexical.indented + (closing ? 0 : indentUnit);
     },
 
     electricChars: ":{}"
   };
 });
 
 CodeMirror.defineMIME("text/javascript", "javascript");
 CodeMirror.defineMIME("application/json", {name: "javascript", json: true});

IPython/frontend/html/notebook/static/codemirror/mode/markdown/index.html

@@ -1,340 +1,339 b''
 <!doctype html>
 <html>
   <head>
-    <title>CodeMirror 2: Markdown mode</title>
+    <title>CodeMirror: Markdown mode</title>
     <link rel="stylesheet" href="../../lib/codemirror.css">
     <script src="../../lib/codemirror.js"></script>
     <script src="../xml/xml.js"></script>
     <script src="markdown.js"></script>
-    <link rel="stylesheet" href="../../theme/default.css">
     <link rel="stylesheet" href="markdown.css">
     <style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
-    <link rel="stylesheet" href="../../css/docs.css">
+    <link rel="stylesheet" href="../../doc/docs.css">
   </head>
   <body>
-    <h1>CodeMirror 2: Markdown mode</h1>
+    <h1>CodeMirror: Markdown mode</h1>
 
 <!-- source: http://daringfireball.net/projects/markdown/basics.text -->
 <form><textarea id="code" name="code">
 Markdown: Basics
 ================
 
 &lt;ul id="ProjectSubmenu"&gt;
     &lt;li&gt;&lt;a href="/projects/markdown/" title="Markdown Project Page"&gt;Main&lt;/a&gt;&lt;/li&gt;
     &lt;li&gt;&lt;a class="selected" title="Markdown Basics"&gt;Basics&lt;/a&gt;&lt;/li&gt;
     &lt;li&gt;&lt;a href="/projects/markdown/syntax" title="Markdown Syntax Documentation"&gt;Syntax&lt;/a&gt;&lt;/li&gt;
     &lt;li&gt;&lt;a href="/projects/markdown/license" title="Pricing and License Information"&gt;License&lt;/a&gt;&lt;/li&gt;
     &lt;li&gt;&lt;a href="/projects/markdown/dingus" title="Online Markdown Web Form"&gt;Dingus&lt;/a&gt;&lt;/li&gt;
 &lt;/ul&gt;
 
 
 Getting the Gist of Markdown's Formatting Syntax
 ------------------------------------------------
 
 This page offers a brief overview of what it's like to use Markdown.
 The [syntax page] [s] provides complete, detailed documentation for
 every feature, but Markdown should be very easy to pick up simply by
 looking at a few examples of it in action. The examples on this page
 are written in a before/after style, showing example syntax and the
 HTML output produced by Markdown.
 
 It's also helpful to simply try Markdown out; the [Dingus] [d] is a
 web application that allows you type your own Markdown-formatted text
 and translate it to XHTML.
 
 **Note:** This document is itself written using Markdown; you
 can [see the source for it by adding '.text' to the URL] [src].
 
   [s]: /projects/markdown/syntax  "Markdown Syntax"
   [d]: /projects/markdown/dingus  "Markdown Dingus"
   [src]: /projects/markdown/basics.text
 
 
 ## Paragraphs, Headers, Blockquotes ##
 
 A paragraph is simply one or more consecutive lines of text, separated
 by one or more blank lines. (A blank line is any line that looks like
 a blank line -- a line containing nothing but spaces or tabs is
 considered blank.) Normal paragraphs should not be indented with
 spaces or tabs.
 
 Markdown offers two styles of headers: *Setext* and *atx*.
 Setext-style headers for `&lt;h1&gt;` and `&lt;h2&gt;` are created by
 "underlining" with equal signs (`=`) and hyphens (`-`), respectively.
 To create an atx-style header, you put 1-6 hash marks (`#`) at the
 beginning of the line -- the number of hashes equals the resulting
 HTML header level.
 
 Blockquotes are indicated using email-style '`&gt;`' angle brackets.
 
 Markdown:
 
     A First Level Header
     ====================
 
     A Second Level Header
     ---------------------
 
     Now is the time for all good men to come to
     the aid of their country. This is just a
     regular paragraph.
 
     The quick brown fox jumped over the lazy
     dog's back.
 
     ### Header 3
 
     &gt; This is a blockquote.
     &gt;
     &gt; This is the second paragraph in the blockquote.
     &gt;
     &gt; ## This is an H2 in a blockquote
 
 
 Output:
 
     &lt;h1&gt;A First Level Header&lt;/h1&gt;
 
     &lt;h2&gt;A Second Level Header&lt;/h2&gt;
 
     &lt;p&gt;Now is the time for all good men to come to
     the aid of their country. This is just a
     regular paragraph.&lt;/p&gt;
 
     &lt;p&gt;The quick brown fox jumped over the lazy
     dog's back.&lt;/p&gt;
 
     &lt;h3&gt;Header 3&lt;/h3&gt;
 
     &lt;blockquote&gt;
         &lt;p&gt;This is a blockquote.&lt;/p&gt;
 
         &lt;p&gt;This is the second paragraph in the blockquote.&lt;/p&gt;
 
         &lt;h2&gt;This is an H2 in a blockquote&lt;/h2&gt;
     &lt;/blockquote&gt;
 
 
 
 ### Phrase Emphasis ###
 
 Markdown uses asterisks and underscores to indicate spans of emphasis.
 
 Markdown:
 
     Some of these words *are emphasized*.
     Some of these words _are emphasized also_.
 
     Use two asterisks for **strong emphasis**.
     Or, if you prefer, __use two underscores instead__.
 
 Output:
 
     &lt;p&gt;Some of these words &lt;em&gt;are emphasized&lt;/em&gt;.
     Some of these words &lt;em&gt;are emphasized also&lt;/em&gt;.&lt;/p&gt;
 
     &lt;p&gt;Use two asterisks for &lt;strong&gt;strong emphasis&lt;/strong&gt;.
     Or, if you prefer, &lt;strong&gt;use two underscores instead&lt;/strong&gt;.&lt;/p&gt;
 
 
 
 ## Lists ##
 
 Unordered (bulleted) lists use asterisks, pluses, and hyphens (`*`,
 `+`, and `-`) as list markers. These three markers are
 interchangable; this:
 
     *   Candy.
     *   Gum.
     *   Booze.
 
 this:
 
     +   Candy.
     +   Gum.
     +   Booze.
 
 and this:
 
     -   Candy.
     -   Gum.
     -   Booze.
 
 all produce the same output:
 
     &lt;ul&gt;
     &lt;li&gt;Candy.&lt;/li&gt;
     &lt;li&gt;Gum.&lt;/li&gt;
     &lt;li&gt;Booze.&lt;/li&gt;
     &lt;/ul&gt;
 
 Ordered (numbered) lists use regular numbers, followed by periods, as
 list markers:
 
     1.  Red
     2.  Green
     3.  Blue
 
 Output:
 
     &lt;ol&gt;
     &lt;li&gt;Red&lt;/li&gt;
     &lt;li&gt;Green&lt;/li&gt;
     &lt;li&gt;Blue&lt;/li&gt;
     &lt;/ol&gt;
 
 If you put blank lines between items, you'll get `&lt;p&gt;` tags for the
 list item text. You can create multi-paragraph list items by indenting
 the paragraphs by 4 spaces or 1 tab:
 
     *   A list item.
 
         With multiple paragraphs.
 
     *   Another item in the list.
 
 Output:
 
     &lt;ul&gt;
     &lt;li&gt;&lt;p&gt;A list item.&lt;/p&gt;
     &lt;p&gt;With multiple paragraphs.&lt;/p&gt;&lt;/li&gt;
     &lt;li&gt;&lt;p&gt;Another item in the list.&lt;/p&gt;&lt;/li&gt;
     &lt;/ul&gt;
 
 
 
 ### Links ###
 
 Markdown supports two styles for creating links: *inline* and
 *reference*. With both styles, you use square brackets to delimit the
 text you want to turn into a link.
 
 Inline-style links use parentheses immediately after the link text.
 For example:
 
     This is an [example link](http://example.com/).
 
 Output:
 
     &lt;p&gt;This is an &lt;a href="http://example.com/"&gt;
     example link&lt;/a&gt;.&lt;/p&gt;
 
 Optionally, you may include a title attribute in the parentheses:
 
     This is an [example link](http://example.com/ "With a Title").
 
 Output:
 
     &lt;p&gt;This is an &lt;a href="http://example.com/" title="With a Title"&gt;
     example link&lt;/a&gt;.&lt;/p&gt;
 
 Reference-style links allow you to refer to your links by names, which
 you define elsewhere in your document:
 
     I get 10 times more traffic from [Google][1] than from
     [Yahoo][2] or [MSN][3].
 
     [1]: http://google.com/        "Google"
     [2]: http://search.yahoo.com/  "Yahoo Search"
     [3]: http://search.msn.com/    "MSN Search"
 
 Output:
 
     &lt;p&gt;I get 10 times more traffic from &lt;a href="http://google.com/"
     title="Google"&gt;Google&lt;/a&gt; than from &lt;a href="http://search.yahoo.com/"
     title="Yahoo Search"&gt;Yahoo&lt;/a&gt; or &lt;a href="http://search.msn.com/"
     title="MSN Search"&gt;MSN&lt;/a&gt;.&lt;/p&gt;
 
 The title attribute is optional. Link names may contain letters,
 numbers and spaces, but are *not* case sensitive:
 
     I start my morning with a cup of coffee and
     [The New York Times][NY Times].
 
     [ny times]: http://www.nytimes.com/
 
 Output:
 
     &lt;p&gt;I start my morning with a cup of coffee and
     &lt;a href="http://www.nytimes.com/"&gt;The New York Times&lt;/a&gt;.&lt;/p&gt;
 
 
 ### Images ###
 
 Image syntax is very much like link syntax.
 
 Inline (titles are optional):
 
     ![alt text](/path/to/img.jpg "Title")
 
 Reference-style:
 
     ![alt text][id]
 
     [id]: /path/to/img.jpg "Title"
 
 Both of the above examples produce the same output:
 
     &lt;img src="/path/to/img.jpg" alt="alt text" title="Title" /&gt;
 
 
 
 ### Code ###
 
 In a regular paragraph, you can create code span by wrapping text in
 backtick quotes. Any ampersands (`&amp;`) and angle brackets (`&lt;` or
 `&gt;`) will automatically be translated into HTML entities. This makes
 it easy to use Markdown to write about HTML example code:
 
     I strongly recommend against using any `&lt;blink&gt;` tags.
 
     I wish SmartyPants used named entities like `&amp;mdash;`
     instead of decimal-encoded entites like `&amp;#8212;`.
 
 Output:
 
     &lt;p&gt;I strongly recommend against using any
     &lt;code&gt;&amp;lt;blink&amp;gt;&lt;/code&gt; tags.&lt;/p&gt;
 
     &lt;p&gt;I wish SmartyPants used named entities like
     &lt;code&gt;&amp;amp;mdash;&lt;/code&gt; instead of decimal-encoded
     entites like &lt;code&gt;&amp;amp;#8212;&lt;/code&gt;.&lt;/p&gt;
 
 
 To specify an entire block of pre-formatted code, indent every line of
 the block by 4 spaces or 1 tab. Just like with code spans, `&amp;`, `&lt;`,
 and `&gt;` characters will be escaped automatically.
 
 Markdown:
 
     If you want your page to validate under XHTML 1.0 Strict,
     you've got to put paragraph tags in your blockquotes:
 
         &lt;blockquote&gt;
             &lt;p&gt;For example.&lt;/p&gt;
         &lt;/blockquote&gt;
 
 Output:
 
     &lt;p&gt;If you want your page to validate under XHTML 1.0 Strict,
     you've got to put paragraph tags in your blockquotes:&lt;/p&gt;
 
     &lt;pre&gt;&lt;code&gt;&amp;lt;blockquote&amp;gt;
         &amp;lt;p&amp;gt;For example.&amp;lt;/p&amp;gt;
     &amp;lt;/blockquote&amp;gt;
     &lt;/code&gt;&lt;/pre&gt;
 </textarea></form>
 
     <script>
       var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
         mode: 'markdown',
         lineNumbers: true,
         matchBrackets: true,
         theme: "default"
       });
     </script>
 
     <p><strong>MIME types defined:</strong> <code>text/x-markdown</code>.</p>
 
   </body>
 </html>

IPython/frontend/html/notebook/static/codemirror/mode/markdown/markdown.js

@@ -1,230 +1,242 b''
 CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
 
   var htmlMode = CodeMirror.getMode(cmCfg, { name: 'xml', htmlMode: true });
 
   var header   = 'header'
-  ,   code     = 'code'
+  ,   code     = 'comment'
   ,   quote    = 'quote'
-  ,   list     = 'list'
+  ,   list     = 'string'
   ,   hr       = 'hr'
-  ,   linktext = 'linktext'
-  ,   linkhref = 'linkhref'
+  ,   linktext = 'link'
+  ,   linkhref = 'string'
   ,   em       = 'em'
   ,   strong   = 'strong'
   ,   emstrong = 'emstrong';
 
   var hrRE = /^[*-=_]/
   ,   ulRE = /^[*-+]\s+/
   ,   olRE = /^[0-9]\.\s+/
   ,   headerRE = /^(?:\={3,}|-{3,})$/
   ,   codeRE = /^(k:\t|\s{4,})/
   ,   textRE = /^[^\[*_\\<>`]+/;
 
   function switchInline(stream, state, f) {
     state.f = state.inline = f;
     return f(stream, state);
   }
 
   function switchBlock(stream, state, f) {
     state.f = state.block = f;
     return f(stream, state);
   }
 
 
   // Blocks
 
   function blockNormal(stream, state) {
     if (stream.match(codeRE)) {
       stream.skipToEnd();
       return code;
     }
 
     if (stream.eatSpace()) {
       return null;
     }
 
     if (stream.peek() === '#' || stream.match(headerRE)) {
       stream.skipToEnd();
       return header;
     }
     if (stream.eat('>')) {
       state.indentation++;
       return quote;
     }
-    if (stream.peek() === '<') {
-      return switchBlock(stream, state, htmlBlock);
-    }
     if (stream.peek() === '[') {
       return switchInline(stream, state, footnoteLink);
     }
     if (hrRE.test(stream.peek())) {
       var re = new RegExp('(?:\s*['+stream.peek()+']){3,}$');
       if (stream.match(re, true)) {
         return hr;
       }
     }
 
     var match;
     if (match = stream.match(ulRE, true) || stream.match(olRE, true)) {
       state.indentation += match[0].length;
       return list;
     }
 
     return switchInline(stream, state, state.inline);
   }
 
   function htmlBlock(stream, state) {
-    var type = htmlMode.token(stream, state.htmlState);
-    if (stream.eol() && !state.htmlState.context) {
+    var style = htmlMode.token(stream, state.htmlState);
+    if (style === 'tag' && state.htmlState.type !== 'openTag' && !state.htmlState.context) {
+      state.f = inlineNormal;
       state.block = blockNormal;
     }
-    return type;
+    return style;
   }
 
 
   // Inline
-
-  function inlineNormal(stream, state) {
-    function getType() {
+  function getType(state) {
       return state.strong ? (state.em ? emstrong : strong)
                           : (state.em ? em       : null);
     }
 
+  function handleText(stream, state) {
     if (stream.match(textRE, true)) {
-      return getType();
+      return getType(state);
+    }
+    return undefined;        
     }
 
+  function inlineNormal(stream, state) {
+    var style = state.text(stream, state)
+    if (typeof style !== 'undefined')
+      return style;
+    
     var ch = stream.next();
 
     if (ch === '\\') {
       stream.next();
-      return getType();
+      return getType(state);
     }
     if (ch === '`') {
       return switchInline(stream, state, inlineElement(code, '`'));
     }
-    if (ch === '<') {
-      return switchInline(stream, state, inlineElement(linktext, '>'));
-    }
     if (ch === '[') {
       return switchInline(stream, state, linkText);
     }
+    if (ch === '<' && stream.match(/^\w/, false)) {
+      stream.backUp(1);
+      return switchBlock(stream, state, htmlBlock);
+    }
 
-    var t = getType();
+    var t = getType(state);
     if (ch === '*' || ch === '_') {
       if (stream.eat(ch)) {
-        return (state.strong = !state.strong) ? getType() : t;
+        return (state.strong = !state.strong) ? getType(state) : t;
       }
-      return (state.em = !state.em) ? getType() : t;
+      return (state.em = !state.em) ? getType(state) : t;
     }
 
-    return getType();
+    return getType(state);
   }
 
   function linkText(stream, state) {
     while (!stream.eol()) {
       var ch = stream.next();
       if (ch === '\\') stream.next();
       if (ch === ']') {
         state.inline = state.f = linkHref;
         return linktext;
       }
     }
     return linktext;
   }
 
   function linkHref(stream, state) {
     stream.eatSpace();
     var ch = stream.next();
     if (ch === '(' || ch === '[') {
       return switchInline(stream, state, inlineElement(linkhref, ch === '(' ? ')' : ']'));
     }
     return 'error';
   }
 
   function footnoteLink(stream, state) {
     if (stream.match(/^[^\]]*\]:/, true)) {
       state.f = footnoteUrl;
       return linktext;
     }
     return switchInline(stream, state, inlineNormal);
   }
 
   function footnoteUrl(stream, state) {
     stream.eatSpace();
     stream.match(/^[^\s]+/, true);
     state.f = state.inline = inlineNormal;
     return linkhref;
   }
 
+  function inlineRE(endChar) {
+    if (!inlineRE[endChar]) {
+      // match any not-escaped-non-endChar and any escaped char
+      // then match endChar or eol
+      inlineRE[endChar] = new RegExp('^(?:[^\\\\\\' + endChar + ']|\\\\.)*(?:\\' + endChar + '|$)');
+    }
+    return inlineRE[endChar];
+  }
+
   function inlineElement(type, endChar, next) {
     next = next || inlineNormal;
     return function(stream, state) {
-      while (!stream.eol()) {
-        var ch = stream.next();
-        if (ch === '\\') stream.next();
-        if (ch === endChar) {
+      stream.match(inlineRE(endChar));
           state.inline = state.f = next;
           return type;
-        }
-      }
-      return type;
     };
   }
 
   return {
     startState: function() {
       return {
         f: blockNormal,
 
         block: blockNormal,
         htmlState: htmlMode.startState(),
         indentation: 0,
 
         inline: inlineNormal,
+        text: handleText,
         em: false,
         strong: false
       };
     },
 
     copyState: function(s) {
       return {
         f: s.f,
 
         block: s.block,
         htmlState: CodeMirror.copyState(htmlMode, s.htmlState),
         indentation: s.indentation,
 
         inline: s.inline,
+        text: s.text,
         em: s.em,
         strong: s.strong
       };
     },
 
     token: function(stream, state) {
       if (stream.sol()) {
         state.f = state.block;
         var previousIndentation = state.indentation
         ,   currentIndentation = 0;
         while (previousIndentation > 0) {
           if (stream.eat(' ')) {
             previousIndentation--;
             currentIndentation++;
           } else if (previousIndentation >= 4 && stream.eat('\t')) {
             previousIndentation -= 4;
             currentIndentation += 4;
           } else {
             break;
           }
         }
         state.indentation = currentIndentation;
 
         if (currentIndentation > 0) return null;
       }
       return state.f(stream, state);
-    }
+    },
+
+    getType: getType
   };
 
 });
 
 CodeMirror.defineMIME("text/x-markdown", "markdown");

IPython/frontend/html/notebook/static/codemirror/mode/python/index.html

@@ -1,123 +1,122 b''
 <!doctype html>
 <html>
   <head>
-    <title>CodeMirror 2: Python mode</title>
+    <title>CodeMirror: Python mode</title>
     <link rel="stylesheet" href="../../lib/codemirror.css">
     <script src="../../lib/codemirror.js"></script>
     <script src="python.js"></script>
-    <link rel="stylesheet" href="../../theme/default.css">
-    <link rel="stylesheet" href="../../css/docs.css">
+    <link rel="stylesheet" href="../../doc/docs.css">
     <style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
   </head>
   <body>
-    <h1>CodeMirror 2: Python mode</h1>
+    <h1>CodeMirror: Python mode</h1>
 
     <div><textarea id="code" name="code">
 # Literals
 1234
 0.0e101
 .123
 0b01010011100
 0o01234567
 0x0987654321abcdef
 7
 2147483647
 3L
 79228162514264337593543950336L
 0x100000000L
 79228162514264337593543950336
 0xdeadbeef
 3.14j
 10.j
 10j
 .001j
 1e100j
 3.14e-10j
 
 
 # String Literals
 'For\''
 "God\""
 """so loved
 the world"""
 '''that he gave
 his only begotten\' '''
 'that whosoever believeth \
 in him'
 ''
 
 # Identifiers
 __a__
 a.b
 a.b.c
 
 # Operators
 + - * / % & | ^ ~ < >
 == != <= >= <> << >> // **
 and or not in is
 
 # Delimiters
 () [] {} , : ` = ; @ .  # Note that @ and . require the proper context.
 += -= *= /= %= &= |= ^=
 //= >>= <<= **=
 
 # Keywords
 as assert break class continue def del elif else except
 finally for from global if import lambda pass raise
 return try while with yield
 
 # Python 2 Keywords (otherwise Identifiers)
 exec print
 
 # Python 3 Keywords (otherwise Identifiers)
 nonlocal
 
 # Types
 bool classmethod complex dict enumerate float frozenset int list object
 property reversed set slice staticmethod str super tuple type
 
 # Python 2 Types (otherwise Identifiers)
 basestring buffer file long unicode xrange
 
 # Python 3 Types (otherwise Identifiers)
 bytearray bytes filter map memoryview open range zip
 
 # Some Example code
 import os
 from package import ParentClass
 
 @nonsenseDecorator
 def doesNothing():
     pass
 
 class ExampleClass(ParentClass):
     @staticmethod
     def example(inputStr):
         a = list(inputStr)
         a.reverse()
         return ''.join(a)
 
     def __init__(self, mixin = 'Hello'):
         self.mixin = mixin
 
 </textarea></div>
     <script>
       var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
         mode: {name: "python",
                version: 2,
                singleLineStringErrors: false},
         lineNumbers: true,
         indentUnit: 4,
         tabMode: "shift",
         matchBrackets: true
       });
     </script>
     <h2>Configuration Options:</h2>
     <ul>
       <li>version - 2/3 - The version of Python to recognize.  Default is 2.</li>
       <li>singleLineStringErrors - true/false - If you have a single-line string that is not terminated at the end of the line, this will show subsequent lines as errors if true, otherwise it will consider the newline as the end of the string. Default is false.</li>
     </ul>
 
     <p><strong>MIME types defined:</strong> <code>text/x-python</code>.</p>
   </body>
 </html>

IPython/frontend/html/notebook/static/codemirror/mode/python/python.js

@@ -1,324 +1,333 b''
 CodeMirror.defineMode("python", function(conf, parserConf) {
     var ERRORCLASS = 'error';
 
     function wordRegexp(words) {
         return new RegExp("^((" + words.join(")|(") + "))\\b");
     }
 
-    // IPython-specific changes: add '?' as recognized character.
-    //var singleOperators = new RegExp("^[\\+\\-\\*/%&|\\^~<>!]");
     var singleOperators = new RegExp("^[\\+\\-\\*/%&|\\^~<>!\\?]");
-    // End IPython changes.
-    
     var singleDelimiters = new RegExp('^[\\(\\)\\[\\]\\{\\}@,:`=;\\.]');
     var doubleOperators = new RegExp("^((==)|(!=)|(<=)|(>=)|(<>)|(<<)|(>>)|(//)|(\\*\\*))");
     var doubleDelimiters = new RegExp("^((\\+=)|(\\-=)|(\\*=)|(%=)|(/=)|(&=)|(\\|=)|(\\^=))");
     var tripleDelimiters = new RegExp("^((//=)|(>>=)|(<<=)|(\\*\\*=))");
     var identifiers = new RegExp("^[_A-Za-z][_A-Za-z0-9]*");
 
     var wordOperators = wordRegexp(['and', 'or', 'not', 'is', 'in']);
     var commonkeywords = ['as', 'assert', 'break', 'class', 'continue',
                           'def', 'del', 'elif', 'else', 'except', 'finally',
                           'for', 'from', 'global', 'if', 'import',
                           'lambda', 'pass', 'raise', 'return',
                           'try', 'while', 'with', 'yield'];
     var commontypes = ['bool', 'classmethod', 'complex', 'dict', 'enumerate',
                        'float', 'frozenset', 'int', 'list', 'object',
                        'property', 'reversed', 'set', 'slice', 'staticmethod',
                        'str', 'super', 'tuple', 'type'];
     var py2 = {'types': ['basestring', 'buffer', 'file', 'long', 'unicode',
                          'xrange'],
                'keywords': ['exec', 'print']};
     var py3 = {'types': ['bytearray', 'bytes', 'filter', 'map', 'memoryview',
                          'open', 'range', 'zip'],
                'keywords': ['nonlocal']};
 
     if (!!parserConf.version && parseInt(parserConf.version, 10) === 3) {
         commonkeywords = commonkeywords.concat(py3.keywords);
         commontypes = commontypes.concat(py3.types);
         var stringPrefixes = new RegExp("^(([rb]|(br))?('{3}|\"{3}|['\"]))", "i");
     } else {
         commonkeywords = commonkeywords.concat(py2.keywords);
         commontypes = commontypes.concat(py2.types);
         var stringPrefixes = new RegExp("^(([rub]|(ur)|(br))?('{3}|\"{3}|['\"]))", "i");
     }
     var keywords = wordRegexp(commonkeywords);
     var types = wordRegexp(commontypes);
 
     var indentInfo = null;
 
     // tokenizers
     function tokenBase(stream, state) {
         // Handle scope changes
         if (stream.sol()) {
             var scopeOffset = state.scopes[0].offset;
             if (stream.eatSpace()) {
                 var lineOffset = stream.indentation();
                 if (lineOffset > scopeOffset) {
                     indentInfo = 'indent';
                 } else if (lineOffset < scopeOffset) {
                     indentInfo = 'dedent';
                 }
                 return null;
             } else {
                 if (scopeOffset > 0) {
                     dedent(stream, state);
                 }
             }
         }
         if (stream.eatSpace()) {
             return null;
         }
 
         var ch = stream.peek();
 
         // Handle Comments
         if (ch === '#') {
             stream.skipToEnd();
             return 'comment';
         }
 
         // Handle Number Literals
         if (stream.match(/^[0-9\.]/, false)) {
             var floatLiteral = false;
             // Floats
             if (stream.match(/^\d*\.\d+(e[\+\-]?\d+)?/i)) { floatLiteral = true; }
             if (stream.match(/^\d+\.\d*/)) { floatLiteral = true; }
             if (stream.match(/^\.\d+/)) { floatLiteral = true; }
             if (floatLiteral) {
                 // Float literals may be "imaginary"
                 stream.eat(/J/i);
                 return 'number';
             }
             // Integers
             var intLiteral = false;
             // Hex
             if (stream.match(/^0x[0-9a-f]+/i)) { intLiteral = true; }
             // Binary
             if (stream.match(/^0b[01]+/i)) { intLiteral = true; }
             // Octal
             if (stream.match(/^0o[0-7]+/i)) { intLiteral = true; }
             // Decimal
             if (stream.match(/^[1-9]\d*(e[\+\-]?\d+)?/)) {
                 // Decimal literals may be "imaginary"
                 stream.eat(/J/i);
                 // TODO - Can you have imaginary longs?
                 intLiteral = true;
             }
             // Zero by itself with no other piece of number.
             if (stream.match(/^0(?![\dx])/i)) { intLiteral = true; }
             if (intLiteral) {
                 // Integer literals may be "long"
                 stream.eat(/L/i);
                 return 'number';
             }
         }
 
         // Handle Strings
         if (stream.match(stringPrefixes)) {
             state.tokenize = tokenStringFactory(stream.current());
             return state.tokenize(stream, state);
         }
 
         // Handle operators and Delimiters
         if (stream.match(tripleDelimiters) || stream.match(doubleDelimiters)) {
             return null;
         }
         if (stream.match(doubleOperators)
             || stream.match(singleOperators)
             || stream.match(wordOperators)) {
             return 'operator';
         }
         if (stream.match(singleDelimiters)) {
             return null;
         }
 
         if (stream.match(types)) {
             return 'builtin';
         }
 
         if (stream.match(keywords)) {
             return 'keyword';
         }
 
         if (stream.match(identifiers)) {
             return 'variable';
         }
 
         // Handle non-detected items
         stream.next();
         return ERRORCLASS;
     }
 
     function tokenStringFactory(delimiter) {
         while ('rub'.indexOf(delimiter.charAt(0).toLowerCase()) >= 0) {
             delimiter = delimiter.substr(1);
         }
         var singleline = delimiter.length == 1;
         var OUTCLASS = 'string';
 
         return function tokenString(stream, state) {
             while (!stream.eol()) {
                 stream.eatWhile(/[^'"\\]/);
                 if (stream.eat('\\')) {
                     stream.next();
                     if (singleline && stream.eol()) {
                         return OUTCLASS;
                     }
                 } else if (stream.match(delimiter)) {
                     state.tokenize = tokenBase;
                     return OUTCLASS;
                 } else {
                     stream.eat(/['"]/);
                 }
             }
             if (singleline) {
                 if (parserConf.singleLineStringErrors) {
                     return ERRORCLASS;
                 } else {
                     state.tokenize = tokenBase;
                 }
             }
             return OUTCLASS;
         };
     }
 
     function indent(stream, state, type) {
         type = type || 'py';
         var indentUnit = 0;
         if (type === 'py') {
+            if (state.scopes[0].type !== 'py') {
+                state.scopes[0].offset = stream.indentation();
+                return;
+            }
             for (var i = 0; i < state.scopes.length; ++i) {
                 if (state.scopes[i].type === 'py') {
                     indentUnit = state.scopes[i].offset + conf.indentUnit;
                     break;
                 }
             }
         } else {
             indentUnit = stream.column() + stream.current().length;
         }
         state.scopes.unshift({
             offset: indentUnit,
             type: type
         });
     }
 
-    function dedent(stream, state) {
+    function dedent(stream, state, type) {
+        type = type || 'py';
         if (state.scopes.length == 1) return;
         if (state.scopes[0].type === 'py') {
             var _indent = stream.indentation();
             var _indent_index = -1;
             for (var i = 0; i < state.scopes.length; ++i) {
                 if (_indent === state.scopes[i].offset) {
                     _indent_index = i;
                     break;
                 }
             }
             if (_indent_index === -1) {
                 return true;
             }
             while (state.scopes[0].offset !== _indent) {
                 state.scopes.shift();
             }
             return false
         } else {
+            if (type === 'py') {
+                state.scopes[0].offset = stream.indentation();
+                return false;
+            } else {
+                if (state.scopes[0].type != type) {
+                    return true;
+                }
             state.scopes.shift();
             return false;
         }
     }
+    }
 
     function tokenLexer(stream, state) {
         indentInfo = null;
         var style = state.tokenize(stream, state);
         var current = stream.current();
 
         // Handle '.' connected identifiers
         if (current === '.') {
             style = state.tokenize(stream, state);
             current = stream.current();
             if (style === 'variable') {
                 return 'variable';
             } else {
                 return ERRORCLASS;
             }
         }
 
         // Handle decorators
         if (current === '@') {
             style = state.tokenize(stream, state);
             current = stream.current();
             if (style === 'variable'
                 || current === '@staticmethod'
                 || current === '@classmethod') {
                 return 'meta';
             } else {
                 return ERRORCLASS;
             }
         }
 
         // Handle scope changes.
         if (current === 'pass' || current === 'return') {
             state.dedent += 1;
         }
         if ((current === ':' && !state.lambda && state.scopes[0].type == 'py')
             || indentInfo === 'indent') {
             indent(stream, state);
         }
         var delimiter_index = '[({'.indexOf(current);
         if (delimiter_index !== -1) {
             indent(stream, state, '])}'.slice(delimiter_index, delimiter_index+1));
         }
         if (indentInfo === 'dedent') {
             if (dedent(stream, state)) {
                 return ERRORCLASS;
             }
         }
         delimiter_index = '])}'.indexOf(current);
         if (delimiter_index !== -1) {
-            if (dedent(stream, state)) {
+            if (dedent(stream, state, current)) {
                 return ERRORCLASS;
             }
         }
         if (state.dedent > 0 && stream.eol() && state.scopes[0].type == 'py') {
             if (state.scopes.length > 1) state.scopes.shift();
             state.dedent -= 1;
         }
 
         return style;
     }
 
     var external = {
         startState: function(basecolumn) {
             return {
               tokenize: tokenBase,
               scopes: [{offset:basecolumn || 0, type:'py'}],
               lastToken: null,
               lambda: false,
               dedent: 0
           };
         },
 
         token: function(stream, state) {
             var style = tokenLexer(stream, state);
 
             state.lastToken = {style:style, content: stream.current()};
 
             if (stream.eol() && stream.lambda) {
                 state.lambda = false;
             }
 
             return style;
         },
 
         indent: function(state, textAfter) {
             if (state.tokenize != tokenBase) {
                 return 0;
             }
 
             return state.scopes[0].offset;
         }
 
     };
     return external;
 });
 
 CodeMirror.defineMIME("text/x-python", "python");

IPython/frontend/html/notebook/static/codemirror/mode/rst/index.html

@@ -1,525 +1,525 b''
 <!doctype html>
 <html>
   <head>
-    <title>CodeMirror 2: reStructuredText mode</title>
+    <title>CodeMirror: reStructuredText mode</title>
     <link rel="stylesheet" href="../../lib/codemirror.css">
     <script src="../../lib/codemirror.js"></script>
     <script src="rst.js"></script>
-    <link rel="stylesheet" href="rst.css">
     <style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
-    <link rel="stylesheet" href="../../css/docs.css">
+    <link rel="stylesheet" href="../../doc/docs.css">
   </head>
   <body>
-    <h1>CodeMirror 2: reStructuredText mode</h1>
+    <h1>CodeMirror: reStructuredText mode</h1>
 
 <form><textarea id="code" name="code">
 .. This is an excerpt from Sphinx documentation: http://sphinx.pocoo.org/_sources/rest.txt
 
 .. highlightlang:: rest
 
 .. _rst-primer:
 
 reStructuredText Primer
 =======================
 
 This section is a brief introduction to reStructuredText (reST) concepts and
 syntax, intended to provide authors with enough information to author documents
 productively.  Since reST was designed to be a simple, unobtrusive markup
 language, this will not take too long.
 
 .. seealso::
 
    The authoritative `reStructuredText User Documentation
    &lt;http://docutils.sourceforge.net/rst.html&gt;`_.  The "ref" links in this
    document link to the description of the individual constructs in the reST
    reference.
 
 
 Paragraphs
 ----------
 
 The paragraph (:duref:`ref &lt;paragraphs&gt;`) is the most basic block in a reST
 document.  Paragraphs are simply chunks of text separated by one or more blank
 lines.  As in Python, indentation is significant in reST, so all lines of the
 same paragraph must be left-aligned to the same level of indentation.
 
 
 .. _inlinemarkup:
 
 Inline markup
 -------------
 
 The standard reST inline markup is quite simple: use
 
 * one asterisk: ``*text*`` for emphasis (italics),
 * two asterisks: ``**text**`` for strong emphasis (boldface), and
 * backquotes: ````text```` for code samples.
 
 If asterisks or backquotes appear in running text and could be confused with
 inline markup delimiters, they have to be escaped with a backslash.
 
 Be aware of some restrictions of this markup:
 
 * it may not be nested,
 * content may not start or end with whitespace: ``* text*`` is wrong,
 * it must be separated from surrounding text by non-word characters.  Use a
   backslash escaped space to work around that: ``thisis\ *one*\ word``.
 
 These restrictions may be lifted in future versions of the docutils.
 
 reST also allows for custom "interpreted text roles"', which signify that the
 enclosed text should be interpreted in a specific way.  Sphinx uses this to
 provide semantic markup and cross-referencing of identifiers, as described in
 the appropriate section.  The general syntax is ``:rolename:`content```.
 
 Standard reST provides the following roles:
 
 * :durole:`emphasis` -- alternate spelling for ``*emphasis*``
 * :durole:`strong` -- alternate spelling for ``**strong**``
 * :durole:`literal` -- alternate spelling for ````literal````
 * :durole:`subscript` -- subscript text
 * :durole:`superscript` -- superscript text
 * :durole:`title-reference` -- for titles of books, periodicals, and other
   materials
 
 See :ref:`inline-markup` for roles added by Sphinx.
 
 
 Lists and Quote-like blocks
 ---------------------------
 
 List markup (:duref:`ref &lt;bullet-lists&gt;`) is natural: just place an asterisk at
 the start of a paragraph and indent properly.  The same goes for numbered lists;
 they can also be autonumbered using a ``#`` sign::
 
    * This is a bulleted list.
    * It has two items, the second
      item uses two lines.
 
    1. This is a numbered list.
    2. It has two items too.
 
    #. This is a numbered list.
    #. It has two items too.
 
 
 Nested lists are possible, but be aware that they must be separated from the
 parent list items by blank lines::
 
    * this is
    * a list
 
      * with a nested list
      * and some subitems
 
    * and here the parent list continues
 
 Definition lists (:duref:`ref &lt;definition-lists&gt;`) are created as follows::
 
    term (up to a line of text)
       Definition of the term, which must be indented
 
       and can even consist of multiple paragraphs
 
    next term
       Description.
 
 Note that the term cannot have more than one line of text.
 
 Quoted paragraphs (:duref:`ref &lt;block-quotes&gt;`) are created by just indenting
 them more than the surrounding paragraphs.
 
 Line blocks (:duref:`ref &lt;line-blocks&gt;`) are a way of preserving line breaks::
 
    | These lines are
    | broken exactly like in
    | the source file.
 
 There are also several more special blocks available:
 
 * field lists (:duref:`ref &lt;field-lists&gt;`)
 * option lists (:duref:`ref &lt;option-lists&gt;`)
 * quoted literal blocks (:duref:`ref &lt;quoted-literal-blocks&gt;`)
 * doctest blocks (:duref:`ref &lt;doctest-blocks&gt;`)
 
 
 Source Code
 -----------
 
 Literal code blocks (:duref:`ref &lt;literal-blocks&gt;`) are introduced by ending a
 paragraph with the special marker ``::``.  The literal block must be indented
 (and, like all paragraphs, separated from the surrounding ones by blank lines)::
 
    This is a normal text paragraph. The next paragraph is a code sample::
 
       It is not processed in any way, except
       that the indentation is removed.
 
       It can span multiple lines.
 
    This is a normal text paragraph again.
 
 The handling of the ``::`` marker is smart:
 
 * If it occurs as a paragraph of its own, that paragraph is completely left
   out of the document.
 * If it is preceded by whitespace, the marker is removed.
 * If it is preceded by non-whitespace, the marker is replaced by a single
   colon.
 
 That way, the second sentence in the above example's first paragraph would be
 rendered as "The next paragraph is a code sample:".
 
 
 .. _rst-tables:
 
 Tables
 ------
 
 Two forms of tables are supported.  For *grid tables* (:duref:`ref
 &lt;grid-tables&gt;`), you have to "paint" the cell grid yourself.  They look like
 this::
 
    +------------------------+------------+----------+----------+
    | Header row, column 1   | Header 2   | Header 3 | Header 4 |
    | (header rows optional) |            |          |          |
    +========================+============+==========+==========+
    | body row 1, column 1   | column 2   | column 3 | column 4 |
    +------------------------+------------+----------+----------+
    | body row 2             | ...        | ...      |          |
    +------------------------+------------+----------+----------+
 
 *Simple tables* (:duref:`ref &lt;simple-tables&gt;`) are easier to write, but
 limited: they must contain more than one row, and the first column cannot
 contain multiple lines.  They look like this::
 
    =====  =====  =======
    A      B      A and B
    =====  =====  =======
    False  False  False
    True   False  False
    False  True   False
    True   True   True
    =====  =====  =======
 
 
 Hyperlinks
 ----------
 
 External links
 ^^^^^^^^^^^^^^
 
 Use ```Link text &lt;http://example.com/&gt;`_`` for inline web links.  If the link
 text should be the web address, you don't need special markup at all, the parser
 finds links and mail addresses in ordinary text.
 
 You can also separate the link and the target definition (:duref:`ref
 &lt;hyperlink-targets&gt;`), like this::
 
    This is a paragraph that contains `a link`_.
 
    .. _a link: http://example.com/
 
 
 Internal links
 ^^^^^^^^^^^^^^
 
 Internal linking is done via a special reST role provided by Sphinx, see the
 section on specific markup, :ref:`ref-role`.
 
 
 Sections
 --------
 
 Section headers (:duref:`ref &lt;sections&gt;`) are created by underlining (and
 optionally overlining) the section title with a punctuation character, at least
 as long as the text::
 
    =================
    This is a heading
    =================
 
 Normally, there are no heading levels assigned to certain characters as the
 structure is determined from the succession of headings.  However, for the
 Python documentation, this convention is used which you may follow:
 
 * ``#`` with overline, for parts
 * ``*`` with overline, for chapters
 * ``=``, for sections
 * ``-``, for subsections
 * ``^``, for subsubsections
 * ``"``, for paragraphs
 
 Of course, you are free to use your own marker characters (see the reST
 documentation), and use a deeper nesting level, but keep in mind that most
 target formats (HTML, LaTeX) have a limited supported nesting depth.
 
 
 Explicit Markup
 ---------------
 
 "Explicit markup" (:duref:`ref &lt;explicit-markup-blocks&gt;`) is used in reST for
 most constructs that need special handling, such as footnotes,
 specially-highlighted paragraphs, comments, and generic directives.
 
 An explicit markup block begins with a line starting with ``..`` followed by
 whitespace and is terminated by the next paragraph at the same level of
 indentation.  (There needs to be a blank line between explicit markup and normal
 paragraphs.  This may all sound a bit complicated, but it is intuitive enough
 when you write it.)
 
 
 .. _directives:
 
 Directives
 ----------
 
 A directive (:duref:`ref &lt;directives&gt;`) is a generic block of explicit markup.
 Besides roles, it is one of the extension mechanisms of reST, and Sphinx makes
 heavy use of it.
 
 Docutils supports the following directives:
 
 * Admonitions: :dudir:`attention`, :dudir:`caution`, :dudir:`danger`,
   :dudir:`error`, :dudir:`hint`, :dudir:`important`, :dudir:`note`,
   :dudir:`tip`, :dudir:`warning` and the generic :dudir:`admonition`.
   (Most themes style only "note" and "warning" specially.)
 
 * Images:
 
   - :dudir:`image` (see also Images_ below)
   - :dudir:`figure` (an image with caption and optional legend)
 
 * Additional body elements:
 
   - :dudir:`contents` (a local, i.e. for the current file only, table of
     contents)
   - :dudir:`container` (a container with a custom class, useful to generate an
     outer ``&lt;div&gt;`` in HTML)
   - :dudir:`rubric` (a heading without relation to the document sectioning)
   - :dudir:`topic`, :dudir:`sidebar` (special highlighted body elements)
   - :dudir:`parsed-literal` (literal block that supports inline markup)
   - :dudir:`epigraph` (a block quote with optional attribution line)
   - :dudir:`highlights`, :dudir:`pull-quote` (block quotes with their own
     class attribute)
   - :dudir:`compound` (a compound paragraph)
 
 * Special tables:
 
   - :dudir:`table` (a table with title)
   - :dudir:`csv-table` (a table generated from comma-separated values)
   - :dudir:`list-table` (a table generated from a list of lists)
 
 * Special directives:
 
   - :dudir:`raw` (include raw target-format markup)
   - :dudir:`include` (include reStructuredText from another file)
     -- in Sphinx, when given an absolute include file path, this directive takes
     it as relative to the source directory
   - :dudir:`class` (assign a class attribute to the next element) [1]_
 
 * HTML specifics:
 
   - :dudir:`meta` (generation of HTML ``&lt;meta&gt;`` tags)
   - :dudir:`title` (override document title)
 
 * Influencing markup:
 
   - :dudir:`default-role` (set a new default role)
   - :dudir:`role` (create a new role)
 
   Since these are only per-file, better use Sphinx' facilities for setting the
   :confval:`default_role`.
 
 Do *not* use the directives :dudir:`sectnum`, :dudir:`header` and
 :dudir:`footer`.
 
 Directives added by Sphinx are described in :ref:`sphinxmarkup`.
 
 Basically, a directive consists of a name, arguments, options and content. (Keep
 this terminology in mind, it is used in the next chapter describing custom
 directives.)  Looking at this example, ::
 
    .. function:: foo(x)
                  foo(y, z)
       :module: some.module.name
 
       Return a line of text input from the user.
 
 ``function`` is the directive name.  It is given two arguments here, the
 remainder of the first line and the second line, as well as one option
 ``module`` (as you can see, options are given in the lines immediately following
 the arguments and indicated by the colons).  Options must be indented to the
 same level as the directive content.
 
 The directive content follows after a blank line and is indented relative to the
 directive start.
 
 
 Images
 ------
 
 reST supports an image directive (:dudir:`ref &lt;image&gt;`), used like so::
 
    .. image:: gnu.png
       (options)
 
 When used within Sphinx, the file name given (here ``gnu.png``) must either be
 relative to the source file, or absolute which means that they are relative to
 the top source directory.  For example, the file ``sketch/spam.rst`` could refer
 to the image ``images/spam.png`` as ``../images/spam.png`` or
 ``/images/spam.png``.
 
 Sphinx will automatically copy image files over to a subdirectory of the output
 directory on building (e.g. the ``_static`` directory for HTML output.)
 
 Interpretation of image size options (``width`` and ``height``) is as follows:
 if the size has no unit or the unit is pixels, the given size will only be
 respected for output channels that support pixels (i.e. not in LaTeX output).
 Other units (like ``pt`` for points) will be used for HTML and LaTeX output.
 
 Sphinx extends the standard docutils behavior by allowing an asterisk for the
 extension::
 
    .. image:: gnu.*
 
 Sphinx then searches for all images matching the provided pattern and determines
 their type.  Each builder then chooses the best image out of these candidates.
 For instance, if the file name ``gnu.*`` was given and two files :file:`gnu.pdf`
 and :file:`gnu.png` existed in the source tree, the LaTeX builder would choose
 the former, while the HTML builder would prefer the latter.
 
 .. versionchanged:: 0.4
    Added the support for file names ending in an asterisk.
 
 .. versionchanged:: 0.6
    Image paths can now be absolute.
 
 
 Footnotes
 ---------
 
 For footnotes (:duref:`ref &lt;footnotes&gt;`), use ``[#name]_`` to mark the footnote
 location, and add the footnote body at the bottom of the document after a
 "Footnotes" rubric heading, like so::
 
    Lorem ipsum [#f1]_ dolor sit amet ... [#f2]_
 
    .. rubric:: Footnotes
 
    .. [#f1] Text of the first footnote.
    .. [#f2] Text of the second footnote.
 
 You can also explicitly number the footnotes (``[1]_``) or use auto-numbered
 footnotes without names (``[#]_``).
 
 
 Citations
 ---------
 
 Standard reST citations (:duref:`ref &lt;citations&gt;`) are supported, with the
 additional feature that they are "global", i.e. all citations can be referenced
 from all files.  Use them like so::
 
    Lorem ipsum [Ref]_ dolor sit amet.
 
    .. [Ref] Book or article reference, URL or whatever.
 
 Citation usage is similar to footnote usage, but with a label that is not
 numeric or begins with ``#``.
 
 
 Substitutions
 -------------
 
 reST supports "substitutions" (:duref:`ref &lt;substitution-definitions&gt;`), which
 are pieces of text and/or markup referred to in the text by ``|name|``.  They
 are defined like footnotes with explicit markup blocks, like this::
 
    .. |name| replace:: replacement *text*
 
 or this::
 
    .. |caution| image:: warning.png
                 :alt: Warning!
 
 See the :duref:`reST reference for substitutions &lt;substitution-definitions&gt;`
 for details.
 
 If you want to use some substitutions for all documents, put them into
 :confval:`rst_prolog` or put them into a separate file and include it into all
 documents you want to use them in, using the :rst:dir:`include` directive.  (Be
 sure to give the include file a file name extension differing from that of other
 source files, to avoid Sphinx finding it as a standalone document.)
 
 Sphinx defines some default substitutions, see :ref:`default-substitutions`.
 
 
 Comments
 --------
 
 Every explicit markup block which isn't a valid markup construct (like the
 footnotes above) is regarded as a comment (:duref:`ref &lt;comments&gt;`).  For
 example::
 
    .. This is a comment.
 
 You can indent text after a comment start to form multiline comments::
 
    ..
       This whole indented block
       is a comment.
 
       Still in the comment.
 
 
 Source encoding
 ---------------
 
 Since the easiest way to include special characters like em dashes or copyright
 signs in reST is to directly write them as Unicode characters, one has to
 specify an encoding.  Sphinx assumes source files to be encoded in UTF-8 by
 default; you can change this with the :confval:`source_encoding` config value.
 
 
 Gotchas
 -------
 
 There are some problems one commonly runs into while authoring reST documents:
 
 * **Separation of inline markup:** As said above, inline markup spans must be
   separated from the surrounding text by non-word characters, you have to use a
   backslash-escaped space to get around that.  See `the reference
   &lt;http://docutils.sf.net/docs/ref/rst/restructuredtext.html#inline-markup&gt;`_
   for the details.
 
 * **No nested inline markup:** Something like ``*see :func:`foo`*`` is not
   possible.
 
 
 .. rubric:: Footnotes
 
 .. [1] When the default domain contains a :rst:dir:`class` directive, this directive
        will be shadowed.  Therefore, Sphinx re-exports it as :rst:dir:`rst-class`.
 </textarea></form>
 
     <script>
       var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
         lineNumbers: true,
       });
     </script>
     <p>The reStructuredText mode supports one configuration parameter:</p>
     <dl>
       <dt><code>verbatim (string)</code></dt>
       <dd>A name or MIME type of a mode that will be used for highlighting
       verbatim blocks. By default, reStructuredText mode uses uniform color
       for whole block of verbatim text if no mode is given.</dd>
     </dl>
-    <p>If <code>python</code> mode is available (not a part of CodeMirror 2 yet),
+    <p>If <code>python</code> mode is available,
     it will be used for highlighting blocks containing Python/IPython terminal
     sessions (blocks starting with <code>&gt;&gt;&gt;</code> (for Python) or
     <code>In [num]:</code> (for IPython).
 
     <p><strong>MIME types defined:</strong> <code>text/x-rst</code>.</p>
   </body>
 </html>
+

IPython/frontend/html/notebook/static/codemirror/mode/rst/rst.js

@@ -1,333 +1,326 b''
 CodeMirror.defineMode('rst', function(config, options) {
     function setState(state, fn, ctx) {
         state.fn = fn;
         setCtx(state, ctx);
     }
 
     function setCtx(state, ctx) {
         state.ctx = ctx || {};
     }
 
     function setNormal(state, ch) {
         if (ch && (typeof ch !== 'string')) {
             var str = ch.current();
             ch = str[str.length-1];
         }
 
         setState(state, normal, {back: ch});
     }
 
     function hasMode(mode) {
         if (mode) {
             var modes = CodeMirror.listModes();
 
             for (var i in modes) {
                 if (modes[i] == mode) {
                     return true;
                 }
             }
         }
 
         return false;
     }
 
     function getMode(mode) {
         if (hasMode(mode)) {
             return CodeMirror.getMode(config, mode);
         } else {
             return null;
         }
     }
 
     var verbatimMode = getMode(options.verbatim);
     var pythonMode = getMode('python');
 
     var reSection = /^[!"#$%&'()*+,-./:;<=>?@[\\\]^_`{|}~]/;
     var reDirective = /^\s*\w([-:.\w]*\w)?::(\s|$)/;
     var reHyperlink = /^\s*_[\w-]+:(\s|$)/;
     var reFootnote = /^\s*\[(\d+|#)\](\s|$)/;
     var reCitation = /^\s*\[[A-Za-z][\w-]*\](\s|$)/;
     var reFootnoteRef = /^\[(\d+|#)\]_/;
     var reCitationRef = /^\[[A-Za-z][\w-]*\]_/;
     var reDirectiveMarker = /^\.\.(\s|$)/;
     var reVerbatimMarker = /^::\s*$/;
     var rePreInline = /^[-\s"([{</:]/;
     var rePostInline = /^[-\s`'")\]}>/:.,;!?\\_]/;
     var reEnumeratedList = /^\s*((\d+|[A-Za-z#])[.)]|\((\d+|[A-Z-a-z#])\))\s/;
     var reBulletedList = /^\s*[-\+\*]\s/;
     var reExamples = /^\s+(>>>|In \[\d+\]:)\s/;
 
     function normal(stream, state) {
         var ch, sol, i;
 
         if (stream.eat(/\\/)) {
             ch = stream.next();
             setNormal(state, ch);
             return null;
         }
 
         sol = stream.sol();
 
         if (sol && (ch = stream.eat(reSection))) {
             for (i = 0; stream.eat(ch); i++);
 
             if (i >= 3 && stream.match(/^\s*$/)) {
                 setNormal(state, null);
-                return 'section';
+                return 'header';
             } else {
                 stream.backUp(i + 1);
             }
         }
 
         if (sol && stream.match(reDirectiveMarker)) {
             if (!stream.eol()) {
                 setState(state, directive);
             }
-
-            return 'directive-marker';
+            return 'meta';
         }
 
         if (stream.match(reVerbatimMarker)) {
             if (!verbatimMode) {
                 setState(state, verbatim);
             } else {
                 var mode = verbatimMode;
 
                 setState(state, verbatim, {
                     mode: mode,
                     local: mode.startState()
                 });
             }
-
-            return 'verbatim-marker';
+            return 'meta';
         }
 
         if (sol && stream.match(reExamples, false)) {
             if (!pythonMode) {
                 setState(state, verbatim);
-                return 'verbatim-marker';
+                return 'meta';
             } else {
                 var mode = pythonMode;
 
                 setState(state, verbatim, {
                     mode: mode,
                     local: mode.startState()
                 });
 
                 return null;
             }
         }
 
-        if (sol && (stream.match(reEnumeratedList) ||
-                    stream.match(reBulletedList))) {
-            setNormal(state, stream);
-            return 'list';
-        }
-
         function testBackward(re) {
             return sol || !state.ctx.back || re.test(state.ctx.back);
         }
 
         function testForward(re) {
             return stream.eol() || stream.match(re, false);
         }
 
         function testInline(re) {
             return stream.match(re) && testBackward(/\W/) && testForward(/\W/);
         }
 
         if (testInline(reFootnoteRef)) {
             setNormal(state, stream);
             return 'footnote';
         }
 
         if (testInline(reCitationRef)) {
             setNormal(state, stream);
             return 'citation';
         }
 
         ch = stream.next();
 
         if (testBackward(rePreInline)) {
             if ((ch === ':' || ch === '|') && stream.eat(/\S/)) {
                 var token;
 
                 if (ch === ':') {
-                    token = 'role';
+                    token = 'builtin';
                 } else {
-                    token = 'replacement';
+                    token = 'atom';
                 }
 
                 setState(state, inline, {
                     ch: ch,
                     wide: false,
                     prev: null,
                     token: token
                 });
 
                 return token;
             }
 
             if (ch === '*' || ch === '`') {
                 var orig = ch,
                     wide = false;
 
                 ch = stream.next();
 
                 if (ch == orig) {
                     wide = true;
                     ch = stream.next();
                 }
 
                 if (ch && !/\s/.test(ch)) {
                     var token;
 
                     if (orig === '*') {
-                        token = wide ? 'strong' : 'emphasis';
+                        token = wide ? 'strong' : 'em';
                     } else {
-                        token = wide ? 'inline' : 'interpreted';
+                        token = wide ? 'string' : 'string-2';
                     }
 
                     setState(state, inline, {
                         ch: orig,               // inline() has to know what to search for
                         wide: wide,             // are we looking for `ch` or `chch`
                         prev: null,             // terminator must not be preceeded with whitespace
                         token: token            // I don't want to recompute this all the time
                     });
 
                     return token;
                 }
             }
         }
 
         setNormal(state, ch);
         return null;
     }
 
     function inline(stream, state) {
         var ch = stream.next(),
             token = state.ctx.token;
 
         function finish(ch) {
             state.ctx.prev = ch;
             return token;
         }
 
         if (ch != state.ctx.ch) {
             return finish(ch);
         }
 
         if (/\s/.test(state.ctx.prev)) {
             return finish(ch);
         }
 
         if (state.ctx.wide) {
             ch = stream.next();
 
             if (ch != state.ctx.ch) {
                 return finish(ch);
             }
         }
 
         if (!stream.eol() && !rePostInline.test(stream.peek())) {
             if (state.ctx.wide) {
                 stream.backUp(1);
             }
 
             return finish(ch);
         }
 
         setState(state, normal);
         setNormal(state, ch);
 
         return token;
     }
 
     function directive(stream, state) {
         var token = null;
 
         if (stream.match(reDirective)) {
-            token = 'directive';
+            token = 'attribute';
         } else if (stream.match(reHyperlink)) {
-            token = 'hyperlink';
+            token = 'link';
         } else if (stream.match(reFootnote)) {
-            token = 'footnote';
+            token = 'quote';
         } else if (stream.match(reCitation)) {
-            token = 'citation';
+            token = 'quote';
         } else {
             stream.eatSpace();
 
             if (stream.eol()) {
                 setNormal(state, stream);
                 return null;
             } else {
                 stream.skipToEnd();
                 setState(state, comment);
                 return 'comment';
             }
         }
 
+        // FIXME this is unreachable
         setState(state, body, {start: true});
         return token;
     }
 
     function body(stream, state) {
         var token = 'body';
 
         if (!state.ctx.start || stream.sol()) {
             return block(stream, state, token);
         }
 
         stream.skipToEnd();
         setCtx(state);
 
         return token;
     }
 
     function comment(stream, state) {
         return block(stream, state, 'comment');
     }
 
     function verbatim(stream, state) {
         if (!verbatimMode) {
-            return block(stream, state, 'verbatim');
+            return block(stream, state, 'meta');
         } else {
             if (stream.sol()) {
                 if (!stream.eatSpace()) {
                     setNormal(state, stream);
                 }
 
                 return null;
             }
 
             return verbatimMode.token(stream, state.ctx.local);
         }
     }
 
     function block(stream, state, token) {
         if (stream.eol() || stream.eatSpace()) {
             stream.skipToEnd();
             return token;
         } else {
             setNormal(state, stream);
             return null;
         }
     }
 
     return {
         startState: function() {
             return {fn: normal, ctx: {}};
         },
 
         copyState: function(state) {
             return {fn: state.fn, ctx: state.ctx};
         },
 
         token: function(stream, state) {
             var token = state.fn(stream, state);
             return token;
         }
     };
 });
 
 CodeMirror.defineMIME("text/x-rst", "rst");

IPython/frontend/html/notebook/static/codemirror/mode/xml/index.html

@@ -1,42 +1,44 b''
 <!doctype html>
 <html>
   <head>
-    <title>CodeMirror 2: XML mode</title>
+    <title>CodeMirror: XML mode</title>
     <link rel="stylesheet" href="../../lib/codemirror.css">
     <script src="../../lib/codemirror.js"></script>
     <script src="xml.js"></script>
-    <link rel="stylesheet" href="../../theme/default.css">
     <style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
-    <link rel="stylesheet" href="../../css/docs.css">
+    <link rel="stylesheet" href="../../doc/docs.css">
   </head>
   <body>
-    <h1>CodeMirror 2: XML mode</h1>
+    <h1>CodeMirror: XML mode</h1>
     <form><textarea id="code" name="code">
 &lt;html style="color: green"&gt;
   &lt;!-- this is a comment --&gt;
   &lt;head&gt;
     &lt;title&gt;HTML Example&lt;/title&gt;
   &lt;/head&gt;
   &lt;body&gt;
     The indentation tries to be &lt;em&gt;somewhat &amp;quot;do what
     I mean&amp;quot;&lt;/em&gt;... but might not match your style.
   &lt;/body&gt;
 &lt;/html&gt;
 </textarea></form>
     <script>
-      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {mode: {name: "xml", htmlMode: true}});
+      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
+        mode: {name: "xml", alignCDATA: true},
+        lineNumbers: true
+      });
     </script>
     <p>The XML mode supports two configuration parameters:</p>
     <dl>
       <dt><code>htmlMode (boolean)</code></dt>
       <dd>This switches the mode to parse HTML instead of XML. This
       means attributes do not have to be quoted, and some elements
       (such as <code>br</code>) do not require a closing tag.</dd>
       <dt><code>alignCDATA (boolean)</code></dt>
       <dd>Setting this to true will force the opening tag of CDATA
       blocks to not be indented.</dd>
     </dl>
 
     <p><strong>MIME types defined:</strong> <code>application/xml</code>, <code>text/html</code>.</p>
   </body>
 </html>

IPython/frontend/html/notebook/static/codemirror/mode/xml/xml.js

@@ -1,231 +1,252 b''
 CodeMirror.defineMode("xml", function(config, parserConfig) {
   var indentUnit = config.indentUnit;
   var Kludges = parserConfig.htmlMode ? {
     autoSelfClosers: {"br": true, "img": true, "hr": true, "link": true, "input": true,
                       "meta": true, "col": true, "frame": true, "base": true, "area": true},
-    doNotIndent: {"pre": true, "!cdata": true},
+    doNotIndent: {"pre": true},
     allowUnquoted: true
-  } : {autoSelfClosers: {}, doNotIndent: {"!cdata": true}, allowUnquoted: false};
+  } : {autoSelfClosers: {}, doNotIndent: {}, allowUnquoted: false};
   var alignCDATA = parserConfig.alignCDATA;
 
   // Return variables for tokenizers
   var tagName, type;
 
   function inText(stream, state) {
     function chain(parser) {
       state.tokenize = parser;
       return parser(stream, state);
     }
 
     var ch = stream.next();
     if (ch == "<") {
       if (stream.eat("!")) {
         if (stream.eat("[")) {
           if (stream.match("CDATA[")) return chain(inBlock("atom", "]]>"));
           else return null;
         }
         else if (stream.match("--")) return chain(inBlock("comment", "-->"));
         else if (stream.match("DOCTYPE", true, true)) {
           stream.eatWhile(/[\w\._\-]/);
-          return chain(inBlock("meta", ">"));
+          return chain(doctype(1));
         }
         else return null;
       }
       else if (stream.eat("?")) {
         stream.eatWhile(/[\w\._\-]/);
         state.tokenize = inBlock("meta", "?>");
         return "meta";
       }
       else {
         type = stream.eat("/") ? "closeTag" : "openTag";
         stream.eatSpace();
         tagName = "";
         var c;
         while ((c = stream.eat(/[^\s\u00a0=<>\"\'\/?]/))) tagName += c;
         state.tokenize = inTag;
         return "tag";
       }
     }
     else if (ch == "&") {
       stream.eatWhile(/[^;]/);
       stream.eat(";");
       return "atom";
     }
     else {
       stream.eatWhile(/[^&<]/);
       return null;
     }
   }
 
   function inTag(stream, state) {
     var ch = stream.next();
     if (ch == ">" || (ch == "/" && stream.eat(">"))) {
       state.tokenize = inText;
       type = ch == ">" ? "endTag" : "selfcloseTag";
       return "tag";
     }
     else if (ch == "=") {
       type = "equals";
       return null;
     }
     else if (/[\'\"]/.test(ch)) {
       state.tokenize = inAttribute(ch);
       return state.tokenize(stream, state);
     }
     else {
       stream.eatWhile(/[^\s\u00a0=<>\"\'\/?]/);
       return "word";
     }
   }
 
   function inAttribute(quote) {
     return function(stream, state) {
       while (!stream.eol()) {
         if (stream.next() == quote) {
           state.tokenize = inTag;
           break;
         }
       }
       return "string";
     };
   }
 
   function inBlock(style, terminator) {
     return function(stream, state) {
       while (!stream.eol()) {
         if (stream.match(terminator)) {
           state.tokenize = inText;
           break;
         }
         stream.next();
       }
       return style;
     };
   }
+  function doctype(depth) {
+    return function(stream, state) {
+      var ch;
+      while ((ch = stream.next()) != null) {
+        if (ch == "<") {
+          state.tokenize = doctype(depth + 1);
+          return state.tokenize(stream, state);
+        } else if (ch == ">") {
+          if (depth == 1) {
+            state.tokenize = inText;
+            break;
+          } else {
+            state.tokenize = doctype(depth - 1);
+            return state.tokenize(stream, state);
+          }
+        }
+      }
+      return "meta";
+    };
+  }
 
   var curState, setStyle;
   function pass() {
     for (var i = arguments.length - 1; i >= 0; i--) curState.cc.push(arguments[i]);
   }
   function cont() {
     pass.apply(null, arguments);
     return true;
   }
 
   function pushContext(tagName, startOfLine) {
     var noIndent = Kludges.doNotIndent.hasOwnProperty(tagName) || (curState.context && curState.context.noIndent);
     curState.context = {
       prev: curState.context,
       tagName: tagName,
       indent: curState.indented,
       startOfLine: startOfLine,
       noIndent: noIndent
     };
   }
   function popContext() {
     if (curState.context) curState.context = curState.context.prev;
   }
 
   function element(type) {
-    if (type == "openTag") {curState.tagName = tagName; return cont(attributes, endtag(curState.startOfLine));}
-    else if (type == "closeTag") {
+    if (type == "openTag") {
+      curState.tagName = tagName;
+      return cont(attributes, endtag(curState.startOfLine));
+    } else if (type == "closeTag") {
       var err = false;
       if (curState.context) {
         err = curState.context.tagName != tagName;
       } else {
         err = true;
       }
       if (err) setStyle = "error";
       return cont(endclosetag(err));
     }
-    else if (type == "string") {
-      if (!curState.context || curState.context.name != "!cdata") pushContext("!cdata");
-      if (curState.tokenize == inText) popContext();
       return cont();
     }
-    else return cont();
-  }
   function endtag(startOfLine) {
     return function(type) {
       if (type == "selfcloseTag" ||
           (type == "endTag" && Kludges.autoSelfClosers.hasOwnProperty(curState.tagName.toLowerCase())))
         return cont();
       if (type == "endTag") {pushContext(curState.tagName, startOfLine); return cont();}
       return cont();
     };
   }
   function endclosetag(err) {
     return function(type) {
       if (err) setStyle = "error";
       if (type == "endTag") { popContext(); return cont(); }
       setStyle = "error";
       return cont(arguments.callee);
     }
   }
 
   function attributes(type) {
     if (type == "word") {setStyle = "attribute"; return cont(attributes);}
     if (type == "equals") return cont(attvalue, attributes);
+    if (type == "string") {setStyle = "error"; return cont(attributes);}
     return pass();
   }
   function attvalue(type) {
     if (type == "word" && Kludges.allowUnquoted) {setStyle = "string"; return cont();}
     if (type == "string") return cont(attvaluemaybe);
     return pass();
   }
   function attvaluemaybe(type) {
     if (type == "string") return cont(attvaluemaybe);
     else return pass();
   }
 
   return {
     startState: function() {
       return {tokenize: inText, cc: [], indented: 0, startOfLine: true, tagName: null, context: null};
     },
 
     token: function(stream, state) {
       if (stream.sol()) {
         state.startOfLine = true;
         state.indented = stream.indentation();
       }
       if (stream.eatSpace()) return null;
 
       setStyle = type = tagName = null;
       var style = state.tokenize(stream, state);
+      state.type = type;
       if ((style || type) && style != "comment") {
         curState = state;
         while (true) {
           var comb = state.cc.pop() || element;
           if (comb(type || style)) break;
         }
       }
       state.startOfLine = false;
       return setStyle || style;
     },
 
-    indent: function(state, textAfter) {
+    indent: function(state, textAfter, fullLine) {
       var context = state.context;
-      if (context && context.noIndent) return 0;
+      if ((state.tokenize != inTag && state.tokenize != inText) ||
+          context && context.noIndent)
+        return fullLine ? fullLine.match(/^(\s*)/)[0].length : 0;
       if (alignCDATA && /<!\[CDATA\[/.test(textAfter)) return 0;
       if (context && /^<\//.test(textAfter))
         context = context.prev;
       while (context && !context.startOfLine)
         context = context.prev;
       if (context) return context.indent + indentUnit;
       else return 0;
     },
 
     compareStates: function(a, b) {
-      if (a.indented != b.indented) return false;
+      if (a.indented != b.indented || a.tokenize != b.tokenize) return false;
       for (var ca = a.context, cb = b.context; ; ca = ca.prev, cb = cb.prev) {
         if (!ca || !cb) return ca == cb;
         if (ca.tagName != cb.tagName) return false;
       }
     },
 
     electricChars: "/"
   };
 });
 
 CodeMirror.defineMIME("application/xml", "xml");
 CodeMirror.defineMIME("text/html", {name: "xml", htmlMode: true});

IPython/frontend/html/notebook/static/codemirror/theme/elegant.css

@@ -1,9 +1,10 b''
 .cm-s-elegant span.cm-number, .cm-s-elegant span.cm-string, .cm-s-elegant span.cm-atom {color: #762;}
 .cm-s-elegant span.cm-comment {color: #262;font-style: italic;}
 .cm-s-elegant span.cm-meta {color: #555;font-style: italic;}
 .cm-s-elegant span.cm-variable {color: black;}
 .cm-s-elegant span.cm-variable-2 {color: #b11;}
 .cm-s-elegant span.cm-qualifier {color: #555;}
 .cm-s-elegant span.cm-keyword {color: #730;}
 .cm-s-elegant span.cm-builtin {color: #30a;}
 .cm-s-elegant span.cm-error {background-color: #fdd;}
+.cm-s-elegant span.cm-link {color: #762;}

IPython/frontend/html/notebook/static/codemirror/theme/neat.css

@@ -1,8 +1,9 b''
 .cm-s-neat span.cm-comment { color: #a86; }
 .cm-s-neat span.cm-keyword { font-weight: bold; color: blue; }
 .cm-s-neat span.cm-string { color: #a22; }
 .cm-s-neat span.cm-builtin { font-weight: bold; color: #077; }
 .cm-s-neat span.cm-special { font-weight: bold; color: #0aa; }
 .cm-s-neat span.cm-variable { color: black; }
 .cm-s-neat span.cm-number, .cm-s-neat span.cm-atom { color: #3a3; }
 .cm-s-neat span.cm-meta {color: #555;}
+.cm-s-neat span.cm-link { color: #3a3; }

IPython/frontend/html/notebook/static/codemirror/theme/night.css

@@ -1,20 +1,21 b''
 /* Loosely based on the Midnight Textmate theme */
 
 .cm-s-night { background: #0a001f; color: #f8f8f8; }
 .cm-s-night span.CodeMirror-selected { background: #a8f !important; }
 .cm-s-night .CodeMirror-gutter { background: #0a001f; border-right: 1px solid #aaa; }
 .cm-s-night .CodeMirror-gutter-text { color: #f8f8f8; }
 .cm-s-night .CodeMirror-cursor { border-left: 1px solid white !important; }
 
 .cm-s-night span.cm-comment { color: #6900a1; }
 .cm-s-night span.cm-atom { color: #845dc4; }
 .cm-s-night span.cm-number, .cm-s-night span.cm-attribute { color: #ffd500; }
 .cm-s-night span.cm-keyword { color: #599eff; }
 .cm-s-night span.cm-string { color: #37f14a; }
 .cm-s-night span.cm-meta { color: #7678e2; }
 .cm-s-night span.cm-variable-2, .cm-s-night span.cm-tag { color: #99b2ff; }
 .cm-s-night span.cm-variable-3, .cm-s-night span.cm-def { color: white; }
 .cm-s-night span.cm-error { color: #9d1e15; }
 .cm-s-night span.cm-bracket { color: #8da6ce; }
 .cm-s-night span.cm-comment { color: #6900a1; }
 .cm-s-night span.cm-builtin, .cm-s-night span.cm-special { color: #ff9e59; }
+.cm-s-night span.cm-link { color: #845dc4; }

IPython/frontend/html/notebook/templates/notebook.html

@@ -1,208 +1,205 b''
 <!DOCTYPE HTML>
 <html>
 
 <head>
     <meta charset="utf-8">
 
     <title>IPython Notebook</title>
 
     {% if mathjax_url %}
     <script type="text/javascript" src="{{mathjax_url}}?config=TeX-AMS_HTML" charset="utf-8"></script>
     {% end %}
     <script type="text/javascript">
     // MathJax disabled, set as null to distingish from *missing* MathJax,
     // where it will be undefined, and should prompt a dialog later.
     window.mathjax_url = "{{mathjax_url}}";
     </script>
 
     <link rel="stylesheet" href="/static/jquery/css/themes/base/jquery-ui.min.css" type="text/css" />
     <link rel="stylesheet" href="/static/codemirror/lib/codemirror.css">
-    <link rel="stylesheet" href="/static/codemirror/mode/markdown/markdown.css">
-    <link rel="stylesheet" href="/static/codemirror/mode/rst/rst.css">
     <link rel="stylesheet" href="/static/codemirror/theme/ipython.css">
-    <link rel="stylesheet" href="/static/codemirror/theme/default.css">
 
     <link rel="stylesheet" href="/static/prettify/prettify.css"/>
 
     <link rel="stylesheet" href="/static/css/boilerplate.css" type="text/css" />
     <link rel="stylesheet" href="/static/css/layout.css" type="text/css" />
     <link rel="stylesheet" href="/static/css/base.css" type="text/css" />
     <link rel="stylesheet" href="/static/css/notebook.css" type="text/css" />
     <link rel="stylesheet" href="/static/css/renderedhtml.css" type="text/css" />
 
     {% comment  In the notebook, the read-only flag is used to determine %}
     {% comment  whether to hide the side panels and switch off input %}
     <meta name="read_only" content="{{read_only and not logged_in}}"/>
 
 </head>
 
 <body
     data-project={{project}} data-notebook-id={{notebook_id}}
     data-base-project-url={{base_project_url}} data-base-kernel-url={{base_kernel_url}}
 >
 
 <div id="header">
     <span id="ipython_notebook"><h1><a href='..' alt='dashboard'><img src='/static/ipynblogo.png' alt='IPython Notebook'/></a></h1></span>
     <span id="save_widget">
         <span id="notebook_name"></span>
         <span id="save_status"></span>
     </span>
 
     <span id="login_widget">
       {% comment  This is a temporary workaround to hide the logout button %}
       {% comment  when appropriate until notebook.html is templated %}
       {% if logged_in %}
         <button id="logout">Logout</button>
       {% elif not logged_in and login_available %}
         <button id="login">Login</button>
       {% end %}
     </span>
 
     <span id="kernel_status">Idle</span>
 </div>
 
 <div id="menubar">
     <ul id="menus">
         <li><a href="#">File</a>
             <ul>
                 <li id="new_notebook"><a href="#">New</a></li>
                 <li id="open_notebook"><a href="#">Open...</a></li>
                 <hr/>
                 <li id="copy_notebook"><a href="#">Make a Copy...</a></li>
                 <li id="rename_notebook"><a href="#">Rename...</a></li>
                 <li id="save_notebook"><a href="#">Save</a></li>
                 <hr/>
                 <li><a href="#">Download as</a>
                     <ul>
                         <li id="download_ipynb"><a href="#">IPython (.ipynb)</a></li>
                         <li id="download_py"><a href="#">Python (.py)</a></li>
                     </ul>
                 </li>
                 <hr/>
                 <li id="print_notebook"><a href="/{{notebook_id}}/print" target="_blank">Print View</a></li>
             </ul>
         </li>
         <li><a href="#">Edit</a>
             <ul>
                 <li id="cut_cell"><a href="#">Cut</a></li>
                 <li id="copy_cell"><a href="#">Copy</a></li>
                 <li id="paste_cell" class="ui-state-disabled"><a href="#">Paste</a></li>
                 <li id="paste_cell_above" class="ui-state-disabled"><a href="#">Paste Above</a></li>
                 <li id="paste_cell_below" class="ui-state-disabled"><a href="#">Paste Below</a></li>
                 <li id="delete_cell"><a href="#">Delete</a></li>
                 <hr/>
                 <li id="split_cell"><a href="#">Split</a></li>
                 <li id="merge_cell_above"><a href="#">Merge Above</a></li>
                 <li id="merge_cell_below"><a href="#">Merge Below</a></li>
                 <hr/>
                 <li id="move_cell_up"><a href="#">Move Up</a></li>
                 <li id="move_cell_down"><a href="#">Move Down</a></li>
                 <hr/>
                 <li id="select_previous"><a href="#">Select Previous</a></li>
                 <li id="select_next"><a href="#">Select Next</a></li>
             </ul>
         </li>
         <li><a href="#">Insert</a>
             <ul>
                 <li id="insert_cell_above"><a href="#">Insert Cell Above</a></li>
                 <li id="insert_cell_below"><a href="#">Insert Cell Below</a></li>
             </ul>
         </li>
         <li><a href="#">Cell</a>
             <ul>
                 <li id="full_edit_cell"><a href="#">Edit in Ace</a></li>
                 <hr/>
                 <li id="run_cell"><a href="#">Run</a></li>
                 <li id="run_cell_in_place"><a href="#">Run in Place</a></li>
                 <li id="run_all_cells"><a href="#">Run All</a></li>
                 <hr/>
                 <li id="to_code"><a href="#">Code Cell</a></li>
                 <li id="to_markdown"><a href="#">Markdown Cell</a></li>
                 <hr/>
                 <li id="toggle_output"><a href="#">Toggle Output</a></li>
                 <li id="clear_all_output"><a href="#">Clear All Output</a></li>
             </ul>
         </li>
         <li><a href="#">Kernel</a>
             <ul>
                 <li id="int_kernel"><a href="#">Interrupt</a></li>
                 <li id="restart_kernel"><a href="#">Restart</a></li>
             </ul>
         </li>
         <li><a href="#">Help</a>
             <ul>
                 <li><a href="http://ipython.org/documentation.html" target="_blank">IPython Help</a></li>
                 <li><a href="http://ipython.org/ipython-doc/stable/interactive/htmlnotebook.html" target="_blank">Notebook Help</a></li>
                 <li id="keyboard_shortcuts"><a href="#">Keyboard Shortcuts</a></li>
                 <hr/>
                 <li><a href="https://github.com/ajaxorg/ace/wiki/Default-Keyboard-Shortcuts" target="_blank">Ace Keyboard Shortcuts</a></li>
                 <hr/>
                 <li><a href="http://docs.python.org" target="_blank">Python</a></li>
                 <li><a href="http://docs.scipy.org/doc/numpy/reference/" target="_blank">NumPy</a></li>
                 <li><a href="http://docs.scipy.org/doc/scipy/reference/" target="_blank">SciPy</a></li>
                 <li><a href="http://docs.sympy.org/dev/index.html" target="_blank">SymPy</a></li>
                 <li><a href="http://matplotlib.sourceforge.net/" target="_blank">Matplotlib</a></li>
             </ul>
         </li>
     </ul>
 
 </div>
 
 <div id="main_app">
 
     <div id="notebook_panel">
         <div id="notebook"></div>
         <div id="pager_splitter"></div>
         <div id="pager"></div>
     </div>
 
 </div>
 
 <div id="fulledit_widget" >
     <div id="fulledit_header">
         <button id="close_fulledit">Close</button>
     </div>
     <div id="fulledit_editor">some text</div>
 </div>
 
 <script src="/static/jquery/js/jquery-1.7.1.min.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/jquery/js/jquery-ui.min.js" type="text/javascript" charset="utf-8"></script>
 
 <script src="/static/codemirror/lib/codemirror.js" charset="utf-8"></script>
 <script src="/static/codemirror/mode/python/python.js" charset="utf-8"></script>
 <script src="/static/codemirror/mode/htmlmixed/htmlmixed.js" charset="utf-8"></script>
 <script src="/static/codemirror/mode/xml/xml.js" charset="utf-8"></script>
 <script src="/static/codemirror/mode/javascript/javascript.js" charset="utf-8"></script>
 <script src="/static/codemirror/mode/css/css.js" charset="utf-8"></script>
 <script src="/static/codemirror/mode/rst/rst.js" charset="utf-8"></script>
 <script src="/static/codemirror/mode/markdown/markdown.js" charset="utf-8"></script>
 
 <script src="/static/ace/ace.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/ace/mode-python.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/ace/theme-textmate.js" type="text/javascript" charset="utf-8"></script>
 
 <script src="/static/pagedown/Markdown.Converter.js" charset="utf-8"></script>
 
 <script src="/static/prettify/prettify.js" charset="utf-8"></script>
 <script src="/static/dateformat/date.format.js" charset="utf-8"></script>
 
 <script src="/static/js/namespace.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/js/utils.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/js/cell.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/js/codecell.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/js/textcell.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/js/kernel.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/js/kernelstatus.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/js/layout.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/js/savewidget.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/js/quickhelp.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/js/loginwidget.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/js/pager.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/js/menubar.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/js/notebook.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/js/notebookmain.js" type="text/javascript" charset="utf-8"></script>
 <script src="/static/js/fulleditwidget.js" type="text/javascript" charset="utf-8"></script>
 
 </body>
 
 </html>