Removed CodeMirror 2.21, upgrade to 2.22

CodeMirror-2.21/LICENSE

@@ -1,23 +0,0 @@
-Copyright (C) 2011 by Marijn Haverbeke <marijnh@gmail.com>
-
-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.
-
-Please note that some subdirectories of the CodeMirror distribution
-include their own LICENSE files, and are released under different
-licences.

CodeMirror-2.21/README.md

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

CodeMirror-2.21/keymap/emacs.js

@@ -1,29 +0,0 @@
-// TODO number prefixes
-(function() {
-  // Really primitive kill-ring implementation.
-  var killRing = [];
-  function addToRing(str) {
-    killRing.push(str);
-    if (killRing.length > 50) killRing.shift();
-  }
-  function getFromRing() { return killRing[killRing.length - 1] || ""; }
-  function popFromRing() { if (killRing.length > 1) killRing.pop(); return getFromRing(); }
-
-  CodeMirror.keyMap.emacs = {
-    "Ctrl-X": function(cm) {cm.setOption("keyMap", "emacs-Ctrl-X");},
-    "Ctrl-W": function(cm) {addToRing(cm.getSelection()); cm.replaceSelection("");},
-    "Ctrl-Alt-W": function(cm) {addToRing(cm.getSelection()); cm.replaceSelection("");},
-    "Alt-W": function(cm) {addToRing(cm.getSelection());},
-    "Ctrl-Y": function(cm) {cm.replaceSelection(getFromRing());},
-    "Alt-Y": function(cm) {cm.replaceSelection(popFromRing());},
-    "Ctrl-/": "undo", "Shift-Ctrl--": "undo", "Shift-Alt-,": "goDocStart", "Shift-Alt-.": "goDocEnd",
-    "Ctrl-S": "findNext", "Ctrl-R": "findPrev", "Ctrl-G": "clearSearch", "Shift-Alt-5": "replace",
-    "Ctrl-Z": "undo", "Cmd-Z": "undo",
-    fallthrough: ["basic", "emacsy"]
-  };
-
-  CodeMirror.keyMap["emacs-Ctrl-X"] = {
-    "Ctrl-S": "save", "Ctrl-W": "save", "S": "saveAll", "F": "open", "U": "undo", "K": "close",
-    auto: "emacs", catchall: function(cm) {/*ignore*/}
-  };
-})();

CodeMirror-2.21/keymap/vim.js

