rmap.connect('files_edit_home',

                 '/{repo_name:.*}/edit/{revision}/{f_path:.*}',

                 controller='files', action='edit', revision='tip',

                 f_path='', conditions=dict(function=check_repo))

import traceback

from rhodecode.lib import convert_line_endings, detect_mode

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.utils import EmptyChangeset

import rhodecode.lib.helpers as h

from rhodecode.model.repo import RepoModel

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')

    def edit(self, repo_name, revision, f_path):

        r_post = request.POST

        if c.rhodecode_repo.alias == 'hg':

            from vcs.backends.hg import MercurialInMemoryChangeset as IMC

        elif c.rhodecode_repo.alias == 'git':

            from vcs.backends.git import GitInMemoryChangeset as IMC

        c.cs = self.__get_cs_or_redirect(revision, repo_name)

        c.file = self.__get_filenode_or_redirect(repo_name, c.cs, f_path)

        c.file_history = self._get_node_history(c.cs, f_path)

        c.f_path = f_path

        if r_post:

            old_content = c.file.content

            # modes:  0 - Unix, 1 - Mac, 2 - DOS

            mode = detect_mode(old_content.splitlines(1)[0], 0)

            content = convert_line_endings(r_post.get('content'), mode)

            message = r_post.get('message') or (_('Edited %s via RhodeCode')

                                                % (f_path))

            if content == old_content:

                h.flash(_('No changes'),

                    category='warning')

                return redirect(url('changeset_home',

                                    repo_name=c.repo_name, revision='tip'))

            try:

                new_node = FileNode(f_path, content)

                m = IMC(c.rhodecode_repo)

                m.change(new_node)

                m.commit(message=message,

                         author=self.rhodecode_user.full_contact,

                         parents=[c.cs], branch=c.cs.branch)

                h.flash(_('Successfully committed to %s' % f_path),

                        category='success')

            except Exception, e:

                log.error(traceback.format_exc())

                h.flash(_('Error occurred during commit'), category='error')

            return redirect(url('changeset_home',

                                repo_name=c.repo_name, revision='tip'))

        return render('files/files_edit.html')

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

def convert_line_endings(temp, mode):

    from string import replace

    #modes:  0 - Unix, 1 - Mac, 2 - DOS

    if mode == 0:

            temp = replace(temp, '\r\n', '\n')

            temp = replace(temp, '\r', '\n')

    elif mode == 1:

            temp = replace(temp, '\r\n', '\r')

            temp = replace(temp, '\n', '\r')

    elif mode == 2:

            import re

            temp = re.sub("\r(?!\n)|(?<!\r)\n", "\r\n", temp)

    return temp

def detect_mode(line, default):

    if line.endswith('\r\n'):

        return 2

    elif line.endswith('\n'):

        return 0

    elif line.endswith('\r'):

        return 1

    else:

        return default

    @property

    def full_contact(self):

        return '%s %s <%s>' % (self.name, self.lastname, self.email)

.CodeMirror {

  overflow: auto;

  height: 450px;

  line-height: 1em;

  font-family: monospace;

  _position: relative; /* IE6 hack */

}

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

}

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

