diff --git a/IPython/frontend/html/notebook/static/codemirror-2.12/LICENSE b/IPython/frontend/html/notebook/static/codemirror-2.12/LICENSE
new file mode 100644
index 0000000..3f7c0bb
--- /dev/null
+++ b/IPython/frontend/html/notebook/static/codemirror-2.12/LICENSE
@@ -0,0 +1,19 @@
+Copyright (C) 2011 by Marijn Haverbeke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/IPython/frontend/html/notebook/static/codemirror-2.12/README.md b/IPython/frontend/html/notebook/static/codemirror-2.12/README.md
new file mode 100644
index 0000000..3f1b1cc
--- /dev/null
+++ b/IPython/frontend/html/notebook/static/codemirror-2.12/README.md
@@ -0,0 +1,6 @@
+# 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
+[http://codemirror.net/](http://codemirror.net/).
diff --git a/IPython/frontend/html/notebook/static/codemirror-2.12/lib/Untitled0.ipynb b/IPython/frontend/html/notebook/static/codemirror-2.12/lib/Untitled0.ipynb
new file mode 100644
index 0000000..d176f0b
--- /dev/null
+++ b/IPython/frontend/html/notebook/static/codemirror-2.12/lib/Untitled0.ipynb
@@ -0,0 +1,17 @@
+
+
+ Untitled0
+ 29302174-c688-4580-b694-1e786ef3ca1f
+ 2
+
+
+
+
+
+ python
+
+
+
+
+
+
diff --git a/IPython/frontend/html/notebook/static/codemirror-2.12/lib/codemirror.css b/IPython/frontend/html/notebook/static/codemirror-2.12/lib/codemirror.css
new file mode 100644
index 0000000..d93e72d
--- /dev/null
+++ b/IPython/frontend/html/notebook/static/codemirror-2.12/lib/codemirror.css
@@ -0,0 +1,67 @@
+.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;
+ 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;
+}
+.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 textarea {
+ font-family: inherit !important;
+ font-size: inherit !important;
+}
+
+.CodeMirror-cursor {
+ z-index: 10;
+ position: absolute;
+ visibility: hidden;
+ border-left: 1px solid black !important;
+}
+.CodeMirror-focused .CodeMirror-cursor {
+ visibility: visible;
+}
+
+span.CodeMirror-selected {
+ background: #ccc !important;
+ color: HighlightText !important;
+}
+.CodeMirror-focused span.CodeMirror-selected {
+ background: Highlight !important;
+}
+
+.CodeMirror-matchingbracket {color: #0f0 !important;}
+.CodeMirror-nonmatchingbracket {color: #f22 !important;}
diff --git a/IPython/frontend/html/notebook/static/codemirror-2.12/lib/codemirror.js b/IPython/frontend/html/notebook/static/codemirror-2.12/lib/codemirror.js
new file mode 100644
index 0000000..27bec72
--- /dev/null
+++ b/IPython/frontend/html/notebook/static/codemirror-2.12/lib/codemirror.js
@@ -0,0 +1,2144 @@
+// 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";
+ // This mess creates the base DOM structure for the editor.
+ wrapper.innerHTML =
+ '
' + // Wraps and hides input textarea
+ '
' +
+ '
' +
+ '
' + // Set to the height of the text, causes scrolling
+ '' +
+ '
' + // Moved around its parent to cover visible view
+ '
' +
+ // Provides positioning relative to (visible) text origin
+ '
' +
+ '
' + // Absolutely positioned blinky cursor
+ '' + // This DIV contains the actual code
+ '
';
+ 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;
+ if (!options.gutter && !options.lineNumbers) gutter.style.display = "none";
+
+ // 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;
+ 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, lastDoubleClick;
+ // Variables used by startOperation/endOperation to track what
+ // happened during the operation.
+ var updateInput, changes, textChanged, selectionChanged, leaveInputAlone;
+ // 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.
+ // bracketHighlighted is used to remember that a backet has been
+ // marked.
+ var editing, bracketHighlighted;
+ // Tracks the maximum line length so that the horizontal scrollbar
+ // can be kept static when scrolling.
+ var maxLine = "", maxWidth;
+
+ // Initialize the content.
+ operation(function(){setValue(options.value || ""); updateInput = false;})();
+
+ // Register our event handlers.
+ connect(scroller, "mousedown", operation(onMouseDown));
+ // 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(code, "dblclick", operation(onDblClick));
+ connect(scroller, "scroll", function() {updateDisplay([]); if (options.onScroll) options.onScroll(instance);});
+ connect(window, "resize", function() {updateDisplay(true);});
+ connect(input, "keyup", operation(onKeyUp));
+ 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();});
+
+ // 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;}
+ // 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 = {
+ getValue: getValue,
+ setValue: operation(setValue),
+ getSelection: getSelection,
+ replaceSelection: operation(replaceSelection),
+ focus: function(){focusInput(); onFocus(); fastPoll();},
+ setOption: function(option, value) {
+ options[option] = value;
+ if (option == "lineNumbers" || option == "gutter") 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) {if (isLine(n)) indentLine(n, "smart");}),
+ historySize: function() {return {undo: history.done.length, redo: history.undone.length};},
+ matchBrackets: operation(function(){matchBrackets(true);}),
+ getTokenAt: function(pos) {
+ pos = clipPos(pos);
+ return lines[pos.line].getTokenAt(mode, getStateBefore(pos.line), pos.ch);
+ },
+ getStateAfter: function(line) {
+ line = clipLine(line == null ? lines.length - 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)});
+ },
+ getSearchCursor: function(query, pos, caseFold) {return new SearchCursor(query, pos, caseFold);},
+ markText: operation(function(a, b, c){return operation(markText(a, b, c));}),
+ setMarker: addGutterMarker,
+ clearMarker: removeGutterMarker,
+ setLineClass: operation(setLineClass),
+ lineInfo: lineInfo,
+ addWidget: function(pos, node, scroll, where) {
+ pos = localCoords(clipPos(pos));
+ var top = pos.yBot, left = pos.x;
+ node.style.position = "absolute";
+ code.appendChild(node);
+ node.style.left = left + "px";
+ if (where == "over") top = pos.y;
+ else if (where == "near") {
+ var vspace = Math.max(scroller.offsetHeight, lines.length * lineHeight()),
+ 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 = (left + paddingLeft()) + "px";
+ if (scroll)
+ scrollIntoView(left, top, left + node.offsetWidth, top + node.offsetHeight);
+ },
+
+ lineCount: function() {return lines.length;},
+ 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);
+ }),
+ setSelection: operation(function(from, to) {setSelection(clipPos(from), clipPos(to || from));}),
+ getLine: function(line) {if (isLine(line)) return lines[line].text;},
+ setLine: operation(function(line, text) {
+ if (isLine(line)) replaceRange(text, {line: line, ch: 0}, {line: line, ch: lines[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));},
+
+ operation: function(f){return operation(f)();},
+ refresh: function(){updateDisplay(true);},
+ getInputField: function(){return input;},
+ getWrapperElement: function(){return wrapper;},
+ getScrollerElement: function(){return scroller;}
+ };
+
+ function setValue(code) {
+ history = null;
+ var top = {line: 0, ch: 0};
+ updateLines(top, {line: lines.length - 1, ch: lines[lines.length-1].text.length},
+ splitLines(code), top, top);
+ history = new History();
+ }
+ function getValue(code) {
+ var text = [];
+ for (var i = 0, l = lines.length; i < l; ++i)
+ text.push(lines[i].text);
+ return text.join("\n");
+ }
+
+ function onMouseDown(e) {
+ // 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;
+ var ld = lastDoubleClick; lastDoubleClick = null;
+ // First, 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);
+ 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();
+ e_preventDefault(e);
+ if (ld && +new Date - ld < 400) return selectLine(start.line);
+
+ setCursor(start.line, start.ch, true);
+ var last = start, going;
+ // And then we have to see if it's a drag event, in which case
+ // the dragged-over text must be selected.
+ function end() {
+ focusInput();
+ updateInput = true;
+ move(); up();
+ }
+ 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);
+ end();
+ }), true);
+ }
+ function onDblClick(e) {
+ var pos = posFromMouse(e);
+ if (!pos) return;
+ selectWordAt(pos);
+ e_preventDefault(e);
+ lastDoubleClick = +new Date;
+ }
+ 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));
+ };
+ 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);
+ }
+ catch(e){}
+ }
+ }
+ 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;
+ // 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
+ }
+
+ // 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" : "") + code;
+ if (sel.inverted && movementKeys.hasOwnProperty(curKeyId)) {
+ var range = selRange(input);
+ if (range) {
+ reducedSelection = {anchor: range.start};
+ setSelRange(input, range.start, range.start);
+ }
+ }
+ fastPoll(curKeyId);
+ }
+ 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 (options.onKeyEvent && options.onKeyEvent(instance, addStop(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);
+ }
+ 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);
+ }
+
+ function onFocus() {
+ if (options.readOnly == "nocursor") 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();
+ }
+ 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);
+ 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);
+ 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);
+ 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;}
+ }
+
+ var nlines = to.line - from.line, firstLine = lines[from.line], lastLine = lines[to.line];
+ // First adjust the line structure, taking some care to leave highlighting intact.
+ 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;
+ 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;
+ 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);
+ }
+ 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};
+
+ // 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";
+ }
+
+ 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));
+ 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() {
+ startOperation();
+ readInput();
+ if (focused) slowPoll();
+ endOperation();
+ });
+ }
+ function fastPoll(keyId) {
+ var missed = false;
+ pollingFast = true;
+ function p() {
+ startOperation();
+ var changed = readInput();
+ if (changed == "moved" && keyId) movementKeys[keyId] = true;
+ if (!changed && !missed) {missed = true; poll.set(80, 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.
+ 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;
+ }
+ else setSelection(from, to);
+
+ editing.text = text; editing.start = sr.start; editing.end = sr.end;
+ return changed ? "changed" : moved ? "moved" : false;
+ }
+
+ // 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();
+ }
+
+ function scrollCursorIntoView() {
+ var cursor = localCoords(sel.inverted ? sel.from : sel.to);
+ return scrollIntoView(cursor.x, cursor.y, cursor.x, cursor.yBot);
+ }
+ function scrollIntoView(x1, y1, x2, y2) {
+ var pl = paddingLeft(), pt = paddingTop(), lh = lineHeight();
+ 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;
+ if (x1 < screenleft) {
+ if (x1 < 50) x1 = 0;
+ scroller.scrollLeft = Math.max(0, x1 - 10);
+ scrolled = true;
+ }
+ else if (x2 > screenw + screenleft) {
+ 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))};
+ }
+ // 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) {
+ if (!scroller.clientWidth) {
+ showingFrom = showingTo = 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.
+ 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) {
+ 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 (!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);
+ 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;
+ showingFrom = from; showingTo = to;
+ mover.style.top = (from * lineHeight()) + "px";
+ if (different) {
+ lastHeight = scroller.clientHeight;
+ code.style.height = (lines.length * lineHeight() + 2 * paddingTop()) + "px";
+ updateGutter();
+ }
+
+ 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);
+ updateCursor();
+ }
+
+ 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;}
+ }
+ 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) {
+ var ch1 = null, ch2 = null;
+ if (inSel) {
+ ch1 = 0;
+ if (sto == j) {inSel = false; ch2 = sel.to.ch;}
+ }
+ 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;
+ }
+ }
+
+ 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 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 ? '
' : "
"), text, "
");
+ }
+ gutter.style.display = "none";
+ gutterText.innerHTML = html.join("");
+ var minwidth = String(lines.length).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";
+ }
+ function updateCursor() {
+ var head = sel.inverted ? sel.from : sel.to, lh = lineHeight();
+ var x = charX(head.line, head.ch) + "px", y = (head.line - showingFrom) * lh + "px";
+ inputDiv.style.top = (head.line * lh - scroller.scrollTop) + "px";
+ if (posEq(sel.from, sel.to)) {
+ cursor.style.top = y; cursor.style.left = x;
+ cursor.style.display = "";
+ }
+ else cursor.style.display = "none";
+ }
+
+ 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);
+ }
+ // 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) {
+ if (posEq(sel.from, from) && posEq(sel.to, to)) return;
+ if (posLess(to, from)) {var tmp = to; to = from; from = tmp;}
+
+ 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 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 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 (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 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 selectWordAt(pos) {
+ var line = lines[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;
+ 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");
+ }
+ 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 indentLine(n, how) {
+ 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;
+ if (how == "prev") {
+ if (n) indentation = lines[n-1].indentation();
+ else indentation = 0;
+ }
+ else if (how == "smart") indentation = mode.indent(state, line.text.slice(curSpaceString.length));
+ 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";}
+ 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;
+ work = [0];
+ startWorker();
+ }
+ function gutterChanged() {
+ var visible = options.gutter || options.lineNumbers;
+ gutter.style.display = visible ? "" : "none";
+ if (visible) updateGutter();
+ else lineDiv.parentNode.style.marginLeft = 0;
+ }
+
+ function markText(from, to, className) {
+ from = clipPos(from); to = clipPos(to);
+ var accum = [];
+ function add(line, from, to, className) {
+ var line = lines[line], mark = line.addMark(from, to, className);
+ mark.line = line;
+ accum.push(mark);
+ }
+ 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);
+ }
+ 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;
+ }
+ }
+ if (start != null) changes.push({from: start, to: end + 1});
+ };
+ }
+
+ function addGutterMarker(line, text, className) {
+ if (typeof line == "number") line = lines[clipLine(line)];
+ line.gutterMarker = {text: text, style: className};
+ updateGutter();
+ return line;
+ }
+ function removeGutterMarker(line) {
+ if (typeof line == "number") line = lines[clipLine(line)];
+ line.gutterMarker = null;
+ updateGutter();
+ }
+ 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;
+ }
+ if (line.className != className) {
+ line.className = className;
+ changes.push({from: no, to: no + 1});
+ }
+ return line;
+ }
+
+ function lineInfo(line) {
+ if (typeof line == "number") {
+ var n = line;
+ line = lines[line];
+ if (!line) return null;
+ }
+ else {
+ var n = indexOf(lines, line);
+ if (n == -1) return null;
+ }
+ var marker = line.gutterMarker;
+ return {line: n, text: line.text, markerText: marker && marker.text, markerClass: marker && marker.style};
+ }
+
+ function stringWidth(str) {
+ measure.innerHTML = "
x
";
+ 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 = "
+
+
diff --git a/IPython/frontend/html/notebook/static/codemirror-2.12/mode/javascript/javascript.js b/IPython/frontend/html/notebook/static/codemirror-2.12/mode/javascript/javascript.js
new file mode 100644
index 0000000..bdf9952
--- /dev/null
+++ b/IPython/frontend/html/notebook/static/codemirror-2.12/mode/javascript/javascript.js
@@ -0,0 +1,348 @@
+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"),
+ "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+)?/);
+ 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 (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) :
+ 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 == "(") 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 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,
+ 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(/^[\[{}\(,;:]$/);
+ 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});
diff --git a/IPython/frontend/html/notebook/static/codemirror-2.12/mode/python/LICENSE.txt b/IPython/frontend/html/notebook/static/codemirror-2.12/mode/python/LICENSE.txt
new file mode 100644
index 0000000..918866b
--- /dev/null
+++ b/IPython/frontend/html/notebook/static/codemirror-2.12/mode/python/LICENSE.txt
@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2010 Timothy Farrell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
\ No newline at end of file
diff --git a/IPython/frontend/html/notebook/static/codemirror-2.12/mode/python/index.html b/IPython/frontend/html/notebook/static/codemirror-2.12/mode/python/index.html
new file mode 100644
index 0000000..1c36643
--- /dev/null
+++ b/IPython/frontend/html/notebook/static/codemirror-2.12/mode/python/index.html
@@ -0,0 +1,123 @@
+
+
+
+ CodeMirror 2: Python mode
+
+
+
+
+
+
+
+
+
CodeMirror 2: Python mode
+
+
+
+
Configuration Options:
+
+
version - 2/3 - The version of Python to recognize. Default is 2.
+
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.
+
+
+
MIME types defined:text/x-python.
+
+
diff --git a/IPython/frontend/html/notebook/static/codemirror-2.12/mode/python/python.js b/IPython/frontend/html/notebook/static/codemirror-2.12/mode/python/python.js
new file mode 100644
index 0000000..0cda2aa
--- /dev/null
+++ b/IPython/frontend/html/notebook/static/codemirror-2.12/mode/python/python.js
@@ -0,0 +1,321 @@
+CodeMirror.defineMode("python", function(conf) {
+ var ERRORCLASS = 'error';
+
+ function wordRegexp(words) {
+ return new RegExp("^((" + words.join(")|(") + "))\\b");
+ }
+
+ var singleOperators = new RegExp("^[\\+\\-\\*/%&|\\^~<>!\\?]");
+ 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 (!!conf.mode.version && parseInt(conf.mode.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[0].toLowerCase()) >= 0) {
+ delimiter = delimiter.substr(1);
+ }
+ var delim_re = new RegExp(delimiter);
+ 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(delim_re)) {
+ state.tokenize = tokenBase;
+ return OUTCLASS;
+ } else {
+ stream.eat(/['"]/);
+ }
+ }
+ if (singleline) {
+ if (conf.mode.singleLineStringErrors) {
+ OUTCLASS = ERRORCLASS
+ } else {
+ state.tokenize = tokenBase;
+ }
+ }
+ return OUTCLASS;
+ };
+ }
+
+ function indent(stream, state, type) {
+ type = type || 'py';
+ var indentUnit = 0;
+ if (type === 'py') {
+ 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) {
+ 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 {
+ 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)) {
+ 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");
diff --git a/IPython/frontend/html/notebook/static/codemirror-2.12/mode/rst/index.html b/IPython/frontend/html/notebook/static/codemirror-2.12/mode/rst/index.html
new file mode 100644
index 0000000..0831dff
--- /dev/null
+++ b/IPython/frontend/html/notebook/static/codemirror-2.12/mode/rst/index.html
@@ -0,0 +1,526 @@
+
+
+
+ CodeMirror 2: reStructuredText mode
+
+
+
+
+
+
+
+
+
CodeMirror 2: reStructuredText mode
+
+
+
+
+
The reStructuredText mode supports one configuration parameter:
+
+
verbatim (string)
+
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.
+
+
If python mode is available (not a part of CodeMirror 2 yet),
+ it will be used for highlighting blocks containing Python/IPython terminal
+ sessions (blocks starting with >>> (for Python) or
+ In [num]: (for IPython).
+
+
The XML mode supports two configuration parameters:
+
+
htmlMode (boolean)
+
This switches the mode to parse HTML instead of XML. This
+ means attributes do not have to be quoted, and some elements
+ (such as br) do not require a closing tag.
+
alignCDATA (boolean)
+
Setting this to true will force the opening tag of CDATA
+ blocks to not be indented.