@@ -1,347 +0,0 @@
-(function() {
-  var count = "";
-  var sdir = "f";
-  var buf = "";
-  var yank = 0;
-  var mark = [];
-  function emptyBuffer() { buf = ""; }
-  function pushInBuffer(str) { buf += str; };
-  function pushCountDigit(digit) { return function(cm) {count += digit;} }
-  function popCount() { var i = parseInt(count); count = ""; return i || 1; }
-  function countTimes(func) {
-    if (typeof func == "string") func = CodeMirror.commands[func];
-    return function(cm) { for (var i = 0, c = popCount(); i < c; ++i) func(cm); }
-  }
-
-  function iterObj(o, f) {
-    for (var prop in o) if (o.hasOwnProperty(prop)) f(prop, o[prop]);
-  }
-
-  var word = [/\w/, /[^\w\s]/], bigWord = [/\S/];
-  function findWord(line, pos, dir, regexps) {
-    var stop = 0, next = -1;
-    if (dir > 0) { stop = line.length; next = 0; }
-    var start = stop, end = stop;
-    // Find bounds of next one.
-    outer: for (; pos != stop; pos += dir) {
-      for (var i = 0; i < regexps.length; ++i) {
-        if (regexps[i].test(line.charAt(pos + next))) {
-          start = pos;
-          for (; pos != stop; pos += dir) {
-            if (!regexps[i].test(line.charAt(pos + next))) break;
-          }
-          end = pos;
-          break outer;
-        }
-      }
-    }
-    return {from: Math.min(start, end), to: Math.max(start, end)};
-  }
-  function moveToWord(cm, regexps, dir, where) {
-    var cur = cm.getCursor(), ch = cur.ch, line = cm.getLine(cur.line), word;
-    while (true) {
-      word = findWord(line, ch, dir, regexps);
-      ch = word[where == "end" ? "to" : "from"];
-      if (ch == cur.ch && word.from != word.to) ch = word[dir < 0 ? "from" : "to"];
-      else break;
-    }
-    cm.setCursor(cur.line, word[where == "end" ? "to" : "from"], true);
-  }
-  function joinLineNext(cm) {
-    var cur = cm.getCursor(), ch = cur.ch, line = cm.getLine(cur.line);
-    CodeMirror.commands.goLineEnd(cm); 
-    if (cur.line != cm.lineCount()) {
-      CodeMirror.commands.goLineEnd(cm);
-      cm.replaceSelection(" ", "end");
-      CodeMirror.commands.delCharRight(cm);
-    } 
-  }
-  function editCursor(mode) {
-    if (mode == "vim-insert") {  
-      // put in your cursor css changing code
-    } else if (mode == "vim") {
-      // put in your cursor css changing code
-    }
-  }
-  function delTillMark(cm, cHar) { 
-    var i = mark[cHar], l = cm.getCursor().line, start = i > l ? l : i, end = i > l ? i : l;
-    cm.setCursor(start);
-    for (var c = start; c <= end; c++) {
-      pushInBuffer("\n"+cm.getLine(start)); 
-      cm.removeLine(start);
-    }
-  }
-  function yankTillMark(cm, cHar) { 
-    var i = mark[cHar], l = cm.getCursor().line, start = i > l ? l : i, end = i > l ? i : l;
-    for (var c = start; c <= end; c++) {
-      pushInBuffer("\n"+cm.getLine(c));
-    }
-    cm.setCursor(start);
-  }
-
-  var map = CodeMirror.keyMap.vim = {
-    "0": function(cm) {count.length > 0 ? pushCountDigit("0")(cm) : CodeMirror.commands.goLineStart(cm);},
-    "A": function(cm) {popCount(); cm.setCursor(cm.getCursor().line, cm.getCursor().ch+1, true); cm.setOption("keyMap", "vim-insert"); editCursor("vim-insert");},
-    "Shift-A": function(cm) {popCount(); CodeMirror.commands.goLineEnd(cm); cm.setOption("keyMap", "vim-insert"); editCursor("vim-insert");},
-    "I": function(cm) {popCount(); cm.setOption("keyMap", "vim-insert"); editCursor("vim-insert");},
-    "Shift-I": function(cm) {popCount(); CodeMirror.commands.goLineStartSmart(cm); cm.setOption("keyMap", "vim-insert"); editCursor("vim-insert");},
-    "O": function(cm) {popCount(); CodeMirror.commands.goLineEnd(cm); cm.replaceSelection("\n", "end"); cm.setOption("keyMap", "vim-insert"); editCursor("vim-insert");},
-    "Shift-O": function(cm) {popCount(); CodeMirror.commands.goLineStart(cm); cm.replaceSelection("\n", "start"); cm.setOption("keyMap", "vim-insert"); editCursor("vim-insert");},
-    "G": function(cm) {cm.setOption("keyMap", "vim-prefix-g");},
-    "D": function(cm) {cm.setOption("keyMap", "vim-prefix-d"); emptyBuffer();},
-    "M": function(cm) {cm.setOption("keyMap", "vim-prefix-m"); mark = [];},
-    "Y": function(cm) {cm.setOption("keyMap", "vim-prefix-y"); emptyBuffer(); yank = 0;},
-    "/": function(cm) {var f = CodeMirror.commands.find; f && f(cm); sdir = "f"},
-    "Shift-/": function(cm) {
-      var f = CodeMirror.commands.find;
-      if (f) { f(cm); CodeMirror.commands.findPrev(cm); sdir = "r"; }
-    },
-    "N": function(cm) {
-      var fn = CodeMirror.commands.findNext;
-      if (fn) sdir != "r" ? fn(cm) : CodeMirror.commands.findPrev(cm);
-    },
-    "Shift-N": function(cm) {
-      var fn = CodeMirror.commands.findNext;
-      if (fn) sdir != "r" ? CodeMirror.commands.findPrev(cm) : fn.findNext(cm);
-    },
-    "Shift-G": function(cm) {count == "" ? cm.setCursor(cm.lineCount()) : cm.setCursor(parseInt(count)-1); popCount(); CodeMirror.commands.goLineStart(cm);},
-    catchall: function(cm) {/*ignore*/}
-  };
-  // Add bindings for number keys
-  for (var i = 1; i < 10; ++i) map[i] = pushCountDigit(i);
-  // Add bindings that are influenced by number keys
-  iterObj({"H": "goColumnLeft", "L": "goColumnRight", "J": "goLineDown", "K": "goLineUp",
-		       "Left": "goColumnLeft", "Right": "goColumnRight", "Down": "goLineDown", "Up": "goLineUp",
-           "Backspace": "goCharLeft", "Space": "goCharRight",
-           "B": function(cm) {moveToWord(cm, word, -1, "end");},
-           "E": function(cm) {moveToWord(cm, word, 1, "end");},
-           "W": function(cm) {moveToWord(cm, word, 1, "start");},
-           "Shift-B": function(cm) {moveToWord(cm, bigWord, -1, "end");},
-           "Shift-E": function(cm) {moveToWord(cm, bigWord, 1, "end");},
-           "Shift-W": function(cm) {moveToWord(cm, bigWord, 1, "start");},
-           "X": function(cm) {CodeMirror.commands.delCharRight(cm)},
-           "P": function(cm) {
-		  var cur = cm.getCursor().line;
-		  if (buf!= "") {
-                    CodeMirror.commands.goLineEnd(cm); 
-		    cm.replaceSelection(buf, "end");
-		  }
-		  cm.setCursor(cur+1);
-	        },
-           "Shift-X": function(cm) {CodeMirror.commands.delCharLeft(cm)},
-           "Shift-J": function(cm) {joinLineNext(cm)},
-           "Shift-`": function(cm) {
-                        var cur = cm.getCursor(), cHar = cm.getRange({line: cur.line, ch: cur.ch}, {line: cur.line, ch: cur.ch+1});
-			cHar = cHar != cHar.toLowerCase() ? cHar.toLowerCase() : cHar.toUpperCase();
-                        cm.replaceRange(cHar, {line: cur.line, ch: cur.ch}, {line: cur.line, ch: cur.ch+1});
-			cm.setCursor(cur.line, cur.ch+1);
-	              },
-           "Ctrl-B": function(cm) {CodeMirror.commands.goPageUp(cm)},
-           "Ctrl-F": function(cm) {CodeMirror.commands.goPageDown(cm)},
-	   "Ctrl-P": "goLineUp", "Ctrl-N": "goLineDown",
-           "U": "undo", "Ctrl-R": "redo", "Shift-4": "goLineEnd"},
-          function(key, cmd) { map[key] = countTimes(cmd); });
-
-  CodeMirror.keyMap["vim-prefix-g"] = {
-    "E": countTimes(function(cm) { moveToWord(cm, word, -1, "start");}),
-    "Shift-E": countTimes(function(cm) { moveToWord(cm, bigWord, -1, "start");}),
-    auto: "vim", 
-    catchall: function(cm) {/*ignore*/}
-  };
-
-  CodeMirror.keyMap["vim-prefix-m"] = {
-    "A": function(cm) {mark["A"] = cm.getCursor().line;},
-    "Shift-A": function(cm) {mark["Shift-A"] = cm.getCursor().line;},
-    "B": function(cm) {mark["B"] = cm.getCursor().line;},
-    "Shift-B": function(cm) {mark["Shift-B"] = cm.getCursor().line;},
-    "C": function(cm) {mark["C"] = cm.getCursor().line;},
-    "Shift-C": function(cm) {mark["Shift-C"] = cm.getCursor().line;},
-    "D": function(cm) {mark["D"] = cm.getCursor().line;},
-    "Shift-D": function(cm) {mark["Shift-D"] = cm.getCursor().line;},
-    "E": function(cm) {mark["E"] = cm.getCursor().line;},
-    "Shift-E": function(cm) {mark["Shift-E"] = cm.getCursor().line;},
-    "F": function(cm) {mark["F"] = cm.getCursor().line;},
-    "Shift-F": function(cm) {mark["Shift-F"] = cm.getCursor().line;},
-    "G": function(cm) {mark["G"] = cm.getCursor().line;},
-    "Shift-G": function(cm) {mark["Shift-G"] = cm.getCursor().line;},
-    "H": function(cm) {mark["H"] = cm.getCursor().line;},
-    "Shift-H": function(cm) {mark["Shift-H"] = cm.getCursor().line;},
-    "I": function(cm) {mark["I"] = cm.getCursor().line;},
-    "Shift-I": function(cm) {mark["Shift-I"] = cm.getCursor().line;},
-    "J": function(cm) {mark["J"] = cm.getCursor().line;},
-    "Shift-J": function(cm) {mark["Shift-J"] = cm.getCursor().line;},
-    "K": function(cm) {mark["K"] = cm.getCursor().line;},
-    "Shift-K": function(cm) {mark["Shift-K"] = cm.getCursor().line;},
-    "L": function(cm) {mark["L"] = cm.getCursor().line;},
-    "Shift-L": function(cm) {mark["Shift-L"] = cm.getCursor().line;},
-    "M": function(cm) {mark["M"] = cm.getCursor().line;},
-    "Shift-M": function(cm) {mark["Shift-M"] = cm.getCursor().line;},
-    "N": function(cm) {mark["N"] = cm.getCursor().line;},
-    "Shift-N": function(cm) {mark["Shift-N"] = cm.getCursor().line;},
-    "O": function(cm) {mark["O"] = cm.getCursor().line;},
-    "Shift-O": function(cm) {mark["Shift-O"] = cm.getCursor().line;},
-    "P": function(cm) {mark["P"] = cm.getCursor().line;},
-    "Shift-P": function(cm) {mark["Shift-P"] = cm.getCursor().line;},
-    "Q": function(cm) {mark["Q"] = cm.getCursor().line;},
-    "Shift-Q": function(cm) {mark["Shift-Q"] = cm.getCursor().line;},
-    "R": function(cm) {mark["R"] = cm.getCursor().line;},
-    "Shift-R": function(cm) {mark["Shift-R"] = cm.getCursor().line;},
-    "S": function(cm) {mark["S"] = cm.getCursor().line;},
-    "Shift-S": function(cm) {mark["Shift-S"] = cm.getCursor().line;},
-    "T": function(cm) {mark["T"] = cm.getCursor().line;},
-    "Shift-T": function(cm) {mark["Shift-T"] = cm.getCursor().line;},
-    "U": function(cm) {mark["U"] = cm.getCursor().line;},
-    "Shift-U": function(cm) {mark["Shift-U"] = cm.getCursor().line;},
-    "V": function(cm) {mark["V"] = cm.getCursor().line;},
-    "Shift-V": function(cm) {mark["Shift-V"] = cm.getCursor().line;},
-    "W": function(cm) {mark["W"] = cm.getCursor().line;},
-    "Shift-W": function(cm) {mark["Shift-W"] = cm.getCursor().line;},
-    "X": function(cm) {mark["X"] = cm.getCursor().line;},
-    "Shift-X": function(cm) {mark["Shift-X"] = cm.getCursor().line;},
-    "Y": function(cm) {mark["Y"] = cm.getCursor().line;},
-    "Shift-Y": function(cm) {mark["Shift-Y"] = cm.getCursor().line;},
-    "Z": function(cm) {mark["Z"] = cm.getCursor().line;},
-    "Shift-Z": function(cm) {mark["Shift-Z"] = cm.getCursor().line;},
-    auto: "vim", 
-    catchall: function(cm) {/*ignore*/}
-  }
-  
-  CodeMirror.keyMap["vim-prefix-d"] = {
-    "D": countTimes(function(cm) { pushInBuffer("\n"+cm.getLine(cm.getCursor().line)); cm.removeLine(cm.getCursor().line); }),
-    "'": function(cm) {cm.setOption("keyMap", "vim-prefix-d'"); emptyBuffer();},
-    auto: "vim", 
-    catchall: function(cm) {/*ignore*/}
-  };
-
-  CodeMirror.keyMap["vim-prefix-d'"] = {
-    "A": function(cm) {delTillMark(cm,"A");},
-    "Shift-A": function(cm) {delTillMark(cm,"Shift-A");},
-    "B": function(cm) {delTillMark(cm,"B");},
-    "Shift-B": function(cm) {delTillMark(cm,"Shift-B");},
-    "C": function(cm) {delTillMark(cm,"C");},
-    "Shift-C": function(cm) {delTillMark(cm,"Shift-C");},
-    "D": function(cm) {delTillMark(cm,"D");},
-    "Shift-D": function(cm) {delTillMark(cm,"Shift-D");},
-    "E": function(cm) {delTillMark(cm,"E");},
-    "Shift-E": function(cm) {delTillMark(cm,"Shift-E");},
-    "F": function(cm) {delTillMark(cm,"F");},
-    "Shift-F": function(cm) {delTillMark(cm,"Shift-F");},
-    "G": function(cm) {delTillMark(cm,"G");},
-    "Shift-G": function(cm) {delTillMark(cm,"Shift-G");},
-    "H": function(cm) {delTillMark(cm,"H");},
-    "Shift-H": function(cm) {delTillMark(cm,"Shift-H");},
-    "I": function(cm) {delTillMark(cm,"I");},
-    "Shift-I": function(cm) {delTillMark(cm,"Shift-I");},
-    "J": function(cm) {delTillMark(cm,"J");},
-    "Shift-J": function(cm) {delTillMark(cm,"Shift-J");},
-    "K": function(cm) {delTillMark(cm,"K");},
-    "Shift-K": function(cm) {delTillMark(cm,"Shift-K");},
-    "L": function(cm) {delTillMark(cm,"L");},
-    "Shift-L": function(cm) {delTillMark(cm,"Shift-L");},
-    "M": function(cm) {delTillMark(cm,"M");},
-    "Shift-M": function(cm) {delTillMark(cm,"Shift-M");},
-    "N": function(cm) {delTillMark(cm,"N");},
-    "Shift-N": function(cm) {delTillMark(cm,"Shift-N");},
-    "O": function(cm) {delTillMark(cm,"O");},
-    "Shift-O": function(cm) {delTillMark(cm,"Shift-O");},
-    "P": function(cm) {delTillMark(cm,"P");},
-    "Shift-P": function(cm) {delTillMark(cm,"Shift-P");},
-    "Q": function(cm) {delTillMark(cm,"Q");},
-    "Shift-Q": function(cm) {delTillMark(cm,"Shift-Q");},
-    "R": function(cm) {delTillMark(cm,"R");},
-    "Shift-R": function(cm) {delTillMark(cm,"Shift-R");},
-    "S": function(cm) {delTillMark(cm,"S");},
-    "Shift-S": function(cm) {delTillMark(cm,"Shift-S");},
-    "T": function(cm) {delTillMark(cm,"T");},
-    "Shift-T": function(cm) {delTillMark(cm,"Shift-T");},
-    "U": function(cm) {delTillMark(cm,"U");},
-    "Shift-U": function(cm) {delTillMark(cm,"Shift-U");},
-    "V": function(cm) {delTillMark(cm,"V");},
-    "Shift-V": function(cm) {delTillMark(cm,"Shift-V");},
-    "W": function(cm) {delTillMark(cm,"W");},
-    "Shift-W": function(cm) {delTillMark(cm,"Shift-W");},
-    "X": function(cm) {delTillMark(cm,"X");},
-    "Shift-X": function(cm) {delTillMark(cm,"Shift-X");},
-    "Y": function(cm) {delTillMark(cm,"Y");},
-    "Shift-Y": function(cm) {delTillMark(cm,"Shift-Y");},
-    "Z": function(cm) {delTillMark(cm,"Z");},
-    "Shift-Z": function(cm) {delTillMark(cm,"Shift-Z");},
-    auto: "vim", 
-    catchall: function(cm) {/*ignore*/}
-  };
-
-  CodeMirror.keyMap["vim-prefix-y'"] = {
-    "A": function(cm) {yankTillMark(cm,"A");},
-    "Shift-A": function(cm) {yankTillMark(cm,"Shift-A");},
-    "B": function(cm) {yankTillMark(cm,"B");},
-    "Shift-B": function(cm) {yankTillMark(cm,"Shift-B");},
-    "C": function(cm) {yankTillMark(cm,"C");},
-    "Shift-C": function(cm) {yankTillMark(cm,"Shift-C");},
-    "D": function(cm) {yankTillMark(cm,"D");},
-    "Shift-D": function(cm) {yankTillMark(cm,"Shift-D");},
-    "E": function(cm) {yankTillMark(cm,"E");},
-    "Shift-E": function(cm) {yankTillMark(cm,"Shift-E");},
-    "F": function(cm) {yankTillMark(cm,"F");},
-    "Shift-F": function(cm) {yankTillMark(cm,"Shift-F");},
-    "G": function(cm) {yankTillMark(cm,"G");},
-    "Shift-G": function(cm) {yankTillMark(cm,"Shift-G");},
-    "H": function(cm) {yankTillMark(cm,"H");},
-    "Shift-H": function(cm) {yankTillMark(cm,"Shift-H");},
-    "I": function(cm) {yankTillMark(cm,"I");},
-    "Shift-I": function(cm) {yankTillMark(cm,"Shift-I");},
-    "J": function(cm) {yankTillMark(cm,"J");},
-    "Shift-J": function(cm) {yankTillMark(cm,"Shift-J");},
-    "K": function(cm) {yankTillMark(cm,"K");},
-    "Shift-K": function(cm) {yankTillMark(cm,"Shift-K");},
-    "L": function(cm) {yankTillMark(cm,"L");},
-    "Shift-L": function(cm) {yankTillMark(cm,"Shift-L");},
-    "M": function(cm) {yankTillMark(cm,"M");},
-    "Shift-M": function(cm) {yankTillMark(cm,"Shift-M");},
-    "N": function(cm) {yankTillMark(cm,"N");},
-    "Shift-N": function(cm) {yankTillMark(cm,"Shift-N");},
-    "O": function(cm) {yankTillMark(cm,"O");},
-    "Shift-O": function(cm) {yankTillMark(cm,"Shift-O");},
-    "P": function(cm) {yankTillMark(cm,"P");},
-    "Shift-P": function(cm) {yankTillMark(cm,"Shift-P");},
-    "Q": function(cm) {yankTillMark(cm,"Q");},
-    "Shift-Q": function(cm) {yankTillMark(cm,"Shift-Q");},
-    "R": function(cm) {yankTillMark(cm,"R");},
-    "Shift-R": function(cm) {yankTillMark(cm,"Shift-R");},
-    "S": function(cm) {yankTillMark(cm,"S");},
-    "Shift-S": function(cm) {yankTillMark(cm,"Shift-S");},
-    "T": function(cm) {yankTillMark(cm,"T");},
-    "Shift-T": function(cm) {yankTillMark(cm,"Shift-T");},
-    "U": function(cm) {yankTillMark(cm,"U");},
-    "Shift-U": function(cm) {yankTillMark(cm,"Shift-U");},
-    "V": function(cm) {yankTillMark(cm,"V");},
-    "Shift-V": function(cm) {yankTillMark(cm,"Shift-V");},
-    "W": function(cm) {yankTillMark(cm,"W");},
-    "Shift-W": function(cm) {yankTillMark(cm,"Shift-W");},
-    "X": function(cm) {yankTillMark(cm,"X");},
-    "Shift-X": function(cm) {yankTillMark(cm,"Shift-X");},
-    "Y": function(cm) {yankTillMark(cm,"Y");},
-    "Shift-Y": function(cm) {yankTillMark(cm,"Shift-Y");},
-    "Z": function(cm) {yankTillMark(cm,"Z");},
-    "Shift-Z": function(cm) {yankTillMark(cm,"Shift-Z");},
-    auto: "vim", 
-    catchall: function(cm) {/*ignore*/}
-  };
-
-  CodeMirror.keyMap["vim-prefix-y"] = {
-    "Y": countTimes(function(cm) { pushInBuffer("\n"+cm.getLine(cm.getCursor().line+yank)); yank++; }),
-    "'": function(cm) {cm.setOption("keyMap", "vim-prefix-y'"); emptyBuffer();},
-    auto: "vim", 
-    catchall: function(cm) {/*ignore*/}
-  };
-
-  CodeMirror.keyMap["vim-insert"] = {
-    "Esc": function(cm) {
-	     cm.setCursor(cm.getCursor().line, cm.getCursor().ch-1, true); 
-	     cm.setOption("keyMap", "vim");
-	     editCursor("vim");
-           },
-    "Ctrl-N": function(cm) {/* Code to bring up autocomplete hint */},
-    "Ctrl-P": function(cm) {/* Code to bring up autocomplete hint */},
-    fallthrough: ["default"]
-  };
-})();