.CodeMirror-gutter-text{color: #003367 !important;}

#content div.box input.ui-button-small-blue {

background:#4e85bb url("../images/button_highlight.png") repeat-x;

border-top:1px solid #5c91a4;

border-left:1px solid #2a6f89;

border-right:1px solid #2b7089;

border-bottom:1px solid #1a6480;

color:#fff;

}

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

    // The element in which the editor lives. Takes care of scrolling

    // (if enabled).

    var wrapper = document.createElement("div");

    wrapper.className = "CodeMirror";

    // This mess creates the base DOM structure for the editor.

    wrapper.innerHTML =

      '<div style="position: relative">' + // Set to the height of the text, causes scrolling

        '<pre style="position: relative; height: 0; visibility: hidden; overflow: hidden;">' + // To measure line/char size

           '<span>xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx</span></pre>' +

        '<div style="position: relative">' + // Moved around its parent to cover visible view

          '<div class="CodeMirror-gutter"><div class="CodeMirror-gutter-text"></div></div>' +

          '<div style="overflow: hidden; position: absolute; width: 0; left: 0">' + // Wraps and hides input textarea

            '<textarea style="height: 1px; position: absolute; width: 1px;" wrap="off"></textarea></div>' +

          // Provides positioning relative to (visible) text origin

          '<div class="CodeMirror-lines"><div style="position: relative">' +

            '<pre class="CodeMirror-cursor">&#160;</pre>' + // Absolutely positioned blinky cursor

            '<div></div></div></div></div></div>'; // 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 code = wrapper.firstChild, measure = code.firstChild, mover = measure.nextSibling,

        gutter = mover.firstChild, gutterText = gutter.firstChild,

        inputDiv = gutter.nextSibling, input = inputDiv.firstChild,

        lineSpace = inputDiv.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;

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

    // Initialize the content. Somewhat hacky (delayed prepareInput)

    // to work around browser issues.

    operation(function(){setValue(options.value || ""); updateInput = false;})();

    setTimeout(prepareInput, 20);

    // Register our event handlers.

    connect(wrapper, "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(wrapper, "contextmenu", operation(onContextMenu));

    connect(code, "dblclick", operation(onDblClick));

    connect(wrapper, "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(wrapper, "dragenter", function(e){e.stop();});

    connect(wrapper, "dragover", function(e){e.stop();});

    connect(wrapper, "drop", operation(onDrop));

    connect(wrapper, "paste", function(){input.focus(); fastPoll();});

    connect(input, "paste", function(){fastPoll();});

    connect(input, "cut", function(){fastPoll();});

    if (document.activeElement == input) onFocus();

    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(){input.focus(); onFocus(); fastPoll();},

      setOption: function(option, value) {

        options[option] = value;

        if (option == "lineNumbers" || option == "gutter") gutterChanged();

        else if (option == "mode" || option == "indentUnit") loadMode();

      },

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

      },

      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 = Math.min(showingTo - 1, showingFrom + Math.floor(coords.y / lineHeight()));

        return clipPos({line: line, ch: charFromX(clipLine(line), coords.x)});

      },

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

        var pos = localCoords(clipPos(pos), true);

        node.style.top = (showingFrom * lineHeight() + pos.yBot + paddingTop()) + "px";

        node.style.left = (pos.x + paddingLeft()) + "px";

        code.appendChild(node);

        if (scroll)

          scrollIntoView(pos.x, pos.yBot, pos.x + node.offsetWidth, pos.yBot + 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;}

    };

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

      // First, see if this is a click in the gutter

      for (var n = e.target(); n != wrapper; n = n.parentNode)

        if (n.parentNode == gutterText) {

          if (options.onGutterClick)

            options.onGutterClick(instance, indexOf(gutterText.childNodes, n) + showingFrom);

          return e.stop();

        }

      if (gecko && e.button() == 3) onContextMenu(e);

      if (e.button() != 1) return;

      // For button 1, if it was clicked inside the editor

      // (posFromMouse returning non-null), we have to adjust the

      // selection.

      var start = posFromMouse(e), last = start, going;

      if (!start) {if (e.target() == wrapper) e.stop(); return;}

      setCursor(start.line, start.ch, false);

      if (!focused) onFocus();

      e.stop();

      // And then we have to see if it's a drag event, in which case

      // the dragged-over text must be selected.

      function end() {

        input.focus();

        updateInput = true;

        move(); up();

      }

      function extend(e) {

        var cur = posFromMouse(e, true);

        if (cur && !posEq(cur, last)) {

          if (!focused) onFocus();

          last = cur;

          setSelection(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(document, "mousemove", operation(function(e) {

        clearTimeout(going);

        e.stop();

        extend(e);

      }), true);

      var up = connect(document, "mouseup", operation(function(e) {

        clearTimeout(going);

        var cur = posFromMouse(e);

        if (cur) setSelection(start, cur);

        e.stop();

        end();

      }), true);

    }

    function onDblClick(e) {

      var pos = posFromMouse(e);

      if (!pos) return;

      selectWordAt(pos);

      e.stop();

    }

    function onDrop(e) {

      var pos = posFromMouse(e, true), files = e.e.dataTransfer.files;

      if (!pos || options.readOnly) return;

      if (files && files.length && window.FileReader && window.File) {

        var n = files.length, text = Array(n), read = 0;

        for (var i = 0; i < n; ++i) loadFile(files[i], i);

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

        }

      }

      else {

        try {

          var text = e.e.dataTransfer.getData("Text");

          if (text) replaceRange(text, pos, pos);

        }

        catch(e){}

      }

    }

    function onKeyDown(e) {

      if (!focused) onFocus();

      var code = e.e.keyCode;

      // Tries to detect ctrl on non-mac, cmd on mac.

      var mod = (mac ? e.e.metaKey : e.e.ctrlKey) && !e.e.altKey, anyMod = e.e.ctrlKey || e.e.altKey || e.e.metaKey;

      if (code == 16 || e.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.e))) return;

      if (code == 33 || code == 34) {scrollPage(code == 34); return e.stop();} // page up/down

      if (mod && (code == 36 || code == 35)) {scrollEnd(code == 36); return e.stop();} // ctrl-home/end

      if (mod && code == 65) {selectAll(); return e.stop();} // ctrl-a

      if (!options.readOnly) {

        if (!anyMod && code == 13) {return;} // enter

        if (!anyMod && code == 9 && handleTab(e.e.shiftKey)) return e.stop(); // tab

        if (mod && code == 90) {undo(); return e.stop();} // ctrl-z

        if (mod && ((e.e.shiftKey && code == 90) || code == 89)) {redo(); return e.stop();} // 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 (reducedSelection) {

        reducedSelection = null;

        updateInput = true;

      }

      if (e.e.keyCode == 16) shiftSelecting = null;

    }

    function onKeyPress(e) {

      if (options.onKeyEvent && options.onKeyEvent(instance, addStop(e.e))) return;

      if (options.electricChars && mode.electricChars) {

        var ch = String.fromCharCode(e.e.charCode == null ? e.e.keyCode : e.e.charCode);

        if (mode.electricChars.indexOf(ch) > -1)

          setTimeout(operation(function() {indentLine(sel.to.line, "smart");}), 50);

      }

      var code = e.e.keyCode;

      // Re-stop tab and enter. Necessary on some browsers.

      if (code == 13) {handleEnter(); e.stop();}

      else if (code == 9 && options.tabMode != "default") e.stop();

      else fastPoll(curKeyId);

    }

    function onFocus() {

      if (!focused && options.onFocus) options.onFocus(instance);

      focused = true;

      slowPoll();

      if (wrapper.className.search(/\bCodeMirror-focused\b/) == -1)

        wrapper.className += " CodeMirror-focused";

      restartBlink();

    }

    function onBlur() {

      if (focused && options.onBlur) options.onBlur(instance);

      clearInterval(blinker);

      shiftSelecting = null;

      focused = false;

      wrapper.className = wrapper.className.replace(" CodeMirror-focused", "");

    }

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

      }

    }

    function undo() {unredoHelper(history.done, history.undone);}

    function redo() {unredoHelper(history.undone, history.done);}

    function updateLinesNoUndo(from, to, newText, selFrom, selTo) {

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

      }

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

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

      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 (reducedSelection && !moved && sel.from.line == 0 && sel.from.ch == 0)

        reducedSelection = null;

      else if (!moved) 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) {

        from = sr.start == rs.anchor ? to : from;

        to = shiftSelecting ? sel.to : sr.start == rs.anchor ? from : to;

        if (!posLess(from, to)) {

          reducedSelection = null;

          sel.inverted = false;

          var tmp = from; from = to; to = tmp;

        }

      }

      // 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 (c == "\n") endline--;

          if (text.charAt(end) != c) {++end; ++edend; break;}

          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)