CodeMirror-2.21/lib/codemirror.css

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

CodeMirror-2.21/lib/util/dialog.css

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

CodeMirror-2.21/lib/util/dialog.js

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

CodeMirror-2.21/lib/util/foldcode.js

@@ -1,173 +0,0 @@
-// the tagRangeFinder function is
-//   Copyright (C) 2011 by Daniel Glazman <daniel@glazman.org>
-// released under the MIT license (../../LICENSE) like the rest of CodeMirror
-CodeMirror.tagRangeFinder = function(cm, line) {
-  var nameStartChar = "A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
-  var nameChar = nameStartChar + "\-\.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
-  var xmlNAMERegExp = new RegExp("^[" + nameStartChar + "][" + nameChar + "]*");
-
-  var lineText = cm.getLine(line);
-  var found = false;
-  var tag = null;
-  var pos = 0;
-  while (!found) {
-    pos = lineText.indexOf("<", pos);
-    if (-1 == pos) // no tag on line
-      return;
-    if (pos + 1 < lineText.length && lineText[pos + 1] == "/") { // closing tag
-      pos++;
-      continue;
-    }
-    // ok we weem to have a start tag
-    if (!lineText.substr(pos + 1).match(xmlNAMERegExp)) { // not a tag name...
-      pos++;
-      continue;
-    }
-    var gtPos = lineText.indexOf(">", pos + 1);
-    if (-1 == gtPos) { // end of start tag not in line
-      var l = line + 1;
-      var foundGt = false;
-      var lastLine = cm.lineCount();
-      while (l < lastLine && !foundGt) {
-        var lt = cm.getLine(l);
-        var gt = lt.indexOf(">");
-        if (-1 != gt) { // found a >
-          foundGt = true;
-          var slash = lt.lastIndexOf("/", gt);
-          if (-1 != slash && slash < gt) {
-            var str = lineText.substr(slash, gt - slash + 1);
-            if (!str.match( /\/\s*\>/ )) // yep, that's the end of empty tag
-              return l+1;
-          }
-        }
-        l++;
-      }
-      found = true;
-    }
-    else {
-      var slashPos = lineText.lastIndexOf("/", gtPos);
-      if (-1 == slashPos) { // cannot be empty tag
-        found = true;
-        // don't continue
-      }
-      else { // empty tag?
-        // check if really empty tag
-        var str = lineText.substr(slashPos, gtPos - slashPos + 1);
-        if (!str.match( /\/\s*\>/ )) { // finally not empty
-          found = true;
-          // don't continue
-        }
-      }
-    }
-    if (found) {
-      var subLine = lineText.substr(pos + 1);
-      tag = subLine.match(xmlNAMERegExp);
-      if (tag) {
-        // we have an element name, wooohooo !
-        tag = tag[0];
-        // do we have the close tag on same line ???
-        if (-1 != lineText.indexOf("</" + tag + ">", pos)) // yep
-        {
-          found = false;
-        }
-        // we don't, so we have a candidate...
-      }
-      else
-        found = false;
-    }
-    if (!found)
-      pos++;
-  }
-
-  if (found) {
-    var startTag = "(\\<\\/" + tag + "\\>)|(\\<" + tag + "\\>)|(\\<" + tag + "\s)|(\\<" + tag + "$)";
-    var startTagRegExp = new RegExp(startTag, "g");
-    var endTag = "</" + tag + ">";
-    var depth = 1;
-    var l = line + 1;
-    var lastLine = cm.lineCount();
-    while (l < lastLine) {
-      lineText = cm.getLine(l);
-      var match = lineText.match(startTagRegExp);
-      if (match) {
-        for (var i = 0; i < match.length; i++) {
-          if (match[i] == endTag)
-            depth--;
-          else
-            depth++;
-          if (!depth)
-            return l+1;
-        }
-      }
-      l++;
-    }
-    return;
-  }
-};
-
-CodeMirror.braceRangeFinder = function(cm, line) {
-  var lineText = cm.getLine(line);
-  var startChar = lineText.lastIndexOf("{");
-  if (startChar < 0 || lineText.lastIndexOf("}") > startChar) return;
-  var tokenType = cm.getTokenAt({line: line, ch: startChar}).className;
-  var count = 1, lastLine = cm.lineCount(), end;
-  outer: for (var i = line + 1; i < lastLine; ++i) {
-    var text = cm.getLine(i), pos = 0;
-    for (;;) {
-      var nextOpen = text.indexOf("{", pos), nextClose = text.indexOf("}", pos);
-      if (nextOpen < 0) nextOpen = text.length;
-      if (nextClose < 0) nextClose = text.length;
-      pos = Math.min(nextOpen, nextClose);
-      if (pos == text.length) break;
-      if (cm.getTokenAt({line: i, ch: pos + 1}).className == tokenType) {
-        if (pos == nextOpen) ++count;
-        else if (!--count) { end = i; break outer; }
-      }
-      ++pos;
-    }
-  }
-  if (end == null || end == line + 1) return;
-  return end;
-};
-
-
-CodeMirror.newFoldFunction = function(rangeFinder, markText) {
-  var folded = [];
-  if (markText == null) markText = '<div style="position: absolute; left: 2px; color:#600">&#x25bc;</div>%N%';
-
-  function isFolded(cm, n) {
-    for (var i = 0; i < folded.length; ++i) {
-      var start = cm.lineInfo(folded[i].start);
-      if (!start) folded.splice(i--, 1);
-      else if (start.line == n) return {pos: i, region: folded[i]};
-    }
-  }
-
-  function expand(cm, region) {
-    cm.clearMarker(region.start);
-    for (var i = 0; i < region.hidden.length; ++i)
-      cm.showLine(region.hidden[i]);
-  }
-
-  return function(cm, line) {
-    cm.operation(function() {
-      var known = isFolded(cm, line);
-      if (known) {
-        folded.splice(known.pos, 1);
-        expand(cm, known.region);
-      } else {
-        var end = rangeFinder(cm, line);
-        if (end == null) return;
-        var hidden = [];
-        for (var i = line + 1; i < end; ++i) {
-          var handle = cm.hideLine(i);
-          if (handle) hidden.push(handle);
-        }
-        var first = cm.setMarker(line, markText);
-        var region = {start: first, hidden: hidden};
-        cm.onDeleteLine(first, function() { expand(cm, region); });
-        folded.push(region);
-      }
-    });
-  };
-};

CodeMirror-2.21/lib/util/formatting.js

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

CodeMirror-2.21/lib/util/javascript-hint.js

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

CodeMirror-2.21/lib/util/overlay.js

@@ -1,51 +0,0 @@
-// Utility function that allows modes to be combined. The mode given
-// as the base argument takes care of most of the normal mode
-// functionality, but a second (typically simple) mode is used, which
-// can override the style of text. Both modes get to parse all of the
-// text, but when both assign a non-null style to a piece of code, the
-// overlay wins, unless the combine argument was true, in which case
-// the styles are combined.
-
-CodeMirror.overlayParser = function(base, overlay, combine) {
-  return {
-    startState: function() {
-      return {
-        base: CodeMirror.startState(base),
-        overlay: CodeMirror.startState(overlay),
-        basePos: 0, baseCur: null,
-        overlayPos: 0, overlayCur: null
-      };
-    },
-    copyState: function(state) {
-      return {
-        base: CodeMirror.copyState(base, state.base),
-        overlay: CodeMirror.copyState(overlay, state.overlay),
-        basePos: state.basePos, baseCur: null,
-        overlayPos: state.overlayPos, overlayCur: null
-      };
-    },
-
-    token: function(stream, state) {
-      if (stream.start == state.basePos) {
-        state.baseCur = base.token(stream, state.base);
-        state.basePos = stream.pos;
-      }
-      if (stream.start == state.overlayPos) {
-        stream.pos = stream.start;
-        state.overlayCur = overlay.token(stream, state.overlay);
-        state.overlayPos = stream.pos;
-      }
-      stream.pos = Math.min(state.basePos, state.overlayPos);
-      if (stream.eol()) state.basePos = state.overlayPos = 0;
-
-      if (state.overlayCur == null) return state.baseCur;
-      if (state.baseCur != null && combine) return state.baseCur + " " + state.overlayCur;
-      else return state.overlayCur;
-    },
-    
-    indent: function(state, textAfter) {
-      return base.indent(state.base, textAfter);
-    },
-    electricChars: base.electricChars
-  };
-};

CodeMirror-2.21/lib/util/runmode.js

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

CodeMirror-2.21/lib/util/search.js

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

CodeMirror-2.21/lib/util/searchcursor.js

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

CodeMirror-2.21/lib/util/simple-hint.css

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

CodeMirror-2.21/lib/util/simple-hint.js

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

CodeMirror-2.21/mode/clike/clike.js

@@ -1,234 +0,0 @@
-CodeMirror.defineMode("clike", function(config, parserConfig) {
-  var indentUnit = config.indentUnit,
-      keywords = parserConfig.keywords || {},
-      blockKeywords = parserConfig.blockKeywords || {},
-      atoms = parserConfig.atoms || {},
-      hooks = parserConfig.hooks || {},
-      multiLineStrings = parserConfig.multiLineStrings;
-  var isOperatorChar = /[+\-*&%=<>!?|\/]/;
-
-  var curPunc;
-
-  function tokenBase(stream, state) {
-    var ch = stream.next();
-    if (hooks[ch]) {
-      var result = hooks[ch](stream, state);
-      if (result !== false) return result;
-    }
-    if (ch == '"' || ch == "'") {
-      state.tokenize = tokenString(ch);
-      return state.tokenize(stream, state);
-    }
-    if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
-      curPunc = ch;
-      return null
-    }
-    if (/\d/.test(ch)) {
-      stream.eatWhile(/[\w\.]/);
-      return "number";
-    }
-    if (ch == "/") {
-      if (stream.eat("*")) {
-        state.tokenize = tokenComment;
-        return tokenComment(stream, state);
-      }
-      if (stream.eat("/")) {
-        stream.skipToEnd();
-        return "comment";
-      }
-    }
-    if (isOperatorChar.test(ch)) {
-      stream.eatWhile(isOperatorChar);
-      return "operator";
-    }
-    stream.eatWhile(/[\w\$_]/);
-    var cur = stream.current();
-    if (keywords.propertyIsEnumerable(cur)) {
-      if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
-      return "keyword";
-    }
-    if (atoms.propertyIsEnumerable(cur)) return "atom";
-    return "word";
-  }
-
-  function tokenString(quote) {
-    return function(stream, state) {
-      var escaped = false, next, end = false;
-      while ((next = stream.next()) != null) {
-        if (next == quote && !escaped) {end = true; break;}
-        escaped = !escaped && next == "\\";
-      }
-      if (end || !(escaped || multiLineStrings))
-        state.tokenize = tokenBase;
-      return "string";
-    };
-  }
-
-  function tokenComment(stream, state) {
-    var maybeEnd = false, ch;
-    while (ch = stream.next()) {
-      if (ch == "/" && maybeEnd) {
-        state.tokenize = tokenBase;
-        break;
-      }
-      maybeEnd = (ch == "*");
-    }
-    return "comment";
-  }
-
-  function Context(indented, column, type, align, prev) {
-    this.indented = indented;
-    this.column = column;
-    this.type = type;
-    this.align = align;
-    this.prev = prev;
-  }
-  function pushContext(state, col, type) {
-    return state.context = new Context(state.indented, col, type, null, state.context);
-  }
-  function popContext(state) {
-    var t = state.context.type;
-    if (t == ")" || t == "]" || t == "}")
-      state.indented = state.context.indented;
-    return state.context = state.context.prev;
-  }
-
-  // Interface
-
-  return {
-    startState: function(basecolumn) {
-      return {
-        tokenize: null,
-        context: new Context((basecolumn || 0) - indentUnit, 0, "top", false),
-        indented: 0,
-        startOfLine: true
-      };
-    },
-
-    token: function(stream, state) {
-      var ctx = state.context;
-      if (stream.sol()) {
-        if (ctx.align == null) ctx.align = false;
-        state.indented = stream.indentation();
-        state.startOfLine = true;
-      }
-      if (stream.eatSpace()) return null;
-      curPunc = null;
-      var style = (state.tokenize || tokenBase)(stream, state);
-      if (style == "comment" || style == "meta") return style;
-      if (ctx.align == null) ctx.align = true;
-
-      if ((curPunc == ";" || curPunc == ":") && ctx.type == "statement") popContext(state);
-      else if (curPunc == "{") pushContext(state, stream.column(), "}");
-      else if (curPunc == "[") pushContext(state, stream.column(), "]");
-      else if (curPunc == "(") pushContext(state, stream.column(), ")");
-      else if (curPunc == "}") {
-        while (ctx.type == "statement") ctx = popContext(state);
-        if (ctx.type == "}") ctx = popContext(state);
-        while (ctx.type == "statement") ctx = popContext(state);
-      }
-      else if (curPunc == ctx.type) popContext(state);
-      else if (ctx.type == "}" || ctx.type == "top" || (ctx.type == "statement" && curPunc == "newstatement"))
-        pushContext(state, stream.column(), "statement");
-      state.startOfLine = false;
-      return style;
-    },
-
-    indent: function(state, textAfter) {
-      if (state.tokenize != tokenBase && state.tokenize != null) return 0;
-      var ctx = state.context, firstChar = textAfter && textAfter.charAt(0);
-      if (ctx.type == "statement" && firstChar == "}") ctx = ctx.prev;
-      var closing = firstChar == ctx.type;
-      if (ctx.type == "statement") return ctx.indented + (firstChar == "{" ? 0 : indentUnit);
-      else if (ctx.align) return ctx.column + (closing ? 0 : 1);
-      else return ctx.indented + (closing ? 0 : indentUnit);
-    },
-
-    electricChars: "{}"
-  };
-});
-
-(function() {
-  function words(str) {
-    var obj = {}, words = str.split(" ");
-    for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
-    return obj;
-  }
-  var cKeywords = "auto if break int case long char register continue return default short do sizeof " +
-    "double static else struct entry switch extern typedef float union for unsigned " +
-    "goto while enum void const signed volatile";
-
-  function cppHook(stream, state) {
-    if (!state.startOfLine) return false;
-    stream.skipToEnd();
-    return "meta";
-  }
-
-  // C#-style strings where "" escapes a quote.
-  function tokenAtString(stream, state) {
-    var next;
-    while ((next = stream.next()) != null) {
-      if (next == '"' && !stream.eat('"')) {
-        state.tokenize = null;
-        break;
-      }
-    }
-    return "string";
-  }
-
-  CodeMirror.defineMIME("text/x-csrc", {
-    name: "clike",
-    keywords: words(cKeywords),
-    blockKeywords: words("case do else for if switch while struct"),
-    atoms: words("null"),
-    hooks: {"#": cppHook}
-  });
-  CodeMirror.defineMIME("text/x-c++src", {
-    name: "clike",
-    keywords: words(cKeywords + " asm dynamic_cast namespace reinterpret_cast try bool explicit new " +
-                    "static_cast typeid catch operator template typename class friend private " +
-                    "this using const_cast inline public throw virtual delete mutable protected " +
-                    "wchar_t"),
-    blockKeywords: words("catch class do else finally for if struct switch try while"),
-    atoms: words("true false null"),
-    hooks: {"#": cppHook}
-  });
-  CodeMirror.defineMIME("text/x-java", {
-    name: "clike",
-    keywords: words("abstract assert boolean break byte case catch char class const continue default " + 
-                    "do double else enum extends final finally float for goto if implements import " +
-                    "instanceof int interface long native new package private protected public " +
-                    "return short static strictfp super switch synchronized this throw throws transient " +
-                    "try void volatile while"),
-    blockKeywords: words("catch class do else finally for if switch try while"),
-    atoms: words("true false null"),
-    hooks: {
-      "@": function(stream, state) {
-        stream.eatWhile(/[\w\$_]/);
-        return "meta";
-      }
-    }
-  });
-  CodeMirror.defineMIME("text/x-csharp", {
-    name: "clike",
-    keywords: words("abstract as base bool break byte case catch char checked class const continue decimal" + 
-                    " default delegate do double else enum event explicit extern finally fixed float for" + 
-                    " foreach goto if implicit in int interface internal is lock long namespace new object" + 
-                    " operator out override params private protected public readonly ref return sbyte sealed short" + 
-                    " sizeof stackalloc static string struct switch this throw try typeof uint ulong unchecked" + 
-                    " unsafe ushort using virtual void volatile while add alias ascending descending dynamic from get" + 
-                    " global group into join let orderby partial remove select set value var yield"),
-    blockKeywords: words("catch class do else finally for foreach if struct switch try while"),
-    atoms: words("true false null"),
-    hooks: {
-      "@": function(stream, state) {
-        if (stream.eat('"')) {
-          state.tokenize = tokenAtString;
-          return tokenAtString(stream, state);
-        }
-        stream.eatWhile(/[\w\$_]/);
-        return "meta";
-      }
-    }
-  });
-}());

CodeMirror-2.21/mode/clike/index.html

@@ -1,101 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <title>CodeMirror: C-like mode</title>
-    <link rel="stylesheet" href="../../lib/codemirror.css">
-    <script src="../../lib/codemirror.js"></script>
-    <script src="clike.js"></script>
-    <link rel="stylesheet" href="../../doc/docs.css">
-    <style>.CodeMirror {border: 2px inset #dee;}</style>
-  </head>
-  <body>
-    <h1>CodeMirror: C-like mode</h1>
-
-<form><textarea id="code" name="code">
-/* C demo code */
-
-#include <zmq.h>
-#include <pthread.h>
-#include <semaphore.h>
-#include <time.h>
-#include <stdio.h>
-#include <fcntl.h>
-#include <malloc.h>
-
-typedef struct {
-  void* arg_socket;
-  zmq_msg_t* arg_msg;
-  char* arg_string;
-  unsigned long arg_len;
-  int arg_int, arg_command;
-
-  int signal_fd;
-  int pad;
-  void* context;
-  sem_t sem;
-} acl_zmq_context;
-
-#define p(X) (context->arg_##X)
-
-void* zmq_thread(void* context_pointer) {
-  acl_zmq_context* context = (acl_zmq_context*)context_pointer;
-  char ok = 'K', err = 'X';
-  int res;
-
-  while (1) {
-    while ((res = sem_wait(&amp;context->sem)) == EINTR);
-    if (res) {write(context->signal_fd, &amp;err, 1); goto cleanup;}
-    switch(p(command)) {
-    case 0: goto cleanup;
-    case 1: p(socket) = zmq_socket(context->context, p(int)); break;
-    case 2: p(int) = zmq_close(p(socket)); break;
-    case 3: p(int) = zmq_bind(p(socket), p(string)); break;
-    case 4: p(int) = zmq_connect(p(socket), p(string)); break;
-    case 5: p(int) = zmq_getsockopt(p(socket), p(int), (void*)p(string), &amp;p(len)); break;
-    case 6: p(int) = zmq_setsockopt(p(socket), p(int), (void*)p(string), p(len)); break;
-    case 7: p(int) = zmq_send(p(socket), p(msg), p(int)); break;
-    case 8: p(int) = zmq_recv(p(socket), p(msg), p(int)); break;
-    case 9: p(int) = zmq_poll(p(socket), p(int), p(len)); break;
-    }
-    p(command) = errno;
-    write(context->signal_fd, &amp;ok, 1);
-  }
- cleanup:
-  close(context->signal_fd);
-  free(context_pointer);
-  return 0;
-}
-
-void* zmq_thread_init(void* zmq_context, int signal_fd) {
-  acl_zmq_context* context = malloc(sizeof(acl_zmq_context));
-  pthread_t thread;
-
-  context->context = zmq_context;
-  context->signal_fd = signal_fd;
-  sem_init(&amp;context->sem, 1, 0);
-  pthread_create(&amp;thread, 0, &amp;zmq_thread, context);
-  pthread_detach(thread);
-  return context;
-}
-</textarea></form>
-
-    <script>
-      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
-        lineNumbers: true,
-        matchBrackets: true,
-        mode: "text/x-csrc"
-      });
-    </script>
-
-    <p>Simple mode that tries to handle C-like languages as well as it
-    can. Takes two configuration parameters: <code>keywords</code>, an
-    object whose property names are the keywords in the language,
-    and <code>useCPP</code>, which determines whether C preprocessor
-    directives are recognized.</p>
-
-    <p><strong>MIME types defined:</strong> <code>text/x-csrc</code>
-    (C code), <code>text/x-c++src</code> (C++
-    code), <code>text/x-java</code> (Java
-    code).</p>
-  </body>
-</html>

CodeMirror-2.21/mode/css/css.js

@@ -1,124 +0,0 @@
-CodeMirror.defineMode("css", function(config) {
-  var indentUnit = config.indentUnit, type;
-  function ret(style, tp) {type = tp; return style;}
-
-  function tokenBase(stream, state) {
-    var ch = stream.next();
-    if (ch == "@") {stream.eatWhile(/[\w\\\-]/); return ret("meta", stream.current());}
-    else if (ch == "/" && stream.eat("*")) {
-      state.tokenize = tokenCComment;
-      return tokenCComment(stream, state);
-    }
-    else if (ch == "<" && stream.eat("!")) {
-      state.tokenize = tokenSGMLComment;
-      return tokenSGMLComment(stream, state);
-    }
-    else if (ch == "=") ret(null, "compare");
-    else if ((ch == "~" || ch == "|") && stream.eat("=")) return ret(null, "compare");
-    else if (ch == "\"" || ch == "'") {
-      state.tokenize = tokenString(ch);
-      return state.tokenize(stream, state);
-    }
-    else if (ch == "#") {
-      stream.eatWhile(/[\w\\\-]/);
-      return ret("atom", "hash");
-    }
-    else if (ch == "!") {
-      stream.match(/^\s*\w*/);
-      return ret("keyword", "important");
-    }
-    else if (/\d/.test(ch)) {
-      stream.eatWhile(/[\w.%]/);
-      return ret("number", "unit");
-    }
-    else if (/[,.+>*\/]/.test(ch)) {
-      return ret(null, "select-op");
-    }
-    else if (/[;{}:\[\]]/.test(ch)) {
-      return ret(null, ch);
-    }
-    else {
-      stream.eatWhile(/[\w\\\-]/);
-      return ret("variable", "variable");
-    }
-  }
-
-  function tokenCComment(stream, state) {
-    var maybeEnd = false, ch;
-    while ((ch = stream.next()) != null) {
-      if (maybeEnd && ch == "/") {
-        state.tokenize = tokenBase;
-        break;
-      }
-      maybeEnd = (ch == "*");
-    }
-    return ret("comment", "comment");
-  }
-
-  function tokenSGMLComment(stream, state) {
-    var dashes = 0, ch;
-    while ((ch = stream.next()) != null) {
-      if (dashes >= 2 && ch == ">") {
-        state.tokenize = tokenBase;
-        break;
-      }
-      dashes = (ch == "-") ? dashes + 1 : 0;
-    }
-    return ret("comment", "comment");
-  }
-
-  function tokenString(quote) {
-    return function(stream, state) {
-      var escaped = false, ch;
-      while ((ch = stream.next()) != null) {
-        if (ch == quote && !escaped)
-          break;
-        escaped = !escaped && ch == "\\";
-      }
-      if (!escaped) state.tokenize = tokenBase;
-      return ret("string", "string");
-    };
-  }
-
-  return {
-    startState: function(base) {
-      return {tokenize: tokenBase,
-              baseIndent: base || 0,
-              stack: []};
-    },
-
-    token: function(stream, state) {
-      if (stream.eatSpace()) return null;
-      var style = state.tokenize(stream, state);
-
-      var context = state.stack[state.stack.length-1];
-      if (type == "hash" && context == "rule") style = "atom";
-      else if (style == "variable") {
-        if (context == "rule") style = "number";
-        else if (!context || context == "@media{") style = "tag";
-      }
-
-      if (context == "rule" && /^[\{\};]$/.test(type))
-        state.stack.pop();
-      if (type == "{") {
-        if (context == "@media") state.stack[state.stack.length-1] = "@media{";
-        else state.stack.push("{");
-      }
-      else if (type == "}") state.stack.pop();
-      else if (type == "@media") state.stack.push("@media");
-      else if (context == "{" && type != "comment") state.stack.push("rule");
-      return style;
-    },
-
-    indent: function(state, textAfter) {
-      var n = state.stack.length;
-      if (/^\}/.test(textAfter))
-        n -= state.stack[state.stack.length-1] == "rule" ? 2 : 1;
-      return state.baseIndent + n * indentUnit;
-    },
-
-    electricChars: "}"
-  };
-});
-
-CodeMirror.defineMIME("text/css", "css");

CodeMirror-2.21/mode/css/index.html

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

CodeMirror-2.21/mode/javascript/index.html

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

CodeMirror-2.21/mode/javascript/javascript.js

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

CodeMirror-2.21/mode/php/index.html

@@ -1,48 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <title>CodeMirror: PHP mode</title>
-    <link rel="stylesheet" href="../../lib/codemirror.css">
-    <script src="../../lib/codemirror.js"></script>
-    <script src="../xml/xml.js"></script>
-    <script src="../javascript/javascript.js"></script>
-    <script src="../css/css.js"></script>
-    <script src="../clike/clike.js"></script>
-    <script src="php.js"></script>
-    <style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
-    <link rel="stylesheet" href="../../doc/docs.css">
-  </head>
-  <body>
-    <h1>CodeMirror: PHP mode</h1>
-
-<form><textarea id="code" name="code">
-<?php
-function hello($who) {
-	return "Hello " . $who;
-}
-?>
-<p>The program says <?= hello("World") ?>.</p>
-<script>
-	alert("And here is some JS code"); // also colored
-</script>
-</textarea></form>
-
-    <script>
-      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
-        lineNumbers: true,
-        matchBrackets: true,
-        mode: "application/x-httpd-php",
-        indentUnit: 4,
-        indentWithTabs: true,
-        enterMode: "keep",
-        tabMode: "shift"
-      });
-    </script>
-
-    <p>Simple HTML/PHP mode based on
-    the <a href="../clike/">C-like</a> mode. Depends on XML,
-    JavaScript, CSS, and C-like modes.</p>
-
-    <p><strong>MIME types defined:</strong> <code>application/x-httpd-php</code> (HTML with PHP code), <code>text/x-php</code> (plain, non-wrapped PHP code).</p>
-  </body>
-</html>

CodeMirror-2.21/mode/php/php.js

@@ -1,121 +0,0 @@
-(function() {
-  function keywords(str) {
-    var obj = {}, words = str.split(" ");
-    for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
-    return obj;
-  }
-  function heredoc(delim) {
-    return function(stream, state) {
-      if (stream.match(delim)) state.tokenize = null;
-      else stream.skipToEnd();
-      return "string";
-    }
-  }
-  var phpConfig = {
-    name: "clike",
-    keywords: keywords("abstract and array as break case catch cfunction class clone const continue declare " +
-                       "default do else elseif enddeclare endfor endforeach endif endswitch endwhile extends " +
-                       "final for foreach function global goto if implements interface instanceof namespace " +
-                       "new or private protected public static switch throw try use var while xor return" +
-                       "die echo empty exit eval include include_once isset list require require_once print unset"),
-    blockKeywords: keywords("catch do else elseif for foreach if switch try while"),
-    atoms: keywords("true false null TRUE FALSE NULL"),
-    multiLineStrings: true,
-    hooks: {
-      "$": function(stream, state) {
-        stream.eatWhile(/[\w\$_]/);
-        return "variable-2";
-      },
-      "<": function(stream, state) {
-        if (stream.match(/<</)) {
-          stream.eatWhile(/[\w\.]/);
-          state.tokenize = heredoc(stream.current().slice(3));
-          return state.tokenize(stream, state);
-        }
-        return false;
-      },
-      "#": function(stream, state) {
-        stream.skipToEnd();
-        return "comment";
-      }
-    }
-  };
-
-  CodeMirror.defineMode("php", function(config, parserConfig) {
-    var htmlMode = CodeMirror.getMode(config, {name: "xml", htmlMode: true});
-    var jsMode = CodeMirror.getMode(config, "javascript");
-    var cssMode = CodeMirror.getMode(config, "css");
-    var phpMode = CodeMirror.getMode(config, phpConfig);
-
-    function dispatch(stream, state) { // TODO open PHP inside text/css
-      if (state.curMode == htmlMode) {
-        var style = htmlMode.token(stream, state.curState);
-        if (style == "meta" && /^<\?/.test(stream.current())) {
-          state.curMode = phpMode;
-          state.curState = state.php;
-          state.curClose = /^\?>/;
-		  state.mode =  'php';
-        }
-        else if (style == "tag" && stream.current() == ">" && state.curState.context) {
-          if (/^script$/i.test(state.curState.context.tagName)) {
-            state.curMode = jsMode;
-            state.curState = jsMode.startState(htmlMode.indent(state.curState, ""));
-            state.curClose = /^<\/\s*script\s*>/i;
-			state.mode =  'javascript';
-          }
-          else if (/^style$/i.test(state.curState.context.tagName)) {
-            state.curMode = cssMode;
-            state.curState = cssMode.startState(htmlMode.indent(state.curState, ""));
-            state.curClose =  /^<\/\s*style\s*>/i;
-            state.mode =  'css';
-          }
-        }
-        return style;
-      }
-      else if (stream.match(state.curClose, false)) {
-        state.curMode = htmlMode;
-        state.curState = state.html;
-        state.curClose = null;
-		state.mode =  'html';
-        return dispatch(stream, state);
-      }
-      else return state.curMode.token(stream, state.curState);
-    }
-
-    return {
-      startState: function() {
-        var html = htmlMode.startState();
-        return {html: html,
-                php: phpMode.startState(),
-                curMode:	parserConfig.startOpen ? phpMode : htmlMode,
-                curState:	parserConfig.startOpen ? phpMode.startState() : html,
-                curClose:	parserConfig.startOpen ? /^\?>/ : null,
-				mode:		parserConfig.startOpen ? 'php' : 'html'}
-      },
-
-      copyState: function(state) {
-        var html = state.html, htmlNew = CodeMirror.copyState(htmlMode, html),
-            php = state.php, phpNew = CodeMirror.copyState(phpMode, php), cur;
-        if (state.curState == html) cur = htmlNew;
-        else if (state.curState == php) cur = phpNew;
-        else cur = CodeMirror.copyState(state.curMode, state.curState);
-        return {html: htmlNew, php: phpNew, curMode: state.curMode, curState: cur,
-                curClose: state.curClose, mode: state.mode};
-      },
-
-      token: dispatch,
-
-      indent: function(state, textAfter) {
-        if ((state.curMode != phpMode && /^\s*<\//.test(textAfter)) ||
-            (state.curMode == phpMode && /^\?>/.test(textAfter)))
-          return htmlMode.indent(state.html, textAfter);
-        return state.curMode.indent(state.curState, textAfter);
-      },
-
-      electricChars: "/{}:"
-    }
-  });
-  CodeMirror.defineMIME("application/x-httpd-php", "php");
-  CodeMirror.defineMIME("application/x-httpd-php-open", {name: "php", startOpen: true});
-  CodeMirror.defineMIME("text/x-php", phpConfig);
-})();

CodeMirror-2.21/mode/xml/index.html

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

CodeMirror-2.21/mode/xml/xml.js

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