Active Line Demo
+ + + + +Styling the current cursor line.
+ + the CSS class "CodeMirror-activeline",
+// and gives its background
+
+
+
+
+
+
diff --git a/www/code/codemirror-5.7/demo/buffers.html b/www/code/codemirror-5.7/demo/buffers.html
new file mode 100644
index 000000000..16ffc7dfe
--- /dev/null
+++ b/www/code/codemirror-5.7/demo/buffers.html
@@ -0,0 +1,109 @@
+
+
+ the class "CodeMirror-activeline-background".
+
+(function(mod) {
+ if (typeof exports == "object" && typeof module == "object") // CommonJS
+ mod(require("../../lib/codemirror"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+ "use strict";
+ var WRAP_CLASS = "CodeMirror-activeline";
+ var BACK_CLASS = "CodeMirror-activeline-background";
+
+ CodeMirror.defineOption("styleActiveLine", false, function(cm, val, old) {
+ var prev = old && old != CodeMirror.Init;
+ if (val && !prev) {
+ cm.state.activeLines = [];
+ updateActiveLines(cm, cm.listSelections());
+ cm.on("beforeSelectionChange", selectionChange);
+ } else if (!val && prev) {
+ cm.off("beforeSelectionChange", selectionChange);
+ clearActiveLines(cm);
+ delete cm.state.activeLines;
+ }
+ });
+
+ function clearActiveLines(cm) {
+ for (var i = 0; i < cm.state.activeLines.length; i++) {
+ cm.removeLineClass(cm.state.activeLines[i], "wrap", WRAP_CLASS);
+ cm.removeLineClass(cm.state.activeLines[i], "background", BACK_CLASS);
+ }
+ }
+
+ function sameArray(a, b) {
+ if (a.length != b.length) return false;
+ for (var i = 0; i < a.length; i++)
+ if (a[i] != b[i]) return false;
+ return true;
+ }
+
+ function updateActiveLines(cm, ranges) {
+ var active = [];
+ for (var i = 0; i < ranges.length; i++) {
+ var range = ranges[i];
+ if (!range.empty()) continue;
+ var line = cm.getLineHandleVisualStart(range.head.line);
+ if (active[active.length - 1] != line) active.push(line);
+ }
+ if (sameArray(cm.state.activeLines, active)) return;
+ cm.operation(function() {
+ clearActiveLines(cm);
+ for (var i = 0; i < active.length; i++) {
+ cm.addLineClass(active[i], "wrap", WRAP_CLASS);
+ cm.addLineClass(active[i], "background", BACK_CLASS);
+ }
+ cm.state.activeLines = active;
+ });
+ }
+
+ function selectionChange(cm, sel) {
+ updateActiveLines(cm, sel.ranges);
+ }
+});
diff --git a/www/code/codemirror-5.7/addon/selection/mark-selection.js b/www/code/codemirror-5.7/addon/selection/mark-selection.js
new file mode 100644
index 000000000..5c42d21eb
--- /dev/null
+++ b/www/code/codemirror-5.7/addon/selection/mark-selection.js
@@ -0,0 +1,118 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// Because sometimes you need to mark the selected *text*.
+//
+// Adds an option 'styleSelectedText' which, when enabled, gives
+// selected text the CSS class given as option value, or
+// "CodeMirror-selectedtext" when the value is not a string.
+
+(function(mod) {
+ if (typeof exports == "object" && typeof module == "object") // CommonJS
+ mod(require("../../lib/codemirror"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+ "use strict";
+
+ CodeMirror.defineOption("styleSelectedText", false, function(cm, val, old) {
+ var prev = old && old != CodeMirror.Init;
+ if (val && !prev) {
+ cm.state.markedSelection = [];
+ cm.state.markedSelectionStyle = typeof val == "string" ? val : "CodeMirror-selectedtext";
+ reset(cm);
+ cm.on("cursorActivity", onCursorActivity);
+ cm.on("change", onChange);
+ } else if (!val && prev) {
+ cm.off("cursorActivity", onCursorActivity);
+ cm.off("change", onChange);
+ clear(cm);
+ cm.state.markedSelection = cm.state.markedSelectionStyle = null;
+ }
+ });
+
+ function onCursorActivity(cm) {
+ cm.operation(function() { update(cm); });
+ }
+
+ function onChange(cm) {
+ if (cm.state.markedSelection.length)
+ cm.operation(function() { clear(cm); });
+ }
+
+ var CHUNK_SIZE = 8;
+ var Pos = CodeMirror.Pos;
+ var cmp = CodeMirror.cmpPos;
+
+ function coverRange(cm, from, to, addAt) {
+ if (cmp(from, to) == 0) return;
+ var array = cm.state.markedSelection;
+ var cls = cm.state.markedSelectionStyle;
+ for (var line = from.line;;) {
+ var start = line == from.line ? from : Pos(line, 0);
+ var endLine = line + CHUNK_SIZE, atEnd = endLine >= to.line;
+ var end = atEnd ? to : Pos(endLine, 0);
+ var mark = cm.markText(start, end, {className: cls});
+ if (addAt == null) array.push(mark);
+ else array.splice(addAt++, 0, mark);
+ if (atEnd) break;
+ line = endLine;
+ }
+ }
+
+ function clear(cm) {
+ var array = cm.state.markedSelection;
+ for (var i = 0; i < array.length; ++i) array[i].clear();
+ array.length = 0;
+ }
+
+ function reset(cm) {
+ clear(cm);
+ var ranges = cm.listSelections();
+ for (var i = 0; i < ranges.length; i++)
+ coverRange(cm, ranges[i].from(), ranges[i].to());
+ }
+
+ function update(cm) {
+ if (!cm.somethingSelected()) return clear(cm);
+ if (cm.listSelections().length > 1) return reset(cm);
+
+ var from = cm.getCursor("start"), to = cm.getCursor("end");
+
+ var array = cm.state.markedSelection;
+ if (!array.length) return coverRange(cm, from, to);
+
+ var coverStart = array[0].find(), coverEnd = array[array.length - 1].find();
+ if (!coverStart || !coverEnd || to.line - from.line < CHUNK_SIZE ||
+ cmp(from, coverEnd.to) >= 0 || cmp(to, coverStart.from) <= 0)
+ return reset(cm);
+
+ while (cmp(from, coverStart.from) > 0) {
+ array.shift().clear();
+ coverStart = array[0].find();
+ }
+ if (cmp(from, coverStart.from) < 0) {
+ if (coverStart.to.line - from.line < CHUNK_SIZE) {
+ array.shift().clear();
+ coverRange(cm, from, coverStart.to, 0);
+ } else {
+ coverRange(cm, from, coverStart.from, 0);
+ }
+ }
+
+ while (cmp(to, coverEnd.to) < 0) {
+ array.pop().clear();
+ coverEnd = array[array.length - 1].find();
+ }
+ if (cmp(to, coverEnd.to) > 0) {
+ if (to.line - coverEnd.from.line < CHUNK_SIZE) {
+ array.pop().clear();
+ coverRange(cm, coverEnd.from, to);
+ } else {
+ coverRange(cm, coverEnd.to, to);
+ }
+ }
+ }
+});
diff --git a/www/code/codemirror-5.7/addon/selection/selection-pointer.js b/www/code/codemirror-5.7/addon/selection/selection-pointer.js
new file mode 100644
index 000000000..ef5e404ad
--- /dev/null
+++ b/www/code/codemirror-5.7/addon/selection/selection-pointer.js
@@ -0,0 +1,98 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+ if (typeof exports == "object" && typeof module == "object") // CommonJS
+ mod(require("../../lib/codemirror"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+ "use strict";
+
+ CodeMirror.defineOption("selectionPointer", false, function(cm, val) {
+ var data = cm.state.selectionPointer;
+ if (data) {
+ CodeMirror.off(cm.getWrapperElement(), "mousemove", data.mousemove);
+ CodeMirror.off(cm.getWrapperElement(), "mouseout", data.mouseout);
+ CodeMirror.off(window, "scroll", data.windowScroll);
+ cm.off("cursorActivity", reset);
+ cm.off("scroll", reset);
+ cm.state.selectionPointer = null;
+ cm.display.lineDiv.style.cursor = "";
+ }
+ if (val) {
+ data = cm.state.selectionPointer = {
+ value: typeof val == "string" ? val : "default",
+ mousemove: function(event) { mousemove(cm, event); },
+ mouseout: function(event) { mouseout(cm, event); },
+ windowScroll: function() { reset(cm); },
+ rects: null,
+ mouseX: null, mouseY: null,
+ willUpdate: false
+ };
+ CodeMirror.on(cm.getWrapperElement(), "mousemove", data.mousemove);
+ CodeMirror.on(cm.getWrapperElement(), "mouseout", data.mouseout);
+ CodeMirror.on(window, "scroll", data.windowScroll);
+ cm.on("cursorActivity", reset);
+ cm.on("scroll", reset);
+ }
+ });
+
+ function mousemove(cm, event) {
+ var data = cm.state.selectionPointer;
+ if (event.buttons == null ? event.which : event.buttons) {
+ data.mouseX = data.mouseY = null;
+ } else {
+ data.mouseX = event.clientX;
+ data.mouseY = event.clientY;
+ }
+ scheduleUpdate(cm);
+ }
+
+ function mouseout(cm, event) {
+ if (!cm.getWrapperElement().contains(event.relatedTarget)) {
+ var data = cm.state.selectionPointer;
+ data.mouseX = data.mouseY = null;
+ scheduleUpdate(cm);
+ }
+ }
+
+ function reset(cm) {
+ cm.state.selectionPointer.rects = null;
+ scheduleUpdate(cm);
+ }
+
+ function scheduleUpdate(cm) {
+ if (!cm.state.selectionPointer.willUpdate) {
+ cm.state.selectionPointer.willUpdate = true;
+ setTimeout(function() {
+ update(cm);
+ cm.state.selectionPointer.willUpdate = false;
+ }, 50);
+ }
+ }
+
+ function update(cm) {
+ var data = cm.state.selectionPointer;
+ if (!data) return;
+ if (data.rects == null && data.mouseX != null) {
+ data.rects = [];
+ if (cm.somethingSelected()) {
+ for (var sel = cm.display.selectionDiv.firstChild; sel; sel = sel.nextSibling)
+ data.rects.push(sel.getBoundingClientRect());
+ }
+ }
+ var inside = false;
+ if (data.mouseX != null) for (var i = 0; i < data.rects.length; i++) {
+ var rect = data.rects[i];
+ if (rect.left <= data.mouseX && rect.right >= data.mouseX &&
+ rect.top <= data.mouseY && rect.bottom >= data.mouseY)
+ inside = true;
+ }
+ var cursor = inside ? data.value : "";
+ if (cm.display.lineDiv.style.cursor != cursor)
+ cm.display.lineDiv.style.cursor = cursor;
+ }
+});
diff --git a/www/code/codemirror-5.7/addon/tern/tern.css b/www/code/codemirror-5.7/addon/tern/tern.css
new file mode 100644
index 000000000..c4b8a2f77
--- /dev/null
+++ b/www/code/codemirror-5.7/addon/tern/tern.css
@@ -0,0 +1,87 @@
+.CodeMirror-Tern-completion {
+ padding-left: 22px;
+ position: relative;
+ line-height: 1.5;
+}
+.CodeMirror-Tern-completion:before {
+ position: absolute;
+ left: 2px;
+ bottom: 2px;
+ border-radius: 50%;
+ font-size: 12px;
+ font-weight: bold;
+ height: 15px;
+ width: 15px;
+ line-height: 16px;
+ text-align: center;
+ color: white;
+ -moz-box-sizing: border-box;
+ box-sizing: border-box;
+}
+.CodeMirror-Tern-completion-unknown:before {
+ content: "?";
+ background: #4bb;
+}
+.CodeMirror-Tern-completion-object:before {
+ content: "O";
+ background: #77c;
+}
+.CodeMirror-Tern-completion-fn:before {
+ content: "F";
+ background: #7c7;
+}
+.CodeMirror-Tern-completion-array:before {
+ content: "A";
+ background: #c66;
+}
+.CodeMirror-Tern-completion-number:before {
+ content: "1";
+ background: #999;
+}
+.CodeMirror-Tern-completion-string:before {
+ content: "S";
+ background: #999;
+}
+.CodeMirror-Tern-completion-bool:before {
+ content: "B";
+ background: #999;
+}
+
+.CodeMirror-Tern-completion-guess {
+ color: #999;
+}
+
+.CodeMirror-Tern-tooltip {
+ border: 1px solid silver;
+ border-radius: 3px;
+ color: #444;
+ padding: 2px 5px;
+ font-size: 90%;
+ font-family: monospace;
+ background-color: white;
+ white-space: pre-wrap;
+
+ max-width: 40em;
+ position: absolute;
+ z-index: 10;
+ -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);
+
+ transition: opacity 1s;
+ -moz-transition: opacity 1s;
+ -webkit-transition: opacity 1s;
+ -o-transition: opacity 1s;
+ -ms-transition: opacity 1s;
+}
+
+.CodeMirror-Tern-hint-doc {
+ max-width: 25em;
+ margin-top: -3px;
+}
+
+.CodeMirror-Tern-fname { color: black; }
+.CodeMirror-Tern-farg { color: #70a; }
+.CodeMirror-Tern-farg-current { text-decoration: underline; }
+.CodeMirror-Tern-type { color: #07c; }
+.CodeMirror-Tern-fhint-guess { opacity: .7; }
diff --git a/www/code/codemirror-5.7/addon/tern/tern.js b/www/code/codemirror-5.7/addon/tern/tern.js
new file mode 100644
index 000000000..3ff2d53e5
--- /dev/null
+++ b/www/code/codemirror-5.7/addon/tern/tern.js
@@ -0,0 +1,700 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// Glue code between CodeMirror and Tern.
+//
+// Create a CodeMirror.TernServer to wrap an actual Tern server,
+// register open documents (CodeMirror.Doc instances) with it, and
+// call its methods to activate the assisting functions that Tern
+// provides.
+//
+// Options supported (all optional):
+// * defs: An array of JSON definition data structures.
+// * plugins: An object mapping plugin names to configuration
+// options.
+// * getFile: A function(name, c) that can be used to access files in
+// the project that haven't been loaded yet. Simply do c(null) to
+// indicate that a file is not available.
+// * fileFilter: A function(value, docName, doc) that will be applied
+// to documents before passing them on to Tern.
+// * switchToDoc: A function(name, doc) that should, when providing a
+// multi-file view, switch the view or focus to the named file.
+// * showError: A function(editor, message) that can be used to
+// override the way errors are displayed.
+// * completionTip: Customize the content in tooltips for completions.
+// Is passed a single argument—the completion's data as returned by
+// Tern—and may return a string, DOM node, or null to indicate that
+// no tip should be shown. By default the docstring is shown.
+// * typeTip: Like completionTip, but for the tooltips shown for type
+// queries.
+// * responseFilter: A function(doc, query, request, error, data) that
+// will be applied to the Tern responses before treating them
+//
+//
+// It is possible to run the Tern server in a web worker by specifying
+// these additional options:
+// * useWorker: Set to true to enable web worker mode. You'll probably
+// want to feature detect the actual value you use here, for example
+// !!window.Worker.
+// * workerScript: The main script of the worker. Point this to
+// wherever you are hosting worker.js from this directory.
+// * workerDeps: An array of paths pointing (relative to workerScript)
+// to the Acorn and Tern libraries and any Tern plugins you want to
+// load. Or, if you minified those into a single script and included
+// them in the workerScript, simply leave this undefined.
+
+(function(mod) {
+ if (typeof exports == "object" && typeof module == "object") // CommonJS
+ mod(require("../../lib/codemirror"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+ "use strict";
+ // declare global: tern
+
+ CodeMirror.TernServer = function(options) {
+ var self = this;
+ this.options = options || {};
+ var plugins = this.options.plugins || (this.options.plugins = {});
+ if (!plugins.doc_comment) plugins.doc_comment = true;
+ this.docs = Object.create(null);
+ if (this.options.useWorker) {
+ this.server = new WorkerServer(this);
+ } else {
+ this.server = new tern.Server({
+ getFile: function(name, c) { return getFile(self, name, c); },
+ async: true,
+ defs: this.options.defs || [],
+ plugins: plugins
+ });
+ }
+ this.trackChange = function(doc, change) { trackChange(self, doc, change); };
+
+ this.cachedArgHints = null;
+ this.activeArgHints = null;
+ this.jumpStack = [];
+
+ this.getHint = function(cm, c) { return hint(self, cm, c); };
+ this.getHint.async = true;
+ };
+
+ CodeMirror.TernServer.prototype = {
+ addDoc: function(name, doc) {
+ var data = {doc: doc, name: name, changed: null};
+ this.server.addFile(name, docValue(this, data));
+ CodeMirror.on(doc, "change", this.trackChange);
+ return this.docs[name] = data;
+ },
+
+ delDoc: function(id) {
+ var found = resolveDoc(this, id);
+ if (!found) return;
+ CodeMirror.off(found.doc, "change", this.trackChange);
+ delete this.docs[found.name];
+ this.server.delFile(found.name);
+ },
+
+ hideDoc: function(id) {
+ closeArgHints(this);
+ var found = resolveDoc(this, id);
+ if (found && found.changed) sendDoc(this, found);
+ },
+
+ complete: function(cm) {
+ cm.showHint({hint: this.getHint});
+ },
+
+ showType: function(cm, pos, c) { showContextInfo(this, cm, pos, "type", c); },
+
+ showDocs: function(cm, pos, c) { showContextInfo(this, cm, pos, "documentation", c); },
+
+ updateArgHints: function(cm) { updateArgHints(this, cm); },
+
+ jumpToDef: function(cm) { jumpToDef(this, cm); },
+
+ jumpBack: function(cm) { jumpBack(this, cm); },
+
+ rename: function(cm) { rename(this, cm); },
+
+ selectName: function(cm) { selectName(this, cm); },
+
+ request: function (cm, query, c, pos) {
+ var self = this;
+ var doc = findDoc(this, cm.getDoc());
+ var request = buildRequest(this, doc, query, pos);
+ var extraOptions = request.query && this.options.queryOptions && this.options.queryOptions[request.query.type]
+ if (extraOptions) for (var prop in extraOptions) request.query[prop] = extraOptions[prop];
+
+ this.server.request(request, function (error, data) {
+ if (!error && self.options.responseFilter)
+ data = self.options.responseFilter(doc, query, request, error, data);
+ c(error, data);
+ });
+ },
+
+ destroy: function () {
+ if (this.worker) {
+ this.worker.terminate();
+ this.worker = null;
+ }
+ }
+ };
+
+ var Pos = CodeMirror.Pos;
+ var cls = "CodeMirror-Tern-";
+ var bigDoc = 250;
+
+ function getFile(ts, name, c) {
+ var buf = ts.docs[name];
+ if (buf)
+ c(docValue(ts, buf));
+ else if (ts.options.getFile)
+ ts.options.getFile(name, c);
+ else
+ c(null);
+ }
+
+ function findDoc(ts, doc, name) {
+ for (var n in ts.docs) {
+ var cur = ts.docs[n];
+ if (cur.doc == doc) return cur;
+ }
+ if (!name) for (var i = 0;; ++i) {
+ n = "[doc" + (i || "") + "]";
+ if (!ts.docs[n]) { name = n; break; }
+ }
+ return ts.addDoc(name, doc);
+ }
+
+ function resolveDoc(ts, id) {
+ if (typeof id == "string") return ts.docs[id];
+ if (id instanceof CodeMirror) id = id.getDoc();
+ if (id instanceof CodeMirror.Doc) return findDoc(ts, id);
+ }
+
+ function trackChange(ts, doc, change) {
+ var data = findDoc(ts, doc);
+
+ var argHints = ts.cachedArgHints;
+ if (argHints && argHints.doc == doc && cmpPos(argHints.start, change.to) <= 0)
+ ts.cachedArgHints = null;
+
+ var changed = data.changed;
+ if (changed == null)
+ data.changed = changed = {from: change.from.line, to: change.from.line};
+ var end = change.from.line + (change.text.length - 1);
+ if (change.from.line < changed.to) changed.to = changed.to - (change.to.line - end);
+ if (end >= changed.to) changed.to = end + 1;
+ if (changed.from > change.from.line) changed.from = change.from.line;
+
+ if (doc.lineCount() > bigDoc && change.to - changed.from > 100) setTimeout(function() {
+ if (data.changed && data.changed.to - data.changed.from > 100) sendDoc(ts, data);
+ }, 200);
+ }
+
+ function sendDoc(ts, doc) {
+ ts.server.request({files: [{type: "full", name: doc.name, text: docValue(ts, doc)}]}, function(error) {
+ if (error) window.console.error(error);
+ else doc.changed = null;
+ });
+ }
+
+ // Completion
+
+ function hint(ts, cm, c) {
+ ts.request(cm, {type: "completions", types: true, docs: true, urls: true}, function(error, data) {
+ if (error) return showError(ts, cm, error);
+ var completions = [], after = "";
+ var from = data.start, to = data.end;
+ if (cm.getRange(Pos(from.line, from.ch - 2), from) == "[\"" &&
+ cm.getRange(to, Pos(to.line, to.ch + 2)) != "\"]")
+ after = "\"]";
+
+ for (var i = 0; i < data.completions.length; ++i) {
+ var completion = data.completions[i], className = typeToIcon(completion.type);
+ if (data.guess) className += " " + cls + "guess";
+ completions.push({text: completion.name + after,
+ displayText: completion.displayName || completion.name,
+ className: className,
+ data: completion});
+ }
+
+ var obj = {from: from, to: to, list: completions};
+ var tooltip = null;
+ CodeMirror.on(obj, "close", function() { remove(tooltip); });
+ CodeMirror.on(obj, "update", function() { remove(tooltip); });
+ CodeMirror.on(obj, "select", function(cur, node) {
+ remove(tooltip);
+ var content = ts.options.completionTip ? ts.options.completionTip(cur.data) : cur.data.doc;
+ if (content) {
+ tooltip = makeTooltip(node.parentNode.getBoundingClientRect().right + window.pageXOffset,
+ node.getBoundingClientRect().top + window.pageYOffset, content);
+ tooltip.className += " " + cls + "hint-doc";
+ }
+ });
+ c(obj);
+ });
+ }
+
+ function typeToIcon(type) {
+ var suffix;
+ if (type == "?") suffix = "unknown";
+ else if (type == "number" || type == "string" || type == "bool") suffix = type;
+ else if (/^fn\(/.test(type)) suffix = "fn";
+ else if (/^\[/.test(type)) suffix = "array";
+ else suffix = "object";
+ return cls + "completion " + cls + "completion-" + suffix;
+ }
+
+ // Type queries
+
+ function showContextInfo(ts, cm, pos, queryName, c) {
+ ts.request(cm, queryName, function(error, data) {
+ if (error) return showError(ts, cm, error);
+ if (ts.options.typeTip) {
+ var tip = ts.options.typeTip(data);
+ } else {
+ var tip = elt("span", null, elt("strong", null, data.type || "not found"));
+ if (data.doc)
+ tip.appendChild(document.createTextNode(" — " + data.doc));
+ if (data.url) {
+ tip.appendChild(document.createTextNode(" "));
+ var child = tip.appendChild(elt("a", null, "[docs]"));
+ child.href = data.url;
+ child.target = "_blank";
+ }
+ }
+ tempTooltip(cm, tip, ts);
+ if (c) c();
+ }, pos);
+ }
+
+ // Maintaining argument hints
+
+ function updateArgHints(ts, cm) {
+ closeArgHints(ts);
+
+ if (cm.somethingSelected()) return;
+ var state = cm.getTokenAt(cm.getCursor()).state;
+ var inner = CodeMirror.innerMode(cm.getMode(), state);
+ if (inner.mode.name != "javascript") return;
+ var lex = inner.state.lexical;
+ if (lex.info != "call") return;
+
+ var ch, argPos = lex.pos || 0, tabSize = cm.getOption("tabSize");
+ for (var line = cm.getCursor().line, e = Math.max(0, line - 9), found = false; line >= e; --line) {
+ var str = cm.getLine(line), extra = 0;
+ for (var pos = 0;;) {
+ var tab = str.indexOf("\t", pos);
+ if (tab == -1) break;
+ extra += tabSize - (tab + extra) % tabSize - 1;
+ pos = tab + 1;
+ }
+ ch = lex.column - extra;
+ if (str.charAt(ch) == "(") {found = true; break;}
+ }
+ if (!found) return;
+
+ var start = Pos(line, ch);
+ var cache = ts.cachedArgHints;
+ if (cache && cache.doc == cm.getDoc() && cmpPos(start, cache.start) == 0)
+ return showArgHints(ts, cm, argPos);
+
+ ts.request(cm, {type: "type", preferFunction: true, end: start}, function(error, data) {
+ if (error || !data.type || !(/^fn\(/).test(data.type)) return;
+ ts.cachedArgHints = {
+ start: pos,
+ type: parseFnType(data.type),
+ name: data.exprName || data.name || "fn",
+ guess: data.guess,
+ doc: cm.getDoc()
+ };
+ showArgHints(ts, cm, argPos);
+ });
+ }
+
+ function showArgHints(ts, cm, pos) {
+ closeArgHints(ts);
+
+ var cache = ts.cachedArgHints, tp = cache.type;
+ var tip = elt("span", cache.guess ? cls + "fhint-guess" : null,
+ elt("span", cls + "fname", cache.name), "(");
+ for (var i = 0; i < tp.args.length; ++i) {
+ if (i) tip.appendChild(document.createTextNode(", "));
+ var arg = tp.args[i];
+ tip.appendChild(elt("span", cls + "farg" + (i == pos ? " " + cls + "farg-current" : ""), arg.name || "?"));
+ if (arg.type != "?") {
+ tip.appendChild(document.createTextNode(":\u00a0"));
+ tip.appendChild(elt("span", cls + "type", arg.type));
+ }
+ }
+ tip.appendChild(document.createTextNode(tp.rettype ? ") ->\u00a0" : ")"));
+ if (tp.rettype) tip.appendChild(elt("span", cls + "type", tp.rettype));
+ var place = cm.cursorCoords(null, "page");
+ ts.activeArgHints = makeTooltip(place.right + 1, place.bottom, tip);
+ }
+
+ function parseFnType(text) {
+ var args = [], pos = 3;
+
+ function skipMatching(upto) {
+ var depth = 0, start = pos;
+ for (;;) {
+ var next = text.charAt(pos);
+ if (upto.test(next) && !depth) return text.slice(start, pos);
+ if (/[{\[\(]/.test(next)) ++depth;
+ else if (/[}\]\)]/.test(next)) --depth;
+ ++pos;
+ }
+ }
+
+ // Parse arguments
+ if (text.charAt(pos) != ")") for (;;) {
+ var name = text.slice(pos).match(/^([^, \(\[\{]+): /);
+ if (name) {
+ pos += name[0].length;
+ name = name[1];
+ }
+ args.push({name: name, type: skipMatching(/[\),]/)});
+ if (text.charAt(pos) == ")") break;
+ pos += 2;
+ }
+
+ var rettype = text.slice(pos).match(/^\) -> (.*)$/);
+
+ return {args: args, rettype: rettype && rettype[1]};
+ }
+
+ // Moving to the definition of something
+
+ function jumpToDef(ts, cm) {
+ function inner(varName) {
+ var req = {type: "definition", variable: varName || null};
+ var doc = findDoc(ts, cm.getDoc());
+ ts.server.request(buildRequest(ts, doc, req), function(error, data) {
+ if (error) return showError(ts, cm, error);
+ if (!data.file && data.url) { window.open(data.url); return; }
+
+ if (data.file) {
+ var localDoc = ts.docs[data.file], found;
+ if (localDoc && (found = findContext(localDoc.doc, data))) {
+ ts.jumpStack.push({file: doc.name,
+ start: cm.getCursor("from"),
+ end: cm.getCursor("to")});
+ moveTo(ts, doc, localDoc, found.start, found.end);
+ return;
+ }
+ }
+ showError(ts, cm, "Could not find a definition.");
+ });
+ }
+
+ if (!atInterestingExpression(cm))
+ dialog(cm, "Jump to variable", function(name) { if (name) inner(name); });
+ else
+ inner();
+ }
+
+ function jumpBack(ts, cm) {
+ var pos = ts.jumpStack.pop(), doc = pos && ts.docs[pos.file];
+ if (!doc) return;
+ moveTo(ts, findDoc(ts, cm.getDoc()), doc, pos.start, pos.end);
+ }
+
+ function moveTo(ts, curDoc, doc, start, end) {
+ doc.doc.setSelection(start, end);
+ if (curDoc != doc && ts.options.switchToDoc) {
+ closeArgHints(ts);
+ ts.options.switchToDoc(doc.name, doc.doc);
+ }
+ }
+
+ // The {line,ch} representation of positions makes this rather awkward.
+ function findContext(doc, data) {
+ var before = data.context.slice(0, data.contextOffset).split("\n");
+ var startLine = data.start.line - (before.length - 1);
+ var start = Pos(startLine, (before.length == 1 ? data.start.ch : doc.getLine(startLine).length) - before[0].length);
+
+ var text = doc.getLine(startLine).slice(start.ch);
+ for (var cur = startLine + 1; cur < doc.lineCount() && text.length < data.context.length; ++cur)
+ text += "\n" + doc.getLine(cur);
+ if (text.slice(0, data.context.length) == data.context) return data;
+
+ var cursor = doc.getSearchCursor(data.context, 0, false);
+ var nearest, nearestDist = Infinity;
+ while (cursor.findNext()) {
+ var from = cursor.from(), dist = Math.abs(from.line - start.line) * 10000;
+ if (!dist) dist = Math.abs(from.ch - start.ch);
+ if (dist < nearestDist) { nearest = from; nearestDist = dist; }
+ }
+ if (!nearest) return null;
+
+ if (before.length == 1)
+ nearest.ch += before[0].length;
+ else
+ nearest = Pos(nearest.line + (before.length - 1), before[before.length - 1].length);
+ if (data.start.line == data.end.line)
+ var end = Pos(nearest.line, nearest.ch + (data.end.ch - data.start.ch));
+ else
+ var end = Pos(nearest.line + (data.end.line - data.start.line), data.end.ch);
+ return {start: nearest, end: end};
+ }
+
+ function atInterestingExpression(cm) {
+ var pos = cm.getCursor("end"), tok = cm.getTokenAt(pos);
+ if (tok.start < pos.ch && tok.type == "comment") return false;
+ return /[\w)\]]/.test(cm.getLine(pos.line).slice(Math.max(pos.ch - 1, 0), pos.ch + 1));
+ }
+
+ // Variable renaming
+
+ function rename(ts, cm) {
+ var token = cm.getTokenAt(cm.getCursor());
+ if (!/\w/.test(token.string)) return showError(ts, cm, "Not at a variable");
+ dialog(cm, "New name for " + token.string, function(newName) {
+ ts.request(cm, {type: "rename", newName: newName, fullDocs: true}, function(error, data) {
+ if (error) return showError(ts, cm, error);
+ applyChanges(ts, data.changes);
+ });
+ });
+ }
+
+ function selectName(ts, cm) {
+ var name = findDoc(ts, cm.doc).name;
+ ts.request(cm, {type: "refs"}, function(error, data) {
+ if (error) return showError(ts, cm, error);
+ var ranges = [], cur = 0;
+ var curPos = cm.getCursor();
+ for (var i = 0; i < data.refs.length; i++) {
+ var ref = data.refs[i];
+ if (ref.file == name) {
+ ranges.push({anchor: ref.start, head: ref.end});
+ if (cmpPos(curPos, ref.start) >= 0 && cmpPos(curPos, ref.end) <= 0)
+ cur = ranges.length - 1;
+ }
+ }
+ cm.setSelections(ranges, cur);
+ });
+ }
+
+ var nextChangeOrig = 0;
+ function applyChanges(ts, changes) {
+ var perFile = Object.create(null);
+ for (var i = 0; i < changes.length; ++i) {
+ var ch = changes[i];
+ (perFile[ch.file] || (perFile[ch.file] = [])).push(ch);
+ }
+ for (var file in perFile) {
+ var known = ts.docs[file], chs = perFile[file];;
+ if (!known) continue;
+ chs.sort(function(a, b) { return cmpPos(b.start, a.start); });
+ var origin = "*rename" + (++nextChangeOrig);
+ for (var i = 0; i < chs.length; ++i) {
+ var ch = chs[i];
+ known.doc.replaceRange(ch.text, ch.start, ch.end, origin);
+ }
+ }
+ }
+
+ // Generic request-building helper
+
+ function buildRequest(ts, doc, query, pos) {
+ var files = [], offsetLines = 0, allowFragments = !query.fullDocs;
+ if (!allowFragments) delete query.fullDocs;
+ if (typeof query == "string") query = {type: query};
+ query.lineCharPositions = true;
+ if (query.end == null) {
+ query.end = pos || doc.doc.getCursor("end");
+ if (doc.doc.somethingSelected())
+ query.start = doc.doc.getCursor("start");
+ }
+ var startPos = query.start || query.end;
+
+ if (doc.changed) {
+ if (doc.doc.lineCount() > bigDoc && allowFragments !== false &&
+ doc.changed.to - doc.changed.from < 100 &&
+ doc.changed.from <= startPos.line && doc.changed.to > query.end.line) {
+ files.push(getFragmentAround(doc, startPos, query.end));
+ query.file = "#0";
+ var offsetLines = files[0].offsetLines;
+ if (query.start != null) query.start = Pos(query.start.line - -offsetLines, query.start.ch);
+ query.end = Pos(query.end.line - offsetLines, query.end.ch);
+ } else {
+ files.push({type: "full",
+ name: doc.name,
+ text: docValue(ts, doc)});
+ query.file = doc.name;
+ doc.changed = null;
+ }
+ } else {
+ query.file = doc.name;
+ }
+ for (var name in ts.docs) {
+ var cur = ts.docs[name];
+ if (cur.changed && cur != doc) {
+ files.push({type: "full", name: cur.name, text: docValue(ts, cur)});
+ cur.changed = null;
+ }
+ }
+
+ return {query: query, files: files};
+ }
+
+ function getFragmentAround(data, start, end) {
+ var doc = data.doc;
+ var minIndent = null, minLine = null, endLine, tabSize = 4;
+ for (var p = start.line - 1, min = Math.max(0, p - 50); p >= min; --p) {
+ var line = doc.getLine(p), fn = line.search(/\bfunction\b/);
+ if (fn < 0) continue;
+ var indent = CodeMirror.countColumn(line, null, tabSize);
+ if (minIndent != null && minIndent <= indent) continue;
+ minIndent = indent;
+ minLine = p;
+ }
+ if (minLine == null) minLine = min;
+ var max = Math.min(doc.lastLine(), end.line + 20);
+ if (minIndent == null || minIndent == CodeMirror.countColumn(doc.getLine(start.line), null, tabSize))
+ endLine = max;
+ else for (endLine = end.line + 1; endLine < max; ++endLine) {
+ var indent = CodeMirror.countColumn(doc.getLine(endLine), null, tabSize);
+ if (indent <= minIndent) break;
+ }
+ var from = Pos(minLine, 0);
+
+ return {type: "part",
+ name: data.name,
+ offsetLines: from.line,
+ text: doc.getRange(from, Pos(endLine, 0))};
+ }
+
+ // Generic utilities
+
+ var cmpPos = CodeMirror.cmpPos;
+
+ function elt(tagname, cls /*, ... elts*/) {
+ var e = document.createElement(tagname);
+ if (cls) e.className = cls;
+ for (var i = 2; i < arguments.length; ++i) {
+ var elt = arguments[i];
+ if (typeof elt == "string") elt = document.createTextNode(elt);
+ e.appendChild(elt);
+ }
+ return e;
+ }
+
+ function dialog(cm, text, f) {
+ if (cm.openDialog)
+ cm.openDialog(text + ": ", f);
+ else
+ f(prompt(text, ""));
+ }
+
+ // Tooltips
+
+ function tempTooltip(cm, content, ts) {
+ if (cm.state.ternTooltip) remove(cm.state.ternTooltip);
+ var where = cm.cursorCoords();
+ var tip = cm.state.ternTooltip = makeTooltip(where.right + 1, where.bottom, content);
+ function maybeClear() {
+ old = true;
+ if (!mouseOnTip) clear();
+ }
+ function clear() {
+ cm.state.ternTooltip = null;
+ if (!tip.parentNode) return;
+ cm.off("cursorActivity", clear);
+ cm.off('blur', clear);
+ cm.off('scroll', clear);
+ fadeOut(tip);
+ }
+ var mouseOnTip = false, old = false;
+ CodeMirror.on(tip, "mousemove", function() { mouseOnTip = true; });
+ CodeMirror.on(tip, "mouseout", function(e) {
+ if (!CodeMirror.contains(tip, e.relatedTarget || e.toElement)) {
+ if (old) clear();
+ else mouseOnTip = false;
+ }
+ });
+ setTimeout(maybeClear, ts.options.hintDelay ? ts.options.hintDelay : 1700);
+ cm.on("cursorActivity", clear);
+ cm.on('blur', clear);
+ cm.on('scroll', clear);
+ }
+
+ function makeTooltip(x, y, content) {
+ var node = elt("div", cls + "tooltip", content);
+ node.style.left = x + "px";
+ node.style.top = y + "px";
+ document.body.appendChild(node);
+ return node;
+ }
+
+ function remove(node) {
+ var p = node && node.parentNode;
+ if (p) p.removeChild(node);
+ }
+
+ function fadeOut(tooltip) {
+ tooltip.style.opacity = "0";
+ setTimeout(function() { remove(tooltip); }, 1100);
+ }
+
+ function showError(ts, cm, msg) {
+ if (ts.options.showError)
+ ts.options.showError(cm, msg);
+ else
+ tempTooltip(cm, String(msg), ts);
+ }
+
+ function closeArgHints(ts) {
+ if (ts.activeArgHints) { remove(ts.activeArgHints); ts.activeArgHints = null; }
+ }
+
+ function docValue(ts, doc) {
+ var val = doc.doc.getValue();
+ if (ts.options.fileFilter) val = ts.options.fileFilter(val, doc.name, doc.doc);
+ return val;
+ }
+
+ // Worker wrapper
+
+ function WorkerServer(ts) {
+ var worker = ts.worker = new Worker(ts.options.workerScript);
+ worker.postMessage({type: "init",
+ defs: ts.options.defs,
+ plugins: ts.options.plugins,
+ scripts: ts.options.workerDeps});
+ var msgId = 0, pending = {};
+
+ function send(data, c) {
+ if (c) {
+ data.id = ++msgId;
+ pending[msgId] = c;
+ }
+ worker.postMessage(data);
+ }
+ worker.onmessage = function(e) {
+ var data = e.data;
+ if (data.type == "getFile") {
+ getFile(ts, data.name, function(err, text) {
+ send({type: "getFile", err: String(err), text: text, id: data.id});
+ });
+ } else if (data.type == "debug") {
+ window.console.log(data.message);
+ } else if (data.id && pending[data.id]) {
+ pending[data.id](data.err, data.body);
+ delete pending[data.id];
+ }
+ };
+ worker.onerror = function(e) {
+ for (var id in pending) pending[id](e);
+ pending = {};
+ };
+
+ this.addFile = function(name, text) { send({type: "add", name: name, text: text}); };
+ this.delFile = function(name) { send({type: "del", name: name}); };
+ this.request = function(body, c) { send({type: "req", body: body}, c); };
+ }
+});
diff --git a/www/code/codemirror-5.7/addon/tern/worker.js b/www/code/codemirror-5.7/addon/tern/worker.js
new file mode 100644
index 000000000..887f906a4
--- /dev/null
+++ b/www/code/codemirror-5.7/addon/tern/worker.js
@@ -0,0 +1,44 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// declare global: tern, server
+
+var server;
+
+this.onmessage = function(e) {
+ var data = e.data;
+ switch (data.type) {
+ case "init": return startServer(data.defs, data.plugins, data.scripts);
+ case "add": return server.addFile(data.name, data.text);
+ case "del": return server.delFile(data.name);
+ case "req": return server.request(data.body, function(err, reqData) {
+ postMessage({id: data.id, body: reqData, err: err && String(err)});
+ });
+ case "getFile":
+ var c = pending[data.id];
+ delete pending[data.id];
+ return c(data.err, data.text);
+ default: throw new Error("Unknown message type: " + data.type);
+ }
+};
+
+var nextId = 0, pending = {};
+function getFile(file, c) {
+ postMessage({type: "getFile", name: file, id: ++nextId});
+ pending[nextId] = c;
+}
+
+function startServer(defs, plugins, scripts) {
+ if (scripts) importScripts.apply(null, scripts);
+
+ server = new tern.Server({
+ getFile: getFile,
+ async: true,
+ defs: defs,
+ plugins: plugins
+ });
+}
+
+this.console = {
+ log: function(v) { postMessage({type: "debug", message: v}); }
+};
diff --git a/www/code/codemirror-5.7/addon/wrap/hardwrap.js b/www/code/codemirror-5.7/addon/wrap/hardwrap.js
new file mode 100644
index 000000000..fe9b4dd66
--- /dev/null
+++ b/www/code/codemirror-5.7/addon/wrap/hardwrap.js
@@ -0,0 +1,139 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+ if (typeof exports == "object" && typeof module == "object") // CommonJS
+ mod(require("../../lib/codemirror"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+ "use strict";
+
+ var Pos = CodeMirror.Pos;
+
+ function findParagraph(cm, pos, options) {
+ var startRE = options.paragraphStart || cm.getHelper(pos, "paragraphStart");
+ for (var start = pos.line, first = cm.firstLine(); start > first; --start) {
+ var line = cm.getLine(start);
+ if (startRE && startRE.test(line)) break;
+ if (!/\S/.test(line)) { ++start; break; }
+ }
+ var endRE = options.paragraphEnd || cm.getHelper(pos, "paragraphEnd");
+ for (var end = pos.line + 1, last = cm.lastLine(); end <= last; ++end) {
+ var line = cm.getLine(end);
+ if (endRE && endRE.test(line)) { ++end; break; }
+ if (!/\S/.test(line)) break;
+ }
+ return {from: start, to: end};
+ }
+
+ function findBreakPoint(text, column, wrapOn, killTrailingSpace) {
+ for (var at = column; at > 0; --at)
+ if (wrapOn.test(text.slice(at - 1, at + 1))) break;
+ if (at == 0) at = column;
+ var endOfText = at;
+ if (killTrailingSpace)
+ while (text.charAt(endOfText - 1) == " ") --endOfText;
+ return {from: endOfText, to: at};
+ }
+
+ function wrapRange(cm, from, to, options) {
+ from = cm.clipPos(from); to = cm.clipPos(to);
+ var column = options.column || 80;
+ var wrapOn = options.wrapOn || /\s\S|-[^\.\d]/;
+ var killTrailing = options.killTrailingSpace !== false;
+ var changes = [], curLine = "", curNo = from.line;
+ var lines = cm.getRange(from, to, false);
+ if (!lines.length) return null;
+ var leadingSpace = lines[0].match(/^[ \t]*/)[0];
+
+ for (var i = 0; i < lines.length; ++i) {
+ var text = lines[i], oldLen = curLine.length, spaceInserted = 0;
+ if (curLine && text && !wrapOn.test(curLine.charAt(curLine.length - 1) + text.charAt(0))) {
+ curLine += " ";
+ spaceInserted = 1;
+ }
+ var spaceTrimmed = "";
+ if (i) {
+ spaceTrimmed = text.match(/^\s*/)[0];
+ text = text.slice(spaceTrimmed.length);
+ }
+ curLine += text;
+ if (i) {
+ var firstBreak = curLine.length > column && leadingSpace == spaceTrimmed &&
+ findBreakPoint(curLine, column, wrapOn, killTrailing);
+ // If this isn't broken, or is broken at a different point, remove old break
+ if (!firstBreak || firstBreak.from != oldLen || firstBreak.to != oldLen + spaceInserted) {
+ changes.push({text: [spaceInserted ? " " : ""],
+ from: Pos(curNo, oldLen),
+ to: Pos(curNo + 1, spaceTrimmed.length)});
+ } else {
+ curLine = leadingSpace + text;
+ ++curNo;
+ }
+ }
+ while (curLine.length > column) {
+ var bp = findBreakPoint(curLine, column, wrapOn, killTrailing);
+ changes.push({text: ["", leadingSpace],
+ from: Pos(curNo, bp.from),
+ to: Pos(curNo, bp.to)});
+ curLine = leadingSpace + curLine.slice(bp.to);
+ ++curNo;
+ }
+ }
+ if (changes.length) cm.operation(function() {
+ for (var i = 0; i < changes.length; ++i) {
+ var change = changes[i];
+ cm.replaceRange(change.text, change.from, change.to);
+ }
+ });
+ return changes.length ? {from: changes[0].from, to: CodeMirror.changeEnd(changes[changes.length - 1])} : null;
+ }
+
+ CodeMirror.defineExtension("wrapParagraph", function(pos, options) {
+ options = options || {};
+ if (!pos) pos = this.getCursor();
+ var para = findParagraph(this, pos, options);
+ return wrapRange(this, Pos(para.from, 0), Pos(para.to - 1), options);
+ });
+
+ CodeMirror.commands.wrapLines = function(cm) {
+ cm.operation(function() {
+ var ranges = cm.listSelections(), at = cm.lastLine() + 1;
+ for (var i = ranges.length - 1; i >= 0; i--) {
+ var range = ranges[i], span;
+ if (range.empty()) {
+ var para = findParagraph(cm, range.head, {});
+ span = {from: Pos(para.from, 0), to: Pos(para.to - 1)};
+ } else {
+ span = {from: range.from(), to: range.to()};
+ }
+ if (span.to.line >= at) continue;
+ at = span.from.line;
+ wrapRange(cm, span.from, span.to, {});
+ }
+ });
+ };
+
+ CodeMirror.defineExtension("wrapRange", function(from, to, options) {
+ return wrapRange(this, from, to, options || {});
+ });
+
+ CodeMirror.defineExtension("wrapParagraphsInRange", function(from, to, options) {
+ options = options || {};
+ var cm = this, paras = [];
+ for (var line = from.line; line <= to.line;) {
+ var para = findParagraph(cm, Pos(line, 0), options);
+ paras.push(para);
+ line = para.to;
+ }
+ var madeChange = false;
+ if (paras.length) cm.operation(function() {
+ for (var i = paras.length - 1; i >= 0; --i)
+ madeChange = madeChange || wrapRange(cm, Pos(paras[i].from, 0), Pos(paras[i].to - 1), options);
+ });
+ return madeChange;
+ });
+});
diff --git a/www/code/codemirror-5.7/bin/authors.sh b/www/code/codemirror-5.7/bin/authors.sh
new file mode 100644
index 000000000..b3ee99c6d
--- /dev/null
+++ b/www/code/codemirror-5.7/bin/authors.sh
@@ -0,0 +1,6 @@
+# Combine existing list of authors with everyone known in git, sort, add header.
+tail --lines=+3 AUTHORS > AUTHORS.tmp
+git log --format='%aN' >> AUTHORS.tmp
+echo -e "List of CodeMirror contributors. Updated before every release.\n" > AUTHORS
+sort -u AUTHORS.tmp >> AUTHORS
+rm -f AUTHORS.tmp
diff --git a/www/code/codemirror-5.7/bin/compress b/www/code/codemirror-5.7/bin/compress
new file mode 100644
index 000000000..809fbe83d
--- /dev/null
+++ b/www/code/codemirror-5.7/bin/compress
@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+// Compression helper for CodeMirror
+//
+// Example:
+//
+// bin/compress codemirror runmode javascript xml
+//
+// Will take lib/codemirror.js, addon/runmode/runmode.js,
+// mode/javascript/javascript.js, and mode/xml/xml.js, run them though
+// the online minifier at http://marijnhaverbeke.nl/uglifyjs, and spit
+// out the result.
+//
+// bin/compress codemirror --local /path/to/bin/UglifyJS
+//
+// Will use a local minifier instead of the online default one.
+//
+// Script files are specified without .js ending. Prefixing them with
+// their full (local) path is optional. So you may say lib/codemirror
+// or mode/xml/xml to be more precise. In fact, even the .js suffix
+// may be speficied, if wanted.
+
+"use strict";
+
+var fs = require("fs");
+
+function help(ok) {
+ console.log("usage: " + process.argv[1] + " [--local /path/to/uglifyjs] files...");
+ process.exit(ok ? 0 : 1);
+}
+
+var local = null, args = [], extraArgs = null, files = [], blob = "";
+
+for (var i = 2; i < process.argv.length; ++i) {
+ var arg = process.argv[i];
+ if (arg == "--local" && i + 1 < process.argv.length) {
+ var parts = process.argv[++i].split(/\s+/);
+ local = parts[0];
+ extraArgs = parts.slice(1);
+ if (!extraArgs.length) extraArgs = ["-c", "-m"];
+ } else if (arg == "--help") {
+ help(true);
+ } else if (arg[0] != "-") {
+ files.push({name: arg, re: new RegExp("(?:\\/|^)" + arg + (/\.js$/.test(arg) ? "$" : "\\.js$"))});
+ } else help(false);
+}
+
+function walk(dir) {
+ fs.readdirSync(dir).forEach(function(fname) {
+ if (/^[_\.]/.test(fname)) return;
+ var file = dir + fname;
+ if (fs.statSync(file).isDirectory()) return walk(file + "/");
+ if (files.some(function(spec, i) {
+ var match = spec.re.test(file);
+ if (match) files.splice(i, 1);
+ return match;
+ })) {
+ if (local) args.push(file);
+ else blob += fs.readFileSync(file, "utf8");
+ }
+ });
+}
+
+walk("lib/");
+walk("addon/");
+walk("mode/");
+
+if (!local && !blob) help(false);
+
+if (files.length) {
+ console.log("Some speficied files were not found: " +
+ files.map(function(a){return a.name;}).join(", "));
+ process.exit(1);
+}
+
+if (local) {
+ require("child_process").spawn(local, args.concat(extraArgs), {stdio: ["ignore", process.stdout, process.stderr]});
+} else {
+ var data = new Buffer("js_code=" + require("querystring").escape(blob), "utf8");
+ var req = require("http").request({
+ host: "marijnhaverbeke.nl",
+ port: 80,
+ method: "POST",
+ path: "/uglifyjs",
+ headers: {"content-type": "application/x-www-form-urlencoded",
+ "content-length": data.length}
+ });
+ req.on("response", function(resp) {
+ resp.on("data", function (chunk) { process.stdout.write(chunk); });
+ });
+ req.end(data);
+}
diff --git a/www/code/codemirror-5.7/bin/lint b/www/code/codemirror-5.7/bin/lint
new file mode 100644
index 000000000..47f45f367
--- /dev/null
+++ b/www/code/codemirror-5.7/bin/lint
@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+process.exit(require("../test/lint").ok ? 0 : 1);
diff --git a/www/code/codemirror-5.7/bin/release b/www/code/codemirror-5.7/bin/release
new file mode 100644
index 000000000..b782739fa
--- /dev/null
+++ b/www/code/codemirror-5.7/bin/release
@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+var fs = require("fs"), child = require("child_process");
+
+var number, bumpOnly;
+
+for (var i = 2; i < process.argv.length; i++) {
+ if (process.argv[i] == "-bump") bumpOnly = true;
+ else if (/^\d+\.\d+\.\d+$/.test(process.argv[i])) number = process.argv[i];
+ else { console.log("Bogus command line arg: " + process.argv[i]); process.exit(1); }
+}
+
+if (!number) { console.log("Must give a version"); process.exit(1); }
+
+function rewrite(file, f) {
+ fs.writeFileSync(file, f(fs.readFileSync(file, "utf8")), "utf8");
+}
+
+rewrite("lib/codemirror.js", function(lib) {
+ return lib.replace(/CodeMirror\.version = "\d+\.\d+\.\d+"/,
+ "CodeMirror.version = \"" + number + "\"");
+});
+function rewriteJSON(pack) {
+ return pack.replace(/"version":"\d+\.\d+\.\d+"/, "\"version\":\"" + number + "\"");
+}
+rewrite("package.json", rewriteJSON);
+rewrite("doc/manual.html", function(manual) {
+ return manual.replace(/>version \d+\.\d+\.\d+<\/span>/, ">version " + number + "");
+});
+
+if (bumpOnly) process.exit(0);
+
+child.exec("bash bin/authors.sh", function(){});
+
+var simple = number.slice(0, number.lastIndexOf("."));
+
+rewrite("doc/compress.html", function(cmp) {
+ return cmp.replace(/\n ");
+});
+
+rewrite("index.html", function(index) {
+ return index.replace(/\.zip">\d+\.\d+<\/a>/,
+ ".zip\">" + simple + "");
+});
diff --git a/www/code/codemirror-5.7/bin/source-highlight b/www/code/codemirror-5.7/bin/source-highlight
new file mode 100644
index 000000000..6d15f1ae3
--- /dev/null
+++ b/www/code/codemirror-5.7/bin/source-highlight
@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+// Simple command-line code highlighting tool. Reads code from stdin,
+// spits html to stdout. For example:
+//
+// echo 'function foo(a) { return a; }' | bin/source-highlight -s javascript
+// bin/source-highlight -s
+
+var fs = require("fs");
+
+var CodeMirror = require("../addon/runmode/runmode.node.js");
+require("../mode/meta.js");
+
+var sPos = process.argv.indexOf("-s");
+if (sPos == -1 || sPos == process.argv.length - 1) {
+ console.error("Usage: source-highlight -s language");
+ process.exit(1);
+}
+var lang = process.argv[sPos + 1].toLowerCase(), modeName = lang;
+CodeMirror.modeInfo.forEach(function(info) {
+ if (info.mime == lang) {
+ modeName = info.mode;
+ } else if (info.name.toLowerCase() == lang) {
+ modeName = info.mode;
+ lang = info.mime;
+ }
+});
+
+if (!CodeMirror.modes[modeName])
+ require("../mode/" + modeName + "/" + modeName + ".js");
+
+function esc(str) {
+ return str.replace(/[<&]/g, function(ch) { return ch == "&" ? "&" : "<"; });
+}
+
+var code = fs.readFileSync("/dev/stdin", "utf8");
+var curStyle = null, accum = "";
+function flush() {
+ if (curStyle) process.stdout.write("" + esc(accum) + "");
+ else process.stdout.write(esc(accum));
+}
+
+CodeMirror.runMode(code, lang, function(text, style) {
+ if (style != curStyle) {
+ flush();
+ curStyle = style; accum = text;
+ } else {
+ accum += text;
+ }
+});
+flush();
diff --git a/www/code/codemirror-5.7/bower.json b/www/code/codemirror-5.7/bower.json
new file mode 100644
index 000000000..903d9f55f
--- /dev/null
+++ b/www/code/codemirror-5.7/bower.json
@@ -0,0 +1,17 @@
+{
+ "name": "codemirror",
+ "main": ["lib/codemirror.js", "lib/codemirror.css"],
+ "ignore": [
+ "**/.*",
+ "node_modules",
+ "components",
+ "bin",
+ "demo",
+ "doc",
+ "test",
+ "index.html",
+ "package.json",
+ "mode/*/*test.js",
+ "mode/*/*.html"
+ ]
+}
diff --git a/www/code/codemirror-5.7/demo/activeline.html b/www/code/codemirror-5.7/demo/activeline.html
new file mode 100644
index 000000000..741f6c45a
--- /dev/null
+++ b/www/code/codemirror-5.7/demo/activeline.html
@@ -0,0 +1,78 @@
+
+
+CodeMirror: Active Line Demo
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/www/code/codemirror-5.7/demo/anywordhint.html b/www/code/codemirror-5.7/demo/anywordhint.html
new file mode 100644
index 000000000..0a7caece2
--- /dev/null
+++ b/www/code/codemirror-5.7/demo/anywordhint.html
@@ -0,0 +1,79 @@
+
+
+CodeMirror: Any Word Completion Demo
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/www/code/codemirror-5.7/demo/bidi.html b/www/code/codemirror-5.7/demo/bidi.html
new file mode 100644
index 000000000..6dd73bec3
--- /dev/null
+++ b/www/code/codemirror-5.7/demo/bidi.html
@@ -0,0 +1,74 @@
+
+
+CodeMirror: Bi-directional Text Demo
+
+
+
+
+
+
+
+
+
+
+
diff --git a/www/code/codemirror-5.7/demo/btree.html b/www/code/codemirror-5.7/demo/btree.html
new file mode 100644
index 000000000..fc4997f4f
--- /dev/null
+++ b/www/code/codemirror-5.7/demo/btree.html
@@ -0,0 +1,85 @@
+
+
+CodeMirror: B-Tree visualization
+
+
+
+
+
+
+
+
+
+
+
+ Any Word Completion Demo
+ + +Press ctrl-space to activate autocompletion. The +completion uses +the anyword-hint.js +module, which simply looks at nearby words in the buffer and completes +to those.
+ + +Bi-directional Text Demo
+ + + + +Demonstration of bi-directional text support. See + the related + blog post for more background.
+ +Note: There is + a known + bug with cursor motion and mouse clicks in bi-directional lines + that are line wrapped.
+ +B-Tree visualization
+ +Multiple Buffer & Split View Demo
+ + + +
+ Select buffer:
+
+
+
+
+ Select buffer:
+
+
+
+
+
+ Demonstration of
+ using linked documents
+ to provide a split view on a document, and
+ using swapDoc
+ to use a single editor to display multiple documents.
Mode-Changing Demo
+ + +On changes to the content of the above editor, a (crude) script +tries to auto-detect the language used, and switches the editor to +either JavaScript or Scheme mode based on that.
+ + +Closebrackets Demo
+ + + +Close-Tag Demo
+ + + +Autocomplete Demo
+ + +Press ctrl-space to activate autocompletion. Built
+on top of the show-hint
+and javascript-hint
+addons.
Emacs bindings demo
+ + +The emacs keybindings are enabled by
+including keymap/emacs.js and setting
+the keyMap option to "emacs". Because
+CodeMirror's internal API is quite different from Emacs, they are only
+a loose approximation of actual emacs bindings, though.
Also note that a lot of browsers disallow certain keys from being +captured. For example, Chrome blocks both Ctrl-W and Ctrl-N, with the +result that idiomatic use of Emacs keys will constantly close your tab +or open a new window.
+ + + +Code Folding Demo
+ + +Full Screen Editing
+ + + +Demonstration of + the fullscreen + addon. Press F11 when cursor is in the editor to + toggle full screen editing. Esc can also be used + to exit full screen editing.
+Hard-wrapping Demo
+ + +Demonstration of
+the hardwrap addon.
+The above editor has its change event hooked up to
+the wrapParagraphsInRange method, so that the paragraphs
+are reflown as you are typing.
HTML completion demo
+ +Shows the XML completer + parameterized with information about the tags in HTML. + Press ctrl-space to activate completion.
+ + + + +Indented wrapped line demo
+ + +This page uses a hack on top of the "renderLine"
+ event to make wrapped text line up with the base indentation of
+ the line.
Linter Demo
+ + + + + + + + + +Lazy Mode Loading Demo
+Current mode: text/plain
+ +Filename, mime, or mode name:
+ + +Breakpoint Demo
+ + +Click the line-number gutter to add or remove 'breakpoints'.
+ + + +Selection Marking Demo
+ + + + +Simple addon to easily mark (and style) selected text. Docs.
+ +Match Highlighter Demo
+ + + + +Search and highlight occurences of the selected text.
+ +Tag Matcher Demo
+ + + + + + +Put the cursor on or inside a pair of tags to highlight them. + Press Ctrl-J to jump to the tag that matches the one under the + cursor.
+merge view demo
+ + + + +The merge
+addon provides an interface for displaying and merging diffs,
+either two-way
+or three-way.
+The left (or center) pane is editable, and the differences with the
+other pane(s) are optionally shown live as you edit
+it. In the two-way configuration, there are also options to pad changed
+sections to align them, and to collapse unchanged
+stretches of text.
This addon depends on +the google-diff-match-patch +library to compute the diffs.
+ + +Multiplexing Parser Demo
+ + + + +Demonstration of a multiplexing mode, which, at certain
+ boundary strings, switches to one or more inner modes. The out
+ (HTML) mode does not get fed the content of the <<
+ >> blocks. See
+ the manual and
+ the source for more
+ information.
Overlay Parser Demo
+ + + + +Demonstration of a mode that parses HTML, highlighting
+ the Mustache templating
+ directives inside of it by using the code
+ in overlay.js. View
+ source to see the 15 lines of code needed to accomplish this.
Panel Demo
+ +
+
+
+
+
+ The panel
+ addon allows you to display panels above or below an editor.
+
+ Click the links below to add panels at the given position:
+
+
+
++ top + after-top + before-bottom + bottom +
++ You can also replace an existing panel: +
+ + + + +Placeholder demo
+ + +The placeholder
+ plug-in adds an option placeholder that can be set to
+ make text appear in the editor when it is empty and not focused.
+ If the source textarea has a placeholder attribute,
+ it will automatically be inherited.
HTML5 preview
+ + + + +RequireJS module loading demo
+ +This demo does the same thing as + the HTML5 completion demo, but + loads its dependencies + with Require.js, rather than + explicitly. Press ctrl-space to activate + completion.
+ + + + + + +Autoresize Demo
+ + +By setting an editor's height style
+to auto and giving
+the viewportMargin
+a value of Infinity, CodeMirror can be made to
+automatically resize to fit its content.
Ruler Demo
+ + + +Demonstration of +the rulers addon, which +displays vertical lines at given column offsets.
+ +Mode Runner Demo
+ + ++ + + + + +
Running a CodeMirror mode outside of the editor.
+ The CodeMirror.runMode function, defined
+ in lib/runmode.js takes the following arguments:
-
+
text (string)
+ - The document to run through the highlighter. +
mode (mode spec)
+ - The mode to use (must be loaded as normal). +
output (function or DOM node)
+ - If this is a function, it will be called for each token with
+ two arguments, the token's text and the token's style class (may
+ be
nullfor unstyled tokens). If it is a DOM node, + the tokens will be converted tospanelements as in + an editor, and inserted into the node + (throughinnerHTML).
+
Search/Replace Demo
+ + + + +Demonstration of primitive search/replace functionality. The + keybindings (which can be configured with custom keymaps) are:
+-
+
- Ctrl-F / Cmd-F
- Start searching +
- Ctrl-G / Cmd-G
- Find next +
- Shift-Ctrl-G / Shift-Cmd-G
- Find previous +
- Shift-Ctrl-F / Cmd-Option-F
- Replace +
- Shift-Ctrl-R / Shift-Cmd-Option-F
- Replace all +
- Alt-F
- Persistent search (dialog doesn't autoclose, enter to find next, shift-enter to find previous) +
Searching is enabled by + including addon/search/search.js + and addon/search/searchcursor.js. + For good-looking input dialogs, you also want to include + addon/dialog/dialog.js + and addon/dialog/dialog.css.
+Simple Mode Demo
+ +The mode/simple
+addon allows CodeMirror modes to be specified using a relatively simple
+declarative format. This format is not as powerful as writing code
+directly against the mode
+interface, but is a lot easier to get started with, and
+sufficiently expressive for many simple language modes.
This interface is still in flux. It is unlikely to be scrapped or +overhauled completely, so do start writing code against it, but +details might change as it stabilizes, and you might have to tweak +your code when upgrading.
+ +Simple modes (loosely based on +the Common +JavaScript Syntax Highlighting Specification, which never took +off), are state machines, where each state has a number of rules that +match tokens. A rule describes a type of token that may occur in the +current state, and possibly a transition to another state caused by +that token.
+ +The CodeMirror.defineSimpleMode(name, states) method
+takes a mode name and an object that describes the mode's states. The
+editor below shows an example of such a mode (and is itself
+highlighted by the mode shown in it).
Each state is an array of rules. A rule may have the following properties:
+ +-
+
regex: string | RegExp
+ - The regular expression that matches the token. May be a string
+ or a regex object. When a regex, the
ignoreCaseflag + will be taken into account when matching the token. This regex + should only capture groups when thetokenproperty is + an array.
+ token: string | null
+ - An optional token style. Multiple styles can be specified by
+ separating them with dots or spaces. When the
regexfor + this rule captures groups, it must capture all of the + string (since JS provides no way to find out where a group matched), + and this property must hold an array of token styles that has one + style for each matched group.
+ sol: boolean
+ - When true, this token will only match at the start of the line.
+ (The
^regexp marker doesn't work as you'd expect in + this context because of limitations in JavaScript's RegExp + API.)
+ next: string
+ - When a
nextproperty is present, the mode will + transfer to the state named by the property when the token is + encountered.
+ push: string
+ - Like
next, but instead replacing the current state + by the new state, the current state is kept on a stack, and can be + returned to with thepopdirective.
+ pop: bool
+ - When true, and there is another state on the state stack, will + cause the mode to pop that state off the stack and transition to + it. +
mode: {spec, end, persistent}
+ - Can be used to embed another mode inside a mode. When present,
+ must hold an object with a
specproperty that describes + the embedded mode, and an optionalendend property + that specifies the regexp that will end the extent of the mode. When + apersistentproperty is set (and true), the nested + mode's state will be preserved between occurrences of the mode.
+ indent: bool
+ - When true, this token changes the indentation to be one unit + more than the current line's indentation. +
dedent: bool
+ - When true, this token will pop one scope off the indentation + stack. +
dedentIfLineStart: bool
+ - If a token has its
dedentproperty set, it will, by + default, cause lines where it appears at the start to be dedented. + Set this property to false to prevent that behavior.
+
The meta property of the states object is special, and
+will not be interpreted as a state. Instead, properties set on it will
+be set on the mode, which is useful for properties
+like lineComment,
+which sets the comment style for a mode. The simple mode addon also
+recognizes a few such properties:
-
+
dontIndentStates: array<string>
+ - An array of states in which the mode's auto-indentation should + not take effect. Usually used for multi-line comment and string + states. +
Simple Scrollbar Demo
+ + +The simplescrollbars addon defines two
+styles of non-native scrollbars: "simple" and "overlay" (click to try), which can be passed to
+the scrollbarStyle option. These implement
+the scrollbar using DOM elements, allowing more control over
+its appearance.
+ 
+
+
+
+
+
+CodeMirror
+
+
+
+Automatically derive odd wrapping behavior for your browser
+ + +This is a hack to automatically derive
+ a spanAffectsWrapping regexp for a browser. See the
+ comments above that variable
+ in lib/codemirror.js
+ for some more details.
Sublime Text bindings demo
+ +The sublime keymap defines many Sublime Text-specific
+bindings for CodeMirror. See the code below for an overview.
Enable the keymap by
+loading keymap/sublime.js
+and setting
+the keyMap
+option to "sublime".
(A lot of the search functionality is still missing.) + + + +
Tern Demo
+Theme Demo
+ + +Select a theme: +
+ + +Trailing Whitespace Demo
+ + + + +Uses +the trailingspace +addon to highlight trailing whitespace.
+ +Variable Height Demo
+ + +Vim bindings demo
+ +Key buffer:
+
+The vim keybindings are enabled by including keymap/vim.js and setting the
+keyMap option to vim.
Features
+ +-
+
- All common motions and operators, including text objects +
- Operator motion orthogonality +
- Visual mode - characterwise, linewise, blockwise +
- Full macro support (q, @) +
- Incremental highlighted search (/, ?, #, *, g#, g*) +
- Search/replace with confirm (:substitute, :%s) +
- Search history +
- Jump lists (Ctrl-o, Ctrl-i) +
- Key/command mapping with API (:map, :nmap, :vmap) +
- Sort (:sort) +
- Marks (`, ') +
- :global +
- Insert mode behaves identical to base CodeMirror +
- Cross-buffer yank/paste +
For the full list of key mappings and Ex commands, refer to the
+defaultKeymap and defaultExCommandMap at the
+top of keymap/vim.js.
+
+
Note that while the vim mode tries to emulate the most useful +features of vim as faithfully as possible, it does not strive to +become a complete vim implementation
+ + + +Visible tabs demo
+ + +Tabs inside the editor are spans with the
+class cm-tab, and can be styled.
Inline Widget Demo
+ + + + +This demo runs JSHint over the code +in the editor (which is the script used on this page), and +inserts line widgets to +display the warnings that JSHint comes up with.
+XML Autocomplete Demo
+ + +Press ctrl-space, or type a '<' character to + activate autocompletion. This demo defines a simple schema that + guides completion. The schema can be customized—see + the manual.
+ +Development of the xml-hint addon was kindly
+ sponsored
+ by www.xperiment.mobi.
Script compression helper
+ +To optimize loading CodeMirror, especially when including a + bunch of different modes, it is recommended that you combine and + minify (and preferably also gzip) the scripts. This page makes + those first two steps very easy. Simply select the version and + scripts you need in the form below, and + click Compress to download the minified script + file.
+ + + + + +
+ 
+
+
+
+
+CodeMirror
+
+
+ -
+
- Introduction +
- General Approach +
- Input +
- Selection +
- Intelligent Updating +
- Parsing +
- What Gives? +
- Content Representation +
- Key Maps +
(Re-) Implementing A Syntax-Highlighting Editor in JavaScript
+ +
+ Topic: JavaScript, code editor implementation
+ Author: Marijn Haverbeke
+ Date: March 2nd 2011 (updated November 13th 2011)
+
Caution: this text was written briefly after +version 2 was initially written. It no longer (even including the +update at the bottom) fully represents the current implementation. I'm +leaving it here as a historic document. For more up-to-date +information, look at the entries +tagged cm-internals +on my blog.
+ +This is a followup to +my Brutal Odyssey to the +Dark Side of the DOM Tree story. That one describes the +mind-bending process of implementing (what would become) CodeMirror 1. +This one describes the internals of CodeMirror 2, a complete rewrite +and rethink of the old code base. I wanted to give this piece another +Hunter Thompson copycat subtitle, but somehow that would be out of +place—the process this time around was one of straightforward +engineering, requiring no serious mind-bending whatsoever.
+ +So, what is wrong with CodeMirror 1? I'd estimate, by mailing list +activity and general search-engine presence, that it has been +integrated into about a thousand systems by now. The most prominent +one, since a few weeks, +being Google +code's project hosting. It works, and it's being used widely.
+ +Still, I did not start replacing it because I was bored. CodeMirror
+1 was heavily reliant on designMode
+or contentEditable (depending on the browser). Neither of
+these are well specified (HTML5 tries
+to specify
+their basics), and, more importantly, they tend to be one of the more
+obscure and buggy areas of browser functionality—CodeMirror, by using
+this functionality in a non-typical way, was constantly running up
+against browser bugs. WebKit wouldn't show an empty line at the end of
+the document, and in some releases would suddenly get unbearably slow.
+Firefox would show the cursor in the wrong place. Internet Explorer
+would insist on linkifying everything that looked like a URL or email
+address, a behaviour that can't be turned off. Some bugs I managed to
+work around (which was often a frustrating, painful process), others,
+such as the Firefox cursor placement, I gave up on, and had to tell
+user after user that they were known problems, but not something I
+could help.
Also, there is the fact that designMode (which seemed
+to be less buggy than contentEditable in Webkit and
+Firefox, and was thus used by CodeMirror 1 in those browsers) requires
+a frame. Frames are another tricky area. It takes some effort to
+prevent getting tripped up by domain restrictions, they don't
+initialize synchronously, behave strangely in response to the back
+button, and, on several browsers, can't be moved around the DOM
+without having them re-initialize. They did provide a very nice way to
+namespace the library, though—CodeMirror 1 could freely pollute the
+namespace inside the frame.
Finally, working with an editable document means working with
+selection in arbitrary DOM structures. Internet Explorer (8 and
+before) has an utterly different (and awkward) selection API than all
+of the other browsers, and even among the different implementations of
+document.selection, details about how exactly a selection
+is represented vary quite a bit. Add to that the fact that Opera's
+selection support tended to be very buggy until recently, and you can
+imagine why CodeMirror 1 contains 700 lines of selection-handling
+code.
And that brings us to the main issue with the CodeMirror 1 +code base: The proportion of browser-bug-workarounds to real +application code was getting dangerously high. By building on top of a +few dodgy features, I put the system in a vulnerable position—any +incompatibility and bugginess in these features, I had to paper over +with my own code. Not only did I have to do some serious stunt-work to +get it to work on older browsers (as detailed in the +previous story), things +also kept breaking in newly released versions, requiring me to come up +with new scary hacks in order to keep up. This was starting +to lose its appeal.
+ +General Approach
+ +What CodeMirror 2 does is try to sidestep most of the hairy hacks +that came up in version 1. I owe a lot to the +ACE editor for inspiration on how to +approach this.
+ +I absolutely did not want to be completely reliant on key events to +generate my input. Every JavaScript programmer knows that key event +information is horrible and incomplete. Some people (most awesomely +Mihai Bazon with Ymacs) have been able +to build more or less functioning editors by directly reading key +events, but it takes a lot of work (the kind of never-ending, fragile +work I described earlier), and will never be able to properly support +things like multi-keystoke international character +input. [see below for caveat]
+ +So what I do is focus a hidden textarea, and let the browser +believe that the user is typing into that. What we show to the user is +a DOM structure we built to represent his document. If this is updated +quickly enough, and shows some kind of believable cursor, it feels +like a real text-input control.
+ +Another big win is that this DOM representation does not have to
+span the whole document. Some CodeMirror 1 users insisted that they
+needed to put a 30 thousand line XML document into CodeMirror. Putting
+all that into the DOM takes a while, especially since, for some
+reason, an editable DOM tree is slower than a normal one on most
+browsers. If we have full control over what we show, we must only
+ensure that the visible part of the document has been added, and can
+do the rest only when needed. (Fortunately, the onscroll
+event works almost the same on all browsers, and lends itself well to
+displaying things only as they are scrolled into view.)
Input
+ +ACE uses its hidden textarea only as a text input shim, and does +all cursor movement and things like text deletion itself by directly +handling key events. CodeMirror's way is to let the browser do its +thing as much as possible, and not, for example, define its own set of +key bindings. One way to do this would have been to have the whole +document inside the hidden textarea, and after each key event update +the display DOM to reflect what's in that textarea.
+ +That'd be simple, but it is not realistic. For even medium-sized +document the editor would be constantly munging huge strings, and get +terribly slow. What CodeMirror 2 does is put the current selection, +along with an extra line on the top and on the bottom, into the +textarea.
+ +This means that the arrow keys (and their ctrl-variations), home, +end, etcetera, do not have to be handled specially. We just read the +cursor position in the textarea, and update our cursor to match it. +Also, copy and paste work pretty much for free, and people get their +native key bindings, without any special work on my part. For example, +I have emacs key bindings configured for Chrome and Firefox. There is +no way for a script to detect this. [no longer the case]
+ +Of course, since only a small part of the document sits in the +textarea, keys like page up and ctrl-end won't do the right thing. +CodeMirror is catching those events and handling them itself.
+Selection
+ +Getting and setting the selection range of a textarea in modern
+browsers is trivial—you just use the selectionStart
+and selectionEnd properties. On IE you have to do some
+insane stuff with temporary ranges and compensating for the fact that
+moving the selection by a 'character' will treat \r\n as a single
+character, but even there it is possible to build functions that
+reliably set and get the selection range.
But consider this typical case: When I'm somewhere in my document, +press shift, and press the up arrow, something gets selected. Then, if +I, still holding shift, press the up arrow again, the top of my +selection is adjusted. The selection remembers where its head +and its anchor are, and moves the head when we shift-move. +This is a generally accepted property of selections, and done right by +every editing component built in the past twenty years.
+ +But not something that the browser selection APIs expose.
+ +Great. So when someone creates an 'upside-down' selection, the next +time CodeMirror has to update the textarea, it'll re-create the +selection as an 'upside-up' selection, with the anchor at the top, and +the next cursor motion will behave in an unexpected way—our second +up-arrow press in the example above will not do anything, since it is +interpreted in exactly the same way as the first.
+ +No problem. We'll just, ehm, detect that the selection is +upside-down (you can tell by the way it was created), and then, when +an upside-down selection is present, and a cursor-moving key is +pressed in combination with shift, we quickly collapse the selection +in the textarea to its start, allow the key to take effect, and then +combine its new head with its old anchor to get the real +selection.
+ +In short, scary hacks could not be avoided entirely in CodeMirror +2.
+ +And, the observant reader might ask, how do you even know that a +key combo is a cursor-moving combo, if you claim you support any +native key bindings? Well, we don't, but we can learn. The editor +keeps a set known cursor-movement combos (initialized to the +predictable defaults), and updates this set when it observes that +pressing a certain key had (only) the effect of moving the cursor. +This, of course, doesn't work if the first time the key is used was +for extending an inverted selection, but it works most of the +time.
+Intelligent Updating
+ +One thing that always comes up when you have a complicated internal +state that's reflected in some user-visible external representation +(in this case, the displayed code and the textarea's content) is +keeping the two in sync. The naive way is to just update the display +every time you change your state, but this is not only error prone +(you'll forget), it also easily leads to duplicate work on big, +composite operations. Then you start passing around flags indicating +whether the display should be updated in an attempt to be efficient +again and, well, at that point you might as well give up completely.
+ +I did go down that road, but then switched to a much simpler model: +simply keep track of all the things that have been changed during an +action, and then, only at the end, use this information to update the +user-visible display.
+ +CodeMirror uses a concept of operations, which start by
+calling a specific set-up function that clears the state and end by
+calling another function that reads this state and does the required
+updating. Most event handlers, and all the user-visible methods that
+change state are wrapped like this. There's a method
+called operation that accepts a function, and returns
+another function that wraps the given function as an operation.
It's trivial to extend this (as CodeMirror does) to detect nesting, +and, when an operation is started inside an operation, simply +increment the nesting count, and only do the updating when this count +reaches zero again.
+ +If we have a set of changed ranges and know the currently shown +range, we can (with some awkward code to deal with the fact that +changes can add and remove lines, so we're dealing with a changing +coordinate system) construct a map of the ranges that were left +intact. We can then compare this map with the part of the document +that's currently visible (based on scroll offset and editor height) to +determine whether something needs to be updated.
+ +CodeMirror uses two update algorithms—a full refresh, where it just +discards the whole part of the DOM that contains the edited text and +rebuilds it, and a patch algorithm, where it uses the information +about changed and intact ranges to update only the out-of-date parts +of the DOM. When more than 30 percent (which is the current heuristic, +might change) of the lines need to be updated, the full refresh is +chosen (since it's faster to do than painstakingly finding and +updating all the changed lines), in the other case it does the +patching (so that, if you scroll a line or select another character, +the whole screen doesn't have to be +re-rendered). [the full-refresh +algorithm was dropped, it wasn't really faster than the patching +one]
+ +All updating uses innerHTML rather than direct DOM
+manipulation, since that still seems to be by far the fastest way to
+build documents. There's a per-line function that combines the
+highlighting, marking, and
+selection info for that line into a snippet of HTML. The patch updater
+uses this to reset individual lines, the refresh updater builds an
+HTML chunk for the whole visible document at once, and then uses a
+single innerHTML update to do the refresh.
Parsers can be Simple
+ +When I wrote CodeMirror 1, I +thought interruptable +parsers were a hugely scary and complicated thing, and I used a +bunch of heavyweight abstractions to keep this supposed complexity +under control: parsers +were iterators +that consumed input from another iterator, and used funny +closure-resetting tricks to copy and resume themselves.
+ +This made for a rather nice system, in that parsers formed strictly +separate modules, and could be composed in predictable ways. +Unfortunately, it was quite slow (stacking three or four iterators on +top of each other), and extremely intimidating to people not used to a +functional programming style.
+ +With a few small changes, however, we can keep all those +advantages, but simplify the API and make the whole thing less +indirect and inefficient. CodeMirror +2's mode API uses explicit state +objects, and makes the parser/tokenizer a function that simply takes a +state and a character stream abstraction, advances the stream one +token, and returns the way the token should be styled. This state may +be copied, optionally in a mode-defined way, in order to be able to +continue a parse at a given point. Even someone who's never touched a +lambda in his life can understand this approach. Additionally, far +fewer objects are allocated in the course of parsing now.
+ +The biggest speedup comes from the fact that the parsing no longer +has to touch the DOM though. In CodeMirror 1, on an older browser, you +could see the parser work its way through the document, +managing some twenty lines in each 50-millisecond time slice it got. It +was reading its input from the DOM, and updating the DOM as it went +along, which any experienced JavaScript programmer will immediately +spot as a recipe for slowness. In CodeMirror 2, the parser usually +finishes the whole document in a single 100-millisecond time slice—it +manages some 1500 lines during that time on Chrome. All it has to do +is munge strings, so there is no real reason for it to be slow +anymore.
+What Gives?
+ +Given all this, what can you expect from CodeMirror 2?
+ +-
+
+
- Small. the base library is +some 45k when minified +now, 17k when gzipped. It's smaller than +its own logo. + +
- Lightweight. CodeMirror 2 initializes very +quickly, and does almost no work when it is not focused. This means +you can treat it almost like a textarea, have multiple instances on a +page without trouble. + +
- Huge document support. Since highlighting is +really fast, and no DOM structure is being built for non-visible +content, you don't have to worry about locking up your browser when a +user enters a megabyte-sized document. + +
- Extended API. Some things kept coming up in the +mailing list, such as marking pieces of text or lines, which were +extremely hard to do with CodeMirror 1. The new version has proper +support for these built in. + +
- Tab support. Tabs inside editable documents were, +for some reason, a no-go. At least six different people announced they +were going to add tab support to CodeMirror 1, none survived (I mean, +none delivered a working version). CodeMirror 2 no longer removes tabs +from your document. + +
- Sane styling.
iframenodes aren't +really known for respecting document flow. Now that an editor instance +is a plaindivelement, it is much easier to size it to +fit the surrounding elements. You don't even have to make it scroll if +you do not want to.
+
+
On the downside, a CodeMirror 2 instance is not a native +editable component. Though it does its best to emulate such a +component as much as possible, there is functionality that browsers +just do not allow us to hook into. Doing select-all from the context +menu, for example, is not currently detected by CodeMirror.
+ +[Updates from November 13th 2011] Recently, I've made +some changes to the codebase that cause some of the text above to no +longer be current. I've left the text intact, but added markers at the +passages that are now inaccurate. The new situation is described +below.
+Content Representation
+ +The original implementation of CodeMirror 2 represented the
+document as a flat array of line objects. This worked well—splicing
+arrays will require the part of the array after the splice to be
+moved, but this is basically just a simple memmove of a
+bunch of pointers, so it is cheap even for huge documents.
However, I recently added line wrapping and code folding (line +collapsing, basically). Once lines start taking up a non-constant +amount of vertical space, looking up a line by vertical position +(which is needed when someone clicks the document, and to determine +the visible part of the document during scrolling) can only be done +with a linear scan through the whole array, summing up line heights as +you go. Seeing how I've been going out of my way to make big documents +fast, this is not acceptable.
+ +The new representation is based on a B-tree. The leaves of the tree +contain arrays of line objects, with a fixed minimum and maximum size, +and the non-leaf nodes simply hold arrays of child nodes. Each node +stores both the amount of lines that live below them and the vertical +space taken up by these lines. This allows the tree to be indexed both +by line number and by vertical position, and all access has +logarithmic complexity in relation to the document size.
+ +I gave line objects and tree nodes parent pointers, to the node +above them. When a line has to update its height, it can simply walk +these pointers to the top of the tree, adding or subtracting the +difference in height from each node it encounters. The parent pointers +also make it cheaper (in complexity terms, the difference is probably +tiny in normal-sized documents) to find the current line number when +given a line object. In the old approach, the whole document array had +to be searched. Now, we can just walk up the tree and count the sizes +of the nodes coming before us at each level.
+ +I chose B-trees, not regular binary trees, mostly because they +allow for very fast bulk insertions and deletions. When there is a big +change to a document, it typically involves adding, deleting, or +replacing a chunk of subsequent lines. In a regular balanced tree, all +these inserts or deletes would have to be done separately, which could +be really expensive. In a B-tree, to insert a chunk, you just walk +down the tree once to find where it should go, insert them all in one +shot, and then break up the node if needed. This breaking up might +involve breaking up nodes further up, but only requires a single pass +back up the tree. For deletion, I'm somewhat lax in keeping things +balanced—I just collapse nodes into a leaf when their child count goes +below a given number. This means that there are some weird editing +patterns that may result in a seriously unbalanced tree, but even such +an unbalanced tree will perform well, unless you spend a day making +strangely repeating edits to a really big document.
+Keymaps
+ +Above, I claimed that directly catching key +events for things like cursor movement is impractical because it +requires some browser-specific kludges. I then proceeded to explain +some awful hacks that were needed to make it +possible for the selection changes to be detected through the +textarea. In fact, the second hack is about as bad as the first.
+ +On top of that, in the presence of user-configurable tab sizes and +collapsed and wrapped lines, lining up cursor movement in the textarea +with what's visible on the screen becomes a nightmare. Thus, I've +decided to move to a model where the textarea's selection is no longer +depended on.
+ +So I moved to a model where all cursor movement is handled by my +own code. This adds support for a goal column, proper interaction of +cursor movement with collapsed lines, and makes it possible for +vertical movement to move through wrapped lines properly, instead of +just treating them like non-wrapped lines.
+ +The key event handlers now translate the key event into a string,
+something like Ctrl-Home or Shift-Cmd-R, and
+use that string to look up an action to perform. To make keybinding
+customizable, this lookup goes through
+a table, using a scheme that
+allows such tables to be chained together (for example, the default
+Mac bindings fall through to a table named 'emacsy', which defines
+basic Emacs-style bindings like Ctrl-F, and which is also
+used by the custom Emacs bindings).
A new
+option extraKeys
+allows ad-hoc keybindings to be defined in a much nicer way than what
+was possible with the
+old onKeyEvent
+callback. You simply provide an object mapping key identifiers to
+functions, instead of painstakingly looking at raw key events.
Built-in commands map to strings, rather than functions, for
+example "goLineUp" is the default action bound to the up
+arrow key. This allows new keymaps to refer to them without
+duplicating any code. New commands can be defined by assigning to
+the CodeMirror.commands object, which maps such commands
+to functions.
The hidden textarea now only holds the current selection, with no +extra characters around it. This has a nice advantage: polling for +input becomes much, much faster. If there's a big selection, this text +does not have to be read from the textarea every time—when we poll, +just noticing that something is still selected is enough to tell us +that no new text was typed.
+ +The reason that cheap polling is important is that many browsers do
+not fire useful events on IME (input method engine) input, which is
+the thing where people inputting a language like Japanese or Chinese
+use multiple keystrokes to create a character or sequence of
+characters. Most modern browsers fire input when the
+composing is finished, but many don't fire anything when the character
+is updated during composition. So we poll, whenever the
+editor is focused, to provide immediate updates of the display.
+
+
+
+
+CodeMirror
+
+ -
+
- Basic Usage +
- Configuration +
- Events +
- Key maps +
- Commands +
- Customized Styling +
- Programming API + + +
- Addons +
- Writing CodeMirror Modes +
- Vim Mode API
+
-
+
- Configuration +
- Extending VIM +
+
+ User manual and reference guide + version 5.7.0 +
+ +CodeMirror is a code-editor component that can be embedded in + Web pages. The core library provides only the editor + component, no accompanying buttons, auto-completion, or other IDE + functionality. It does provide a rich API on top of which such + functionality can be straightforwardly implemented. See + the addons included in the distribution, + and the list + of externally hosted addons, for reusable + implementations of extra features.
+ +CodeMirror works with language-specific modes. Modes are
+ JavaScript programs that help color (and optionally indent) text
+ written in a given language. The distribution comes with a number
+ of modes (see the mode/
+ directory), and it isn't hard to write new
+ ones for other languages.
Basic Usage
+ +The easiest way to use CodeMirror is to simply load the script
+ and style sheet found under lib/ in the distribution,
+ plus a mode script from one of the mode/ directories.
+ (See the compression helper for an
+ easy way to combine scripts.) For example:
<script src="lib/codemirror.js"></script> +<link rel="stylesheet" href="lib/codemirror.css"> +<script src="mode/javascript/javascript.js"></script>+ +
(Alternatively, use a module loader. More + about that later.)
+ +Having done this, an editor instance can be created like + this:
+ +var myCodeMirror = CodeMirror(document.body);+ +
The editor will be appended to the document body, will start
+ empty, and will use the mode that we loaded. To have more control
+ over the new editor, a configuration object can be passed
+ to CodeMirror as a second
+ argument:
var myCodeMirror = CodeMirror(document.body, {
+ value: "function myScript(){return 100;}\n",
+ mode: "javascript"
+});
+
+ This will initialize the editor with a piece of code already in + it, and explicitly tell it to use the JavaScript mode (which is + useful when multiple modes are loaded). + See below for a full discussion of the + configuration options that CodeMirror accepts.
+ +In cases where you don't want to append the editor to an
+ element, and need more control over the way it is inserted, the
+ first argument to the CodeMirror function can also
+ be a function that, when given a DOM element, inserts it into the
+ document somewhere. This could be used to, for example, replace a
+ textarea with a real editor:
var myCodeMirror = CodeMirror(function(elt) {
+ myTextArea.parentNode.replaceChild(elt, myTextArea);
+}, {value: myTextArea.value});
+
+ However, for this use case, which is a common way to use + CodeMirror, the library provides a much more powerful + shortcut:
+ +var myCodeMirror = CodeMirror.fromTextArea(myTextArea);+ +
This will, among other things, ensure that the textarea's value + is updated with the editor's contents when the form (if it is part + of a form) is submitted. See the API + reference for a full description of this method.
+ +Module loaders
+ +The files in the CodeMirror distribution contain shims for
+ loading them (and their dependencies) in AMD or CommonJS
+ environments. If the variables exports
+ and module exist and have type object, CommonJS-style
+ require will be used. If not, but there is a
+ function define with an amd property
+ present, AMD-style (RequireJS) will be used.
It is possible to + use Browserify or similar + tools to statically build modules using CodeMirror. Alternatively, + use RequireJS to dynamically + load dependencies at runtime. Both of these approaches have the + advantage that they don't use the global namespace and can, thus, + do things like load multiple versions of CodeMirror alongside each + other.
+ +Here's a simple example of using RequireJS to load CodeMirror:
+ +require([
+ "cm/lib/codemirror", "cm/mode/htmlmixed/htmlmixed"
+], function(CodeMirror) {
+ CodeMirror.fromTextArea(document.getElementById("code"), {
+ lineNumbers: true,
+ mode: "htmlmixed"
+ });
+});
+
+ It will automatically load the modes that the mixed HTML mode
+ depends on (XML, JavaScript, and CSS). Do not use
+ RequireJS' paths option to configure the path to
+ CodeMirror, since it will break loading submodules through
+ relative paths. Use
+ the packages
+ configuration option instead, as in:
require.config({
+ packages: [{
+ name: "codemirror",
+ location: "../path/to/codemirror",
+ main: "lib/codemirror"
+ }]
+});
+
+Configuration
+ +Both the CodeMirror
+ function and its fromTextArea method take as second
+ (optional) argument an object containing configuration options.
+ Any option not supplied like this will be taken
+ from CodeMirror.defaults, an
+ object containing the default options. You can update this object
+ to change the defaults on your page.
Options are not checked in any way, so setting bogus option + values is bound to lead to odd errors.
+ +These are the supported options:
+ +-
+
value: string|CodeMirror.Doc
+ - The starting value of the editor. Can be a string, or + a document object. + +
mode: string|object
+ - The mode to use. When not given, this will default to the
+ first mode that was loaded. It may be a string, which either
+ simply names the mode or is
+ a MIME type
+ associated with the mode. Alternatively, it may be an object
+ containing configuration options for the mode, with
+ a
nameproperty that names the mode (for + example{name: "javascript", json: true}). The demo + pages for each mode contain information about what configuration + parameters the mode supports. You can ask CodeMirror which modes + and MIME types have been defined by inspecting + theCodeMirror.modes+ andCodeMirror.mimeModesobjects. The first maps + mode names to their constructors, and the second maps MIME types + to mode specs.
+
+ lineSeparator: string|null
+ - Explicitly set the line separator for the editor. By default
+ (value
null), the document will be split on CRLFs + as well as lone CRs and LFs, and a single LF will be used as + line separator in all output (such + asgetValue). When a + specific string is given, lines will only be split on that + string, and output will, by default, use that same + separator.
+
+ theme: string
+ - The theme to style the editor with. You must make sure the
+ CSS file defining the corresponding
.cm-s-[name]+ styles is loaded (see + thethemedirectory in the + distribution). The default is"default", for which + colors are included incodemirror.css. It is + possible to use multiple theming classes at once—for + example"foo bar"will assign both + thecm-s-fooand thecm-s-barclasses + to the editor.
+
+ indentUnit: integer
+ - How many spaces a block (whatever that means in the edited + language) should be indented. The default is 2. + +
smartIndent: boolean
+ - Whether to use the context-sensitive indentation that the + mode provides (or just indent the same as the line before). + Defaults to true. + +
tabSize: integer
+ - The width of a tab character. Defaults to 4. + +
indentWithTabs: boolean
+ - Whether, when indenting, the first N*
tabSize+ spaces should be replaced by N tabs. Default is false.
+
+ electricChars: boolean
+ - Configures whether the editor should re-indent the current + line when a character is typed that might change its proper + indentation (only works if the mode supports indentation). + Default is true. + +
specialChars: RegExp
+ - A regular expression used to determine which characters
+ should be replaced by a
+ special placeholder.
+ Mostly useful for non-printing special characters. The default
+ is
/[\u0000-\u0019\u00ad\u200b-\u200f\u2028\u2029\ufeff]/.
+ specialCharPlaceholder: function(char) → Element
+ - A function that, given a special character identified by
+ the
specialChars+ option, produces a DOM node that is used to represent the + character. By default, a red dot (•) + is shown, with a title tooltip to indicate the character code.
+
+ rtlMoveVisually: boolean
+ - Determines whether horizontal cursor movement through
+ right-to-left (Arabic, Hebrew) text is visual (pressing the left
+ arrow moves the cursor left) or logical (pressing the left arrow
+ moves to the next lower index in the string, which is visually
+ right in right-to-left text). The default is
false+ on Windows, andtrueon other platforms.
+
+ keyMap: string
+ - Configures the key map to use. The default
+ is
"default", which is the only key map defined + incodemirror.jsitself. Extra key maps are found in + thekey mapdirectory. See + the section on key maps for more + information.
+
+ extraKeys: object
+ - Can be used to specify extra key bindings for the editor,
+ alongside the ones defined
+ by
keyMap. Should be + either null, or a valid key map value.
+
+ lineWrapping: boolean
+ - Whether CodeMirror should scroll or wrap for long lines.
+ Defaults to
false(scroll).
+
+ lineNumbers: boolean
+ - Whether to show line numbers to the left of the editor. + +
firstLineNumber: integer
+ - At which number to start counting lines. Default is 1. + +
lineNumberFormatter: function(line: integer) → string
+ - A function used to format line numbers. The function is + passed the line number, and should return a string that will be + shown in the gutter. + +
gutters: array<string>
+ - Can be used to add extra gutters (beyond or instead of the
+ line number gutter). Should be an array of CSS class names, each
+ of which defines a
width(and optionally a + background), and which will be used to draw the background of + the gutters. May include + theCodeMirror-linenumbersclass, in order to + explicitly set the position of the line number gutter (it will + default to be to the right of all other gutters). These class + names are the keys passed + tosetGutterMarker.
+
+ fixedGutter: boolean
+ - Determines whether the gutter scrolls along with the content + horizontally (false) or whether it stays fixed during horizontal + scrolling (true, the default). + +
scrollbarStyle: string
+ - Chooses a scrollbar implementation. The default
+ is
"native", showing native scrollbars. The core + library also provides the"null"style, which + completely hides the + scrollbars. Addons can + implement additional scrollbar models.
+
+ coverGutterNextToScrollbar: boolean
+ - When
fixedGutter+ is on, and there is a horizontal scrollbar, by default the + gutter will be visible to the left of this scrollbar. If this + option is set to true, it will be covered by an element with + classCodeMirror-gutter-filler.
+
+ inputStyle: string
+ - Selects the way CodeMirror handles input and focus. The core
+ library defines the
"textarea"+ and"contenteditable"input models. On mobile + browsers, the default is"contenteditable". On + desktop browsers, the default is"textarea". + Support for IME and screen readers is better in + the"contenteditable"model. The intention is to + make it the default on modern desktop browsers in the + future.
+
+ readOnly: boolean|string
+ - This disables editing of the editor content by the user. If
+ the special value
"nocursor"is given (instead of + simplytrue), focusing of the editor is also + disallowed.
+
+ showCursorWhenSelecting: boolean
+ - Whether the cursor should be drawn when a selection is + active. Defaults to false. + +
lineWiseCopyCut: boolean
+ - When enabled, which is the default, doing copy or cut when + there is no selection will copy or cut the whole lines that have + cursors on them. + +
undoDepth: integer
+ - The maximum number of undo levels that the editor stores. + Note that this includes selection change events. Defaults to + 200. + +
historyEventDelay: integer
+ - The period of inactivity (in milliseconds) that will cause a + new history event to be started when typing or deleting. + Defaults to 1250. + +
tabindex: integer
+ - The tab + index to assign to the editor. If not given, no tab index + will be assigned. + +
autofocus: boolean
+ - Can be used to make CodeMirror focus itself on
+ initialization. Defaults to off.
+ When
fromTextAreais + used, and no explicit value is given for this option, it will be + set to true when either the source textarea is focused, or it + has anautofocusattribute and no other element is + focused.
+
Below this a few more specialized, low-level options are + listed. These are only useful in very specific situations, you + might want to skip them the first time you read this manual.
+ +-
+
dragDrop: boolean
+ - Controls whether drag-and-drop is enabled. On by default. + +
cursorBlinkRate: number
+ - Half-period in milliseconds used for cursor blinking. The default blink + rate is 530ms. By setting this to zero, blinking can be disabled. A + negative value hides the cursor entirely. + +
cursorScrollMargin: number
+ - How much extra space to always keep above and below the + cursor when approaching the top or bottom of the visible view in + a scrollable document. Default is 0. + +
cursorHeight: number
+ - Determines the height of the cursor. Default is 1, meaning
+ it spans the whole height of the line. For some fonts (and by
+ some tastes) a smaller height (for example
0.85), + which causes the cursor to not reach all the way to the bottom + of the line, looks better
+
+ resetSelectionOnContextMenu: boolean
+ - Controls whether, when the context menu is opened with a
+ click outside of the current selection, the cursor is moved to
+ the point of the click. Defaults to
true.
+
+ workTime, workDelay: number
+ - Highlighting is done by a pseudo background-thread that will
+ work for
workTimemilliseconds, and then use + timeout to sleep forworkDelaymilliseconds. The + defaults are 200 and 300, you can change these options to make + the highlighting more or less aggressive.
+
+ pollInterval: number
+ - Indicates how quickly CodeMirror should poll its input + textarea for changes (when focused). Most input is captured by + events, but some things, like IME input on some browsers, don't + generate events that allow CodeMirror to properly detect it. + Thus, it polls. Default is 100 milliseconds. + +
flattenSpans: boolean
+ - By default, CodeMirror will combine adjacent tokens into a + single span if they have the same class. This will result in a + simpler DOM tree, and thus perform better. With some kinds of + styling (such as rounded corners), this will change the way the + document looks. You can set this option to false to disable this + behavior. + +
addModeClass: boolean
+ - When enabled (off by default), an extra CSS class will be
+ added to each token, indicating the
+ (inner) mode that produced it, prefixed
+ with
"cm-m-". For example, tokens from the XML mode + will get thecm-m-xmlclass.
+
+ maxHighlightLength: number
+ - When highlighting long lines, in order to stay responsive,
+ the editor will give up and simply style the rest of the line as
+ plain text when it reaches a certain position. The default is
+ 10 000. You can set this to
Infinityto turn off + this behavior.
+
+ viewportMargin: integer
+ - Specifies the amount of lines that are rendered above and
+ below the part of the document that's currently scrolled into
+ view. This affects the amount of updates needed when scrolling,
+ and the amount of work that such an update does. You should
+ usually leave it at its default, 10. Can be set
+ to
Infinityto make sure the whole document is + always rendered, and thus the browser's text search works on it. + This will have bad effects on performance of big + documents.
+
Events
+ +Various CodeMirror-related objects emit events, which allow
+ client code to react to various situations. Handlers for such
+ events can be registered with the on
+ and off methods on the objects
+ that the event fires on. To fire your own events,
+ use CodeMirror.signal(target, name, args...),
+ where target is a non-DOM-node object.
An editor instance fires the following events.
+ The instance argument always refers to the editor
+ itself.
-
+
"change" (instance: CodeMirror, changeObj: object)
+ - Fires every time the content of the editor is changed.
+ The
changeObjis a{from, to, text, removed, + origin}object containing information about the changes + that occurred as second argument.from+ andtoare the positions (in the pre-change + coordinate system) where the change started and ended (for + example, it might be{ch:0, line:18}if the + position is at the beginning of line #19).textis + an array of strings representing the text that replaced the + changed range (split by line).removedis the text + that used to be betweenfromandto, + which is overwritten by this change. This event is + fired before the end of + an operation, before the DOM updates + happen.
+
+ "changes" (instance: CodeMirror, changes: array<object>)
+ - Like the
"change"+ event, but batched per operation, + passing an array containing all the changes that happened in the + operation. This event is fired after the operation finished, and + display changes it makes will trigger a new operation.
+
+ "beforeChange" (instance: CodeMirror, changeObj: object)
+ - This event is fired before a change is applied, and its
+ handler may choose to modify or cancel the change.
+ The
changeObjobject + hasfrom,to, andtext+ properties, as with + the"change"event. It + also has acancel()method, which can be called to + cancel the change, and, if the change isn't + coming from an undo or redo event, anupdate(from, to, + text)method, which may be used to modify the change. + Undo or redo changes can't be modified, because they hold some + metainformation for restoring old marked ranges that is only + valid for that specific change. All three arguments + toupdateare optional, and can be left off to + leave the existing value for that field + intact. Note: you may not do anything from + a"beforeChange"handler that would cause changes + to the document or its visualization. Doing so will, since this + handler is called directly from the bowels of the CodeMirror + implementation, probably cause the editor to become + corrupted.
+
+ "cursorActivity" (instance: CodeMirror)
+ - Will be fired when the cursor or selection moves, or any + change is made to the editor content. + +
"keyHandled" (instance: CodeMirror, name: string, event: Event)
+ - Fired after a key is handled through a
+ key map.
nameis the name of the handled key (for + example"Ctrl-X"or"'q'"), + andeventis the DOMkeydown+ orkeypressevent.
+
+ "inputRead" (instance: CodeMirror, changeObj: object)
+ - Fired whenever new input is read from the hidden textarea + (typed or pasted by the user). + +
"electrictInput" (instance: CodeMirror, line: integer)
+ - Fired if text input matched the + mode's electric patterns, + and this caused the line's indentation to change. + +
"beforeSelectionChange" (instance: CodeMirror, obj: {ranges, update})
+ - This event is fired before the selection is moved. Its
+ handler may inspect the set of selection ranges, present as an
+ array of
{anchor, head}objects in + therangesproperty of theobj+ argument, and optionally change them by calling + theupdatemethod on this object, passing an array + of ranges in the same format. Handlers for this event have the + same restriction + as"beforeChange"+ handlers — they should not do anything to directly update the + state of the editor.
+
+ "viewportChange" (instance: CodeMirror, from: number, to: number)
+ - Fires whenever the view port of
+ the editor changes (due to scrolling, editing, or any other
+ factor). The
fromandtoarguments + give the new start and end of the viewport.
+
+ "swapDoc" (instance: CodeMirror, oldDoc: Doc)
+ - This is signalled when the editor's document is replaced
+ using the
swapDoc+ method.
+
+ "gutterClick" (instance: CodeMirror, line: integer, gutter: string, clickEvent: Event)
+ - Fires when the editor gutter (the line-number area) is
+ clicked. Will pass the editor instance as first argument, the
+ (zero-based) number of the line that was clicked as second
+ argument, the CSS class of the gutter that was clicked as third
+ argument, and the raw
mousedownevent object as + fourth argument.
+
+ "gutterContextMenu" (instance: CodeMirror, line: integer, gutter: string, contextMenu: Event: Event)
+ - Fires when the editor gutter (the line-number area)
+ receives a
contextmenuevent. Will pass the editor + instance as first argument, the (zero-based) number of the line + that was clicked as second argument, the CSS class of the + gutter that was clicked as third argument, and the raw +contextmenumouse event object as fourth argument. + You canpreventDefaultthe event, to signal that + CodeMirror should do no further handling.
+
+ "focus" (instance: CodeMirror)
+ - Fires whenever the editor is focused. + +
"blur" (instance: CodeMirror)
+ - Fires whenever the editor is unfocused. + +
"scroll" (instance: CodeMirror)
+ - Fires when the editor is scrolled. + +
"scrollCursorIntoView" (instance: CodeMirror, event: Event)
+ - Fires when the editor tries to scroll its cursor into view.
+ Can be hooked into to take care of additional scrollable
+ containers around the editor. When the event object has
+ its
preventDefaultmethod called, CodeMirror will + not itself try to scroll the window.
+
+ "update" (instance: CodeMirror)
+ - Will be fired whenever CodeMirror updates its DOM display. + +
"renderLine" (instance: CodeMirror, line: LineHandle, element: Element)
+ - Fired whenever a line is (re-)rendered to the DOM. Fired + right after the DOM element is built, before it is + added to the document. The handler may mess with the style of + the resulting element, or add event handlers, but + should not try to change the state of the editor. + +
"mousedown", + "dblclick", "contextmenu", "keydown", "keypress", + "keyup", "dragstart", "dragenter", + "dragover", "drop" + (instance: CodeMirror, event: Event)
+ - Fired when CodeMirror is handling a DOM event of this type.
+ You can
preventDefaultthe event, or give it a + truthycodemirrorIgnoreproperty, to signal that + CodeMirror should do no further handling.
+
Document objects (instances
+ of CodeMirror.Doc) emit the
+ following events:
-
+
"change" (doc: CodeMirror.Doc, changeObj: object)
+ - Fired whenever a change occurs to the
+ document.
changeObjhas a similar type as the + object passed to the + editor's"change"+ event.
+
+ "beforeChange" (doc: CodeMirror.Doc, change: object)
+ - See the description of the + same event on editor instances. + +
"cursorActivity" (doc: CodeMirror.Doc)
+ - Fired whenever the cursor or selection in this document + changes. + +
"beforeSelectionChange" (doc: CodeMirror.Doc, selection: {head, anchor})
+ - Equivalent to + the event by the same + name as fired on editor instances. +
Line handles (as returned by, for
+ example, getLineHandle)
+ support these events:
-
+
"delete" ()
+ - Will be fired when the line object is deleted. A line object + is associated with the start of the line. Mostly useful + when you need to find out when your gutter + markers on a given line are removed. +
"change" (line: LineHandle, changeObj: object)
+ - Fires when the line's text content is changed in any way
+ (but the line is not deleted outright). The
change+ object is similar to the one passed + to change event on the editor + object.
+
Marked range handles (CodeMirror.TextMarker), as returned
+ by markText
+ and setBookmark, emit the
+ following events:
-
+
"beforeCursorEnter" ()
+ - Fired when the cursor enters the marked range. From this + event handler, the editor state may be inspected + but not modified, with the exception that the range on + which the event fires may be cleared. +
"clear" (from: {line, ch}, to: {line, ch})
+ - Fired when the range is cleared, either through cursor
+ movement in combination
+ with
clearOnEnter+ or through a call to itsclear()method. Will only + be fired once per handle. Note that deleting the range through + text editing does not fire this event, because an undo action + might bring the range back into existence.from+ andtogive the part of the document that the range + spanned when it was cleared.
+ "hide" ()
+ - Fired when the last part of the marker is removed from the + document by editing operations. +
"unhide" ()
+ - Fired when, after the marker was removed by editing, a undo + operation brought the marker back. +
Line widgets (CodeMirror.LineWidget), returned
+ by addLineWidget, fire
+ these events:
-
+
"redraw" ()
+ - Fired whenever the editor re-adds the widget to the DOM. + This will happen once right after the widget is added (if it is + scrolled into view), and then again whenever it is scrolled out + of view and back in again, or when changes to the editor options + or the line the widget is on require the widget to be + redrawn. +
Key Maps
+ +Key maps are ways to associate keys with functionality. A key map + is an object mapping strings that identify the keys to functions + that implement their functionality.
+ +The CodeMirror distributions comes + with Emacs, Vim, + and Sublime Text-style keymaps.
+ +Keys are identified either by name or by character.
+ The CodeMirror.keyNames object defines names for
+ common keys and associates them with their key codes. Examples of
+ names defined here are Enter, F5,
+ and Q. These can be prefixed
+ with Shift-, Cmd-, Ctrl-,
+ and Alt- to specify a modifier. So for
+ example, Shift-Ctrl-Space would be a valid key
+ identifier.
Common example: map the Tab key to insert spaces instead of a tab + character.
+ +
+editor.setOption("extraKeys", {
+ Tab: function(cm) {
+ var spaces = Array(cm.getOption("indentUnit") + 1).join(" ");
+ cm.replaceSelection(spaces);
+ }
+});
+
+ Alternatively, a character can be specified directly by
+ surrounding it in single quotes, for example '$'
+ or 'q'. Due to limitations in the way browsers fire
+ key events, these may not be prefixed with modifiers.
Multi-stroke key bindings can be specified
+ by separating the key names by spaces in the property name, for
+ example Ctrl-X Ctrl-V. When a map contains
+ multi-stoke bindings or keys with modifiers that are not specified
+ in the default order (Shift-Cmd-Ctrl-Alt), you must
+ call CodeMirror.normalizeKeyMap on it before it can
+ be used. This function takes a keymap and modifies it to normalize
+ modifier order and properly recognize multi-stroke bindings. It
+ will return the keymap itself.
The CodeMirror.keyMap object associates key maps
+ with names. User code and key map definitions can assign extra
+ properties to this object. Anywhere where a key map is expected, a
+ string can be given, which will be looked up in this object. It
+ also contains the "default" key map holding the
+ default bindings.
The values of properties in key maps can be either functions of
+ a single argument (the CodeMirror instance), strings, or
+ false. Strings refer
+ to commands, which are described below. If
+ the property is set to false, CodeMirror leaves
+ handling of the key up to the browser. A key handler function may
+ return CodeMirror.Pass to indicate that it has
+ decided not to handle the key, and other handlers (or the default
+ behavior) should be given a turn.
Keys mapped to command names that start with the
+ characters "go" or to functions that have a
+ truthy motion property (which should be used for
+ cursor-movement actions) will be fired even when an
+ extra Shift modifier is present (i.e. "Up":
+ "goLineUp" matches both up and shift-up). This is used to
+ easily implement shift-selection.
Key maps can defer to each other by defining
+ a fallthrough property. This indicates that when a
+ key is not found in the map itself, one or more other maps should
+ be searched. It can hold either a single key map or an array of
+ key maps.
When a key map needs to set something up when it becomes
+ active, or tear something down when deactivated, it can
+ contain attach and/or detach properties,
+ which should hold functions that take the editor instance and the
+ next or previous keymap. Note that this only works for the
+ top-level keymap, not for fallthrough
+ maps or maps added
+ with extraKeys
+ or addKeyMap.
Commands
+ +Commands are parameter-less actions that can be performed on an
+ editor. Their main use is for key bindings. Commands are defined by
+ adding properties to the CodeMirror.commands object.
+ A number of common commands are defined by the library itself,
+ most of them used by the default key bindings. The value of a
+ command property must be a function of one argument (an editor
+ instance).
Some of the commands below are referenced in the default + key map, but not defined by the core library. These are intended to + be defined by user code or addons.
+ +Commands can also be run with
+ the execCommand
+ method.
-
+
selectAllCtrl-A (PC), Cmd-A (Mac)
+ - Select the whole content of the editor. + +
singleSelectionEsc
+ - When multiple selections are present, this deselects all but + the primary selection. + +
killLineCtrl-K (Mac)
+ - Emacs-style line killing. Deletes the part of the line after + the cursor. If that consists only of whitespace, the newline at + the end of the line is also deleted. + +
deleteLineCtrl-D (PC), Cmd-D (Mac)
+ - Deletes the whole line under the cursor, including newline at the end. + +
delLineLeft
+ - Delete the part of the line before the cursor. + +
delWrappedLineLeftCmd-Backspace (Mac)
+ - Delete the part of the line from the left side of the visual line the cursor is on to the cursor. + +
delWrappedLineRightCmd-Delete (Mac)
+ - Delete the part of the line from the cursor to the right side of the visual line the cursor is on. + +
undoCtrl-Z (PC), Cmd-Z (Mac)
+ - Undo the last change. + +
redoCtrl-Y (PC), Shift-Cmd-Z (Mac), Cmd-Y (Mac)
+ - Redo the last undone change. + +
undoSelectionCtrl-U (PC), Cmd-U (Mac)
+ - Undo the last change to the selection, or if there are no + selection-only changes at the top of the history, undo the last + change. + +
redoSelectionAlt-U (PC), Shift-Cmd-U (Mac)
+ - Redo the last change to the selection, or the last text change if + no selection changes remain. + +
goDocStartCtrl-Home (PC), Cmd-Up (Mac), Cmd-Home (Mac)
+ - Move the cursor to the start of the document. + +
goDocEndCtrl-End (PC), Cmd-End (Mac), Cmd-Down (Mac)
+ - Move the cursor to the end of the document. + +
goLineStartAlt-Left (PC), Ctrl-A (Mac)
+ - Move the cursor to the start of the line. + +
goLineStartSmartHome
+ - Move to the start of the text on the line, or if we are + already there, to the actual start of the line (including + whitespace). + +
goLineEndAlt-Right (PC), Ctrl-E (Mac)
+ - Move the cursor to the end of the line. + +
goLineRightCmd-Right (Mac)
+ - Move the cursor to the right side of the visual line it is on. + +
goLineLeftCmd-Left (Mac)
+ - Move the cursor to the left side of the visual line it is on. If + this line is wrapped, that may not be the start of the line. + +
goLineLeftSmart
+ - Move the cursor to the left side of the visual line it is
+ on. If that takes it to the start of the line, behave
+ like
goLineStartSmart.
+
+ goLineUpUp, Ctrl-P (Mac)
+ - Move the cursor up one line. + +
goLineDownDown, Ctrl-N (Mac)
+ - Move down one line. + +
goPageUpPageUp, Shift-Ctrl-V (Mac)
+ - Move the cursor up one screen, and scroll up by the same distance. + +
goPageDownPageDown, Ctrl-V (Mac)
+ - Move the cursor down one screen, and scroll down by the same distance. + +
goCharLeftLeft, Ctrl-B (Mac)
+ - Move the cursor one character left, going to the previous line + when hitting the start of line. + +
goCharRightRight, Ctrl-F (Mac)
+ - Move the cursor one character right, going to the next line + when hitting the end of line. + +
goColumnLeft
+ - Move the cursor one character left, but don't cross line boundaries. + +
goColumnRight
+ - Move the cursor one character right, don't cross line boundaries. + +
goWordLeftAlt-B (Mac)
+ - Move the cursor to the start of the previous word. + +
goWordRightAlt-F (Mac)
+ - Move the cursor to the end of the next word. + +
goGroupLeftCtrl-Left (PC), Alt-Left (Mac)
+ - Move to the left of the group before the cursor. A group is + a stretch of word characters, a stretch of punctuation + characters, a newline, or a stretch of more than one + whitespace character. + +
goGroupRightCtrl-Right (PC), Alt-Right (Mac)
+ - Move to the right of the group after the cursor + (see above). + +
delCharBeforeShift-Backspace, Ctrl-H (Mac)
+ - Delete the character before the cursor. + +
delCharAfterDelete, Ctrl-D (Mac)
+ - Delete the character after the cursor. + +
delWordBeforeAlt-Backspace (Mac)
+ - Delete up to the start of the word before the cursor. + +
delWordAfterAlt-D (Mac)
+ - Delete up to the end of the word after the cursor. + +
delGroupBeforeCtrl-Backspace (PC), Alt-Backspace (Mac)
+ - Delete to the left of the group before the cursor. + +
delGroupAfterCtrl-Delete (PC), Ctrl-Alt-Backspace (Mac), Alt-Delete (Mac)
+ - Delete to the start of the group after the cursor. + +
indentAutoShift-Tab
+ - Auto-indent the current line or selection. + +
indentMoreCtrl-] (PC), Cmd-] (Mac)
+ - Indent the current line or selection by one indent unit. + +
indentLessCtrl-[ (PC), Cmd-[ (Mac)
+ - Dedent the current line or selection by one indent unit. + +
insertTab
+ - Insert a tab character at the cursor. + +
insertSoftTab
+ - Insert the amount of spaces that match the width a tab at + the cursor position would have. + +
defaultTabTab
+ - If something is selected, indent it by + one indent unit. If nothing is + selected, insert a tab character. + +
transposeCharsCtrl-T (Mac)
+ - Swap the characters before and after the cursor. + +
newlineAndIndentEnter
+ - Insert a newline and auto-indent the new line. + +
toggleOverwriteInsert
+ - Flip the overwrite flag. + +
saveCtrl-S (PC), Cmd-S (Mac)
+ - Not defined by the core library, only referred to in + key maps. Intended to provide an easy way for user code to define + a save command. + +
findCtrl-F (PC), Cmd-F (Mac)
+ findNextCtrl-G (PC), Cmd-G (Mac)
+ findPrevShift-Ctrl-G (PC), Shift-Cmd-G (Mac)
+ replaceShift-Ctrl-F (PC), Cmd-Alt-F (Mac)
+ replaceAllShift-Ctrl-R (PC), Shift-Cmd-Alt-F (Mac)
+ - Not defined by the core library, but defined in + the search addon (or custom client + addons). + +
Customized Styling
+ +Up to a certain extent, CodeMirror's look can be changed by
+ modifying style sheet files. The style sheets supplied by modes
+ simply provide the colors for that mode, and can be adapted in a
+ very straightforward way. To style the editor itself, it is
+ possible to alter or override the styles defined
+ in codemirror.css.
Some care must be taken there, since a lot of the rules in this + file are necessary to have CodeMirror function properly. Adjusting + colors should be safe, of course, and with some care a lot of + other things can be changed as well. The CSS classes defined in + this file serve the following roles:
+ +-
+
CodeMirror
+ - The outer element of the editor. This should be used for the
+ editor width, height, borders and positioning. Can also be used
+ to set styles that should hold for everything inside the editor
+ (such as font and font size), or to set a background. Setting
+ this class'
heightstyle toautowill + make the editor resize to fit its + content (it is recommended to also set + theviewportMargin+ option toInfinitywhen doing this.
+
+ CodeMirror-focused
+ - Whenever the editor is focused, the top element gets this + class. This is used to hide the cursor and give the selection a + different color when the editor is not focused. + +
CodeMirror-gutters
+ - This is the backdrop for all gutters. Use it to set the + default gutter background color, and optionally add a border on + the right of the gutters. + +
CodeMirror-linenumbers
+ - Use this for giving a background or width to the line number + gutter. + +
CodeMirror-linenumber
+ - Used to style the actual individual line numbers. These
+ won't be children of the
CodeMirror-linenumbers+ (plural) element, but rather will be absolutely positioned to + overlay it. Use this to set alignment and text properties for + the line numbers.
+
+ CodeMirror-lines
+ - The visible lines. This is where you specify vertical + padding for the editor content. + +
CodeMirror-cursor
+ - The cursor is a block element that is absolutely positioned. + You can make it look whichever way you want. + +
CodeMirror-selected
+ - The selection is represented by
spanelements + with this class.
+
+ CodeMirror-matchingbracket, +CodeMirror-nonmatchingbracket
+ - These are used to style matched (or unmatched) brackets. +
If your page's style sheets do funky things to
+ all div or pre elements (you probably
+ shouldn't do that), you'll have to define rules to cancel these
+ effects out again for elements under the CodeMirror
+ class.
Themes are also simply CSS files, which define colors for
+ various syntactic elements. See the files in
+ the theme directory.
Programming API
+ +A lot of CodeMirror features are only available through its + API. Thus, you need to write code (or + use addons) if you want to expose them to + your users.
+ +Whenever points in the document are represented, the API uses
+ objects with line and ch properties.
+ Both are zero-based. CodeMirror makes sure to 'clip' any positions
+ passed by client code so that they fit inside the document, so you
+ shouldn't worry too much about sanitizing your coordinates. If you
+ give ch a value of null, or don't
+ specify it, it will be replaced with the length of the specified
+ line.
Methods prefixed with doc. can, unless otherwise
+ specified, be called both on CodeMirror (editor)
+ instances and CodeMirror.Doc instances. Methods
+ prefixed with cm. are only available
+ on CodeMirror instances.
Constructor
+ +Constructing an editor instance is done with
+ the CodeMirror(place: Element|fn(Element),
+ ?option: object) constructor. If the place
+ argument is a DOM element, the editor will be appended to it. If
+ it is a function, it will be called, and is expected to place the
+ editor into the document. options may be an element
+ mapping option names to values. The options
+ that it doesn't explicitly specify (or all options, if it is not
+ passed) will be taken
+ from CodeMirror.defaults.
Note that the options object passed to the constructor will be + mutated when the instance's options + are changed, so you shouldn't share such + objects between instances.
+ +See CodeMirror.fromTextArea
+ for another way to construct an editor instance.
Content manipulation methods
+ +-
+
doc.getValue(?separator: string) → string
+ - Get the current editor content. You can pass it an optional
+ argument to specify the string to be used to separate lines
+ (defaults to
"\n").
+ doc.setValue(content: string)
+ - Set the editor content. + +
doc.getRange(from: {line, ch}, to: {line, ch}, ?separator: string) → string
+ - Get the text between the given points in the editor, which
+ should be
{line, ch}objects. An optional third + argument can be given to indicate the line separator string to + use (defaults to"\n").
+ doc.replaceRange(replacement: string, from: {line, ch}, to: {line, ch}, ?origin: string)
+ - Replace the part of the document between
from+ andtowith the given string.from+ andtomust be{line, ch}+ objects.tocan be left off to simply insert the + string at positionfrom. Whenorigin+ is given, it will be passed on + to"change"events, and + its first letter will be used to determine whether this change + can be merged with previous history events, in the way described + for selection origins.
+
+ doc.getLine(n: integer) → string
+ - Get the content of line
n.
+
+ doc.lineCount() → integer
+ - Get the number of lines in the editor. +
doc.firstLine() → integer
+ - Get the first line of the editor. This will + usually be zero but for linked sub-views, + or documents instantiated with a non-zero + first line, it might return other values. +
doc.lastLine() → integer
+ - Get the last line of the editor. This will
+ usually be
doc.lineCount() - 1, + but for linked sub-views, + it might return other values.
+
+ doc.getLineHandle(num: integer) → LineHandle
+ - Fetches the line handle for the given line number. +
doc.getLineNumber(handle: LineHandle) → integer
+ - Given a line handle, returns the current position of that
+ line (or
nullwhen it is no longer in the + document).
+ doc.eachLine(f: (line: LineHandle))
+ doc.eachLine(start: integer, end: integer, f: (line: LineHandle))
+ - Iterate over the whole document, or if
start+ andendline numbers are given, the range + fromstartup to (not including)end, + and callffor each line, passing the line handle. + This is a faster way to visit a range of line handlers than + callinggetLineHandle+ for each of them. Note that line handles have + atextproperty containing the line's content (as a + string).
+
+ doc.markClean()
+ - Set the editor content as 'clean', a flag that it will
+ retain until it is edited, and which will be set again when such
+ an edit is undone again. Useful to track whether the content
+ needs to be saved. This function is deprecated in favor
+ of
changeGeneration, + which allows multiple subsystems to track different notions of + cleanness without interfering.
+ doc.changeGeneration(?closeEvent: boolean) → integer
+ - Returns a number that can later be passed
+ to
isCleanto test whether + any edits were made (and not undone) in the meantime. + IfcloseEventis true, the current history event + will be ‘closed’, meaning it can't be combined with further + changes (rapid typing or deleting events are typically + combined).
+ doc.isClean(?generation: integer) → boolean
+ - Returns whether the document is currently clean — not
+ modified since initialization or the last call
+ to
markCleanif no + argument is passed, or since the matching call + tochangeGeneration+ if a generation value is given.
+
Cursor and selection methods
+ +-
+
doc.getSelection(?lineSep: string) → string
+ - Get the currently selected code. Optionally pass a line
+ separator to put between the lines in the output. When multiple
+ selections are present, they are concatenated with instances
+ of
lineSepin between.
+ doc.getSelections(?lineSep: string) → string
+ - Returns an array containing a string for each selection, + representing the content of the selections. + +
doc.replaceSelection(replacement: string, ?select: string)
+ - Replace the selection(s) with the given string. By default,
+ the new selection ends up after the inserted text. The
+ optional
selectargument can be used to change + this—passing"around"will cause the new text to be + selected, passing"start"will collapse the + selection to the start of the inserted text.
+ doc.replaceSelections(replacements: array<string>, ?select: string)
+ - The length of the given array should be the same as the
+ number of active selections. Replaces the content of the
+ selections with the strings in the array.
+ The
selectargument works the same as + inreplaceSelection.
+
+ doc.getCursor(?start: string) → {line, ch}
+ - Retrieve one end of the primary
+ selection.
startis a an optional string indicating + which end of the selection to return. It may + be"from","to","head"+ (the side of the selection that moves when you press + shift+arrow), or"anchor"(the fixed side of the + selection). Omitting the argument is the same as + passing"head". A{line, ch}object + will be returned.
+ doc.listSelections() → array<{anchor, head}>
+ - Retrieves a list of all current selections. These will
+ always be sorted, and never overlap (overlapping selections are
+ merged). Each object in the array contains
anchor+ andheadproperties referring to{line, + ch}objects.
+
+ doc.somethingSelected() → boolean
+ - Return true if any text is selected. +
doc.setCursor(pos: {line, ch}|number, ?ch: number, ?options: object)
+ - Set the cursor position. You can either pass a
+ single
{line, ch}object, or the line and the + character as two separate parameters. Will replace all + selections with a single, empty selection at the given position. + The supported options are the same as forsetSelection.
+
+ doc.setSelection(anchor: {line, ch}, ?head: {line, ch}, ?options: object)
+ - Set a single selection range.
anchor+ andheadshould be{line, ch}+ objects.headdefaults toanchorwhen + not given. These options are supported: +-
+
scroll: boolean
+ - Determines whether the selection head should be scrolled + into view. Defaults to true. +
origin: string
+ - Detemines whether the selection history event may be
+ merged with the previous one. When an origin starts with the
+ character
+, and the last recorded selection had + the same origin and was similar (close + in time, both + collapsed or both non-collapsed), the new one will replace the + old one. When it starts with*, it will always + replace the previous event (if that had the same origin). + Built-in motion uses the"+move"origin.
+ bias: number
+ - Determine the direction into which the selection endpoints + should be adjusted when they fall inside + an atomic range. Can be either -1 + (backward) or 1 (forward). When not given, the bias will be + based on the relative position of the old selection—the editor + will try to move further away from that, to prevent getting + stuck. +
+
+ doc.setSelections(ranges: array<{anchor, head}>, ?primary: integer, ?options: object)
+ - Sets a new set of selections. There must be at least one
+ selection in the given array. When
primaryis a + number, it determines which selection is the primary one. When + it is not given, the primary index is taken from the previous + selection, or set to the last range if the previous selection + had less ranges than the new one. Supports the same options + assetSelection.
+ doc.addSelection(anchor: {line, ch}, ?head: {line, ch})
+ - Adds a new selection to the existing set of selections, and + makes it the primary selection. + +
doc.extendSelection(from: {line, ch}, ?to: {line, ch}, ?options: object)
+ - Similar
+ to
setSelection, but + will, if shift is held or + the extending flag is set, move the + head of the selection while leaving the anchor at its current + place.tois optional, and can be passed to ensure + a region (for example a word or paragraph) will end up selected + (in addition to whatever lies between that region and the + current anchor). When multiple selections are present, all but + the primary selection will be dropped by this method. + Supports the same options assetSelection.
+ doc.extendSelections(heads: array<{line, ch}>, ?options: object)
+ - An equivalent
+ of
extendSelection+ that acts on all selections at once.
+ doc.extendSelectionsBy(f: function(range: {anchor, head}) → {anchor, head}), ?options: object)
+ - Applies the given function to all existing selections, and
+ calls
extendSelections+ on the result.
+ doc.setExtending(value: boolean)
+ - Sets or clears the 'extending' flag, which acts similar to
+ the shift key, in that it will cause cursor movement and calls
+ to
extendSelection+ to leave the selection anchor in place.
+ doc.getExtending() → boolean
+ - Get the value of the 'extending' flag. + +
cm.hasFocus() → boolean
+ - Tells you whether the editor currently has focus. + +
cm.findPosH(start: {line, ch}, amount: integer, unit: string, visually: boolean) → {line, ch, ?hitSide: boolean}
+ - Used to find the target position for horizontal cursor
+ motion.
startis a{line, ch}+ object,amountan integer (may be negative), + andunitone of the + string"char","column", + or"word". Will return a position that is produced + by movingamounttimes the distance specified + byunit. Whenvisuallyis true, motion + in right-to-left text will be visual rather than logical. When + the motion was clipped by hitting the end or start of the + document, the returned value will have ahitSide+ property set to true.
+ cm.findPosV(start: {line, ch}, amount: integer, unit: string) → {line, ch, ?hitSide: boolean}
+ - Similar to
findPosH, + but used for vertical motion.unitmay + be"line"or"page". The other + arguments and the returned value have the same interpretation as + they have infindPosH.
+
+ cm.findWordAt(pos: {line, ch}) → {anchor: {line, ch}, head: {line, ch}}
+ - Returns the start and end of the 'word' (the stretch of + letters, whitespace, or punctuation) at the given position. +
Configuration methods
+ +-
+
cm.setOption(option: string, value: any)
+ - Change the configuration of the editor.
option+ should the name of an option, + andvalueshould be a valid value for that + option.
+ cm.getOption(option: string) → any
+ - Retrieves the current value of the given option for this + editor instance. + +
cm.addKeyMap(map: object, bottom: boolean)
+ - Attach an additional key map to the
+ editor. This is mostly useful for addons that need to register
+ some key handlers without trampling on
+ the
extraKeys+ option. Maps added in this way have a higher precedence than + theextraKeys+ andkeyMapoptions, + and between them, the maps added earlier have a lower precedence + than those added later, unless thebottomargument + was passed, in which case they end up below other key maps added + with this method.
+ cm.removeKeyMap(map: object)
+ - Disable a keymap added
+ with
addKeyMap. Either + pass in the key map object itself, or a string, which will be + compared against thenameproperty of the active + key maps.
+
+ cm.addOverlay(mode: string|object, ?options: object)
+ - Enable a highlighting overlay. This is a stateless mini-mode
+ that can be used to add extra highlighting. For example,
+ the search addon uses it to
+ highlight the term that's currently being
+ searched.
modecan be a mode + spec or a mode object (an object with + atokenmethod). + Theoptionsparameter is optional. If given, it + should be an object. Currently, only theopaque+ option is recognized. This defaults to off, but can be given to + allow the overlay styling, when notnull, to + override the styling of the base mode entirely, instead of the + two being applied together.
+ cm.removeOverlay(mode: string|object)
+ - Pass this the exact value passed for the
mode+ parameter toaddOverlay, + or a string that corresponds to thenamepropery of + that value, to remove an overlay again.
+
+ cm.on(type: string, func: (...args))
+ - Register an event handler for the given event type (a
+ string) on the editor instance. There is also
+ a
CodeMirror.on(object, type, func)version + that allows registering of events on any object.
+ cm.off(type: string, func: (...args))
+ - Remove an event handler on the editor instance. An
+ equivalent
CodeMirror.off(object, type, + func)also exists.
+
Document management methods
+ +Each editor is associated with an instance
+ of CodeMirror.Doc, its document. A document
+ represents the editor content, plus a selection, an undo history,
+ and a mode. A document can only be
+ associated with a single editor at a time. You can create new
+ documents by calling the CodeMirror.Doc(text, mode,
+ firstLineNumber) constructor. The last two arguments are
+ optional and can be used to set a mode for the document and make
+ it start at a line number other than 0, respectively.
-
+
cm.getDoc() → Doc
+ - Retrieve the currently active document from an editor. +
doc.getEditor() → CodeMirror
+ - Retrieve the editor associated with a document. May
+ return
null.
+
+ cm.swapDoc(doc: CodeMirror.Doc) → Doc
+ - Attach a new document to the editor. Returns the old + document, which is now no longer associated with an editor. + +
doc.copy(copyHistory: boolean) → Doc
+ - Create an identical copy of the given doc.
+ When
copyHistoryis true, the history will also be + copied. Can not be called directly on an editor.
+
+ doc.linkedDoc(options: object) → Doc
+ - Create a new document that's linked to the target document.
+ Linked documents will stay in sync (changes to one are also
+ applied to the other) until unlinked.
+ These are the options that are supported:
+
-
+
+
- When turned on, the linked copy will share an undo + history with the original. Thus, something done in one of + the two can be undone in the other, and vice versa. +
from: integer
+ to: integer
+ - Can be given to make the new document a subview of the + original. Subviews only show a given range of lines. Note + that line coordinates inside the subview will be consistent + with those of the parent, so that for example a subview + starting at line 10 will refer to its first line as line 10, + not 0. +
mode: string|object
+ - By default, the new document inherits the mode of the + parent. This option can be set to + a mode spec to give it a + different mode. +
+ doc.unlinkDoc(doc: CodeMirror.Doc)
+ - Break the link between two documents. After calling this, + changes will no longer propagate between the documents, and, if + they had a shared history, the history will become + separate. +
doc.iterLinkedDocs(function: (doc: CodeMirror.Doc, sharedHist: boolean))
+ - Will call the given function for all documents linked to the + target document. It will be passed two arguments, the linked document + and a boolean indicating whether that document shares history + with the target. +
History-related methods
+ +-
+
doc.undo()
+ - Undo one edit (if any undo events are stored). +
doc.redo()
+ - Redo one undone edit. + +
doc.undoSelection()
+ - Undo one edit or selection change. +
doc.redoSelection()
+ - Redo one undone edit or selection change. + +
doc.historySize() → {undo: integer, redo: integer}
+ - Returns an object with
{undo, redo}properties, + both of which hold integers, indicating the amount of stored + undo and redo operations.
+ doc.clearHistory()
+ - Clears the editor's undo history. +
doc.getHistory() → object
+ - Get a (JSON-serializeable) representation of the undo history. +
doc.setHistory(history: object)
+ - Replace the editor's undo history with the one provided,
+ which must be a value as returned
+ by
getHistory. Note that + this will have entirely undefined results if the editor content + isn't also the same as it was whengetHistorywas + called.
+
Text-marking methods
+ +-
+
doc.markText(from: {line, ch}, to: {line, ch}, ?options: object) → TextMarker
+ - Can be used to mark a range of text with a specific CSS
+ class name.
fromandtoshould + be{line, ch}objects. Theoptions+ parameter is optional. When given, it should be an object that + may contain the following configuration options: +-
+
className: string
+ - Assigns a CSS class to the marked stretch of text. +
inclusiveLeft: boolean
+ - Determines whether + text inserted on the left of the marker will end up inside + or outside of it. +
inclusiveRight: boolean
+ - Like
inclusiveLeft, + but for the right side.
+ atomic: boolean
+ - Atomic ranges act as a single unit when cursor movement is
+ concerned—i.e. it is impossible to place the cursor inside of
+ them. In atomic ranges,
inclusiveLeft+ andinclusiveRighthave a different meaning—they + will prevent the cursor from being placed respectively + directly before and directly after the range.
+ collapsed: boolean
+ - Collapsed ranges do not show up in the display. Setting a + range to be collapsed will automatically make it atomic. +
clearOnEnter: boolean
+ - When enabled, will cause the mark to clear itself whenever
+ the cursor enters its range. This is mostly useful for
+ text-replacement widgets that need to 'snap open' when the
+ user tries to edit them. The
+
"clear"event + fired on the range handle can be used to be notified when this + happens.
+ clearWhenEmpty: boolean
+ - Determines whether the mark is automatically cleared when + it becomes empty. Default is true. +
replacedWith: Element
+ - Use a given node to display this range. Implies both + collapsed and atomic. The given DOM node must be an + inline element (as opposed to a block element). +
handleMouseEvents: boolean
+ - When
replacedWithis given, this determines + whether the editor will capture mouse and drag events + occurring in this widget. Default is false—the events will be + left alone for the default browser handler, or specific + handlers on the widget, to capture.
+ readOnly: boolean
+ - A read-only span can, as long as it is not cleared, not be
+ modified except by
+ calling
setValueto reset + the whole document. Note: adding a read-only span + currently clears the undo history of the editor, because + existing undo events being partially nullified by read-only + spans would corrupt the history (in the current + implementation).
+ addToHistory: boolean
+ - When set to true (default is false), adding this marker + will create an event in the undo history that can be + individually undone (clearing the marker). +
startStyle: string- Can be used to specify + an extra CSS class to be applied to the leftmost span that + is part of the marker. +
endStyle: string- Equivalent
+ to
startStyle, but for the rightmost span.
+ css: string
+ - A string of CSS to be applied to the covered text. For example
"color: #fe3".
+ title: + string- When given, will give the nodes created
+ for this span a HTML
titleattribute with the + given value.
+ - When the
+ target document is linked to other
+ documents, you can set
sharedto true to make the + marker appear in all documents. By default, a marker appears + only in its target document.
+
CodeMirror.TextMarker), which + exposes three methods: +clear(), to remove the mark, +find(), which returns + a{from, to}object (both holding document + positions), indicating the current position of the marked range, + orundefinedif the marker is no longer in the + document, and finallychanged(), + which you can call if you've done something that might change + the size of the marker (for example changing the content of + areplacedWith+ node), and want to cheaply update the display.
+
+ doc.setBookmark(pos: {line, ch}, ?options: object) → TextMarker
+ - Inserts a bookmark, a handle that follows the text around it
+ as it is being edited, at the given position. A bookmark has two
+ methods
find()andclear(). The first + returns the current position of the bookmark, if it is still in + the document, and the second explicitly removes the bookmark. + The options argument is optional. If given, the following + properties are recognized: +-
+
widget: Element- Can be used to display a DOM
+ node at the current location of the bookmark (analogous to
+ the
replacedWith+ option tomarkText).
+ insertLeft: boolean- By default, text typed + when the cursor is on top of the bookmark will end up to the + right of the bookmark. Set this option to true to make it go + to the left instead. +
shared: boolean- See
+ the corresponding option
+ to
markText.
+ handleMouseEvents: boolean
+ - As with
markText, + this determines whether mouse events on the widget inserted + for this bookmark are handled by CodeMirror. The default is + false.
+
+
+ doc.findMarks(from: {line, ch}, to: {line, ch}) → array<TextMarker>
+ - Returns an array of all the bookmarks and marked ranges + found between the given positions. +
doc.findMarksAt(pos: {line, ch}) → array<TextMarker>
+ - Returns an array of all the bookmarks and marked ranges + present at the given position. +
doc.getAllMarks() → array<TextMarker>
+ - Returns an array containing all marked ranges in the document. +
Widget, gutter, and decoration methods
+ +-
+
cm.setGutterMarker(line: integer|LineHandle, gutterID: string, value: Element) → LineHandle
+ - Sets the gutter marker for the given gutter (identified by
+ its CSS class, see
+ the
guttersoption) + to the given value. Value can be eithernull, to + clear the marker, or a DOM element, to set it. The DOM element + will be shown in the specified gutter next to the specified + line.
+
+ cm.clearGutter(gutterID: string)
+ - Remove all gutter markers in + the gutter with the given ID. + +
doc.addLineClass(line: integer|LineHandle, where: string, class: string) → LineHandle
+ - Set a CSS class name for the given line.
line+ can be a number or a line handle.wheredetermines + to which element this class should be applied, can can be one + of"text"(the text element, which lies in front of + the selection),"background"(a background element + that will be behind the selection),"gutter"(the + line's gutter space), or"wrap"(the wrapper node + that wraps all of the line's elements, including gutter + elements).classshould be the name of the class to + apply.
+
+ doc.removeLineClass(line: integer|LineHandle, where: string, class: string) → LineHandle
+ - Remove a CSS class from a line.
linecan be a + line handle or number.whereshould be one + of"text","background", + or"wrap"+ (seeaddLineClass).class+ can be left off to remove all classes for the specified node, or + be a string to remove only a specific class.
+
+ cm.lineInfo(line: integer|LineHandle) → object
+ - Returns the line number, text content, and marker status of
+ the given line, which can be either a number or a line handle.
+ The returned object has the structure
{line, handle, text, + gutterMarkers, textClass, bgClass, wrapClass, widgets}, + wheregutterMarkersis an object mapping gutter IDs + to marker elements, andwidgetsis an array + of line widgets attached to this + line, and the various class properties refer to classes added + withaddLineClass.
+
+ cm.addWidget(pos: {line, ch}, node: Element, scrollIntoView: boolean)
+ - Puts
node, which should be an absolutely + positioned DOM node, into the editor, positioned right below the + given{line, ch}position. + WhenscrollIntoViewis true, the editor will ensure + that the entire node is visible (if possible). To remove the + widget again, simply use DOM methods (move it somewhere else, or + callremoveChildon its parent).
+
+ doc.addLineWidget(line: integer|LineHandle, node: Element, ?options: object) → LineWidget
+ - Adds a line widget, an element shown below a line, spanning
+ the whole of the editor's width, and moving the lines below it
+ downwards.
lineshould be either an integer or a + line handle, andnodeshould be a DOM node, which + will be displayed below the given line.options, + when given, should be an object that configures the behavior of + the widget. The following options are supported (all default to + false): +-
+
coverGutter: boolean
+ - Whether the widget should cover the gutter. +
noHScroll: boolean
+ - Whether the widget should stay fixed in the face of + horizontal scrolling. +
above: boolean
+ - Causes the widget to be placed above instead of below + the text of the line. +
handleMouseEvents: boolean
+ - Determines whether the editor will capture mouse and + drag events occurring in this widget. Default is false—the + events will be left alone for the default browser handler, + or specific handlers on the widget, to capture. +
insertAt: integer
+ - By default, the widget is added below other widgets for + the line. This option can be used to place it at a different + position (zero for the top, N to put it after the Nth other + widget). Note that this only has effect once, when the + widget is created. +
lineproperty + pointing at the line handle that it is associated with, and the following methods: +-
+
clear()- Removes the widget. +
changed()- Call + this if you made some change to the widget's DOM node that + might affect its height. It'll force CodeMirror to update + the height of the line that contains the widget. +
+
Sizing, scrolling and positioning methods
+ +-
+
cm.setSize(width: number|string, height: number|string)
+ - Programatically set the size of the editor (overriding the
+ applicable CSS
+ rules).
widthandheight+ can be either numbers (interpreted as pixels) or CSS units + ("100%", for example). You can + passnullfor either of them to indicate that that + dimension should not be changed.
+
+ cm.scrollTo(x: number, y: number)
+ - Scroll the editor to a given (pixel) position. Both
+ arguments may be left as
null+ orundefinedto have no effect.
+ cm.getScrollInfo() → {left, top, width, height, clientWidth, clientHeight}
+ - Get an
{left, top, width, height, clientWidth, + clientHeight}object that represents the current scroll + position, the size of the scrollable area, and the size of the + visible area (minus scrollbars).
+ cm.scrollIntoView(what: {line, ch}|{left, top, right, bottom}|{from, to}|null, ?margin: number)
+ - Scrolls the given position into view.
whatmay + benullto scroll the cursor into view, + a{line, ch}position to scroll a character into + view, a{left, top, right, bottom}pixel range (in + editor-local coordinates), or a range{from, to}+ containing either two character positions or two pixel squares. + Themarginparameter is optional. When given, it + indicates the amount of vertical pixels around the given area + that should be made visible as well.
+
+ cm.cursorCoords(where: boolean|{line, ch}, mode: string) → {left, top, bottom}
+ - Returns an
{left, top, bottom}object + containing the coordinates of the cursor position. + Ifmodeis"local", they will be + relative to the top-left corner of the editable document. If it + is"page"or not given, they are relative to the + top-left corner of the page. Ifmode+ is"window", the coordinates are relative to the + top-left corner of the currently visible (scrolled) + window.wherecan be a boolean indicating whether + you want the start (true) or the end + (false) of the selection, or, if a{line, + ch}object is given, it specifies the precise position at + which you want to measure.
+ cm.charCoords(pos: {line, ch}, ?mode: string) → {left, right, top, bottom}
+ - Returns the position and dimensions of an arbitrary
+ character.
posshould be a{line, ch}+ object. This differs fromcursorCoordsin that + it'll give the size of the whole character, rather than just the + position that the cursor would have when it would sit at that + position.
+ cm.coordsChar(object: {left, top}, ?mode: string) → {line, ch}
+ - Given an
{left, top}object, returns + the{line, ch}position that corresponds to it. The + optionalmodeparameter determines relative to what + the coordinates are interpreted. It may + be"window","page"(the default), + or"local".
+ cm.lineAtHeight(height: number, ?mode: string) → number
+ - Computes the line at the given pixel
+ height.
modecan be one of the same strings + thatcoordsChar+ accepts.
+ cm.heightAtLine(line: integer|LineHandle, ?mode: string) → number
+ - Computes the height of the top of a line, in the coordinate
+ system specified by
mode+ (seecoordsChar), which + defaults to"page". When a line below the bottom of + the document is specified, the returned value is the bottom of + the last line in the document.
+ cm.defaultTextHeight() → number
+ - Returns the line height of the default font for the editor. +
cm.defaultCharWidth() → number
+ - Returns the pixel width of an 'x' in the default font for + the editor. (Note that for non-monospace fonts, this is mostly + useless, and even for monospace fonts, non-ascii characters + might have a different width). + +
cm.getViewport() → {from: number, to: number}
+ - Returns a
{from, to}object indicating the + start (inclusive) and end (exclusive) of the currently rendered + part of the document. In big documents, when most content is + scrolled out of view, CodeMirror will only render the visible + part, and a margin around it. See also + theviewportChange+ event.
+
+ cm.refresh()
+ - If your code does something to change the size of the editor + element (window resizes are already listened for), or unhides + it, you should probably follow up by calling this method to + ensure CodeMirror is still looking as intended. See also + the autorefresh addon. +
Mode, state, and token-related methods
+ +When writing language-aware functionality, it can often be + useful to hook into the knowledge that the CodeMirror language + mode has. See the section on modes for a + more detailed description of how these work.
+ +-
+
doc.getMode() → object
+ - Gets the (outer) mode object for the editor. Note that this
+ is distinct from
getOption("mode"), which gives you + the mode specification, rather than the resolved, instantiated + mode object.
+
+ cm.getModeAt(pos: {line, ch}) → object
+ - Gets the inner mode at a given position. This will return
+ the same as
getModefor + simple modes, but will return an inner mode for nesting modes + (such ashtmlmixed).
+
+ cm.getTokenAt(pos: {line, ch}, ?precise: boolean) → object
+ - Retrieves information about the token the current mode found
+ before the given position (a
{line, ch}object). The + returned object has the following properties: +-
+
start- The character (on the given line) at which the token starts. +
end- The character at which the token ends. +
string- The token's string. +
type- The token type the mode assigned
+ to the token, such as
"keyword"+ or"comment"(may also be null).
+ state- The mode's state at the end of this token. +
preciseis true, the token will be guaranteed to be accurate based on recent edits. If false or + not specified, the token will use cached state information, which will be faster but might not be accurate if + edits were recently made and highlighting has not yet completed. +
+
+ cm.getLineTokens(line: integer, ?precise: boolean) → array<{start, end, string, type, state}>
+ - This is similar
+ to
getTokenAt, but + collects all tokens for a given line into an array. It is much + cheaper than repeatedly callinggetTokenAt, which + re-parses the part of the line before the token for every call.
+
+ cm.getTokenTypeAt(pos: {line, ch}) → string
+ - This is a (much) cheaper version
+ of
getTokenAtuseful for + when you just need the type of the token at a given position, + and no other information. Will returnnullfor + unstyled tokens, and a string, potentially containing multiple + space-separated style names, otherwise.
+
+ cm.getHelpers(pos: {line, ch}, type: string) → array<helper>
+ - Fetch the set of applicable helper values for the given
+ position. Helpers provide a way to look up functionality
+ appropriate for a mode. The
typeargument provides + the helper namespace (see +registerHelper), in + which the values will be looked up. When the mode itself has a + property that corresponds to thetype, that + directly determines the keys that are used to look up the helper + values (it may be either a single string, or an array of + strings). Failing that, the mode'shelperType+ property and finally the mode's name are used.
+ - For example, the JavaScript mode has a
+ property
foldcontaining"brace". When + thebrace-foldaddon is loaded, that defines a + helper namedbracein thefold+ namespace. This is then used by + thefoldcodeaddon to + figure out that it can use that folding function to fold + JavaScript code.
+ - When any 'global' + helpers are defined for the given namespace, their predicates + are called on the current mode and editor, and all those that + declare they are applicable will also be added to the array that + is returned. + +
cm.getHelper(pos: {line, ch}, type: string) → helper
+ - Returns the first applicable helper value.
+ See
getHelpers.
+
+ cm.getStateAfter(?line: integer, ?precise: boolean) → object
+ - Returns the mode's parser state, if any, at the end of the
+ given line number. If no line number is given, the state at the
+ end of the document is returned. This can be useful for storing
+ parsing errors in the state, or getting other kinds of
+ contextual information for a line.
preciseis defined + as ingetTokenAt().
+
Miscellaneous methods
+ +-
+
cm.operation(func: () → any) → any
+ - CodeMirror internally buffers changes and only updates its + DOM structure after it has finished performing some operation. + If you need to perform a lot of operations on a CodeMirror + instance, you can call this method with a function argument. It + will call the function, buffering up all changes, and only doing + the expensive update after the function returns. This can be a + lot faster. The return value from this method will be the return + value of your function. + +
cm.indentLine(line: integer, ?dir: string|integer)
+ - Adjust the indentation of the given line. The second
+ argument (which defaults to
"smart") may be one of: +-
+
"prev"
+ - Base indentation on the indentation of the previous line. +
"smart"
+ - Use the mode's smart indentation if available, behave
+ like
"prev"otherwise.
+ "add"
+ - Increase the indentation of the line by + one indent unit. +
"subtract"
+ - Reduce the indentation of the line. +
<integer>
+ - Add (positive number) or reduce (negative number) the + indentation by the given amount of spaces. +
+
+ cm.toggleOverwrite(?value: bool)
+ - Switches between overwrite and normal insert mode (when not + given an argument), or sets the overwrite mode to a specific + state (when given an argument). + +
doc.lineSeparator()
+ - Returns the preferred line separator string for this
+ document, as per the option
+ by the same name. When that option is
null, the + string"\n"is returned.
+
+ cm.execCommand(name: string)
+ - Runs the command with the given name on the editor. + +
doc.posFromIndex(index: integer) → {line, ch}
+ - Calculates and returns a
{line, ch}object for a + zero-basedindexwho's value is relative to the start of the + editor's text. If theindexis out of range of the text then + the returned object is clipped to start or end of the text + respectively.
+ doc.indexFromPos(object: {line, ch}) → integer
+ - The reverse of
posFromIndex.
+
+ cm.focus()
+ - Give the editor focus. + +
cm.getInputField() → Element
+ - Returns the input field for the editor. Will be a textarea
+ or an editable div, depending on the value of
+ the
inputStyle+ option.
+ cm.getWrapperElement() → Element
+ - Returns the DOM node that represents the editor, and + controls its size. Remove this from your tree to delete an + editor instance. +
cm.getScrollerElement() → Element
+ - Returns the DOM node that is responsible for the scrolling + of the editor. +
cm.getGutterElement() → Element
+ - Fetches the DOM node that contains the editor gutters. +
Static properties
+The CodeMirror object itself provides
+ several useful properties.
-
+
CodeMirror.version: string
+ - It contains a string that indicates the version of the
+ library. This is a triple of
+ integers
"major.minor.patch", + wherepatchis zero for releases, and something + else (usually one) for dev snapshots.
+
+ CodeMirror.fromTextArea(textArea: TextAreaElement, ?config: object)
+ -
+ The method provides another way to initialize an editor. It
+ takes a textarea DOM node as first argument and an optional
+ configuration object as second. It will replace the textarea
+ with a CodeMirror instance, and wire up the form of that
+ textarea (if any) to make sure the editor contents are put
+ into the textarea when the form is submitted. The text in the
+ textarea will provide the content for the editor. A CodeMirror
+ instance created this way has three additional methods:
+
-
+
cm.save()
+ - Copy the content of the editor into the textarea. + +
cm.toTextArea()
+ - Remove the editor, and restore the original textarea (with + the editor's current content). + +
cm.getTextArea() → TextAreaElement
+ - Returns the textarea that the instance was based on. +
+
+ CodeMirror.defaults: object
+ - An object containing default values for + all options. You can assign to its + properties to modify defaults (though this won't affect editors + that have already been created). + +
CodeMirror.defineExtension(name: string, value: any)
+ - If you want to define extra methods in terms of the
+ CodeMirror API, it is possible to
+ use
defineExtension. This will cause the given + value (usually a method) to be added to all CodeMirror instances + created from then on.
+
+ CodeMirror.defineDocExtension(name: string, value: any)
+ - Like
defineExtension, + but the method will be added to the interface + forDocobjects instead.
+
+ CodeMirror.defineOption(name: string, + default: any, updateFunc: function)
+ - Similarly,
defineOptioncan be used to define new options for + CodeMirror. TheupdateFuncwill be called with the + editor instance and the new value when an editor is initialized, + and whenever the option is modified + throughsetOption.
+
+ CodeMirror.defineInitHook(func: function)
+ - If your extention just needs to run some
+ code whenever a CodeMirror instance is initialized,
+ use
CodeMirror.defineInitHook. Give it a function as + its only argument, and from then on, that function will be called + (with the instance as argument) whenever a new CodeMirror instance + is initialized.
+
+ CodeMirror.registerHelper(type: string, name: string, value: helper)
+ - Registers a helper value with the given
namein + the given namespace (type). This is used to define + functionality that may be looked up by mode. Will create (if it + doesn't already exist) a property on theCodeMirror+ object for the giventype, pointing to an object + that maps names to values. I.e. after + doingCodeMirror.registerHelper("hint", "foo", + myFoo), the valueCodeMirror.hint.foowill + point tomyFoo.
+
+ CodeMirror.registerGlobalHelper(type: string, name: string, predicate: fn(mode, CodeMirror), value: helper)
+ - Acts
+ like
registerHelper, + but also registers this helper as 'global', meaning that it will + be included bygetHelpers+ whenever the givenpredicatereturns true when + called with the local mode and editor.
+
+ CodeMirror.Pos(line: integer, ?ch: integer)
+ - A constructor for the
{line, ch}objects that + are used to represent positions in editor documents.
+
+ CodeMirror.changeEnd(change: object) → {line, ch}
+ - Utility function that computes an end position from a change
+ (an object with
from,to, + andtextproperties, as passed to + various event handlers). The + returned position will be the end of the changed + range, after the change is applied.
+
Addons
+ +The addon directory in the distribution contains a
+ number of reusable components that implement extra editor
+ functionality (on top of extension functions
+ like defineOption, defineExtension,
+ and registerHelper). In
+ brief, they are:
-
+
dialog/dialog.js
+ - Provides a very simple way to query users for text input.
+ Adds the
openDialog(template, callback, options) → + closeFunctionmethod to CodeMirror instances, + which can be called with an HTML fragment or a detached DOM + node that provides the prompt (should include aninput+ orbuttontag), and a callback function that is called + when the user presses enter. It returns a functioncloseFunction+ which, if called, will close the dialog immediately. +openDialogtakes the following options: +-
+
closeOnEnter:
+ - If true, the dialog will be closed when the user presses
+ enter in the input. Defaults to
true.
+ onKeyDown:
+ - An event handler of the signature
(event, value, closeFunction)+ that will be called wheneverkeydownfires in the + dialog's input. If your callback returnstrue, + the dialog will not do any further processing of the event.
+ onKeyUp:
+ - Same as
onKeyDownbut for the +keyupevent.
+ onInput:
+ - Same as
onKeyDownbut for the +inputevent.
+ onClose:
+ - A callback of the signature
(dialogInstance)+ that will be called after the dialog has been closed and + removed from the DOM. No return value.
+
Also adds an
+ +openNotification(template, options) → + closeFunctionfunction that simply shows an HTML + fragment as a notification at the top of the editor. It takes a + single option:duration, the amount of time after + which the notification will be automatically closed. If+ durationis zero, the dialog will not be closed automatically.Depends on
addon/dialog/dialog.css.
+
+ search/searchcursor.js
+ - Adds the
getSearchCursor(query, start, caseFold) → + cursormethod to CodeMirror instances, which can be used + to implement search/replace functionality.query+ can be a regular expression or a string (only strings will match + across lines—if they contain newlines).start+ provides the starting position of the search. It can be + a{line, ch}object, or can be left off to default + to the start of the document.caseFoldis only + relevant when matching a string. It will cause the search to be + case-insensitive. A search cursor has the following methods: +-
+
findNext() → boolean
+ findPrevious() → boolean
+ - Search forward or backward from the current position.
+ The return value indicates whether a match was found. If
+ matching a regular expression, the return value will be the
+ array returned by the
matchmethod, in case you + want to extract matched groups.
+ from() → {line, ch}
+ to() → {line, ch}
+ - These are only valid when the last call
+ to
findNextorfindPreviousdid + not return false. They will return{line, ch}+ objects pointing at the start and end of the match.
+ replace(text: string, ?origin: string)
+ - Replaces the currently found match with the given text + and adjusts the cursor position to reflect the + replacement. +
+
+ search/search.js
+ - Implements the search commands. CodeMirror has keys bound to
+ these by default, but will not do anything with them unless an
+ implementation is provided. Depends
+ on
searchcursor.js, and will make use + ofopenDialogwhen + available to make prompting for search queries less ugly.
+
+ search/matchesonscrollbar.js
+ - Adds a
showMatchesOnScrollbarmethod to editor + instances, which should be given a query (string or regular + expression), optionally a case-fold flag (only applicable for + strings), and optionally a class name (defaults + toCodeMirror-search-match) as arguments. When + called, matches of the given query will be displayed on the + editor's vertical scrollbar. The method returns an object with + aclearmethod that can be called to remove the + matches. Depends on + theannotatescrollbar+ addon, and + thematchesonscrollbar.css+ file provides a default (transparent yellowish) definition of + the CSS class applied to the matches. Note that the matches are + only perfectly aligned if your scrollbar does not have buttons + at the top and bottom. You can use + thesimplescrollbar+ addon to make sure of this. If this addon is loaded, + thesearchaddon will + automatically use it.
+
+ edit/matchbrackets.js
+ - Defines an option
matchBracketswhich, when set + to true, causes matching brackets to be highlighted whenever the + cursor is next to them. It also adds a + methodmatchBracketsthat forces this to happen + once, and a methodfindMatchingBracketthat can be + used to run the bracket-finding algorithm that this uses + internally.
+
+ edit/closebrackets.js
+ - Defines an option
autoCloseBracketsthat will + auto-close brackets and quotes when typed. By default, it'll + auto-close()[]{}''"", but you can pass it a string + similar to that (containing pairs of matching characters), or an + object withpairsand + optionallyexplodeproperties to customize + it.explodeshould be a similar string that gives + the pairs of characters that, when enter is pressed between + them, should have the second character also moved to its own + line. Demo here.
+
+
+ - Defines an option
matchTagsthat, when enabled, + will cause the tags around the cursor to be highlighted (using + theCodeMirror-matchingtagclass). Also + defines + a commandtoMatchingTag, + which you can bind a key to in order to jump to the tag mathing + the one under the cursor. Depends on + theaddon/fold/xml-fold.js+ addon. Demo here.
+
+ edit/trailingspace.js
+ - Adds an option
showTrailingSpacewhich, when + enabled, adds the CSS classcm-trailingspaceto + stretches of whitespace at the end of lines. + The demo has a nice + squiggly underline style for this class.
+
+ edit/closetag.js
+ - Defines an
autoCloseTagsoption that will + auto-close XML tags when '>' or '/' + is typed, and + acloseTagcommand that + closes the nearest open tag. Depends on + thefold/xml-fold.jsaddon. See + the demo.
+
+ edit/continuelist.js
+ - Markdown specific. Defines
+ a
"newlineAndIndentContinueMarkdownList"command + command that can be bound toenterto automatically + insert the leading characters for continuing a list. See + the Markdown mode + demo.
+
+ comment/comment.js
+ - Addon for commenting and uncommenting code. Adds three
+ methods to CodeMirror instances:
+
-
+
lineComment(from: {line, ch}, to: {line, ch}, ?options: object)
+ - Set the lines in the given range to be line comments. Will
+ fall back to
blockCommentwhen no line comment + style is defined for the mode.
+ blockComment(from: {line, ch}, to: {line, ch}, ?options: object)
+ - Wrap the code in the given range in a block comment. Will
+ fall back to
lineCommentwhen no block comment + style is defined for the mode.
+ uncomment(from: {line, ch}, to: {line, ch}, ?options: object) → boolean
+ - Try to uncomment the given range.
+ Returns
trueif a comment range was found and + removed,falseotherwise.
+
optionsobject accepted by these methods may + have the following properties: +-
+
blockCommentStart, blockCommentEnd, blockCommentLead, lineComment: string
+ - Override the comment string + properties of the mode with custom comment strings. +
padding: string
+ - A string that will be inserted after opening and leading + markers, and before closing comment markers. Defaults to a + single space. +
commentBlankLines: boolean
+ - Whether, when adding line comments, to also comment lines + that contain only whitespace. +
indent: boolean
+ - When adding line comments and this is turned on, it will + align the comment block to the current indentation of the + first line of the block. +
fullLines: boolean
+ - When block commenting, this controls whether the whole
+ lines are indented, or only the precise range that is given.
+ Defaults to
true.
+
toggleCommentcommand, + which will try to uncomment the current selection, and if that + fails, line-comments it.
+
+ fold/foldcode.js
+ - Helps with code folding. Adds a
foldCodemethod + to editor instances, which will try to do a code fold starting + at the given line, or unfold the fold that is already present. + The method takes as first argument the position that should be + folded (may be a line number or + aPos), and as second optional + argument either a range-finder function, or an options object, + supporting the following properties: +-
+
rangeFinder: fn(CodeMirror, Pos)
+ - The function that is used to find
+ foldable ranges. If this is not directly passed, it will
+ default to
CodeMirror.fold.auto, which + usesgetHelperswith + a"fold"type to find folding functions + appropriate for the local mode. There are files in + theaddon/fold/+ directory providingCodeMirror.fold.brace, which + finds blocks in brace languages (JavaScript, C, Java, + etc),CodeMirror.fold.indent, for languages where + indentation determines block structure (Python, Haskell), + andCodeMirror.fold.xml, for XML-style languages, + andCodeMirror.fold.comment, for folding comment + blocks.
+ widget: string|Element
+ - The widget to show for folded ranges. Can be either a
+ string, in which case it'll become a span with
+ class
CodeMirror-foldmarker, or a DOM node.
+ scanUp: boolean
+ - When true (default is false), the addon will try to find + foldable ranges on the lines above the current one if there + isn't an eligible one on the given line. +
minFoldSize: integer
+ - The minimum amount of lines that a fold should span to be + accepted. Defaults to 0, which also allows single-line + folds. +
+
+ fold/foldgutter.js
+ - Provides an option
foldGutter, which can be + used to create a gutter with markers indicating the blocks that + can be folded. Create a gutter using + theguttersoption, + giving it the classCodeMirror-foldgutteror + something else if you configure the addon to use a different + class, and this addon will show markers next to folded and + foldable blocks, and handle clicks in this gutter. Note that + CSS styles should be applied to make the gutter, and the fold + markers within it, visible. A default set of CSS styles are + available in: + +addon/fold/foldgutter.css+ . + The option + can be either set totrue, or an object containing + the following optional option fields: +-
+
gutter: string
+ - The CSS class of the gutter. Defaults
+ to
"CodeMirror-foldgutter". You will have to + style this yourself to give it a width (and possibly a + background). See the default gutter style rules above.
+ indicatorOpen: string | Element
+ - A CSS class or DOM element to be used as the marker for
+ open, foldable blocks. Defaults
+ to
"CodeMirror-foldgutter-open".
+ indicatorFolded: string | Element
+ - A CSS class or DOM element to be used as the marker for
+ folded blocks. Defaults to
"CodeMirror-foldgutter-folded".
+ rangeFinder: fn(CodeMirror, Pos)
+ - The range-finder function to use when determining whether
+ something can be folded. When not
+ given,
CodeMirror.fold.auto+ will be used as default.
+
foldOptionseditor option can be set to an + object to provide an editor-wide default configuration. + Demo here.
+
+ runmode/runmode.js
+ - Can be used to run a CodeMirror mode over text without
+ actually opening an editor instance.
+ See the demo for an example.
+ There are alternate versions of the file avaible for
+ running stand-alone
+ (without including all of CodeMirror) and
+ for running under
+ node.js (see
bin/source-highlightfor an example of using the latter).
+
+ runmode/colorize.js
+ - Provides a convenient way to syntax-highlight code snippets
+ in a webpage. Depends on
+ the
runmodeaddon (or + its standalone variant). Provides + aCodeMirror.colorizefunction that can be called + with an array (or other array-ish collection) of DOM nodes that + represent the code snippets. By default, it'll get + allpretags. Will read thedata-lang+ attribute of these nodes to figure out their language, and + syntax-color their content using the relevant CodeMirror mode + (you'll have to load the scripts for the relevant modes + yourself). A second argument may be provided to give a default + mode, used when no language attribute is found for a node. Used + in this manual to highlight example code.
+
+ mode/overlay.js
+ - Mode combinator that can be used to extend a mode with an
+ 'overlay' — a secondary mode is run over the stream, along with
+ the base mode, and can color specific pieces of text without
+ interfering with the base mode.
+ Defines
CodeMirror.overlayMode, which is used to + create such a mode. See this + demo for a detailed example.
+
+ mode/multiplex.js
+ - Mode combinator that can be used to easily 'multiplex'
+ between several modes.
+ Defines
CodeMirror.multiplexingModewhich, when + given as first argument a mode object, and as other arguments + any number of{open, close, mode [, delimStyle, innerStyle, parseDelimiters]}+ objects, will return a mode object that starts parsing using the + mode passed as first argument, but will switch to another mode + as soon as it encounters a string that occurs in one of + theopenfields of the passed objects. When in a + sub-mode, it will go back to the top mode again when + theclosestring is encountered. + Pass"\n"foropenorclose+ if you want to switch on a blank line. +- When
delimStyleis specified, it will be the token + style returned for the delimiter tokens.
+ - When
innerStyleis specified, it will be the token + style added for each inner mode token.
+ - When
parseDelimitersis true, the content of + the delimiters will also be passed to the inner mode. + (AnddelimStyleis ignored.)
+
+ - When
hint/show-hint.js
+ - Provides a framework for showing autocompletion hints.
+ Defines
editor.showHint, which takes an optional + options object, and pops up a widget that allows the user to + select a completion. Finding hints is done with a hinting + functions (thehintoption), which is a function + that take an editor instance and options object, and return + a{list, from, to}object, wherelist+ is an array of strings or objects (the completions), + andfromandtogive the start and end + of the token that is being completed as{line, ch}+ objects. An optionalselectedHintproperty (an + integer) can be added to the completion object to control the + initially selected hint.
+ - If no hinting function is given, the addon will
+ use
CodeMirror.hint.auto, which + callsgetHelperswith + the"hint"type to find applicable hinting + functions, and tries them one by one. If that fails, it looks + for a"hintWords"helper to fetch a list of + completable words for the mode, and + usesCodeMirror.hint.fromListto complete from + those.
+ - When completions aren't simple strings, they should be
+ objects with the following properties:
+
-
+
text: string
+ - The completion text. This is the only required + property. +
displayText: string
+ - The text that should be displayed in the menu. +
className: string
+ - A CSS class name to apply to the completion's line in the + menu. +
render: fn(Element, self, data)
+ - A method used to create the DOM structure for showing the + completion by appending it to its first argument. +
hint: fn(CodeMirror, self, data)
+ - A method used to actually apply the completion, instead of + the default behavior. +
from: {line, ch}
+ - Optional
fromposition that will be used bypick()instead + of the global one passed with the full list of completions.
+ to: {line, ch}
+ - Optional
toposition that will be used bypick()instead + of the global one passed with the full list of completions.
+
-
+
hint: function
+ - A hinting function, as specified above. It is possible to
+ set the
asyncproperty on a hinting function to + true, in which case it will be called with + arguments(cm, callback, ?options), and the + completion interface will only be popped up when the hinting + function calls the callback, passing it the object holding the + completions.
+ completeSingle: boolean
+ - Determines whether, when only a single completion is + available, it is completed without showing the dialog. + Defaults to true. +
alignWithWord: boolean
+ - Whether the pop-up should be horizontally aligned with the + start of the word (true, default), or with the cursor (false). +
closeOnUnfocus: boolean
+ - When enabled (which is the default), the pop-up will close + when the editor is unfocused. +
customKeys: keymap
+ - Allows you to provide a custom key map of keys to be active
+ when the pop-up is active. The handlers will be called with an
+ extra argument, a handle to the completion menu, which
+ has
moveFocus(n),setFocus(n),pick(), + andclose()methods (see the source for details), + that can be used to change the focused element, pick the + current element or close the menu. AdditionnalymenuSize()+ can give you access to the size of the current dropdown menu, +lengthgive you the number of availlable completions, and +datagive you full access to the completion returned by the + hinting function.
+ extraKeys: keymap
+ - Like
customKeysabove, but the bindings will + be added to the set of default bindings, instead of replacing + them.
+
-
+
"shown" ()
+ - Fired when the pop-up is shown. +
"select" (completion, Element)
+ - Fired when a completion is selected. Passed the completion + value (string or object) and the DOM node that represents it + in the menu. +
"pick" (completion)
+ - Fired when a completion is picked. Passed the completion value + (string or object). +
"close" ()
+ - Fired when the completion is finished. +
addon/hint/show-hint.css. Check + out the demo for an + example.
+
+ hint/javascript-hint.js
+ - Defines a simple hinting function for JavaScript
+ (
CodeMirror.hint.javascript) and CoffeeScript + (CodeMirror.hint.coffeescript) code. This will + simply use the JavaScript environment that the editor runs in as + a source of information about objects and their properties.
+
+ hint/xml-hint.js
+ - Defines
CodeMirror.hint.xml, which produces + hints for XML tagnames, attribute names, and attribute values, + guided by aschemaInfooption (a property of the + second argument passed to the hinting function, or the third + argument passed toCodeMirror.showHint).
The + schema info should be an object mapping tag names to information + about these tags, with optionally a"!top"property + containing a list of the names of valid top-level tags. The + values of the properties should be objects with optional + propertieschildren(an array of valid child + element names, omit to simply allow all tags to appear) + andattrs(an object mapping attribute names + tonullfor free-form attributes, and an array of + valid values for restricted + attributes). Demo + here.
+
+ hint/html-hint.js
+ - Provides schema info to
+ the xml-hint addon for HTML
+ documents. Defines a schema
+ object
CodeMirror.htmlSchemathat you can pass to + as aschemaInfooption, and + aCodeMirror.hint.htmlhinting function that + automatically callsCodeMirror.hint.xmlwith this + schema data. See + the demo.
+
+ hint/css-hint.js
+ - A hinting function for CSS, SCSS, or LESS code.
+ Defines
CodeMirror.hint.css.
+
+ hint/anyword-hint.js
+ - A very simple hinting function
+ (
CodeMirror.hint.anyword) that simply looks for + words in the nearby code and completes to those. Takes two + optional options,word, a regular expression that + matches words (sequences of one or more character), + andrange, which defines how many lines the addon + should scan when completing (defaults to 500).
+
+ hint/sql-hint.js
+ - A simple SQL hinter. Defines
CodeMirror.hint.sql. + Takes two optional options,tables, a object with + table names as keys and array of respective column names as values, + anddefaultTable, a string corresponding to a + table name intablesfor autocompletion.
+
+ search/match-highlighter.js
+ - Adds a
highlightSelectionMatchesoption that + can be enabled to highlight all instances of a currently + selected word. Can be set either to true or to an object + containing the following options:minChars, for the + minimum amount of selected characters that triggers a highlight + (default 2),style, for the style to be used to + highlight the matches (default"matchhighlight", + which will correspond to CSS + classcm-matchhighlight), + andshowTokenwhich can be set totrue+ or to a regexp matching the characters that make up a word. When + enabled, it causes the current word to be highlighted when + nothing is selected (defaults to off). + Demo here.
+
+ lint/lint.js
+ - Defines an interface component for showing linting warnings,
+ with pluggable warning sources
+ (see
html-lint.js, +json-lint.js, +javascript-lint.js, +coffeescript-lint.js, + andcss-lint.js+ in the same directory). Defines alintoption that + can be set to an annotation source (for + exampleCodeMirror.lint.javascript), to an options + object (in which case thegetAnnotationsfield is + used as annotation source), or simply totrue. When + no annotation source is + specified,getHelperwith + type"lint"is used to find an annotation function. + An annotation source function should, when given a document + string, an options object, and an editor instance, return an + array of{message, severity, from, to}objects + representing problems. When the function has + anasyncproperty with a truthy value, it will be + called with an additional second argument, which is a callback + to pass the array to. By default, the linter will run + (debounced) whenever the document is changed. You can pass + alintOnChange: falseoption to disable that. + Depends onaddon/lint/lint.css. A demo can be + found here.
+
+ selection/mark-selection.js
+ - Causes the selected text to be marked with the CSS class
+
CodeMirror-selectedtextwhen thestyleSelectedTextoption + is enabled. Useful to change the colour of the selection (in addition to the background), + like in this demo.
+
+ selection/active-line.js
+ - Defines a
styleActiveLineoption that, when enabled, + gives the wrapper of the active line the classCodeMirror-activeline, + and adds a background with the classCodeMirror-activeline-background. + is enabled. See the demo.
+
+ selection/selection-pointer.js
+ - Defines a
selectionPointeroption which you can + use to control the mouse cursor appearance when hovering over + the selection. It can be set to a string, + like"pointer", or to true, in which case + the"default"(arrow) cursor will be used. You can + see a demo here.
+
+ mode/loadmode.js
+ - Defines a
CodeMirror.requireMode(modename, + callback)function that will try to load a given mode and + call the callback when it succeeded. You'll have to + setCodeMirror.modeURLto a string that mode paths + can be constructed from, for + example"mode/%N/%N.js"—the%N's will + be replaced with the mode name. Also + definesCodeMirror.autoLoadMode(instance, mode), + which will ensure the given mode is loaded and cause the given + editor instance to refresh its mode when the loading + succeeded. See the demo.
+
+ mode/meta.js
+ - Provides meta-information about all the modes in the
+ distribution in a single file.
+ Defines
CodeMirror.modeInfo, an array of objects + with{name, mime, mode}properties, + wherenameis the human-readable + name,mimethe MIME type, andmodethe + name of the mode file that defines this MIME. There are optional + propertiesmimes, which holds an array of MIME + types for modes with multiple MIMEs associated, + andext, which holds an array of file extensions + associated with this mode. Four convenience + functions,CodeMirror.findModeByMIME, +CodeMirror.findModeByExtension, +CodeMirror.findModeByFileName+ andCodeMirror.findModeByNameare provided, which + return such an object given a MIME, extension, file name or mode name + string. Note that, for historical reasons, this file resides in the + top-levelmodedirectory, not + underaddon. Demo.
+
+ comment/continuecomment.js
+ - Adds a
continueCommentsoption, which sets whether the + editor will make the next line continue a comment when you press Enter + inside a comment block. Can be set to a boolean to enable/disable this + functionality. Set to a string, it will continue comments using a custom + shortcut. Set to an object, it will use thekeyproperty for + a custom shortcut and the booleancontinueLineComment+ property to determine whether single-line comments should be continued + (defaulting totrue).
+
+ display/placeholder.js
+ - Adds a
placeholderoption that can be used to + make content appear in the editor when it is empty and not + focused. It can hold either a string or a DOM node. Also gives + the editor aCodeMirror-emptyCSS class whenever it + doesn't contain any text. + See the demo.
+
+ display/fullscreen.js
+ - Defines an option
fullScreenthat, when set + totrue, will make the editor full-screen (as in, + taking up the whole browser window). Depends + onfullscreen.css. Demo + here.
+
+ display/autorefresh.js
+ - This addon can be useful when initalizing an editor in a
+ hidden DOM node, in cases where it is difficult to
+ call
refreshwhen the editor + becomes visible. It defines an optionautoRefresh+ which you can set to true to ensure that, if the editor wasn't + visible on initialization, it will be refreshed the first time + it becomes visible. This is done by polling every 250 + milliseconds (you can pass a value like{delay: + 500}as the option value to configure this). Note that + this addon will only refresh the editor once when it + first becomes visible, and won't take care of further restyling + and resizing.
+
+ scroll/simplescrollbars.js
+ - Defines two additional scrollbar
+ models,
"simple"and"overlay"+ (see demo) that can + be selected with + thescrollbarStyle+ option. Depends + onsimplescrollbars.css, + which can be further overridden to style your own + scrollbars.
+
+ scroll/annotatescrollbar.js
+ - Provides functionality for showing markers on the scrollbar
+ to call out certain parts of the document. Adds a
+ method
annotateScrollbarto editor instances that + can be called, with a CSS class name as argument, to create a + set of annotations. The method returns an object + whoseupdatemethod can be called with an array + of{from: Pos, to: Pos}objects marking the ranges + to be higlighed. To detach the annotations, call the + object'sclearmethod.
+
+ display/rulers.js
+ - Adds a
rulersoption, which can be used to show + one or more vertical rulers in the editor. The option, if + defined, should be given an array of{column [, className, + color, lineStyle, width]}objects or numbers (wich + indicate a column). The ruler will be displayed at the column + indicated by the number or thecolumnproperty. + TheclassNameproperty can be used to assign a + custom style to a ruler. Demo + here.
+
+ display/panel.js
+ - Defines an
addPanelmethod for CodeMirror + instances, which places a DOM node above or below an editor, and + shrinks the editor to make room for the node. The method takes + as first argument as DOM node, and as second an optional options + object. ThePanelobject returned by this method + has aclearmethod that is used to remove the + panel, and achangedmethod that can be used to + notify the addon when the size of the panel's DOM node has + changed.
+ The method accepts the following options: +-
+
position : string
+ - Controls the position of the newly added panel. The
+ following values are recognized:
+
-
+
top (default)
+ - Adds the panel at the very top. +
after-top
+ - Adds the panel at the bottom of the top panels. +
bottom
+ - Adds the panel at the very bottom. +
before-bottom
+ - Adds the panel at the top of the bottom panels. +
+ before : Panel
+ - The new panel will be added before the given panel. +
after : Panel
+ - The new panel will be added after the given panel. +
replace : Panel
+ - The new panel will replace the given panel. +
after,beforeorreplaceoptions, + if the panel doesn't exists or has been removed, + the value of thepositionoption will be used as a fallback. +
+ A demo of the addon is available here. +
+
+ wrap/hardwrap.js
+ - Addon to perform hard line wrapping/breaking for paragraphs
+ of text. Adds these methods to editor instances:
+
-
+
wrapParagraph(?pos: {line, ch}, ?options: object)
+ - Wraps the paragraph at the given position.
+ If
posis not given, it defaults to the cursor + position.
+ wrapRange(from: {line, ch}, to: {line, ch}, ?options: object)
+ - Wraps the given range as one big paragraph. +
wrapParagraphsInRange(from: {line, ch}, to: {line, ch}, ?options: object)
+ - Wrapps the paragraphs in (and overlapping with) the + given range individually. +
-
+
paragraphStart, paragraphEnd: RegExp
+ - Blank lines are always considered paragraph boundaries. + These options can be used to specify a pattern that causes + lines to be considered the start or end of a paragraph. +
column: number
+ - The column to wrap at. Defaults to 80. +
wrapOn: RegExp
+ - A regular expression that matches only those + two-character strings that allow wrapping. By default, the + addon wraps on whitespace and after dash characters. +
killTrailingSpace: boolean
+ - Whether trailing space caused by wrapping should be + preserved, or deleted. Defaults to true. +
+
+ merge/merge.js
+ - Implements an interface for merging changes, using either a
+ 2-way or a 3-way view. The
CodeMirror.MergeView+ constructor takes arguments similar to + theCodeMirror+ constructor, first a node to append the interface to, and then + an options object. Options are passed through to the editors + inside the view. These extra options are recognized: +-
+
origLeftandorigRight: string
+ - If given these provide original versions of the + document, which will be shown to the left and right of the + editor in non-editable CodeMirror instances. The merge + interface will highlight changes between the editable + document and the original(s). To create a 2-way (as opposed + to 3-way) merge view, provide only one of them. +
revertButtons: boolean
+ - Determines whether buttons that allow the user to revert + changes are shown. Defaults to true. +
connect: string
+ - Sets the style used to connect changed chunks of code.
+ By default, connectors are drawn. When this is set
+ to
"align", the smaller chunk is padded to + align with the bigger chunk instead.
+ collapseIdentical: boolean|number
+ - When true (default is false), stretches of unchanged + text will be collapsed. When a number is given, this + indicates the amount of lines to leave visible around such + stretches (which defaults to 2). +
allowEditingOriginals: boolean
+ - Determines whether the original editor allows editing. + Defaults to false. +
showDifferences: boolean
+ - When true (the default), changed pieces of text are + highlighted. +
"goNextDiff"+ and"goPrevDiff"to quickly jump to the next + changed chunk. Demo + here.
+
+ tern/tern.js
+ - Provides integration with + the Tern JavaScript analysis + engine, for completion, definition finding, and minor + refactoring help. See the demo + for a very simple integration. For more involved scenarios, see + the comments at the top of + the addon and the + implementation of the + (multi-file) demonstration + on the Tern website. +
Writing CodeMirror Modes
+ +Modes typically consist of a single JavaScript file. This file + defines, in the simplest case, a lexer (tokenizer) for your + language—a function that takes a character stream as input, + advances it past a token, and returns a style for that token. More + advanced modes can also handle indentation for the language.
+ +This section describes the low-level mode interface. Many modes + are written directly against this, since it offers a lot of + control, but for a quick mode definition, you might want to use + the simple mode addon.
+ +The mode script should
+ call CodeMirror.defineMode to
+ register itself with CodeMirror. This function takes two
+ arguments. The first should be the name of the mode, for which you
+ should use a lowercase string, preferably one that is also the
+ name of the files that define the mode (i.e. "xml" is
+ defined in xml.js). The second argument should be a
+ function that, given a CodeMirror configuration object (the thing
+ passed to the CodeMirror function) and an optional
+ mode configuration object (as in
+ the mode option), returns
+ a mode object.
Typically, you should use this second argument
+ to defineMode as your module scope function (modes
+ should not leak anything into the global scope!), i.e. write your
+ whole mode inside this function.
The main responsibility of a mode script is parsing + the content of the editor. Depending on the language and the + amount of functionality desired, this can be done in really easy + or extremely complicated ways. Some parsers can be stateless, + meaning that they look at one element (token) of the code + at a time, with no memory of what came before. Most, however, will + need to remember something. This is done by using a state + object, which is an object that is always passed when + reading a token, and which can be mutated by the tokenizer.
+ +Modes that use a state must define
+ a startState method on their mode
+ object. This is a function of no arguments that produces a state
+ object to be used at the start of a document.
The most important part of a mode object is
+ its token(stream, state) method. All
+ modes must define this method. It should read one token from the
+ stream it is given as an argument, optionally update its state,
+ and return a style string, or null for tokens that do
+ not have to be styled. For your styles, you are encouraged to use
+ the 'standard' names defined in the themes (without
+ the cm- prefix). If that fails, it is also possible
+ to come up with your own and write your own CSS theme file.
+ +
A typical token string would
+ be "variable" or "comment". Multiple
+ styles can be returned (separated by spaces), for
+ example "string error" for a thing that looks like a
+ string but is invalid somehow (say, missing its closing quote).
+ When a style is prefixed by "line-"
+ or "line-background-", the style will be applied to
+ the whole line, analogous to what
+ the addLineClass method
+ does—styling the "text" in the simple case, and
+ the "background" element
+ when "line-background-" is prefixed.
The stream object that's passed
+ to token encapsulates a line of code (tokens may
+ never span lines) and our current position in that line. It has
+ the following API:
-
+
eol() → boolean
+ - Returns true only if the stream is at the end of the + line. +
sol() → boolean
+ - Returns true only if the stream is at the start of the + line. + +
peek() → string
+ - Returns the next character in the stream without advancing
+ it. Will return an
nullat the end of the + line.
+ next() → string
+ - Returns the next character in the stream and advances it.
+ Also returns
nullwhen no more characters are + available.
+
+ eat(match: string|regexp|function(char: string) → boolean) → string
+ matchcan be a character, a regular expression, + or a function that takes a character and returns a boolean. If + the next character in the stream 'matches' the given argument, + it is consumed and returned. Otherwise,undefined+ is returned.
+ eatWhile(match: string|regexp|function(char: string) → boolean) → boolean
+ - Repeatedly calls
eatwith the given argument, + until it fails. Returns true if any characters were eaten.
+ eatSpace() → boolean
+ - Shortcut for
eatWhilewhen matching + white-space.
+ skipToEnd()
+ - Moves the position to the end of the line. +
skipTo(ch: string) → boolean
+ - Skips to the next occurrence of the given character, if + found on the current line (doesn't advance the stream if the + character does not occur on the line). Returns true if the + character was found. +
match(pattern: string, ?consume: boolean, ?caseFold: boolean) → boolean
+ match(pattern: regexp, ?consume: boolean) → array<string>
+ - Act like a
+ multi-character
eat—ifconsumeis true + or not given—or a look-ahead that doesn't update the stream + position—if it is false.patterncan be either a + string or a regular expression starting with^. + When it is a string,caseFoldcan be set to true to + make the match case-insensitive. When successfully matching a + regular expression, the returned value will be the array + returned bymatch, in case you need to extract + matched groups.
+
+ backUp(n: integer)
+ - Backs up the stream
ncharacters. Backing it up + further than the start of the current token will cause things to + break, so be careful.
+ column() → integer
+ - Returns the column (taking into account tabs) at which the + current token starts. +
indentation() → integer
+ - Tells you how far the current line has been indented, in + spaces. Corrects for tab characters. + +
current() → string
+ - Get the string between the start of the current token and + the current stream position. +
By default, blank lines are simply skipped when
+ tokenizing a document. For languages that have significant blank
+ lines, you can define
+ a blankLine(state) method on your
+ mode that will get called whenever a blank line is passed over, so
+ that it can update the parser state.
Because state object are mutated, and CodeMirror
+ needs to keep valid versions of a state around so that it can
+ restart a parse at any line, copies must be made of state objects.
+ The default algorithm used is that a new state object is created,
+ which gets all the properties of the old object. Any properties
+ which hold arrays get a copy of these arrays (since arrays tend to
+ be used as mutable stacks). When this is not correct, for example
+ because a mode mutates non-array properties of its state object, a
+ mode object should define
+ a copyState method, which is given a
+ state and should return a safe copy of that state.
If you want your mode to provide smart indentation
+ (through the indentLine
+ method and the indentAuto
+ and newlineAndIndent commands, to which keys can be
+ bound), you must define
+ an indent(state, textAfter) method
+ on your mode object.
The indentation method should inspect the given state object,
+ and optionally the textAfter string, which contains
+ the text on the line that is being indented, and return an
+ integer, the amount of spaces to indent. It should usually take
+ the indentUnit
+ option into account. An indentation method may
+ return CodeMirror.Pass to indicate that it
+ could not come up with a precise indentation.
To work well with
+ the commenting addon, a mode may
+ define lineComment (string that
+ starts a line
+ comment), blockCommentStart, blockCommentEnd
+ (strings that start and end block comments),
+ and blockCommentLead (a string to put at the start of
+ continued lines in a block comment). All of these are
+ optional.
Finally, a mode may define either
+ an electricChars or an electricInput
+ property, which are used to automatically reindent the line when
+ certain patterns are typed and
+ the electricChars
+ option is enabled. electricChars may be a string, and
+ will trigger a reindent whenever one of the characters in that
+ string are typed. Often, it is more appropriate to
+ use electricInput, which should hold a regular
+ expression, and will trigger indentation when the part of the
+ line before the cursor matches the expression. It should
+ usually end with a $ character, so that it only
+ matches when the indentation-changing pattern was just typed, not when something was
+ typed after the pattern.
So, to summarize, a mode must provide
+ a token method, and it may
+ provide startState, copyState,
+ and indent methods. For an example of a trivial mode,
+ see the diff mode, for a more
+ involved example, see the C-like
+ mode.
Sometimes, it is useful for modes to nest—to have one
+ mode delegate work to another mode. An example of this kind of
+ mode is the mixed-mode HTML
+ mode. To implement such nesting, it is usually necessary to
+ create mode objects and copy states yourself. To create a mode
+ object, there are CodeMirror.getMode(options,
+ parserConfig), where the first argument is a configuration
+ object as passed to the mode constructor function, and the second
+ argument is a mode specification as in
+ the mode option. To copy a
+ state object, call CodeMirror.copyState(mode, state),
+ where mode is the mode that created the given
+ state.
In a nested mode, it is recommended to add an
+ extra method, innerMode which, given
+ a state object, returns a {state, mode} object with
+ the inner mode and its state for the current position. These are
+ used by utility scripts such as the tag
+ closer to get context information. Use
+ the CodeMirror.innerMode helper function to, starting
+ from a mode and a state, recursively walk down to the innermost
+ mode and state.
To make indentation work properly in a nested parser, it is
+ advisable to give the startState method of modes that
+ are intended to be nested an optional argument that provides the
+ base indentation for the block of code. The JavaScript and CSS
+ parser do this, for example, to allow JavaScript and CSS code
+ inside the mixed-mode HTML mode to be properly indented.
It is possible, and encouraged, to associate
+ your mode, or a certain configuration of your mode, with
+ a MIME type. For
+ example, the JavaScript mode associates itself
+ with text/javascript, and its JSON variant
+ with application/json. To do this,
+ call CodeMirror.defineMIME(mime,
+ modeSpec), where modeSpec can be a string or
+ object specifying a mode, as in
+ the mode option.
If a mode specification wants to add some properties to the
+ resulting mode object, typically for use
+ with getHelpers, it may
+ contain a modeProps property, which holds an object.
+ This object's properties will be copied to the actual mode
+ object.
Sometimes, it is useful to add or override mode
+ object properties from external code.
+ The CodeMirror.extendMode function
+ can be used to add properties to mode objects produced for a
+ specific mode. Its first argument is the name of the mode, its
+ second an object that specifies the properties that should be
+ added. This is mostly useful to add utilities that can later be
+ looked up through getMode.
VIM Mode API
+ +CodeMirror has a robust VIM mode that attempts to faithfully
+ emulate VIM's most useful features. It can be enabled by
+ including keymap/vim.js
+ and setting the keymap option to
+ vim.
Configuration
+ +VIM mode accepts configuration options for customizing
+ behavior at run time. These methods can be called at any time
+ and will affect all existing CodeMirror instances unless
+ specified otherwise. The methods are exposed on the
+ CodeMirror.Vim object.
-
+
setOption(name: string, value: any, ?cm: CodeMirror, ?cfg: object)
+ - Sets the value of a VIM option.
nameshould + be the name of an option. Ifcfg.scopeis not set + andcmis provided, then sets the global and + instance values of the option. Otherwise, sets either the + global or instance value of the option depending on whether +cfg.scopeisglobalor +local.
+ getOption(name: string, ?cm: CodeMirror: ?cfg: object)
+ - Gets the current value of a VIM option. If
+
cfg.scopeis not set andcmis + provided, then gets the instance value of the option, falling + back to the global value if not set. Ifcfg.scopeis provided, then gets theglobalor +localvalue without checking the other.
+
+ map(lhs: string, rhs: string, ?context: string)
+ - Maps a key sequence to another key sequence. Implements
+ VIM's
:mapcommand. To map ; to : in VIM would be +:map ; :. That would translate to +CodeMirror.Vim.map(';', ':');. + Thecontextcan benormal, +visual, orinsert, which correspond + to:nmap,:vmap, and +:imap+ respectively.
+
+ mapCommand(keys: string, type: string, name: string, ?args: object, ?extra: object)
+ - Maps a key sequence to a
motion, +operator, oractiontype command. + The args object is passed through to the command when it is + invoked by the provided key sequence. +extras.contextcan benormal, +visual, orinsert, to map the key + sequence only in the corresponding mode. +extras.isEditis applicable only to actions, + determining whether it is recorded for replay for the +.single-repeat command. +
Extending VIM
+ +CodeMirror's VIM mode implements a large subset of VIM's core
+ editing functionality. But since there's always more to be
+ desired, there is a set of APIs for extending VIM's
+ functionality. As with the configuration API, the methods are
+ exposed on CodeMirror.Vim and may
+ be called at any time.
-
+
defineOption(name: string, default: any, type: string, ?aliases: array<string>, ?callback: function (?value: any, ?cm: CodeMirror) → ?any)
+ - Defines a VIM style option and makes it available to the
+
:setcommand. Type can bebooleanor +string, used for validation and by +:setto determine which syntax to accept. If a +callbackis passed in, VIM does not store the value of the + option itself, but instead uses the callback as a setter/getter. If the + first argument to the callback isundefined, then the + callback should return the value of the option. Otherwise, it should set + instead. Since VIM options have global and instance values, whether a +CodeMirrorinstance is passed in denotes whether the global + or local value should be used. Consequently, it's possible for the + callback to be called twice for a singlesetOptionor +getOptioncall. Note that right now, VIM does not support + defining buffer-local options that do not have global values. If an + option should not have a global value, either always ignore the +cmparameter in the callback, or always pass in a +cfg.scopetosetOptionand +getOption.
+
+ defineMotion(name: string, fn: function(cm: CodeMirror, head: {line, ch}, ?motionArgs: object}) → {line, ch})
+ - Defines a motion command for VIM. The motion should return
+ the desired result position of the cursor.
head+ is the current position of the cursor. It can differ from +cm.getCursor('head')if VIM is in visual mode. +motionArgsis the object passed into +mapCommand().
+
+ defineOperator(name: string, fn: function(cm: CodeMirror, ?operatorArgs: object, ranges: array<{anchor, head}>) → ?{line, ch})
+ - Defines an operator command, similar to
+ defineMotion.rangesis the range + of text the operator should operate on. If the cursor should + be set to a certain position after the operation finishes, it + can return a cursor object.
+
+ defineAction(name: string, fn: function(cm: CodeMirror, ?actionArgs: object))
+ - Defines an action command, similar to
+
defineMotion. Action commands + can have arbitrary behavior, making them more flexible than + motions and operators, at the loss of orthogonality.
+
+ defineEx(name: string, ?prefix: string, fn: function(cm: CodeMirror, ?params: object))
+ - Defines an Ex command, and maps it to
:name. + If a prefix is provided, it, and any prefixed substring of the +namebeginning with theprefixcan + be used to invoke the command. If theprefixis + falsy, thennameis used as the prefix.+ params.argStringcontains the part of the prompted + string after the command name.params.argsis +params.argStringsplit by whitespace. If the + command was prefixed with a +line range, +params.lineandparams.lineEndwill + be set. +
CodeMirror real-world uses
+ +Create a pull + request if you'd like your project to be added to this list.
+ +-
+
- Adobe Brackets (code editor) +
- Amber (JavaScript-based Smalltalk system) +
- Apache GUI +
- APEye (tool for testing & documenting APIs) +
- Better Text Viewer (plain text reader app for Chrome) +
- Bitbucket (code hosting) +
- Blogger's template editor +
- BlueGriffon (HTML editor) +
- Boson Editor (code editor) +
- Cargo Collective (creative publishing platform) +
- Chrome DevTools +
- ClickHelp (technical writing tool) +
- CodeWorld (Haskell playground) +
- Complete.ly playground +
- Codeanywhere (multi-platform cloud editor) +
- Code per Node (Drupal module) +
- Codebug (PHP Xdebug front-end) +
- CodeMirror Eclipse (embed CM in Eclipse) +
- CodeMirror movie (scripted editing demos) +
- CodeMirror2-GWT (Google Web Toolkit wrapper) +
- Code Monster & Code Maven (learning environment) +
- Codepen (gallery of animations) +
- Coderpad (interviewing tool) +
- Code School (online tech learning environment) +
- Code Snippets (WordPress snippet management plugin) +
- Code together (collaborative editing) +
- Codev (collaborative IDE) +
- CodeZample (code snippet sharing) +
- Codio (Web IDE) +
- Collaborative CodeMirror demo (CodeMirror + operational transforms) +
- Community Code Camp (code snippet sharing) +
- compilejava.net (online Java sandbox) +
- CKWNC (UML editor) +
- CrossUI (cross-platform UI builder) +
- Cruncher (notepad with calculation features) +
- Crudzilla (self-hosted web IDE) +
- CSSDeck (CSS showcase) +
- Deck.js integration (slides with editors) +
- DbNinja (MySQL access interface) +
- Echoplexus (chat and collaborative coding) +
- eCSSpert (CSS demos and experiments) +
- Elm language examples +
- Eloquent JavaScript (book) +
- Emmet (fast XML editing) +
- Espruino Web IDE (Chrome App for writing code on Espruino devices) +
- Fastfig (online computation/math tool) +
- Farabi (modern Perl IDE) +
- FathomJS integration (slides with editors, again) +
- Phantomus (blogging platform) +
- Fiddle Salad (web development environment) +
- Filemanager +
- Firefox Developer Tools +
- Firepad (collaborative text editor) +
- Gerrit's diff view +
- Git Crx (Chrome App for browsing local git repos) +
- Go language tour +
- GitHub's Android app +
- Google Apps Script +
- Graphit (function graphing) +
- Handcraft (HTML prototyping) +
- Hawkee +
- Haxe (Haxe Playground) +
- HaxPad (editor for Win RT) +
- Histone template engine playground +
- Homegenie (home automation server) +
- ICEcoder (web IDE) +
- IPython (interactive computing shell) +
- i-MOS (modeling and simulation platform) +
- Janvas (vector graphics editor) +
- Joomla plugin +
- jQuery fundamentals (interactive tutorial) +
- jsbin.com (JS playground) +
- JSER preprocessor +
- jscpd (code duplication detector) +
- JSFiddle (another JS playground) +
- JSHint (JS linter) +
- Jumpseller (online store builder) +
- kl1p (paste service) +
- Kodtest (HTML/JS/CSS playground) +
- Kotlin (web-based mini-IDE for Kotlin) +
- Laborate (collaborative coding) +
- Light Table (experimental IDE) +
- Liveweave (HTML/CSS/JS scratchpad) +
- Marklight editor (lightweight markup editor) +
- Mergely (interactive diffing) +
- MIHTool (iOS web-app debugging tool) +
- Mongo MapReduce WebBrowser +
- Montage Studio (web app creator suite) +
- MVC Playground +
- My2ndGeneration (social coding) +
- Navigate CMS +
- nodeMirror (IDE project) +
- NoTex (rST authoring) +
- Oak (online outliner) +
- ORG (z80 assembly IDE) +
- Orion-CodeMirror integration (running CodeMirror modes in Orion) +
- Paper.js (graphics scripting) +
- PrinBit (collaborative coding tool) +
- Prose.io (github content editor) +
- PubliForge (online publishing system) +
- Puzzlescript (puzzle game engine) +
- ql.io (http API query helper) +
- QiYun web app platform +
- Qt+Webkit integration (building a desktop CodeMirror app) +
- Quivive File Manager +
- Rascal (tiny computer) +
- RealTime.io (Internet-of-Things infrastructure) +
- Refork (animation demo gallery and sharing) +
- SageMathCloud (interactive mathematical software environment) +
- ServePHP (PHP code testing in Chrome dev tools) +
- Shadertoy (shader sharing) +
- sketchPatch Livecodelab +
- Skulpt (in-browser Python environment) +
- Snap Tomato (HTML editing/testing page) +
- Snippets.pro (code snippet sharing) +
- SolidShops (hosted e-commerce platform) +
- SourceCoder 3 (online calculator IDE and editor) +
- SQLFiddle (SQL playground) +
- SubTe (AI bot programming environment) +
- Structure and Interpretation of Computer Programs, Interactive Version +
- SyBox (PHP playground) +
- TagSpaces (personal data manager) +
- The File Tree (collab editor) +
- TileMill (map design tool) +
- Tiki (wiki CMS groupware) +
- Toolsverse Data Explorer (database management) +
- Tributary (augmented editing) +
- Tumblr code highlighting shim +
- TurboPY (web publishing framework) +
- UmpleOnline (model-oriented programming tool) +
- Upsource (code viewer) +
- Waliki (wiki engine) +
- Wamer (web application builder) +
- webappfind (windows file bindings for webapps) +
- WebGL academy (learning WebGL) +
- WebGL playground +
- WebKit Web inspector +
- WeScheme (learning tool) +
- Wide (golang web IDE) +
- WordPress plugin +
- writeLaTeX (Collaborative LaTeX Editor) +
- XOSide (online editor) +
- XQuery tester +
- xsd2codemirror (convert XSD to CM XML completion info) +
+
+
+
+
+
+CodeMirror
+
+
+ -
+
- Version 5.x +
- Version 4.x +
- Version 3.x +
- Version 2.x +
- Version 0.x +
Release notes and version history
+ +Version 5.x
+ +20-08-2015: Version 5.7:
+ +-
+
- New modes: Vue, Oz, MscGen (and dialects), Closure Stylesheets +
- Implement CommonMark-style flexible list indent and cross-line code spans in Markdown mode +
- Add a replace-all button to the search addon, and make the persistent search dialog transparent when it obscures the match +
- Handle
acync/awaitand ocal and binary numbers in JavaScript mode
+ - Fix various issues with the Haxe mode +
- Make the closebrackets addon select only the wrapped text when wrapping selection in brackets +
- Tokenize properties as properties in the CoffeeScript mode +
- The placeholder addon now accepts a DOM node as well as a string placeholder +
- Full list of patches +
20-08-2015: Version 5.6:
+ +-
+
- Fix bug where you could paste into a
readOnlyeditor
+ - Show a cursor at the drop location when dragging over the editor +
- The Rust mode was rewritten to handle modern Rust +
- The editor and theme CSS was cleaned up. Some selectors are now less specific than before +
- New theme: abcdef +
- Lines longer than
maxHighlightLengthare now less likely to mess up indentation
+ - New addons:
autorefreshfor refreshing an editor the first time it becomes visible, andhtml-lintfor using HTMLHint
+ - The
searchaddon now recognizes\rand\nin pattern and replacement input
+ - Full list of patches +
20-07-2015: Version 5.5:
+ +-
+
- New option:
lineSeparator(with corresponding method) + - New themes: dracula, seti, yeti, material, and icecoder +
- New modes: Brainfuck, VHDL, Squirrel (clike dialect) +
- Define a
findPersistentcommand in + the search addon, for a dialog + that stays open as you cycle through matches
+ - From this release on, the NPM module doesn't include documentation and demos +
- Full list of patches +
25-06-2015: Version 5.4:
+ +-
+
- New modes: Twig, Elm, Factor, Swift +
- Prefer clipboard API (if available) when pasting +
- Refined definition highlighting in clike mode +
- Full list of patches +
20-05-2015: Version 5.3:
+ +-
+
- Fix several regressions in the
show-hintaddon (completeSingleoption,"shown"and"close"events)
+ - The vim mode API was documented +
- New modes: ASN.1, TTCN, and TTCN-CFG +
- The clike mode can now deep-indent
switchstatements, and roughly recognizes types and defined identifiers
+ - Full list of patches +
20-04-2015: Version 5.2:
+ +-
+
- Fix several race conditions
+ in
show-hint's + asynchronous mode
+ - Fix backspace binding in Sublime bindings +
- Change the way IME is handled in the
"textarea"input style
+
+ - New modes: MUMPS, Handlebars +
- Rewritten modes: Django, Z80 +
- New theme: Liquibyte +
- New option:
lineWiseCopyCut
+ - The Vim mode now supports buffer-local options and the
filetypesetting
+ - Full list of patches +
23-03-2015: Version 5.1:
+ +-
+
- New modes: ASCII armor (PGP data), Troff, and CMake. +
- Remove SmartyMixed mode, rewrite Smarty mode to supersede it. +
- New commands in the merge
+ addon:
goNextDiffandgoPrevDiff.
+ - The closebrackets addon can now be configured per mode. +
- Full list of patches. +
20-02-2015: Version 5.0:
+ +-
+
- Experimental mobile support (tested on iOS, Android Chrome, stock Android browser) +
- New option
inputStyleto switch between hidden textarea and contenteditable input.
+ - The
getInputField+ method is no longer guaranteed to return a textarea.
+ - Full list of patches. +
Version 4.x
+ +20-02-2015: Version 4.13:
+ +-
+
- Fix the way the
closetagdemo handles the slash character.
+ - New modes: Forth, Stylus. +
- Make the CSS mode understand some modern CSS extensions. +
- Have the Scala mode handle symbols and triple-quoted strings. +
- Full list of patches. +
22-01-2015: Version 4.12:
+ +-
+
- The
closetag+ addon now defines a"closeTag"command.
+ - Adds a
findModeByFileNameto the mode metadata + addon.
+ - Simple mode rules can
+ now contain a
solproperty to only match at the start + of a line.
+ - New
+ addon:
selection-pointer+ to style the mouse cursor over the selection.
+ - Improvements to the Sass mode's indentation. +
- The Vim keymap's search functionality now + supports scrollbar + annotation. +
- Full list of patches. +
9-01-2015: Version 4.11:
+ +Unfortunately, 4.10 did not take care of the + Firefox scrolling issue entirely. This release adds two more patches + to address that.
+ +29-12-2014: Version 4.10:
+ +Emergency single-patch update to 4.9. Fixes + Firefox-specific problem where the cursor could end up behind the + horizontal scrollbar.
+ +23-12-2014: Version 4.9:
+ +-
+
- Overhauled scroll bar handling. + Add pluggable scrollbar + implementations. +
- Tweaked behavior for + the completion addons to + not take text after cursor into account. +
- Two new optional features in + the merge addon: aligning + editors, and folding unchanged text. +
- New + modes: Dart, EBNF, spreadsheet, + and Soy. +
- New addon to show persistent panels below/above an editor. +
- New themes: zenburn + and tomorrow night + bright. +
- Allow ctrl-click to clear existing cursors. +
- Full list of patches. +
22-11-2014: Version 4.8:
+ +-
+
- Built-in support for multi-stroke key bindings. +
- New method:
getLineTokens.
+ - New modes: dockerfile, IDL, Objective C (crude). +
- Support styling of gutter backgrounds, allow
"gutter"styles inaddLineClass.
+ - Many improvements to the Vim mode, rewritten visual mode. +
- Improvements to modes: gfm (strikethrough), SPARQL (version 1.1 support), and sTeX (no more runaway math mode). +
- Full list of patches. +
20-10-2014: Version 4.7:
+ +-
+
- Incompatible: + The lint addon now passes the + editor's value as first argument to asynchronous lint functions, + for consistency. The editor is still passed, as fourth + argument. +
- Improved handling of unicode identifiers in modes for + languages that support them. +
- More mode + improvements: CoffeeScript + (indentation), Verilog + (indentation), Scala + (indentation, triple-quoted strings), + and PHP (interpolated + variables in heredoc strings). +
- New modes: Textile and Tornado templates. +
- Experimental new way to define modes. +
- Improvements to the Vim + bindings: Arbitrary insert mode key mappings are now possible, + and text objects are supported in visual mode. +
- The mode meta-information file
+ now includes information about file extensions,
+ and helper
+ functions
findModeByMIME+ andfindModeByExtension.
+ - New logo! +
- Full list of patches. +
19-09-2014: Version 4.6:
+ +-
+
- New mode: Modelica +
- New method:
findWordAt
+ - Make it easier to use text background styling +
- Full list of patches. +
21-08-2014: Version 4.5:
+ +-
+
- Fix several serious bugs with horizontal scrolling +
- New mode: Slim +
- New command:
goLineLeftSmart
+ - More fixes and extensions for the Vim visual block mode +
- Full list of patches. +
21-07-2014: Version 4.4:
+ +-
+
- Note: Some events might now fire in slightly
+ different order (
"change"is still guaranteed to fire + before"cursorActivity")
+ - Nested operations in multiple editors are now synced (complete + at same time, reducing DOM reflows) +
- Visual block mode for vim (<C-v>) is nearly complete +
- New mode: Kotlin +
- Better multi-selection paste for text copied from multiple CodeMirror selections +
- Full list of patches. +
23-06-2014: Version 4.3:
+ +-
+
- Several vim bindings
+ improvements: search and exCommand history, global flag
+ for
:substitute,:globalcommand. + - Allow hiding the cursor by
+ setting
cursorBlinkRate+ to a negative value.
+ - Make gutter markers themeable, use this in foldgutter. +
- Full list of patches. +
19-05-2014: Version 4.2:
+ +-
+
- Fix problem where some modes were broken by the fact that empty tokens were forbidden. +
- Several fixes to context menu handling. +
- On undo, scroll change, not cursor, into view. +
- Rewritten Jade mode. +
- Various improvements to Shell (support for more syntax) and Python (better indentation) modes. +
- New mode: Cypher. +
- New theme: Neo. +
- Support direct styling options (color, line style, width) in the rulers addon. +
- Recognize per-editor configuration for the show-hint and foldcode addons. +
- More intelligent scanning for existing close tags in closetag addon. +
- In the Vim bindings: Fix bracket matching, support case conversion in visual mode, visual paste, append action. +
- Full list of patches. +
22-04-2014: Version 4.1:
+ +-
+
- Slightly incompatible:
+ The
"cursorActivity"+ event now fires after all other events for the operation (and only + for handlers that were actually registered at the time the + activity happened).
+ - New command:
insertSoftTab.
+ - New mode: Django. +
- Improved modes: Verilog (rewritten), Jinja2, Haxe, PHP (string interpolation highlighted), JavaScript (indentation of trailing else, template strings), LiveScript (multi-line strings). +
- Many small issues from the 3.x→4.x transition were found and fixed. +
- Full list of patches. +
20-03-2014: Version 4.0:
+ +This is a new major version of CodeMirror. There + are a few incompatible changes in the API. Upgrade + with care, and read the upgrading + guide.
+ +-
+
- Multiple selections (ctrl-click, alt-drag, API). +
- Sublime Text bindings. +
- Module loader shims wrapped around all modules. +
- Selection undo/redo. +
- Improved character measuring (faster, handles wrapped lines more robustly). +
- Full list of patches. +
Version 3.x
+ +22-04-2014: Version 3.24:
+ +Merges the improvements from 4.1 that could + easily be applied to the 3.x code. Also improves the way the editor + size is updated when line widgets change.
+ +20-03-2014: Version 3.23:
+ +-
+
- In the XML mode,
+ add
bracketsstyle to angle brackets, fix + case-sensitivity of tags for HTML.
+ - New mode: Dylan. +
- Many improvements to the Vim bindings. +
21-02-2014: Version 3.22:
+ +-
+
- Adds the
findMarksmethod.
+ - New addons: rulers, markdown-fold, yaml-lint. +
- New theme: mdn-like. +
- New mode: Solr. +
- Full list of patches. +
16-01-2014: Version 3.21:
+ +-
+
- Auto-indenting a block will no longer add trailing whitespace to blank lines. +
- Marking text has a new option
clearWhenEmptyto control auto-removal.
+ - Several bugfixes in the handling of bidirectional text. +
- The XML and CSS modes were largely rewritten. LESS support was added to the CSS mode. +
- The OCaml mode was moved to an mllike mode, F# support added. +
- Make it possible to fetch multiple applicable helper values with
getHelpers, and to register helpers matched on predicates withregisterGlobalHelper.
+ - New theme pastel-on-dark. +
- Better ECMAScript 6 support in JavaScript mode. +
- Full list of patches. +
21-11-2013: Version 3.20:
+ +-
+
- New modes: Julia and PEG.js. +
- Support ECMAScript 6 in the JavaScript mode. +
- Improved indentation for the CoffeeScript mode. +
- Make non-printable-character representation configurable. +
- Add ‘notification’ functionality to dialog addon. +
- Full list of patches. +
21-10-2013: Version 3.19:
+ +-
+
- New modes: Eiffel, Gherkin, MSSQL dialect. +
- New addons: hardwrap, sql-hint. +
- New theme: MBO. +
- Add support for line-level styling from mode tokenizers. +
- Full list of patches. +
23-09-2013: Version 3.18:
+ +Emergency release to fix a problem in 3.17
+ where .setOption("lineNumbers", false) would raise an
+ error.
23-09-2013: Version 3.17:
+ +-
+
- New modes: Fortran, Octave (Matlab), TOML, and DTD. +
- New addons:
css-lint,css-hint.
+ - Improve resilience to CSS 'frameworks' that globally mess up
box-sizing.
+ - Full list of patches. +
21-08-2013: Version 3.16:
+ +-
+
- The whole codebase is now under a single license file. +
- The project page was overhauled and redesigned. +
- New themes: Paraiso (light), The Matrix. +
- Improved interaction between themes and active-line/matchbrackets addons. +
- New folding function
CodeMirror.fold.comment.
+ - Added fullscreen addon. +
- Full list of patches. +
29-07-2013: Version 3.15:
+ +-
+
- New modes: Jade, Nginx. +
- New addons: Tern, matchtags, and foldgutter. +
- Introduced helper concept (context). +
- New method:
getModeAt.
+ - New themes: base16 dark/light, 3024 dark/light, tomorrow-night. +
- Full list of patches. +
20-06-2013: Version 3.14:
+ +-
+
- New + addons: trailing + space highlight, XML + completion (rewritten), + and diff merging. +
markText+ andaddLineWidget+ now take ahandleMouseEventsoption.
+ - New methods:
lineAtHeight, +getTokenTypeAt.
+ - More precise cleanness-tracking
+ using
changeGeneration+ andisClean.
+ - Many extensions to Emacs mode + (prefixes, more navigation units, and more). +
- New
+ events
"keyHandled"+ and"inputRead".
+ - Various improvements to Ruby, + Smarty, SQL, + and Vim modes. +
- Full list of patches. +
20-05-2013: Version 3.13:
+ +-
+
- New modes: COBOL and HAML. +
- New options:
cursorScrollMarginandcoverGutterNextToScrollbar.
+ - New addon: commenting. +
- More features added to the Vim keymap. +
- Full list of patches. +
19-04-2013: Version 3.12:
+ +-
+
- New mode: GNU assembler. +
- New
+ options:
maxHighlightLength+ andhistoryEventDelay.
+ - Added
addToHistory+ option formarkText.
+ - Various fixes to JavaScript tokenization and indentation corner cases. +
- Further improvements to the vim mode. +
- Full list of patches. +
20-03-2013: Version 3.11:
+ +-
+
- Removed code:
collapserange, +formatting, andsimple-hint+ addons.plsqlandmysqlmodes + (usesqlmode).
+ - Moved code: the range-finding functions for folding now have their own files. +
- Changed interface:
+ the
continuecomment+ addon now exposes an option, rather than a command.
+ - New + modes: SCSS, Tcl, LiveScript, + and mIRC. +
- New addons:
placeholder, HTML completion.
+ - New
+ methods:
hasFocus,defaultCharWidth.
+ - New events:
beforeCursorEnter,renderLine.
+ - Many improvements to the
show-hintcompletion + dialog addon.
+ - Tweak behavior of by-word cursor motion. +
- Further improvements to the vim mode. +
- Full list of patches. +
21-02-2013: Version 3.1:
+ +-
+
- Incompatible: key handlers may
+ now return, rather
+ than throw
CodeMirror.Passto signal they + didn't handle the key.
+ - Make documents a first-class + construct, support split views and subviews. +
- Add a new module
+ for showing completion hints.
+ Deprecate
simple-hint.js.
+ - Extend htmlmixed mode + to allow custom handling of script types. +
- Support an
insertLeftoption + tosetBookmark.
+ - Add an
eachLine+ method to iterate over a document.
+ - New addon modules: selection + marking, linting, + and automatic bracket + closing. +
- Add
"beforeChange"+ and"beforeSelectionChange"+ events.
+ - Add
"hide"+ and"unhide"+ events to marked ranges.
+ - Fix
coordsChar's + interpretation of its argument to match the documentation.
+ - New modes: Turtle + and Q. +
- Further improvements to the vim mode. +
- Full list of patches. +
25-01-2013: Version 3.02:
+ +Single-bugfix release. Fixes a problem that + prevents CodeMirror instances from being garbage-collected after + they become unused.
+ +21-01-2013: Version 3.01:
+ +-
+
- Move all add-ons into an organized directory structure
+ under
/addon. You might have to adjust your + paths.
+ - New + modes: D, Sass, APL, SQL + (configurable), and Asterisk. +
- Several bugfixes in right-to-left text support. +
- Add
rtlMoveVisuallyoption.
+ - Improvements to vim keymap. +
- Add built-in (lightweight) overlay mode support. +
- Support
showIfHiddenoption for line widgets.
+ - Add simple Python hinter. +
- Bring back the
fixedGutteroption.
+ - Full list of patches. +
10-12-2012: Version 3.0:
+ +New major version. Only + partially backwards-compatible. See + the upgrading guide for more + information. Changes since release candidate 2:
+ +-
+
- Rewritten VIM mode. +
- Fix a few minor scrolling and sizing issues. +
- Work around Safari segfault when dragging. +
- Full list of patches. +
20-11-2012: Version 3.0, release candidate 2:
+ +-
+
- New mode: HTTP. +
- Improved handling of selection anchor position. +
- Improve IE performance on longer lines. +
- Reduce gutter glitches during horiz. scrolling. +
- Add
addKeyMapandremoveKeyMapmethods.
+ - Rewrite
formattingandclosetagadd-ons.
+ - Full list of patches. +
20-11-2012: Version 3.0, release candidate 1:
+ +-
+
- New theme: Solarized. +
- Introduce
addLineClass+ andremoveLineClass, + dropsetLineClass.
+ - Add a lot of + new options for marked text + (read-only, atomic, collapsed, widget replacement). +
- Remove the old code folding interface in favour of these new ranges. +
- Add
isClean/markCleanmethods.
+ - Remove
compoundChangemethod, use better undo-event-combining heuristic.
+ - Improve scrolling performance smoothness. +
- Full list of patches. +
22-10-2012: Version 3.0, beta 2:
+ +-
+
- Fix page-based coordinate computation. +
- Fix firing of
gutterClickevent.
+ - Add
cursorHeightoption.
+ - Fix bi-directional text regression. +
- Add
viewportMarginoption.
+ - Directly handle mousewheel events (again, hopefully better). +
- Make vertical cursor movement more robust (through widgets, big line gaps). +
- Add
flattenSpansoption.
+ - Many optimizations. Poor responsiveness should be fixed. +
- Initialization in hidden state works again. +
- Full list of patches. +
19-09-2012: Version 3.0, beta 1:
+ +-
+
- Bi-directional text support. +
- More powerful gutter model. +
- Support for arbitrary text/widget height. +
- In-line widgets. +
- Generalized event handling. +
Version 2.x
+ +21-01-2013: Version 2.38:
+ +Integrate some bugfixes, enhancements to the vim keymap, and new + modes + (D, Sass, APL) + from the v3 branch.
+ +20-12-2012: Version 2.37:
+ +-
+
- New mode: SQL (will replace plsql and mysql modes). +
- Further work on the new VIM mode. +
- Fix Cmd/Ctrl keys on recent Operas on OS X. +
- Full list of patches. +
20-11-2012: Version 2.36:
+ +-
+
- New mode: Z80 assembly. +
- New theme: Twilight. +
- Add command-line compression helper. +
- Make
scrollIntoViewpublic.
+ - Add
defaultTextHeightmethod.
+ - Various extensions to the vim keymap. +
- Make PHP mode build on mixed HTML mode. +
- Add comment-continuing add-on. +
- Full list of patches. +
22-10-2012: Version 2.35:
+ +-
+
- New (sub) mode: TypeScript. +
- Don't overwrite (insert key) when pasting. +
- Fix several bugs in
markText/undo interaction.
+ - Better indentation of JavaScript code without semicolons. +
- Add
defineInitHookfunction.
+ - Full list of patches. +
19-09-2012: Version 2.34:
+ +-
+
- New mode: Common Lisp. +
- Fix right-click select-all on most browsers. +
- Change the way highlighting happens:
Saves memory and CPU cycles.
compareStatesis no longer needed.
onHighlightCompleteno longer works.
+ - Integrate mode (Markdown, XQuery, CSS, sTex) tests in central testsuite. +
- Add a
CodeMirror.versionproperty.
+ - More robust handling of nested modes in formatting and closetag plug-ins. +
- Un/redo now preserves marked text and bookmarks. +
- Full list of patches. +
23-08-2012: Version 2.33:
+ +-
+
- New mode: Sieve. +
- New
getViewPortandonViewportChangeAPI.
+ - Configurable cursor blink rate. +
- Make binding a key to
falsedisabling handling (again).
+ - Show non-printing characters as red dots. +
- More tweaks to the scrolling model. +
- Expanded testsuite. Basic linter added. +
- Remove most uses of
innerHTML. RemoveCodeMirror.htmlEscape.
+ - Full list of patches. +
23-07-2012: Version 2.32:
+ +Emergency fix for a bug where an editor with + line wrapping on IE will break when there is no + scrollbar.
+ +20-07-2012: Version 2.31:
+ +-
+
- New modes: OCaml, Haxe, and VB.NET. +
- Several fixes to the new scrolling model. +
- Add a
setSizemethod for programmatic resizing.
+ - Add
getHistoryandsetHistorymethods.
+ - Allow custom line separator string in
getValueandgetRange.
+ - Support double- and triple-click drag, double-clicking whitespace. +
- And more... (all patches) +
22-06-2012: Version 2.3:
+ +-
+
- New scrollbar implementation. Should flicker less. Changes DOM structure of the editor. +
- New theme: vibrant-ink. +
- Many extensions to the VIM keymap (including text objects). +
- Add mode-multiplexing utility script. +
- Fix bug where right-click paste works in read-only mode. +
- Add a
getScrollInfomethod.
+ - Lots of other fixes. +
23-05-2012: Version 2.25:
+ +-
+
- New mode: Erlang. +
- Remove xmlpure mode (use xml.js). +
- Fix line-wrapping in Opera. +
- Fix X Windows middle-click paste in Chrome. +
- Fix bug that broke pasting of huge documents. +
- Fix backspace and tab key repeat in Opera. +
23-04-2012: Version 2.24:
+ +-
+
- Drop support for Internet Explorer 6. +
- New + modes: Shell, Tiki + wiki, Pig Latin. +
- New themes: Ambiance, Blackboard. +
- More control over drag/drop
+ with
dragDrop+ andonDragEvent+ options.
+ - Make HTML mode a bit less pedantic. +
- Add
compoundChangeAPI method.
+ - Several fixes in undo history and line hiding. +
- Remove (broken) support for
catchallin key maps, + addnofallthroughboolean field instead.
+
26-03-2012: Version 2.23:
+ +-
+
- Change default binding for tab [more] + + +
- New modes: XQuery and VBScript. +
- Two new themes: lesser-dark and xq-dark. +
- Differentiate between background and text styles in
setLineClass.
+ - Fix drag-and-drop in IE9+. +
- Extend
charCoords+ andcursorCoordswith amodeargument.
+ - Add
autofocusoption.
+ - Add
findMarksAtmethod.
+
27-02-2012: Version 2.22:
+ +-
+
- Allow key handlers to pass up events, allow binding characters. +
- Add
autoClearEmptyLinesoption.
+ - Properly use tab stops when rendering tabs. +
- Make PHP mode more robust. +
- Support indentation blocks in code folder. +
- Add a script for highlighting instances of the selection. +
- New .properties mode. +
- Fix many bugs. +
27-01-2012: Version 2.21:
+ +-
+
- Added LESS, MySQL, + Go, and Verilog modes. +
- Add
smartIndent+ option.
+ - Support a cursor in
readOnly-mode.
+ - Support assigning multiple styles to a token. +
- Use a new approach to drawing the selection. +
- Add
scrollTomethod.
+ - Allow undo/redo events to span non-adjacent lines. +
- Lots and lots of bugfixes. +
20-12-2011: Version 2.2:
+ +-
+
- Slightly incompatible API changes. Read this. +
- New approach + to binding keys, + support for custom + bindings. +
- Support for overwrite (insert). +
- Custom-width + and stylable tabs. +
- Moved more code into add-on scripts. +
- Support for sane vertical cursor movement in wrapped lines. +
- More reliable handling of + editing marked text. +
- Add minimal emacs + and vim bindings. +
- Rename
coordsFromIndex+ toposFromIndex, + addindexFromPos+ method.
+
21-11-2011: Version 2.18:
+Fixes TextMarker.clear, which is broken in 2.17.
21-11-2011: Version 2.17:
+-
+
- Add support for line + wrapping and code + folding. +
- Add Github-style Markdown mode. +
- Add Monokai + and Rubyblue themes. +
- Add
setBookmarkmethod.
+ - Move some of the demo code into reusable components
+ under
lib/util.
+ - Make screen-coord-finding code faster and more reliable. +
- Fix drag-and-drop in Firefox. +
- Improve support for IME. +
- Speed up content rendering. +
- Fix browser's built-in search in Webkit. +
- Make double- and triple-click work in IE. +
- Various fixes to modes. +
27-10-2011: Version 2.16:
+-
+
- Add Perl, Rust, TiddlyWiki, and Groovy modes. +
- Dragging text inside the editor now moves, rather than copies. +
- Add a
coordsFromIndexmethod.
+ - API change:
setValuenow no longer clears history. UseclearHistoryfor that.
+ - API change:
markTextnow + returns an object withclearandfind+ methods. Marked text is now more robust when edited.
+ - Fix editing code with tabs in Internet Explorer. +
26-09-2011: Version 2.15:
+Fix bug that snuck into 2.14: Clicking the + character that currently has the cursor didn't re-focus the + editor.
+ +26-09-2011: Version 2.14:
+-
+
- Add Clojure, Pascal, NTriples, Jinja2, and Markdown modes. +
- Add Cobalt and Eclipse themes. +
- Add a
fixedGutteroption.
+ - Fix bug with
setValuebreaking cursor movement.
+ - Make gutter updates much more efficient. +
- Allow dragging of text out of the editor (on modern browsers). +
23-08-2011: Version 2.13:
+-
+
- Add Ruby, R, CoffeeScript, and Velocity modes. +
- Add
getGutterElementto API.
+ - Several fixes to scrolling and positioning. +
- Add
smartHomeoption.
+ - Add an experimental pure XML mode. +
25-07-2011: Version 2.12:
+-
+
- Add a SPARQL mode. +
- Fix bug with cursor jumping around in an unfocused editor in IE. +
- Allow key and mouse events to bubble out of the editor. Ignore widget clicks. +
- Solve cursor flakiness after undo/redo. +
- Fix block-reindent ignoring the last few lines. +
- Fix parsing of multi-line attrs in XML mode. +
- Use
innerHTMLfor HTML-escaping.
+ - Some fixes to indentation in C-like mode. +
- Shrink horiz scrollbars when long lines removed. +
- Fix width feedback loop bug that caused the width of an inner DIV to shrink. +
04-07-2011: Version 2.11:
+-
+
- Add a Scheme mode. +
- Add a
replacemethod to search cursors, for cursor-preserving replacements.
+ - Make the C-like mode mode more customizable. +
- Update XML mode to spot mismatched tags. +
- Add
getStateAfterAPI andcompareStatemode API methods for finer-grained mode magic.
+ - Add a
getScrollerElementAPI method to manipulate the scrolling DIV.
+ - Fix drag-and-drop for Firefox. +
- Add a C# configuration for the C-like mode. +
- Add full-screen editing and mode-changing demos. +
07-06-2011: Version 2.1:
+Add + a theme system + (demo). Note that this is not + backwards-compatible—you'll have to update your styles and + modes!
+ +07-06-2011: Version 2.02:
+-
+
- Add a Lua mode. +
- Fix reverse-searching for a regexp. +
- Empty lines can no longer break highlighting. +
- Rework scrolling model (the outer wrapper no longer does the scrolling). +
- Solve horizontal jittering on long lines. +
- Add runmode.js. +
- Immediately re-highlight text when typing. +
- Fix problem with 'sticking' horizontal scrollbar. +
26-05-2011: Version 2.01:
+-
+
- Add a Smalltalk mode. +
- Add a reStructuredText mode. +
- Add a Python mode. +
- Add a PL/SQL mode. +
coordsCharnow works
+ - Fix a problem where
onCursorActivityinterfered withonChange.
+ - Fix a number of scrolling and mouse-click-position glitches. +
- Pass information about the changed lines to
onChange.
+ - Support cmd-up/down on OS X. +
- Add triple-click line selection. +
- Don't handle shift when changing the selection through the API. +
- Support
"nocursor"mode forreadOnlyoption.
+ - Add an
onHighlightCompleteoption.
+ - Fix the context menu for Firefox. +
28-03-2011: Version 2.0:
+CodeMirror 2 is a complete rewrite that's + faster, smaller, simpler to use, and less dependent on browser + quirks. See this + and this + for more information.
+ +22-02-2011: Version 2.0 beta 2:
+Somewhat more mature API, lots of bugs shaken out.
+ +17-02-2011: Version 0.94:
+-
+
tabMode: "spaces"was modified slightly (now indents when something is selected).
+ - Fixes a bug that would cause the selection code to break on some IE versions. +
- Disabling spell-check on WebKit browsers now works. +
08-02-2011: Version 2.0 beta 1:
+CodeMirror 2 is a complete rewrite of + CodeMirror, no longer depending on an editable frame.
+ +19-01-2011: Version 0.93:
+-
+
- Added a Regular Expression parser. +
- Fixes to the PHP parser. +
- Support for regular expression in search/replace. +
- Add
savemethod to instances created withfromTextArea.
+ - Add support for MS T-SQL in the SQL parser. +
- Support use of CSS classes for highlighting brackets. +
- Fix yet another hang with line-numbering in hidden editors. +
Version 0.x
+ +28-03-2011: Version 1.0:
+-
+
- Fix error when debug history overflows. +
- Refine handling of C# verbatim strings. +
- Fix some issues with JavaScript indentation. +
17-12-2010: Version 0.92:
+-
+
- Make CodeMirror work in XHTML documents. +
- Fix bug in handling of backslashes in Python strings. +
- The
styleNumbersoption is now officially + supported and documented.
+ onLineNumberClickoption added.
+ - More consistent names
onLoadand +onCursorActivitycallbacks. Old names still work, but + are deprecated.
+ - Add a Freemarker mode. +
11-11-2010: Version 0.91:
+-
+
- Adds support for Java. +
- Small additions to the PHP and SQL parsers. +
- Work around various Webkit issues. +
- Fix
toTextAreato update the code in the textarea.
+ - Add a
noScriptCachingoption (hack to ease development).
+ - Make sub-modes of HTML mixed mode configurable. +
02-10-2010: Version 0.9:
+-
+
- Add support for searching backwards. +
- There are now parsers for Scheme, XQuery, and OmetaJS. +
- Makes
height: "dynamic"more robust.
+ - Fixes bug where paste did not work on OS X. +
- Add a
enterModeandelectricCharsoptions to make indentation even more customizable.
+ - Add
firstLineNumberoption.
+ - Fix bad handling of
@mediarules by the CSS parser.
+ - Take a new, more robust approach to working around the invisible-last-line bug in WebKit. +
22-07-2010: Version 0.8:
+-
+
- Add a
cursorCoordsmethod to find the screen + coordinates of the cursor.
+ - A number of fixes and support for more syntax in the PHP parser. +
- Fix indentation problem with JSON-mode JS parser in Webkit. +
- Add a minification UI. +
- Support a
height: dynamicmode, where the editor's + height will adjust to the size of its content.
+ - Better support for IME input mode. +
- Fix JavaScript parser getting confused when seeing a no-argument + function call. +
- Have CSS parser see the difference between selectors and other + identifiers. +
- Fix scrolling bug when pasting in a horizontally-scrolled + editor. +
- Support
toTextAreamethod in instances created with +fromTextArea.
+ - Work around new Opera cursor bug that causes the cursor to jump + when pressing backspace at the end of a line. +
27-04-2010: Version + 0.67:
+More consistent page-up/page-down behaviour
+ across browsers. Fix some issues with hidden editors looping forever
+ when line-numbers were enabled. Make PHP parser parse
+ "\\" correctly. Have jumpToLine work on
+ line handles, and add cursorLine function to fetch the
+ line handle where the cursor currently is. Add new
+ setStylesheet function to switch style-sheets in a
+ running editor.
01-03-2010: Version + 0.66:
+Adds removeLine method to API.
+ Introduces the PLSQL parser.
+ Marks XML errors by adding (rather than replacing) a CSS class, so
+ that they can be disabled by modifying their style. Fixes several
+ selection bugs, and a number of small glitches.
12-11-2009: Version + 0.65:
+Add support for having both line-wrapping and
+ line-numbers turned on, make paren-highlighting style customisable
+ (markParen and unmarkParen config
+ options), work around a selection bug that Opera
+ reintroduced in version 10.
23-10-2009: Version + 0.64:
+Solves some issues introduced by the
+ paste-handling changes from the previous release. Adds
+ setSpellcheck, setTextWrapping,
+ setIndentUnit, setUndoDepth,
+ setTabMode, and setLineNumbers to
+ customise a running editor. Introduces an SQL parser. Fixes a few small
+ problems in the Python
+ parser. And, as usual, add workarounds for various newly discovered
+ browser incompatibilities.
31-08-2009: Version 0.63:
+Overhaul of paste-handling (less fragile), fixes for several + serious IE8 issues (cursor jumping, end-of-document bugs) and a number + of small problems.
+ +30-05-2009: Version 0.62:
+Introduces Python
+ and Lua parsers. Add
+ setParser (on-the-fly mode changing) and
+ clearHistory methods. Make parsing passes time-based
+ instead of lines-based (see the passTime option).
Reporting bugs effectively
+ +
+
+
+
+So you found a problem in CodeMirror. By all means, report it! Bug +reports from users are the main drive behind improvements to +CodeMirror. But first, please read over these points:
+ +-
+
- CodeMirror is maintained by volunteers. They don't owe you + anything, so be polite. Reports with an indignant or belligerent + tone tend to be moved to the bottom of the pile. + +
- Include information about the browser in which the + problem occurred. Even if you tested several browsers, and + the problem occurred in all of them, mention this fact in the bug + report. Also include browser version numbers and the operating + system that you're on. + +
- Mention which release of CodeMirror you're using. Preferably, + try also with the current development snapshot, to ensure the + problem has not already been fixed. + +
- Mention very precisely what went wrong. "X is broken" is not a + good bug report. What did you expect to happen? What happened + instead? Describe the exact steps a maintainer has to take to make + the problem occur. We can not fix something that we can not + observe. + +
- If the problem can not be reproduced in any of the demos + included in the CodeMirror distribution, please provide an HTML + document that demonstrates the problem. The best way to do this is + to go to jsbin.com, enter + it there, press save, and include the resulting link in your bug + report. +
Upgrading to v2.2
+ +There are a few things in the 2.2 release that require some care +when upgrading.
+ +No more default.css
+ +The default theme is now included
+in codemirror.css, so
+you do not have to included it separately anymore. (It was tiny, so
+even if you're not using it, the extra data overhead is negligible.)
+
+
Different key customization
+ +CodeMirror has moved to a system +where keymaps are used to +bind behavior to keys. This means custom +bindings are now possible.
+ +Three options that influenced key
+behavior, tabMode, enterMode,
+and smartHome, are no longer supported. Instead, you can
+provide custom bindings to influence the way these keys act. This is
+done through the
+new extraKeys
+option, which can hold an object mapping key names to functionality. A
+simple example would be:
extraKeys: {
+ "Ctrl-S": function(instance) { saveText(instance.getValue()); },
+ "Ctrl-/": "undo"
+ }
+
+Keys can be mapped either to functions, which will be given the
+editor instance as argument, or to strings, which are mapped through
+functions through the CodeMirror.commands table, which
+contains all the built-in editing commands, and can be inspected and
+extended by external code.
By default, the Home key is bound to
+the "goLineStartSmart" command, which moves the cursor to
+the first non-whitespace character on the line. You can set do this to
+make it always go to the very start instead:
extraKeys: {"Home": "goLineStart"}
+
+Similarly, Enter is bound
+to "newlineAndIndent" by default. You can bind it to
+something else to get different behavior. To disable special handling
+completely and only get a newline character inserted, you can bind it
+to false:
extraKeys: {"Enter": false}
+
+The same works for Tab. If you don't want CodeMirror
+to handle it, bind it to false. The default behaviour is
+to indent the current line more ("indentMore" command),
+and indent it less when shift is held ("indentLess").
+There are also "indentAuto" (smart indent)
+and "insertTab" commands provided for alternate
+behaviors. Or you can write your own handler function to do something
+different altogether.
Tabs
+ +Handling of tabs changed completely. The display width of tabs can
+now be set with the tabSize option, and tabs can
+be styled by setting CSS rules
+for the cm-tab class.
The default width for tabs is now 4, as opposed to the 8 that is
+hard-wired into browsers. If you are relying on 8-space tabs, make
+sure you explicitly set tabSize: 8 in your options.
+
+
+
+
+
+
+CodeMirror
+
+
+
+Upgrading to version 3
+ +Version 3 does not depart too much from 2.x API, and sites that use +CodeMirror in a very simple way might be able to upgrade without +trouble. But it does introduce a number of incompatibilities. Please +at least skim this text before upgrading.
+ +Note that version 3 drops full support for Internet +Explorer 7. The editor will mostly work on that browser, but +it'll be significantly glitchy.
+ +DOM structure
+ +This one is the most likely to cause problems. The internal +structure of the editor has changed quite a lot, mostly to implement a +new scrolling model.
+ +Editor height is now set on the outer wrapper element (CSS
+class CodeMirror), not on the scroller element
+(CodeMirror-scroll).
Other nodes were moved, dropped, and added. If you have any code +that makes assumptions about the internal DOM structure of the editor, +you'll have to re-test it and probably update it to work with v3.
+ +See the styling section of the +manual for more information.
+Gutter model
+ +In CodeMirror 2.x, there was a single gutter, and line markers
+created with setMarker would have to somehow coexist with
+the line numbers (if present). Version 3 allows you to specify an
+array of gutters, by class
+name,
+use setGutterMarker
+to add or remove markers in individual gutters, and clear whole
+gutters
+with clearGutter.
+Gutter markers are now specified as DOM nodes, rather than HTML
+snippets.
The gutters no longer horizontally scrolls along with the content.
+The fixedGutter option was removed (since it is now the
+only behavior).
+<style>
+ /* Define a gutter style */
+ .note-gutter { width: 3em; background: cyan; }
+</style>
+<script>
+ // Create an instance with two gutters -- line numbers and notes
+ var cm = new CodeMirror(document.body, {
+ gutters: ["note-gutter", "CodeMirror-linenumbers"],
+ lineNumbers: true
+ });
+ // Add a note to line 0
+ cm.setGutterMarker(0, "note-gutter", document.createTextNode("hi"));
+</script>
+
+Event handling
+ +Most of the onXYZ options have been removed. The same
+effect is now obtained by calling
+the on method with a string
+identifying the event type. Multiple handlers can now be registered
+(and individually unregistered) for an event, and objects such as line
+handlers now also expose events. See the
+full list here.
(The onKeyEvent and onDragEvent options,
+which act more as hooks than as event handlers, are still there in
+their old form.)
+cm.on("change", function(cm, change) {
+ console.log("something changed! (" + change.origin + ")");
+});
+
+markText method arguments
+ +The markText method
+(which has gained some interesting new features, such as creating
+atomic and read-only spans, or replacing spans with widgets) no longer
+takes the CSS class name as a separate argument, but makes it an
+optional field in the options object instead.
+// Style first ten lines, and forbid the cursor from entering them
+cm.markText({line: 0, ch: 0}, {line: 10, ch: 0}, {
+ className: "magic-text",
+ inclusiveLeft: true,
+ atomic: true
+});
+
+Line folding
+ +The interface for hiding lines has been
+removed. markText can
+now be used to do the same in a more flexible and powerful way.
The folding script has been +updated to use the new interface, and should now be more robust.
+ +
+// Fold a range, replacing it with the text "??"
+var range = cm.markText({line: 4, ch: 2}, {line: 8, ch: 1}, {
+ replacedWith: document.createTextNode("??"),
+ // Auto-unfold when cursor moves into the range
+ clearOnEnter: true
+});
+// Get notified when auto-unfolding
+CodeMirror.on(range, "clear", function() {
+ console.log("boom");
+});
+
+Line CSS classes
+ +The setLineClass method has been replaced
+by addLineClass
+and removeLineClass,
+which allow more modular control over the classes attached to a line.
+var marked = cm.addLineClass(10, "background", "highlighted-line");
+setTimeout(function() {
+ cm.removeLineClass(marked, "background", "highlighted-line");
+});
+
+Position properties
+ +All methods that take or return objects that represent screen
+positions now use {left, top, bottom, right} properties
+(not always all of them) instead of the {x, y, yBot} used
+by some methods in v2.x.
Affected methods
+are cursorCoords, charCoords, coordsChar,
+and getScrollInfo.
Bracket matching no longer in core
+ +The matchBrackets
+option is no longer defined in the core editor.
+Load addon/edit/matchbrackets.js to enable it.
Mode management
+ +The CodeMirror.listModes
+and CodeMirror.listMIMEs functions, used for listing
+defined modes, are gone. You are now encouraged to simply
+inspect CodeMirror.modes (mapping mode names to mode
+constructors) and CodeMirror.mimeModes (mapping MIME
+strings to mode specs).
New features
+ +Some more reasons to upgrade to version 3.
+ +-
+
- Bi-directional text support. CodeMirror will now mostly do the + right thing when editing Arabic or Hebrew text. +
- Arbitrary line heights. Using fonts with different heights + inside the editor (whether off by one pixel or fifty) is now + supported and handled gracefully. +
- In-line widgets. See the demo + and the docs. +
- Defining custom options
+ with
CodeMirror.defineOption.
+
+
+
+
+
+
+
+CodeMirror
+
+
+
+Upgrading to version 4
+ +CodeMirror 4's interface is very close version 3, but it +does fix a few awkward details in a backwards-incompatible ways. At +least skim the text below before upgrading.
+ +Multiple selections
+ +The main new feature in version 4 is multiple selections. The +single-selection variants of methods are still there, but now +typically act only on the primary selection (usually the last +one added).
+ +The exception to this
+is getSelection,
+which will now return the content of all selections
+(separated by newlines, or whatever lineSep parameter you passed
+it).
The beforeSelectionChange event
+ +This event still exists, but the object it is passed has +a completely new +interface, because such changes now concern multiple +selections.
+ +replaceSelection's collapsing behavior
+ +By
+default, replaceSelection
+would leave the newly inserted text selected. This is only rarely what
+you want, and also (slightly) more expensive in the new model, so the
+default was changed to "end", meaning the old behavior
+must be explicitly specified by passing a second argument
+of "around".
change event data
+ +Rather than forcing client code to follow next
+pointers from one change object to the next, the library will now
+simply fire
+multiple "change"
+events. Existing code will probably continue to work unmodified.
showIfHidden option to line widgets
+ +This option, which conceptually caused line widgets to be visible +even if their line was hidden, was never really well-defined, and was +buggy from the start. It would be a rather expensive feature, both in +code complexity and run-time performance, to implement properly. It +has been dropped entirely in 4.0.
+ +Module loaders
+ +All modules in the CodeMirror distribution are now wrapped in a
+shim function to make them compatible with both AMD
+(requirejs) and CommonJS (as used
+by node
+and browserify) module loaders.
+When neither of these is present, they fall back to simply using the
+global CodeMirror variable.
If you have a module loader present in your environment, CodeMirror +will attempt to use it, and you might need to change the way you load +CodeMirror modules.
+ +Deprecated interfaces dropped
+ +A few properties and methods that have been deprecated for a while
+are now gone. Most notably, the onKeyEvent
+and onDragEvent options (use the
+corresponding events instead).
Two silly methods, which were mostly there to stay close to the 0.x
+API, setLine and removeLine are now gone.
+Use the more
+flexible replaceRange
+method instead.
The long names for folding and completing functions
+(CodeMirror.braceRangeFinder, CodeMirror.javascriptHint,
+etc) are also gone
+(use CodeMirror.fold.brace, CodeMirror.hint.javascript).
The className property in the return value
+of getTokenAt, which
+has been superseded by the type property, is also no
+longer present.
CodeMirror is a versatile text editor + implemented in JavaScript for the browser. It is specialized for + editing code, and comes with a number of language modes and addons + that implement more advanced editing functionality.
+ +A rich programming API and a + CSS theming system are + available for customizing CodeMirror to fit your application, and + extending it with new functionality.
+This is CodeMirror
+ + + +
+
+
+
+
+
+ Get the current version: 5.7.
+ You can see the code or
+ read the release notes.
+ There is a minification helper. +
+
+ + You can see the code or
+ read the release notes.
+ There is a minification helper. +
Features
+-
+
- Support for over 100 languages out of the box +
- A powerful, composable language mode system +
- Autocompletion (XML) +
- Code folding +
- Configurable keybindings +
- Vim, Emacs, and Sublime Text bindings +
- Search and replace interface +
- Bracket and tag matching +
- Support for split views +
- Linter integration +
- Mixing font sizes and styles +
- Various themes +
- Able to resize to fit content +
- Inline and block widgets +
- Programmable gutters +
- Making ranges of text styled, read-only, or atomic +
- Bi-directional text support +
- Many other methods and addons... +
Community
+ +CodeMirror is an open-source project shared under + an MIT license. It is the editor used in the + dev tools for + both Firefox + and Chrome, Light + Table, Adobe + Brackets, Bitbucket, + and many other projects.
+ +Development and bug tracking happens + on github + (alternate git + repository). + Please read these + pointers before submitting a bug. Use pull requests to submit + patches. All contributions must be released under the same MIT + license that CodeMirror uses.
+ +Discussion around the project is done on + a discussion forum. + There is also + the codemirror-announce + list, which is only used for major announcements (such as new + versions). If needed, you can + contact the maintainer + directly. We aim to be an inclusive, welcoming community. To make + that explicit, we have + a code of + conduct that applies to communication around the project.
+ +A list of CodeMirror-related software that is not part of the + main distribution is maintained + on our + wiki. Feel free to add your project.
+Browser support
+The desktop versions of the following browsers,
+ in standards mode (HTML5 <!doctype html>
+ recommended) are supported:
| Firefox | version 4 and up |
|---|---|
| Chrome | any version |
| Safari | version 5.2 and up |
| Internet Explorer | version 8 and up |
| Opera | version 9 and up |
Support for modern mobile browsers is experimental. Recent + versions of the iOS browser and Chrome on Android should work + pretty well.
+'; + if (!regArgs) { + for (var registerName in registers) { + var text = registers[registerName].toString(); + if (text.length) { + regInfo += '"' + registerName + ' ' + text + '
'; + } + } + } else { + var registerName; + regArgs = regArgs.join(''); + for (var i = 0; i < regArgs.length; i++) { + registerName = regArgs.charAt(i); + if (!vimGlobalState.registerController.isValidRegister(registerName)) { + continue; + } + var register = registers[registerName] || new Register(); + regInfo += '"' + registerName + ' ' + register.toString() + '
'; + } + } + showConfirm(cm, regInfo); + }, + sort: function(cm, params) { + var reverse, ignoreCase, unique, number; + function parseArgs() { + if (params.argString) { + var args = new CodeMirror.StringStream(params.argString); + if (args.eat('!')) { reverse = true; } + if (args.eol()) { return; } + if (!args.eatSpace()) { return 'Invalid arguments'; } + var opts = args.match(/[a-z]+/); + if (opts) { + opts = opts[0]; + ignoreCase = opts.indexOf('i') != -1; + unique = opts.indexOf('u') != -1; + var decimal = opts.indexOf('d') != -1 && 1; + var hex = opts.indexOf('x') != -1 && 1; + var octal = opts.indexOf('o') != -1 && 1; + if (decimal + hex + octal > 1) { return 'Invalid arguments'; } + number = decimal && 'decimal' || hex && 'hex' || octal && 'octal'; + } + if (args.match(/\/.*\//)) { return 'patterns not supported'; } + } + } + var err = parseArgs(); + if (err) { + showConfirm(cm, err + ': ' + params.argString); + return; + } + var lineStart = params.line || cm.firstLine(); + var lineEnd = params.lineEnd || params.line || cm.lastLine(); + if (lineStart == lineEnd) { return; } + var curStart = Pos(lineStart, 0); + var curEnd = Pos(lineEnd, lineLength(cm, lineEnd)); + var text = cm.getRange(curStart, curEnd).split('\n'); + var numberRegex = (number == 'decimal') ? /(-?)([\d]+)/ : + (number == 'hex') ? /(-?)(?:0x)?([0-9a-f]+)/i : + (number == 'octal') ? /([0-7]+)/ : null; + var radix = (number == 'decimal') ? 10 : (number == 'hex') ? 16 : (number == 'octal') ? 8 : null; + var numPart = [], textPart = []; + if (number) { + for (var i = 0; i < text.length; i++) { + if (numberRegex.exec(text[i])) { + numPart.push(text[i]); + } else { + textPart.push(text[i]); + } + } + } else { + textPart = text; + } + function compareFn(a, b) { + if (reverse) { var tmp; tmp = a; a = b; b = tmp; } + if (ignoreCase) { a = a.toLowerCase(); b = b.toLowerCase(); } + var anum = number && numberRegex.exec(a); + var bnum = number && numberRegex.exec(b); + if (!anum) { return a < b ? -1 : 1; } + anum = parseInt((anum[1] + anum[2]).toLowerCase(), radix); + bnum = parseInt((bnum[1] + bnum[2]).toLowerCase(), radix); + return anum - bnum; + } + numPart.sort(compareFn); + textPart.sort(compareFn); + text = (!reverse) ? textPart.concat(numPart) : numPart.concat(textPart); + if (unique) { // Remove duplicate lines + var textOld = text; + var lastLine; + text = []; + for (var i = 0; i < textOld.length; i++) { + if (textOld[i] != lastLine) { + text.push(textOld[i]); + } + lastLine = textOld[i]; + } + } + cm.replaceRange(text.join('\n'), curStart, curEnd); + }, + global: function(cm, params) { + // a global command is of the form + // :[range]g/pattern/[cmd] + // argString holds the string /pattern/[cmd] + var argString = params.argString; + if (!argString) { + showConfirm(cm, 'Regular Expression missing from global'); + return; + } + // range is specified here + var lineStart = (params.line !== undefined) ? params.line : cm.firstLine(); + var lineEnd = params.lineEnd || params.line || cm.lastLine(); + // get the tokens from argString + var tokens = splitBySlash(argString); + var regexPart = argString, cmd; + if (tokens.length) { + regexPart = tokens[0]; + cmd = tokens.slice(1, tokens.length).join('/'); + } + if (regexPart) { + // If regex part is empty, then use the previous query. Otherwise + // use the regex part as the new query. + try { + updateSearchQuery(cm, regexPart, true /** ignoreCase */, + true /** smartCase */); + } catch (e) { + showConfirm(cm, 'Invalid regex: ' + regexPart); + return; + } + } + // now that we have the regexPart, search for regex matches in the + // specified range of lines + var query = getSearchState(cm).getQuery(); + var matchedLines = [], content = ''; + for (var i = lineStart; i <= lineEnd; i++) { + var matched = query.test(cm.getLine(i)); + if (matched) { + matchedLines.push(i+1); + content+= cm.getLine(i) + '
'; + } + } + // if there is no [cmd], just display the list of matched lines + if (!cmd) { + showConfirm(cm, content); + return; + } + var index = 0; + var nextCommand = function() { + if (index < matchedLines.length) { + var command = matchedLines[index] + cmd; + exCommandDispatcher.processCommand(cm, command, { + callback: nextCommand + }); + } + index++; + }; + nextCommand(); + }, + substitute: function(cm, params) { + if (!cm.getSearchCursor) { + throw new Error('Search feature not available. Requires searchcursor.js or ' + + 'any other getSearchCursor implementation.'); + } + var argString = params.argString; + var tokens = argString ? splitBySlash(argString) : []; + var regexPart, replacePart = '', trailing, flagsPart, count; + var confirm = false; // Whether to confirm each replace. + var global = false; // True to replace all instances on a line, false to replace only 1. + if (tokens.length) { + regexPart = tokens[0]; + replacePart = tokens[1]; + if (replacePart !== undefined) { + if (getOption('pcre')) { + replacePart = unescapeRegexReplace(replacePart); + } else { + replacePart = translateRegexReplace(replacePart); + } + vimGlobalState.lastSubstituteReplacePart = replacePart; + } + trailing = tokens[2] ? tokens[2].split(' ') : []; + } else { + // either the argString is empty or its of the form ' hello/world' + // actually splitBySlash returns a list of tokens + // only if the string starts with a '/' + if (argString && argString.length) { + showConfirm(cm, 'Substitutions should be of the form ' + + ':s/pattern/replace/'); + return; + } + } + // After the 3rd slash, we can have flags followed by a space followed + // by count. + if (trailing) { + flagsPart = trailing[0]; + count = parseInt(trailing[1]); + if (flagsPart) { + if (flagsPart.indexOf('c') != -1) { + confirm = true; + flagsPart.replace('c', ''); + } + if (flagsPart.indexOf('g') != -1) { + global = true; + flagsPart.replace('g', ''); + } + regexPart = regexPart + '/' + flagsPart; + } + } + if (regexPart) { + // If regex part is empty, then use the previous query. Otherwise use + // the regex part as the new query. + try { + updateSearchQuery(cm, regexPart, true /** ignoreCase */, + true /** smartCase */); + } catch (e) { + showConfirm(cm, 'Invalid regex: ' + regexPart); + return; + } + } + replacePart = replacePart || vimGlobalState.lastSubstituteReplacePart; + if (replacePart === undefined) { + showConfirm(cm, 'No previous substitute regular expression'); + return; + } + var state = getSearchState(cm); + var query = state.getQuery(); + var lineStart = (params.line !== undefined) ? params.line : cm.getCursor().line; + var lineEnd = params.lineEnd || lineStart; + if (lineStart == cm.firstLine() && lineEnd == cm.lastLine()) { + lineEnd = Infinity; + } + if (count) { + lineStart = lineEnd; + lineEnd = lineStart + count - 1; + } + var startPos = clipCursorToContent(cm, Pos(lineStart, 0)); + var cursor = cm.getSearchCursor(query, startPos); + doReplace(cm, confirm, global, lineStart, lineEnd, cursor, query, replacePart, params.callback); + }, + redo: CodeMirror.commands.redo, + undo: CodeMirror.commands.undo, + write: function(cm) { + if (CodeMirror.commands.save) { + // If a save command is defined, call it. + CodeMirror.commands.save(cm); + } else { + // Saves to text area if no save command is defined. + cm.save(); + } + }, + nohlsearch: function(cm) { + clearSearchHighlight(cm); + }, + delmarks: function(cm, params) { + if (!params.argString || !trim(params.argString)) { + showConfirm(cm, 'Argument required'); + return; + } + + var state = cm.state.vim; + var stream = new CodeMirror.StringStream(trim(params.argString)); + while (!stream.eol()) { + stream.eatSpace(); + + // Record the streams position at the beginning of the loop for use + // in error messages. + var count = stream.pos; + + if (!stream.match(/[a-zA-Z]/, false)) { + showConfirm(cm, 'Invalid argument: ' + params.argString.substring(count)); + return; + } + + var sym = stream.next(); + // Check if this symbol is part of a range + if (stream.match('-', true)) { + // This symbol is part of a range. + + // The range must terminate at an alphabetic character. + if (!stream.match(/[a-zA-Z]/, false)) { + showConfirm(cm, 'Invalid argument: ' + params.argString.substring(count)); + return; + } + + var startMark = sym; + var finishMark = stream.next(); + // The range must terminate at an alphabetic character which + // shares the same case as the start of the range. + if (isLowerCase(startMark) && isLowerCase(finishMark) || + isUpperCase(startMark) && isUpperCase(finishMark)) { + var start = startMark.charCodeAt(0); + var finish = finishMark.charCodeAt(0); + if (start >= finish) { + showConfirm(cm, 'Invalid argument: ' + params.argString.substring(count)); + return; + } + + // Because marks are always ASCII values, and we have + // determined that they are the same case, we can use + // their char codes to iterate through the defined range. + for (var j = 0; j <= finish - start; j++) { + var mark = String.fromCharCode(start + j); + delete state.marks[mark]; + } + } else { + showConfirm(cm, 'Invalid argument: ' + startMark + '-'); + return; + } + } else { + // This symbol is a valid mark, and is not part of a range. + delete state.marks[sym]; + } + } + } + }; + + var exCommandDispatcher = new ExCommandDispatcher(); + + /** + * @param {CodeMirror} cm CodeMirror instance we are in. + * @param {boolean} confirm Whether to confirm each replace. + * @param {Cursor} lineStart Line to start replacing from. + * @param {Cursor} lineEnd Line to stop replacing at. + * @param {RegExp} query Query for performing matches with. + * @param {string} replaceWith Text to replace matches with. May contain $1, + * $2, etc for replacing captured groups using Javascript replace. + * @param {function()} callback A callback for when the replace is done. + */ + function doReplace(cm, confirm, global, lineStart, lineEnd, searchCursor, query, + replaceWith, callback) { + // Set up all the functions. + cm.state.vim.exMode = true; + var done = false; + var lastPos = searchCursor.from(); + function replaceAll() { + cm.operation(function() { + while (!done) { + replace(); + next(); + } + stop(); + }); + } + function replace() { + var text = cm.getRange(searchCursor.from(), searchCursor.to()); + var newText = text.replace(query, replaceWith); + searchCursor.replace(newText); + } + function next() { + // The below only loops to skip over multiple occurrences on the same + // line when 'global' is not true. + while(searchCursor.findNext() && + isInRange(searchCursor.from(), lineStart, lineEnd)) { + if (!global && lastPos && searchCursor.from().line == lastPos.line) { + continue; + } + cm.scrollIntoView(searchCursor.from(), 30); + cm.setSelection(searchCursor.from(), searchCursor.to()); + lastPos = searchCursor.from(); + done = false; + return; + } + done = true; + } + function stop(close) { + if (close) { close(); } + cm.focus(); + if (lastPos) { + cm.setCursor(lastPos); + var vim = cm.state.vim; + vim.exMode = false; + vim.lastHPos = vim.lastHSPos = lastPos.ch; + } + if (callback) { callback(); } + } + function onPromptKeyDown(e, _value, close) { + // Swallow all keys. + CodeMirror.e_stop(e); + var keyName = CodeMirror.keyName(e); + switch (keyName) { + case 'Y': + replace(); next(); break; + case 'N': + next(); break; + case 'A': + // replaceAll contains a call to close of its own. We don't want it + // to fire too early or multiple times. + var savedCallback = callback; + callback = undefined; + cm.operation(replaceAll); + callback = savedCallback; + break; + case 'L': + replace(); + // fall through and exit. + case 'Q': + case 'Esc': + case 'Ctrl-C': + case 'Ctrl-[': + stop(close); + break; + } + if (done) { stop(close); } + return true; + } + + // Actually do replace. + next(); + if (done) { + showConfirm(cm, 'No matches for ' + query.source); + return; + } + if (!confirm) { + replaceAll(); + if (callback) { callback(); }; + return; + } + showPrompt(cm, { + prefix: 'replace with ' + replaceWith + ' (y/n/a/q/l)', + onKeyDown: onPromptKeyDown + }); + } + + CodeMirror.keyMap.vim = { + attach: attachVimMap, + detach: detachVimMap, + call: cmKey + }; + + function exitInsertMode(cm) { + var vim = cm.state.vim; + var macroModeState = vimGlobalState.macroModeState; + var insertModeChangeRegister = vimGlobalState.registerController.getRegister('.'); + var isPlaying = macroModeState.isPlaying; + var lastChange = macroModeState.lastInsertModeChanges; + // In case of visual block, the insertModeChanges are not saved as a + // single word, so we convert them to a single word + // so as to update the ". register as expected in real vim. + var text = []; + if (!isPlaying) { + var selLength = lastChange.inVisualBlock ? vim.lastSelection.visualBlock.height : 1; + var changes = lastChange.changes; + var text = []; + var i = 0; + // In case of multiple selections in blockwise visual, + // the inserted text, for example: 'f
APL mode
+ + + + +Simple mode that tries to handle APL as well as it can.
+It attempts to label functions/operators based upon + monadic/dyadic usage (but this is far from fully fleshed out). + This means there are meaningful classnames so hover states can + have popups etc.
+ +MIME types defined: text/apl (APL code)
ASCII Armor (PGP) mode
+ + + + +MIME types
+defined: application/pgp, application/pgp-keys, application/pgp-signature
ASN.1 example
+
+
+
+
+
+ +
Language: Abstract Syntax Notation One + (ASN.1) +
+MIME types defined: text/x-ttcn-asn
+
The development of this mode has been sponsored by Ericsson + .
+Coded by Asmelash Tsegay Gebretsadkan
+Asterisk dialplan mode
+ + + +MIME types defined: text/x-asterisk.
Brainfuck mode
+ + + + +A mode for Brainfuck
+ +MIME types defined: text/x-brainfuck
C-like mode
+ + + +C++ example
+ + + +Objective-C example
+ + + +Java example
+ + + +Scala example
+ + + + + +Simple mode that tries to handle C-like languages as well as it
+ can. Takes two configuration parameters: keywords, an
+ object whose property names are the keywords in the language,
+ and useCPP, which determines whether C preprocessor
+ directives are recognized.
MIME types defined: text/x-csrc
+ (C), text/x-c++src (C++), text/x-java
+ (Java), text/x-csharp (C#),
+ text/x-objectivec (Objective-C),
+ text/x-scala (Scala), text/x-vertex
+ and x-shader/x-fragment (shader programs),
+ text/x-squirrel (Squirrel).
Scala mode
+ + + +Clojure mode
+ + + +MIME types defined: text/x-clojure.
CMake mode
+ + + +MIME types defined: text/x-cmake.
COBOL mode
+ +Select Theme Select Font Size + + + + +
+ + +CoffeeScript mode
+ + + +MIME types defined: text/x-coffeescript.
The CoffeeScript mode was written by Jeff Pickhardt.
+ +Common Lisp mode
+ + + +MIME types defined: text/x-common-lisp.
Closure Stylesheets (GSS) mode
+ + + +A mode for Closure Stylesheets (GSS).
+MIME type defined: text/x-gss.
CSS mode
+ + + +MIME types defined: text/css, text/x-scss (demo), text/x-less (demo).
LESS mode
+ + + +The LESS mode is a sub-mode of the CSS mode (defined in css.js).
SCSS mode
+ + + +The SCSS mode is a sub-mode of the CSS mode (defined in css.js).
Cypher Mode for CodeMirror
+ +MIME types defined:
+ application/x-cypher-query
+
D mode
+ + + + +Simple mode that handle D-Syntax (DLang Homepage).
+ +MIME types defined: text/x-d
+ .
Dart mode
+ + + + +Diff mode
+ + + +MIME types defined: text/x-diff.
Django template mode
+ + + + +Mode for HTML with embedded Django template markup.
+ +MIME types defined: text/x-django
Dockerfile mode
+ + + + +Dockerfile syntax highlighting for CodeMirror. Depends on + the simplemode addon.
+ +MIME types defined: text/x-dockerfile
DTD mode
+ + + +MIME types defined: application/xml-dtd.
Dylan mode
+ + + + + + +MIME types defined: text/x-dylan.
EBNF Mode (bracesMode setting = "javascript")
+ + +The EBNF Mode
+Created by Robert Plummer
+ECL mode
+ + + +Based on CodeMirror's clike mode. For more information see HPCC Systems web site.
+MIME types defined: text/x-ecl.
Eiffel mode
+ + + +MIME types defined: text/x-eiffel.
Created by YNH.
+Elm mode
+ + + + + +MIME types defined: text/x-elm.
Erlang mode
+ + + + +MIME types defined: text/x-erlang.
Factor mode
+ + + + + +Simple mode that handles Factor Syntax (Factor on WikiPedia).
+ +MIME types defined: text/x-factor.
Forth mode
+ + + + + +Simple mode that handle Forth-Syntax (Forth on WikiPedia).
+ +MIME types defined: text/x-forth.
Fortran mode
+ + + + + + +MIME types defined: text/x-Fortran.
Gas mode
+ + + + +Handles AT&T assembler syntax (more specifically this handles
+ the GNU Assembler (gas) syntax.)
+ It takes a single optional configuration parameter:
+ architecture, which can be one of "ARM",
+ "ARMv6" or "x86".
+ Including the parameter adds syntax for the registers and special
+ directives for the supplied architecture.
+
+
MIME types defined: text/x-gas
GFM mode
+ + + + +Optionally depends on other modes for properly highlighted code blocks.
+ + + +Gherkin mode
+ + + +MIME types defined: text/x-feature.
Go mode
+ + + + +MIME type: text/x-go
Groovy mode
+ + + + +MIME types defined: text/x-groovy
HAML mode
+ + + +MIME types defined: text/x-haml.
Handlebars
+ + + + +Handlebars syntax highlighting for CodeMirror.
+ +MIME types defined: text/x-handlebars-template
Haskell mode
+ + + + +MIME types defined: text/x-haskell.
Haxe mode
+ + +
+
+
+
+
+
+ Hxml mode:
+ + +MIME types defined: text/x-haxe, text/x-hxml.
Html Embedded Scripts mode
+ + + + +Mode for html embedded scripts like JSP and ASP.NET. Depends on HtmlMixed which in turn depends on
+ JavaScript, CSS and XML.
Other dependancies include those of the scriping language chosen.
MIME types defined: application/x-aspx (ASP.NET),
+ application/x-ejs (Embedded Javascript), application/x-jsp (JavaServer Pages)
HTML mixed mode
+ + + +The HTML mixed mode depends on the XML, JavaScript, and CSS modes.
+ +It takes an optional mode configuration
+ option, scriptTypes, which can be used to add custom
+ behavior for specific <script type="..."> tags. If
+ given, it should hold an array of {matches, mode}
+ objects, where matches is a string or regexp that
+ matches the script type, and mode is
+ either null, for script types that should stay in
+ HTML mode, or a mode
+ spec corresponding to the mode that should be used for the
+ script.
MIME types defined: text/html
+ (redefined, only takes effect if you load this parser after the
+ XML parser).
HTTP mode
+ + + + + + +MIME types defined: message/http.
IDL mode
+ + + + +MIME types defined: text/x-idl.
Language modes
+ +This is a list of every mode in the distribution. Each mode lives
+in a subdirectory of the mode/ directory, and typically
+defines a single JavaScript file that implements the mode. Loading
+such file will make the language available to CodeMirror, through
+the mode
+option.
+
+
+-
+
- APL +
- ASN.1 +
- Asterisk dialplan +
- Brainfuck +
- C, C++, C# +
- Clojure +
- Closure Stylesheets (GSS) +
- CMake +
- COBOL +
- CoffeeScript +
- Common Lisp +
- CSS +
- Cypher +
- Cython +
- D +
- Dart +
- Django (templating language) +
- Dockerfile +
- diff +
- DTD +
- Dylan +
- EBNF +
- ECL +
- Eiffel +
- Elm +
- Erlang +
- Factor +
- Forth +
- Fortran +
- F# +
- Gas (AT&T-style assembly) +
- Gherkin +
- Go +
- Groovy +
- HAML +
- Handlebars +
- Haskell +
- Haxe +
- HTML embedded (JSP, ASP.NET) +
- HTML mixed-mode +
- HTTP +
- IDL +
- Java +
- Jade +
- JavaScript +
- Jinja2 +
- Julia +
- Kotlin +
- LESS +
- LiveScript +
- Lua +
- Markdown (GitHub-flavour) +
- Mathematica +
- mIRC +
- Modelica +
- MUMPS +
- Nginx +
- NTriples +
- Objective C +
- OCaml +
- Octave (MATLAB) +
- Oz +
- Pascal +
- PEG.js +
- Perl +
- PGP (ASCII armor) +
- PHP +
- Pig Latin +
- Properties files +
- Puppet +
- Python +
- Q +
- R +
- RPM +
- reStructuredText +
- Ruby +
- Rust +
- Sass +
- Spreadsheet +
- Scala +
- Scheme +
- SCSS +
- Shell +
- Sieve +
- Slim +
- Smalltalk +
- Smarty +
- Solr +
- Soy +
- Stylus +
- SQL (several dialects) +
- SPARQL +
- Squirrel +
- Swift +
- sTeX, LaTeX +
- Tcl +
- Textile +
- Tiddlywiki +
- Tiki wiki +
- TOML +
- Tornado (templating language) +
- troff (for manpages) +
- TTCN +
- TTCN Configuration +
- Turtle +
- Twig +
- VB.NET +
- VBScript +
- Velocity +
- Verilog/SystemVerilog +
- VHDL +
- Vue.js app +
- XML/HTML +
- XQuery +
- YAML +
- Z80 +
Jade Templating Mode
+ + +The Jade Templating Mode
+Created by Forbes Lindesay. Managed as part of a Brackets extension at https://github.com/ForbesLindesay/jade-brackets.
+MIME type defined: text/x-jade.
JavaScript mode
+ + + + + + ++ JavaScript mode supports several configuration options: +
-
+
jsonwhich will set the mode to expect JSON + data rather than a JavaScript program.
+ jsonldwhich will set the mode to expect + JSON-LD linked data rather + than a JavaScript program (demo).
+ typescriptwhich will activate additional + syntax highlighting and some other things for TypeScript code + (demo).
+ statementIndentwhich (given a number) will + determine the amount of indentation to use for statements + continued on a new line.
+ wordCharacters, a regexp that indicates which + characters should be considered part of an identifier. + Defaults to/[\w$]/, which does not handle + non-ASCII identifiers. Can be set to something more elaborate + to improve Unicode support.
+
MIME types defined: text/javascript, application/json, application/ld+json, text/typescript, application/typescript.
JSON-LD mode
+ + + + + + +This is a specialization of the JavaScript mode.
+TypeScript mode
+ + + + + + +This is a specialization of the JavaScript mode.
+Jinja2 mode
+ + +Julia mode
+ + + + +MIME types defined: text/x-julia.
Kotlin mode
+ + + + + +Mode for Kotlin (http://kotlin.jetbrains.org/)
+Developed by Hadi Hariri (https://github.com/hhariri).
+MIME type defined: text/x-kotlin.
LiveScript mode
+ + + +MIME types defined: text/x-livescript.
The LiveScript mode was written by Kenneth Bentley.
+ +Lua mode
+ + + +Loosely based on Franciszek
+ Wawrzak's CodeMirror
+ 1 mode. One configuration parameter is
+ supported, specials, to which you can provide an
+ array of strings to have those identifiers highlighted with
+ the lua-special style.
MIME types defined: text/x-lua.
Markdown mode
+ + + + +You might want to use the Github-Flavored Markdown mode instead, which adds support for fenced code blocks and a few other things.
+ +Optionally depends on the XML mode for properly highlighted inline XML blocks.
+ +MIME types defined: text/x-markdown.
Mathematica mode
+ + + + + + +MIME types defined: text/x-mathematica (Mathematica).
mIRC mode
+ + + +MIME types defined: text/mirc.
OCaml mode
+ + + + +F# mode
+ + + + + +MIME types defined: text/x-ocaml (OCaml) and text/x-fsharp (F#).
Modelica mode
+ + + + + +Simple mode that tries to handle Modelica as well as it can.
+ +MIME types defined: text/x-modelica
+ (Modlica code).
MscGen mode
+ + + + + +MIME types defined: text/x-mscgen
CodeMirror: msgenny mode
+ + + + + +MIME types defined: text/x-msgenny
CodeMirror: xù mode
+ + + + + +MIME types defined: text/x-xu
MUMPS mode
+ + +
+
+
+
diff --git a/www/code/codemirror-5.7/mode/mumps/mumps.js b/www/code/codemirror-5.7/mode/mumps/mumps.js
new file mode 100644
index 000000000..469f8c3d1
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/mumps/mumps.js
@@ -0,0 +1,148 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+/*
+ This MUMPS Language script was constructed using vbscript.js as a template.
+*/
+
+(function(mod) {
+ if (typeof exports == "object" && typeof module == "object") // CommonJS
+ mod(require("../../lib/codemirror"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+ "use strict";
+
+ CodeMirror.defineMode("mumps", function() {
+ function wordRegexp(words) {
+ return new RegExp("^((" + words.join(")|(") + "))\\b", "i");
+ }
+
+ var singleOperators = new RegExp("^[\\+\\-\\*/&#!_?\\\\<>=\\'\\[\\]]");
+ var doubleOperators = new RegExp("^(('=)|(<=)|(>=)|('>)|('<)|([[)|(]])|(^$))");
+ var singleDelimiters = new RegExp("^[\\.,:]");
+ var brackets = new RegExp("[()]");
+ var identifiers = new RegExp("^[%A-Za-z][A-Za-z0-9]*");
+ var commandKeywords = ["break","close","do","else","for","goto", "halt", "hang", "if", "job","kill","lock","merge","new","open", "quit", "read", "set", "tcommit", "trollback", "tstart", "use", "view", "write", "xecute", "b","c","d","e","f","g", "h", "i", "j","k","l","m","n","o", "q", "r", "s", "tc", "tro", "ts", "u", "v", "w", "x"];
+ // The following list includes instrinsic functions _and_ special variables
+ var intrinsicFuncsWords = ["\\$ascii", "\\$char", "\\$data", "\\$ecode", "\\$estack", "\\$etrap", "\\$extract", "\\$find", "\\$fnumber", "\\$get", "\\$horolog", "\\$io", "\\$increment", "\\$job", "\\$justify", "\\$length", "\\$name", "\\$next", "\\$order", "\\$piece", "\\$qlength", "\\$qsubscript", "\\$query", "\\$quit", "\\$random", "\\$reverse", "\\$select", "\\$stack", "\\$test", "\\$text", "\\$translate", "\\$view", "\\$x", "\\$y", "\\$a", "\\$c", "\\$d", "\\$e", "\\$ec", "\\$es", "\\$et", "\\$f", "\\$fn", "\\$g", "\\$h", "\\$i", "\\$j", "\\$l", "\\$n", "\\$na", "\\$o", "\\$p", "\\$q", "\\$ql", "\\$qs", "\\$r", "\\$re", "\\$s", "\\$st", "\\$t", "\\$tr", "\\$v", "\\$z"];
+ var intrinsicFuncs = wordRegexp(intrinsicFuncsWords);
+ var command = wordRegexp(commandKeywords);
+
+ function tokenBase(stream, state) {
+ if (stream.sol()) {
+ state.label = true;
+ state.commandMode = 0;
+ }
+
+ // The character has meaning in MUMPS. Ignoring consecutive
+ // spaces would interfere with interpreting whether the next non-space
+ // character belongs to the command or argument context.
+
+ // Examine each character and update a mode variable whose interpretation is:
+ // >0 => command 0 => argument <0 => command post-conditional
+ var ch = stream.peek();
+
+ if (ch == " " || ch == "\t") { // Pre-process
+ state.label = false;
+ if (state.commandMode == 0)
+ state.commandMode = 1;
+ else if ((state.commandMode < 0) || (state.commandMode == 2))
+ state.commandMode = 0;
+ } else if ((ch != ".") && (state.commandMode > 0)) {
+ if (ch == ":")
+ state.commandMode = -1; // SIS - Command post-conditional
+ else
+ state.commandMode = 2;
+ }
+
+ // Do not color parameter list as line tag
+ if ((ch === "(") || (ch === "\u0009"))
+ state.label = false;
+
+ // MUMPS comment starts with ";"
+ if (ch === ";") {
+ stream.skipToEnd();
+ return "comment";
+ }
+
+ // Number Literals // SIS/RLM - MUMPS permits canonic number followed by concatenate operator
+ if (stream.match(/^[-+]?\d+(\.\d+)?([eE][-+]?\d+)?/))
+ return "number";
+
+ // Handle Strings
+ if (ch == '"') {
+ if (stream.skipTo('"')) {
+ stream.next();
+ return "string";
+ } else {
+ stream.skipToEnd();
+ return "error";
+ }
+ }
+
+ // Handle operators and Delimiters
+ if (stream.match(doubleOperators) || stream.match(singleOperators))
+ return "operator";
+
+ // Prevents leading "." in DO block from falling through to error
+ if (stream.match(singleDelimiters))
+ return null;
+
+ if (brackets.test(ch)) {
+ stream.next();
+ return "bracket";
+ }
+
+ if (state.commandMode > 0 && stream.match(command))
+ return "variable-2";
+
+ if (stream.match(intrinsicFuncs))
+ return "builtin";
+
+ if (stream.match(identifiers))
+ return "variable";
+
+ // Detect dollar-sign when not a documented intrinsic function
+ // "^" may introduce a GVN or SSVN - Color same as function
+ if (ch === "$" || ch === "^") {
+ stream.next();
+ return "builtin";
+ }
+
+ // MUMPS Indirection
+ if (ch === "@") {
+ stream.next();
+ return "string-2";
+ }
+
+ if (/[\w%]/.test(ch)) {
+ stream.eatWhile(/[\w%]/);
+ return "variable";
+ }
+
+ // Handle non-detected items
+ stream.next();
+ return "error";
+ }
+
+ return {
+ startState: function() {
+ return {
+ label: false,
+ commandMode: 0
+ };
+ },
+
+ token: function(stream, state) {
+ var style = tokenBase(stream, state);
+ if (state.label) return "tag";
+ return style;
+ }
+ };
+ });
+
+ CodeMirror.defineMIME("text/x-mumps", "mumps");
+});
diff --git a/www/code/codemirror-5.7/mode/nginx/index.html b/www/code/codemirror-5.7/mode/nginx/index.html
new file mode 100644
index 000000000..5ffdc081c
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/nginx/index.html
@@ -0,0 +1,181 @@
+
+
+CodeMirror: NGINX mode
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/www/code/codemirror-5.7/mode/nginx/nginx.js b/www/code/codemirror-5.7/mode/nginx/nginx.js
new file mode 100644
index 000000000..135b9cc7f
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/nginx/nginx.js
@@ -0,0 +1,178 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+ if (typeof exports == "object" && typeof module == "object") // CommonJS
+ mod(require("../../lib/codemirror"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("nginx", function(config) {
+
+ function words(str) {
+ var obj = {}, words = str.split(" ");
+ for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+ return obj;
+ }
+
+ var keywords = words(
+ /* ngxDirectiveControl */ "break return rewrite set" +
+ /* ngxDirective */ " accept_mutex accept_mutex_delay access_log add_after_body add_before_body add_header addition_types aio alias allow ancient_browser ancient_browser_value auth_basic auth_basic_user_file auth_http auth_http_header auth_http_timeout autoindex autoindex_exact_size autoindex_localtime charset charset_types client_body_buffer_size client_body_in_file_only client_body_in_single_buffer client_body_temp_path client_body_timeout client_header_buffer_size client_header_timeout client_max_body_size connection_pool_size create_full_put_path daemon dav_access dav_methods debug_connection debug_points default_type degradation degrade deny devpoll_changes devpoll_events directio directio_alignment empty_gif env epoll_events error_log eventport_events expires fastcgi_bind fastcgi_buffer_size fastcgi_buffers fastcgi_busy_buffers_size fastcgi_cache fastcgi_cache_key fastcgi_cache_methods fastcgi_cache_min_uses fastcgi_cache_path fastcgi_cache_use_stale fastcgi_cache_valid fastcgi_catch_stderr fastcgi_connect_timeout fastcgi_hide_header fastcgi_ignore_client_abort fastcgi_ignore_headers fastcgi_index fastcgi_intercept_errors fastcgi_max_temp_file_size fastcgi_next_upstream fastcgi_param fastcgi_pass_header fastcgi_pass_request_body fastcgi_pass_request_headers fastcgi_read_timeout fastcgi_send_lowat fastcgi_send_timeout fastcgi_split_path_info fastcgi_store fastcgi_store_access fastcgi_temp_file_write_size fastcgi_temp_path fastcgi_upstream_fail_timeout fastcgi_upstream_max_fails flv geoip_city geoip_country google_perftools_profiles gzip gzip_buffers gzip_comp_level gzip_disable gzip_hash gzip_http_version gzip_min_length gzip_no_buffer gzip_proxied gzip_static gzip_types gzip_vary gzip_window if_modified_since ignore_invalid_headers image_filter image_filter_buffer image_filter_jpeg_quality image_filter_transparency imap_auth imap_capabilities imap_client_buffer index ip_hash keepalive_requests keepalive_timeout kqueue_changes kqueue_events large_client_header_buffers limit_conn limit_conn_log_level limit_rate limit_rate_after limit_req limit_req_log_level limit_req_zone limit_zone lingering_time lingering_timeout lock_file log_format log_not_found log_subrequest map_hash_bucket_size map_hash_max_size master_process memcached_bind memcached_buffer_size memcached_connect_timeout memcached_next_upstream memcached_read_timeout memcached_send_timeout memcached_upstream_fail_timeout memcached_upstream_max_fails merge_slashes min_delete_depth modern_browser modern_browser_value msie_padding msie_refresh multi_accept open_file_cache open_file_cache_errors open_file_cache_events open_file_cache_min_uses open_file_cache_valid open_log_file_cache output_buffers override_charset perl perl_modules perl_require perl_set pid pop3_auth pop3_capabilities port_in_redirect postpone_gzipping postpone_output protocol proxy proxy_bind proxy_buffer proxy_buffer_size proxy_buffering proxy_buffers proxy_busy_buffers_size proxy_cache proxy_cache_key proxy_cache_methods proxy_cache_min_uses proxy_cache_path proxy_cache_use_stale proxy_cache_valid proxy_connect_timeout proxy_headers_hash_bucket_size proxy_headers_hash_max_size proxy_hide_header proxy_ignore_client_abort proxy_ignore_headers proxy_intercept_errors proxy_max_temp_file_size proxy_method proxy_next_upstream proxy_pass_error_message proxy_pass_header proxy_pass_request_body proxy_pass_request_headers proxy_read_timeout proxy_redirect proxy_send_lowat proxy_send_timeout proxy_set_body proxy_set_header proxy_ssl_session_reuse proxy_store proxy_store_access proxy_temp_file_write_size proxy_temp_path proxy_timeout proxy_upstream_fail_timeout proxy_upstream_max_fails random_index read_ahead real_ip_header recursive_error_pages request_pool_size reset_timedout_connection resolver resolver_timeout rewrite_log rtsig_overflow_events rtsig_overflow_test rtsig_overflow_threshold rtsig_signo satisfy secure_link_secret send_lowat send_timeout sendfile sendfile_max_chunk server_name_in_redirect server_names_hash_bucket_size server_names_hash_max_size server_tokens set_real_ip_from smtp_auth smtp_capabilities smtp_client_buffer smtp_greeting_delay so_keepalive source_charset ssi ssi_ignore_recycled_buffers ssi_min_file_chunk ssi_silent_errors ssi_types ssi_value_length ssl ssl_certificate ssl_certificate_key ssl_ciphers ssl_client_certificate ssl_crl ssl_dhparam ssl_engine ssl_prefer_server_ciphers ssl_protocols ssl_session_cache ssl_session_timeout ssl_verify_client ssl_verify_depth starttls stub_status sub_filter sub_filter_once sub_filter_types tcp_nodelay tcp_nopush thread_stack_size timeout timer_resolution types_hash_bucket_size types_hash_max_size underscores_in_headers uninitialized_variable_warn use user userid userid_domain userid_expires userid_mark userid_name userid_p3p userid_path userid_service valid_referers variables_hash_bucket_size variables_hash_max_size worker_connections worker_cpu_affinity worker_priority worker_processes worker_rlimit_core worker_rlimit_nofile worker_rlimit_sigpending worker_threads working_directory xclient xml_entities xslt_stylesheet xslt_typesdrew@li229-23"
+ );
+
+ var keywords_block = words(
+ /* ngxDirectiveBlock */ "http mail events server types location upstream charset_map limit_except if geo map"
+ );
+
+ var keywords_important = words(
+ /* ngxDirectiveImportant */ "include root server server_name listen internal proxy_pass memcached_pass fastcgi_pass try_files"
+ );
+
+ var indentUnit = config.indentUnit, type;
+ function ret(style, tp) {type = tp; return style;}
+
+ function tokenBase(stream, state) {
+
+
+ stream.eatWhile(/[\w\$_]/);
+
+ var cur = stream.current();
+
+
+ if (keywords.propertyIsEnumerable(cur)) {
+ return "keyword";
+ }
+ else if (keywords_block.propertyIsEnumerable(cur)) {
+ return "variable-2";
+ }
+ else if (keywords_important.propertyIsEnumerable(cur)) {
+ return "string-2";
+ }
+ /**/
+
+ 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.skipToEnd();
+ return ret("comment", "comment");
+ }
+ 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;
+ type = 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/nginx", "text/x-nginx-conf");
+
+});
diff --git a/www/code/codemirror-5.7/mode/ntriples/index.html b/www/code/codemirror-5.7/mode/ntriples/index.html
new file mode 100644
index 000000000..1355e7189
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/ntriples/index.html
@@ -0,0 +1,45 @@
+
+
+CodeMirror: NTriples mode
+
+
+
+
+
+
+
+
+
+
+
diff --git a/www/code/codemirror-5.7/mode/ntriples/ntriples.js b/www/code/codemirror-5.7/mode/ntriples/ntriples.js
new file mode 100644
index 000000000..0524b1e8a
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/ntriples/ntriples.js
@@ -0,0 +1,186 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+/**********************************************************
+* This script provides syntax highlighting support for
+* the Ntriples format.
+* Ntriples format specification:
+* http://www.w3.org/TR/rdf-testcases/#ntriples
+***********************************************************/
+
+/*
+ The following expression defines the defined ASF grammar transitions.
+
+ pre_subject ->
+ {
+ ( writing_subject_uri | writing_bnode_uri )
+ -> pre_predicate
+ -> writing_predicate_uri
+ -> pre_object
+ -> writing_object_uri | writing_object_bnode |
+ (
+ writing_object_literal
+ -> writing_literal_lang | writing_literal_type
+ )
+ -> post_object
+ -> BEGIN
+ } otherwise {
+ -> ERROR
+ }
+*/
+
+(function(mod) {
+ if (typeof exports == "object" && typeof module == "object") // CommonJS
+ mod(require("../../lib/codemirror"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("ntriples", function() {
+
+ var Location = {
+ PRE_SUBJECT : 0,
+ WRITING_SUB_URI : 1,
+ WRITING_BNODE_URI : 2,
+ PRE_PRED : 3,
+ WRITING_PRED_URI : 4,
+ PRE_OBJ : 5,
+ WRITING_OBJ_URI : 6,
+ WRITING_OBJ_BNODE : 7,
+ WRITING_OBJ_LITERAL : 8,
+ WRITING_LIT_LANG : 9,
+ WRITING_LIT_TYPE : 10,
+ POST_OBJ : 11,
+ ERROR : 12
+ };
+ function transitState(currState, c) {
+ var currLocation = currState.location;
+ var ret;
+
+ // Opening.
+ if (currLocation == Location.PRE_SUBJECT && c == '<') ret = Location.WRITING_SUB_URI;
+ else if(currLocation == Location.PRE_SUBJECT && c == '_') ret = Location.WRITING_BNODE_URI;
+ else if(currLocation == Location.PRE_PRED && c == '<') ret = Location.WRITING_PRED_URI;
+ else if(currLocation == Location.PRE_OBJ && c == '<') ret = Location.WRITING_OBJ_URI;
+ else if(currLocation == Location.PRE_OBJ && c == '_') ret = Location.WRITING_OBJ_BNODE;
+ else if(currLocation == Location.PRE_OBJ && c == '"') ret = Location.WRITING_OBJ_LITERAL;
+
+ // Closing.
+ else if(currLocation == Location.WRITING_SUB_URI && c == '>') ret = Location.PRE_PRED;
+ else if(currLocation == Location.WRITING_BNODE_URI && c == ' ') ret = Location.PRE_PRED;
+ else if(currLocation == Location.WRITING_PRED_URI && c == '>') ret = Location.PRE_OBJ;
+ else if(currLocation == Location.WRITING_OBJ_URI && c == '>') ret = Location.POST_OBJ;
+ else if(currLocation == Location.WRITING_OBJ_BNODE && c == ' ') ret = Location.POST_OBJ;
+ else if(currLocation == Location.WRITING_OBJ_LITERAL && c == '"') ret = Location.POST_OBJ;
+ else if(currLocation == Location.WRITING_LIT_LANG && c == ' ') ret = Location.POST_OBJ;
+ else if(currLocation == Location.WRITING_LIT_TYPE && c == '>') ret = Location.POST_OBJ;
+
+ // Closing typed and language literal.
+ else if(currLocation == Location.WRITING_OBJ_LITERAL && c == '@') ret = Location.WRITING_LIT_LANG;
+ else if(currLocation == Location.WRITING_OBJ_LITERAL && c == '^') ret = Location.WRITING_LIT_TYPE;
+
+ // Spaces.
+ else if( c == ' ' &&
+ (
+ currLocation == Location.PRE_SUBJECT ||
+ currLocation == Location.PRE_PRED ||
+ currLocation == Location.PRE_OBJ ||
+ currLocation == Location.POST_OBJ
+ )
+ ) ret = currLocation;
+
+ // Reset.
+ else if(currLocation == Location.POST_OBJ && c == '.') ret = Location.PRE_SUBJECT;
+
+ // Error
+ else ret = Location.ERROR;
+
+ currState.location=ret;
+ }
+
+ return {
+ startState: function() {
+ return {
+ location : Location.PRE_SUBJECT,
+ uris : [],
+ anchors : [],
+ bnodes : [],
+ langs : [],
+ types : []
+ };
+ },
+ token: function(stream, state) {
+ var ch = stream.next();
+ if(ch == '<') {
+ transitState(state, ch);
+ var parsedURI = '';
+ stream.eatWhile( function(c) { if( c != '#' && c != '>' ) { parsedURI += c; return true; } return false;} );
+ state.uris.push(parsedURI);
+ if( stream.match('#', false) ) return 'variable';
+ stream.next();
+ transitState(state, '>');
+ return 'variable';
+ }
+ if(ch == '#') {
+ var parsedAnchor = '';
+ stream.eatWhile(function(c) { if(c != '>' && c != ' ') { parsedAnchor+= c; return true; } return false;});
+ state.anchors.push(parsedAnchor);
+ return 'variable-2';
+ }
+ if(ch == '>') {
+ transitState(state, '>');
+ return 'variable';
+ }
+ if(ch == '_') {
+ transitState(state, ch);
+ var parsedBNode = '';
+ stream.eatWhile(function(c) { if( c != ' ' ) { parsedBNode += c; return true; } return false;});
+ state.bnodes.push(parsedBNode);
+ stream.next();
+ transitState(state, ' ');
+ return 'builtin';
+ }
+ if(ch == '"') {
+ transitState(state, ch);
+ stream.eatWhile( function(c) { return c != '"'; } );
+ stream.next();
+ if( stream.peek() != '@' && stream.peek() != '^' ) {
+ transitState(state, '"');
+ }
+ return 'string';
+ }
+ if( ch == '@' ) {
+ transitState(state, '@');
+ var parsedLang = '';
+ stream.eatWhile(function(c) { if( c != ' ' ) { parsedLang += c; return true; } return false;});
+ state.langs.push(parsedLang);
+ stream.next();
+ transitState(state, ' ');
+ return 'string-2';
+ }
+ if( ch == '^' ) {
+ stream.next();
+ transitState(state, '^');
+ var parsedType = '';
+ stream.eatWhile(function(c) { if( c != '>' ) { parsedType += c; return true; } return false;} );
+ state.types.push(parsedType);
+ stream.next();
+ transitState(state, '>');
+ return 'variable';
+ }
+ if( ch == ' ' ) {
+ transitState(state, ch);
+ }
+ if( ch == '.' ) {
+ transitState(state, ch);
+ }
+ }
+ };
+});
+
+CodeMirror.defineMIME("text/n-triples", "ntriples");
+
+});
diff --git a/www/code/codemirror-5.7/mode/octave/index.html b/www/code/codemirror-5.7/mode/octave/index.html
new file mode 100644
index 000000000..79df58119
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/octave/index.html
@@ -0,0 +1,83 @@
+
+
+CodeMirror: Octave mode
+
+
+
+
+
+
+
+
+
+
+
diff --git a/www/code/codemirror-5.7/mode/octave/octave.js b/www/code/codemirror-5.7/mode/octave/octave.js
new file mode 100644
index 000000000..a7bec030c
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/octave/octave.js
@@ -0,0 +1,135 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+ if (typeof exports == "object" && typeof module == "object") // CommonJS
+ mod(require("../../lib/codemirror"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("octave", function() {
+ function wordRegexp(words) {
+ return new RegExp("^((" + words.join(")|(") + "))\\b");
+ }
+
+ var singleOperators = new RegExp("^[\\+\\-\\*/&|\\^~<>!@'\\\\]");
+ var singleDelimiters = new RegExp('^[\\(\\[\\{\\},:=;]');
+ var doubleOperators = new RegExp("^((==)|(~=)|(<=)|(>=)|(<<)|(>>)|(\\.[\\+\\-\\*/\\^\\\\]))");
+ var doubleDelimiters = new RegExp("^((!=)|(\\+=)|(\\-=)|(\\*=)|(/=)|(&=)|(\\|=)|(\\^=))");
+ var tripleDelimiters = new RegExp("^((>>=)|(<<=))");
+ var expressionEnd = new RegExp("^[\\]\\)]");
+ var identifiers = new RegExp("^[_A-Za-z\xa1-\uffff][_A-Za-z0-9\xa1-\uffff]*");
+
+ var builtins = wordRegexp([
+ 'error', 'eval', 'function', 'abs', 'acos', 'atan', 'asin', 'cos',
+ 'cosh', 'exp', 'log', 'prod', 'sum', 'log10', 'max', 'min', 'sign', 'sin', 'sinh',
+ 'sqrt', 'tan', 'reshape', 'break', 'zeros', 'default', 'margin', 'round', 'ones',
+ 'rand', 'syn', 'ceil', 'floor', 'size', 'clear', 'zeros', 'eye', 'mean', 'std', 'cov',
+ 'det', 'eig', 'inv', 'norm', 'rank', 'trace', 'expm', 'logm', 'sqrtm', 'linspace', 'plot',
+ 'title', 'xlabel', 'ylabel', 'legend', 'text', 'grid', 'meshgrid', 'mesh', 'num2str',
+ 'fft', 'ifft', 'arrayfun', 'cellfun', 'input', 'fliplr', 'flipud', 'ismember'
+ ]);
+
+ var keywords = wordRegexp([
+ 'return', 'case', 'switch', 'else', 'elseif', 'end', 'endif', 'endfunction',
+ 'if', 'otherwise', 'do', 'for', 'while', 'try', 'catch', 'classdef', 'properties', 'events',
+ 'methods', 'global', 'persistent', 'endfor', 'endwhile', 'printf', 'sprintf', 'disp', 'until',
+ 'continue', 'pkg'
+ ]);
+
+
+ // tokenizers
+ function tokenTranspose(stream, state) {
+ if (!stream.sol() && stream.peek() === '\'') {
+ stream.next();
+ state.tokenize = tokenBase;
+ return 'operator';
+ }
+ state.tokenize = tokenBase;
+ return tokenBase(stream, state);
+ }
+
+
+ function tokenComment(stream, state) {
+ if (stream.match(/^.*%}/)) {
+ state.tokenize = tokenBase;
+ return 'comment';
+ };
+ stream.skipToEnd();
+ return 'comment';
+ }
+
+ function tokenBase(stream, state) {
+ // whitespaces
+ if (stream.eatSpace()) return null;
+
+ // Handle one line Comments
+ if (stream.match('%{')){
+ state.tokenize = tokenComment;
+ stream.skipToEnd();
+ return 'comment';
+ }
+
+ if (stream.match(/^[%#]/)){
+ stream.skipToEnd();
+ return 'comment';
+ }
+
+ // Handle Number Literals
+ if (stream.match(/^[0-9\.+-]/, false)) {
+ if (stream.match(/^[+-]?0x[0-9a-fA-F]+[ij]?/)) {
+ stream.tokenize = tokenBase;
+ return 'number'; };
+ if (stream.match(/^[+-]?\d*\.\d+([EeDd][+-]?\d+)?[ij]?/)) { return 'number'; };
+ if (stream.match(/^[+-]?\d+([EeDd][+-]?\d+)?[ij]?/)) { return 'number'; };
+ }
+ if (stream.match(wordRegexp(['nan','NaN','inf','Inf']))) { return 'number'; };
+
+ // Handle Strings
+ if (stream.match(/^"([^"]|(""))*"/)) { return 'string'; } ;
+ if (stream.match(/^'([^']|(''))*'/)) { return 'string'; } ;
+
+ // Handle words
+ if (stream.match(keywords)) { return 'keyword'; } ;
+ if (stream.match(builtins)) { return 'builtin'; } ;
+ if (stream.match(identifiers)) { return 'variable'; } ;
+
+ if (stream.match(singleOperators) || stream.match(doubleOperators)) { return 'operator'; };
+ if (stream.match(singleDelimiters) || stream.match(doubleDelimiters) || stream.match(tripleDelimiters)) { return null; };
+
+ if (stream.match(expressionEnd)) {
+ state.tokenize = tokenTranspose;
+ return null;
+ };
+
+
+ // Handle non-detected items
+ stream.next();
+ return 'error';
+ };
+
+
+ return {
+ startState: function() {
+ return {
+ tokenize: tokenBase
+ };
+ },
+
+ token: function(stream, state) {
+ var style = state.tokenize(stream, state);
+ if (style === 'number' || style === 'variable'){
+ state.tokenize = tokenTranspose;
+ }
+ return style;
+ }
+ };
+});
+
+CodeMirror.defineMIME("text/x-octave", "octave");
+
+});
diff --git a/www/code/codemirror-5.7/mode/oz/index.html b/www/code/codemirror-5.7/mode/oz/index.html
new file mode 100644
index 000000000..febd82a59
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/oz/index.html
@@ -0,0 +1,59 @@
+
+
+CodeMirror: Oz mode
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/www/code/codemirror-5.7/mode/oz/oz.js b/www/code/codemirror-5.7/mode/oz/oz.js
new file mode 100644
index 000000000..ee8cb0ad1
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/oz/oz.js
@@ -0,0 +1,252 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+ if (typeof exports == "object" && typeof module == "object") // CommonJS
+ mod(require("../../lib/codemirror"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("oz", function (conf) {
+
+ function wordRegexp(words) {
+ return new RegExp("^((" + words.join(")|(") + "))\\b");
+ }
+
+ var singleOperators = /[\^@!\|<>#~\.\*\-\+\\/,=]/;
+ var doubleOperators = /(<-)|(:=)|(=<)|(>=)|(<=)|(<:)|(>:)|(=:)|(\\=)|(\\=:)|(!!)|(==)|(::)/;
+ var tripleOperators = /(:::)|(\.\.\.)|(=<:)|(>=:)/;
+
+ var middle = ["in", "then", "else", "of", "elseof", "elsecase", "elseif", "catch",
+ "finally", "with", "require", "prepare", "import", "export", "define", "do"];
+ var end = ["end"];
+
+ var atoms = wordRegexp(["true", "false", "nil", "unit"]);
+ var commonKeywords = wordRegexp(["andthen", "at", "attr", "declare", "feat", "from", "lex",
+ "mod", "mode", "orelse", "parser", "prod", "prop", "scanner", "self", "syn", "token"]);
+ var openingKeywords = wordRegexp(["local", "proc", "fun", "case", "class", "if", "cond", "or", "dis",
+ "choice", "not", "thread", "try", "raise", "lock", "for", "suchthat", "meth", "functor"]);
+ var middleKeywords = wordRegexp(middle);
+ var endKeywords = wordRegexp(end);
+
+ // Tokenizers
+ function tokenBase(stream, state) {
+ if (stream.eatSpace()) {
+ return null;
+ }
+
+ // Brackets
+ if(stream.match(/[{}]/)) {
+ return "bracket";
+ }
+
+ // Special [] keyword
+ if (stream.match(/(\[])/)) {
+ return "keyword"
+ }
+
+ // Operators
+ if (stream.match(tripleOperators) || stream.match(doubleOperators)) {
+ return "operator";
+ }
+
+ // Atoms
+ if(stream.match(atoms)) {
+ return 'atom';
+ }
+
+ // Opening keywords
+ var matched = stream.match(openingKeywords);
+ if (matched) {
+ if (!state.doInCurrentLine)
+ state.currentIndent++;
+ else
+ state.doInCurrentLine = false;
+
+ // Special matching for signatures
+ if(matched[0] == "proc" || matched[0] == "fun")
+ state.tokenize = tokenFunProc;
+ else if(matched[0] == "class")
+ state.tokenize = tokenClass;
+ else if(matched[0] == "meth")
+ state.tokenize = tokenMeth;
+
+ return 'keyword';
+ }
+
+ // Middle and other keywords
+ if (stream.match(middleKeywords) || stream.match(commonKeywords)) {
+ return "keyword"
+ }
+
+ // End keywords
+ if (stream.match(endKeywords)) {
+ state.currentIndent--;
+ return 'keyword';
+ }
+
+ // Eat the next char for next comparisons
+ var ch = stream.next();
+
+ // Strings
+ if (ch == '"' || ch == "'") {
+ state.tokenize = tokenString(ch);
+ return state.tokenize(stream, state);
+ }
+
+ // Numbers
+ if (/[~\d]/.test(ch)) {
+ if (ch == "~") {
+ if(! /^[0-9]/.test(stream.peek()))
+ return null;
+ else if (( stream.next() == "0" && stream.match(/^[xX][0-9a-fA-F]+/)) || stream.match(/^[0-9]*(\.[0-9]+)?([eE][~+]?[0-9]+)?/))
+ return "number";
+ }
+
+ if ((ch == "0" && stream.match(/^[xX][0-9a-fA-F]+/)) || stream.match(/^[0-9]*(\.[0-9]+)?([eE][~+]?[0-9]+)?/))
+ return "number";
+
+ return null;
+ }
+
+ // Comments
+ if (ch == "%") {
+ stream.skipToEnd();
+ return 'comment';
+ }
+ else if (ch == "/") {
+ if (stream.eat("*")) {
+ state.tokenize = tokenComment;
+ return tokenComment(stream, state);
+ }
+ }
+
+ // Single operators
+ if(singleOperators.test(ch)) {
+ return "operator";
+ }
+
+ // If nothing match, we skip the entire alphanumerical block
+ stream.eatWhile(/\w/);
+
+ return "variable";
+ }
+
+ function tokenClass(stream, state) {
+ if (stream.eatSpace()) {
+ return null;
+ }
+ stream.match(/([A-Z][A-Za-z0-9_]*)|(`.+`)/);
+ state.tokenize = tokenBase;
+ return "variable-3"
+ }
+
+ function tokenMeth(stream, state) {
+ if (stream.eatSpace()) {
+ return null;
+ }
+ stream.match(/([a-zA-Z][A-Za-z0-9_]*)|(`.+`)/);
+ state.tokenize = tokenBase;
+ return "def"
+ }
+
+ function tokenFunProc(stream, state) {
+ if (stream.eatSpace()) {
+ return null;
+ }
+
+ if(!state.hasPassedFirstStage && stream.eat("{")) {
+ state.hasPassedFirstStage = true;
+ return "bracket";
+ }
+ else if(state.hasPassedFirstStage) {
+ stream.match(/([A-Z][A-Za-z0-9_]*)|(`.+`)|\$/);
+ state.hasPassedFirstStage = false;
+ state.tokenize = tokenBase;
+ return "def"
+ }
+ else {
+ state.tokenize = tokenBase;
+ return null;
+ }
+ }
+
+ function tokenComment(stream, state) {
+ var maybeEnd = false, ch;
+ while (ch = stream.next()) {
+ if (ch == "/" && maybeEnd) {
+ state.tokenize = tokenBase;
+ break;
+ }
+ maybeEnd = (ch == "*");
+ }
+ return "comment";
+ }
+
+ 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)
+ state.tokenize = tokenBase;
+ return "string";
+ };
+ }
+
+ function buildElectricInputRegEx() {
+ // Reindentation should occur on [] or on a match of any of
+ // the block closing keywords, at the end of a line.
+ var allClosings = middle.concat(end);
+ return new RegExp("[\\[\\]]|(" + allClosings.join("|") + ")$");
+ }
+
+ return {
+
+ startState: function () {
+ return {
+ tokenize: tokenBase,
+ currentIndent: 0,
+ doInCurrentLine: false,
+ hasPassedFirstStage: false
+ };
+ },
+
+ token: function (stream, state) {
+ if (stream.sol())
+ state.doInCurrentLine = 0;
+
+ return state.tokenize(stream, state);
+ },
+
+ indent: function (state, textAfter) {
+ var trueText = textAfter.replace(/^\s+|\s+$/g, '');
+
+ if (trueText.match(endKeywords) || trueText.match(middleKeywords) || trueText.match(/(\[])/))
+ return conf.indentUnit * (state.currentIndent - 1);
+
+ if (state.currentIndent < 0)
+ return 0;
+
+ return state.currentIndent * conf.indentUnit;
+ },
+ fold: "indent",
+ electricInput: buildElectricInputRegEx(),
+ lineComment: "%",
+ blockCommentStart: "/*",
+ blockCommentEnd: "*/"
+ };
+});
+
+CodeMirror.defineMIME("text/x-oz", "oz");
+
+});
diff --git a/www/code/codemirror-5.7/mode/pascal/index.html b/www/code/codemirror-5.7/mode/pascal/index.html
new file mode 100644
index 000000000..f8a99ad01
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/pascal/index.html
@@ -0,0 +1,61 @@
+
+
+CodeMirror: Pascal mode
+
+
+
+
+
+
+
+
+
+
+
diff --git a/www/code/codemirror-5.7/mode/pascal/pascal.js b/www/code/codemirror-5.7/mode/pascal/pascal.js
new file mode 100644
index 000000000..2d0c3d424
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/pascal/pascal.js
@@ -0,0 +1,109 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+ if (typeof exports == "object" && typeof module == "object") // CommonJS
+ mod(require("../../lib/codemirror"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("pascal", function() {
+ function words(str) {
+ var obj = {}, words = str.split(" ");
+ for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+ return obj;
+ }
+ var keywords = words("and array begin case const div do downto else end file for forward integer " +
+ "boolean char function goto if in label mod nil not of or packed procedure " +
+ "program record repeat set string then to type until var while with");
+ var atoms = {"null": true};
+
+ var isOperatorChar = /[+\-*&%=<>!?|\/]/;
+
+ function tokenBase(stream, state) {
+ var ch = stream.next();
+ if (ch == "#" && state.startOfLine) {
+ stream.skipToEnd();
+ return "meta";
+ }
+ if (ch == '"' || ch == "'") {
+ state.tokenize = tokenString(ch);
+ return state.tokenize(stream, state);
+ }
+ if (ch == "(" && stream.eat("*")) {
+ state.tokenize = tokenComment;
+ return tokenComment(stream, state);
+ }
+ if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
+ return null;
+ }
+ if (/\d/.test(ch)) {
+ stream.eatWhile(/[\w\.]/);
+ return "number";
+ }
+ if (ch == "/") {
+ 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)) return "keyword";
+ if (atoms.propertyIsEnumerable(cur)) return "atom";
+ return "variable";
+ }
+
+ 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) state.tokenize = null;
+ return "string";
+ };
+ }
+
+ function tokenComment(stream, state) {
+ var maybeEnd = false, ch;
+ while (ch = stream.next()) {
+ if (ch == ")" && maybeEnd) {
+ state.tokenize = null;
+ break;
+ }
+ maybeEnd = (ch == "*");
+ }
+ return "comment";
+ }
+
+ // Interface
+
+ return {
+ startState: function() {
+ return {tokenize: null};
+ },
+
+ token: function(stream, state) {
+ if (stream.eatSpace()) return null;
+ var style = (state.tokenize || tokenBase)(stream, state);
+ if (style == "comment" || style == "meta") return style;
+ return style;
+ },
+
+ electricChars: "{}"
+ };
+});
+
+CodeMirror.defineMIME("text/x-pascal", "pascal");
+
+});
diff --git a/www/code/codemirror-5.7/mode/pegjs/index.html b/www/code/codemirror-5.7/mode/pegjs/index.html
new file mode 100644
index 000000000..0c7460488
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/pegjs/index.html
@@ -0,0 +1,66 @@
+
+
+
+ CodeMirror: PEG.js Mode
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/www/code/codemirror-5.7/mode/pegjs/pegjs.js b/www/code/codemirror-5.7/mode/pegjs/pegjs.js
new file mode 100644
index 000000000..306e3768c
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/pegjs/pegjs.js
@@ -0,0 +1,114 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+ if (typeof exports == "object" && typeof module == "object") // CommonJS
+ mod(require("../../lib/codemirror"), require("../javascript/javascript"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror", "../javascript/javascript"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("pegjs", function (config) {
+ var jsMode = CodeMirror.getMode(config, "javascript");
+
+ function identifier(stream) {
+ return stream.match(/^[a-zA-Z_][a-zA-Z0-9_]*/);
+ }
+
+ return {
+ startState: function () {
+ return {
+ inString: false,
+ stringType: null,
+ inComment: false,
+ inChracterClass: false,
+ braced: 0,
+ lhs: true,
+ localState: null
+ };
+ },
+ token: function (stream, state) {
+ if (stream)
+
+ //check for state changes
+ if (!state.inString && !state.inComment && ((stream.peek() == '"') || (stream.peek() == "'"))) {
+ state.stringType = stream.peek();
+ stream.next(); // Skip quote
+ state.inString = true; // Update state
+ }
+ if (!state.inString && !state.inComment && stream.match(/^\/\*/)) {
+ state.inComment = true;
+ }
+
+ //return state
+ if (state.inString) {
+ while (state.inString && !stream.eol()) {
+ if (stream.peek() === state.stringType) {
+ stream.next(); // Skip quote
+ state.inString = false; // Clear flag
+ } else if (stream.peek() === '\\') {
+ stream.next();
+ stream.next();
+ } else {
+ stream.match(/^.[^\\\"\']*/);
+ }
+ }
+ return state.lhs ? "property string" : "string"; // Token style
+ } else if (state.inComment) {
+ while (state.inComment && !stream.eol()) {
+ if (stream.match(/\*\//)) {
+ state.inComment = false; // Clear flag
+ } else {
+ stream.match(/^.[^\*]*/);
+ }
+ }
+ return "comment";
+ } else if (state.inChracterClass) {
+ while (state.inChracterClass && !stream.eol()) {
+ if (!(stream.match(/^[^\]\\]+/) || stream.match(/^\\./))) {
+ state.inChracterClass = false;
+ }
+ }
+ } else if (stream.peek() === '[') {
+ stream.next();
+ state.inChracterClass = true;
+ return 'bracket';
+ } else if (stream.match(/^\/\//)) {
+ stream.skipToEnd();
+ return "comment";
+ } else if (state.braced || stream.peek() === '{') {
+ if (state.localState === null) {
+ state.localState = jsMode.startState();
+ }
+ var token = jsMode.token(stream, state.localState);
+ var text = stream.current();
+ if (!token) {
+ for (var i = 0; i < text.length; i++) {
+ if (text[i] === '{') {
+ state.braced++;
+ } else if (text[i] === '}') {
+ state.braced--;
+ }
+ };
+ }
+ return token;
+ } else if (identifier(stream)) {
+ if (stream.peek() === ':') {
+ return 'variable';
+ }
+ return 'variable-2';
+ } else if (['[', ']', '(', ')'].indexOf(stream.peek()) != -1) {
+ stream.next();
+ return 'bracket';
+ } else if (!stream.eatSpace()) {
+ stream.next();
+ }
+ return null;
+ }
+ };
+}, "javascript");
+
+});
diff --git a/www/code/codemirror-5.7/mode/perl/index.html b/www/code/codemirror-5.7/mode/perl/index.html
new file mode 100644
index 000000000..8c1021c42
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/perl/index.html
@@ -0,0 +1,75 @@
+
+
+CodeMirror: Perl mode
+
+
+
+
+
+
+
+
+
+
+
diff --git a/www/code/codemirror-5.7/mode/perl/perl.js b/www/code/codemirror-5.7/mode/perl/perl.js
new file mode 100644
index 000000000..bef62bc7d
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/perl/perl.js
@@ -0,0 +1,837 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// CodeMirror2 mode/perl/perl.js (text/x-perl) beta 0.10 (2011-11-08)
+// This is a part of CodeMirror from https://github.com/sabaca/CodeMirror_mode_perl (mail@sabaca.com)
+
+(function(mod) {
+ if (typeof exports == "object" && typeof module == "object") // CommonJS
+ mod(require("../../lib/codemirror"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("perl",function(){
+ // http://perldoc.perl.org
+ var PERL={ // null - magic touch
+ // 1 - keyword
+ // 2 - def
+ // 3 - atom
+ // 4 - operator
+ // 5 - variable-2 (predefined)
+ // [x,y] - x=1,2,3; y=must be defined if x{...}
+ // PERL operators
+ '->' : 4,
+ '++' : 4,
+ '--' : 4,
+ '**' : 4,
+ // ! ~ \ and unary + and -
+ '=~' : 4,
+ '!~' : 4,
+ '*' : 4,
+ '/' : 4,
+ '%' : 4,
+ 'x' : 4,
+ '+' : 4,
+ '-' : 4,
+ '.' : 4,
+ '<<' : 4,
+ '>>' : 4,
+ // named unary operators
+ '<' : 4,
+ '>' : 4,
+ '<=' : 4,
+ '>=' : 4,
+ 'lt' : 4,
+ 'gt' : 4,
+ 'le' : 4,
+ 'ge' : 4,
+ '==' : 4,
+ '!=' : 4,
+ '<=>' : 4,
+ 'eq' : 4,
+ 'ne' : 4,
+ 'cmp' : 4,
+ '~~' : 4,
+ '&' : 4,
+ '|' : 4,
+ '^' : 4,
+ '&&' : 4,
+ '||' : 4,
+ '//' : 4,
+ '..' : 4,
+ '...' : 4,
+ '?' : 4,
+ ':' : 4,
+ '=' : 4,
+ '+=' : 4,
+ '-=' : 4,
+ '*=' : 4, // etc. ???
+ ',' : 4,
+ '=>' : 4,
+ '::' : 4,
+ // list operators (rightward)
+ 'not' : 4,
+ 'and' : 4,
+ 'or' : 4,
+ 'xor' : 4,
+ // PERL predefined variables (I know, what this is a paranoid idea, but may be needed for people, who learn PERL, and for me as well, ...and may be for you?;)
+ 'BEGIN' : [5,1],
+ 'END' : [5,1],
+ 'PRINT' : [5,1],
+ 'PRINTF' : [5,1],
+ 'GETC' : [5,1],
+ 'READ' : [5,1],
+ 'READLINE' : [5,1],
+ 'DESTROY' : [5,1],
+ 'TIE' : [5,1],
+ 'TIEHANDLE' : [5,1],
+ 'UNTIE' : [5,1],
+ 'STDIN' : 5,
+ 'STDIN_TOP' : 5,
+ 'STDOUT' : 5,
+ 'STDOUT_TOP' : 5,
+ 'STDERR' : 5,
+ 'STDERR_TOP' : 5,
+ '$ARG' : 5,
+ '$_' : 5,
+ '@ARG' : 5,
+ '@_' : 5,
+ '$LIST_SEPARATOR' : 5,
+ '$"' : 5,
+ '$PROCESS_ID' : 5,
+ '$PID' : 5,
+ '$$' : 5,
+ '$REAL_GROUP_ID' : 5,
+ '$GID' : 5,
+ '$(' : 5,
+ '$EFFECTIVE_GROUP_ID' : 5,
+ '$EGID' : 5,
+ '$)' : 5,
+ '$PROGRAM_NAME' : 5,
+ '$0' : 5,
+ '$SUBSCRIPT_SEPARATOR' : 5,
+ '$SUBSEP' : 5,
+ '$;' : 5,
+ '$REAL_USER_ID' : 5,
+ '$UID' : 5,
+ '$<' : 5,
+ '$EFFECTIVE_USER_ID' : 5,
+ '$EUID' : 5,
+ '$>' : 5,
+ '$a' : 5,
+ '$b' : 5,
+ '$COMPILING' : 5,
+ '$^C' : 5,
+ '$DEBUGGING' : 5,
+ '$^D' : 5,
+ '${^ENCODING}' : 5,
+ '$ENV' : 5,
+ '%ENV' : 5,
+ '$SYSTEM_FD_MAX' : 5,
+ '$^F' : 5,
+ '@F' : 5,
+ '${^GLOBAL_PHASE}' : 5,
+ '$^H' : 5,
+ '%^H' : 5,
+ '@INC' : 5,
+ '%INC' : 5,
+ '$INPLACE_EDIT' : 5,
+ '$^I' : 5,
+ '$^M' : 5,
+ '$OSNAME' : 5,
+ '$^O' : 5,
+ '${^OPEN}' : 5,
+ '$PERLDB' : 5,
+ '$^P' : 5,
+ '$SIG' : 5,
+ '%SIG' : 5,
+ '$BASETIME' : 5,
+ '$^T' : 5,
+ '${^TAINT}' : 5,
+ '${^UNICODE}' : 5,
+ '${^UTF8CACHE}' : 5,
+ '${^UTF8LOCALE}' : 5,
+ '$PERL_VERSION' : 5,
+ '$^V' : 5,
+ '${^WIN32_SLOPPY_STAT}' : 5,
+ '$EXECUTABLE_NAME' : 5,
+ '$^X' : 5,
+ '$1' : 5, // - regexp $1, $2...
+ '$MATCH' : 5,
+ '$&' : 5,
+ '${^MATCH}' : 5,
+ '$PREMATCH' : 5,
+ '$`' : 5,
+ '${^PREMATCH}' : 5,
+ '$POSTMATCH' : 5,
+ "$'" : 5,
+ '${^POSTMATCH}' : 5,
+ '$LAST_PAREN_MATCH' : 5,
+ '$+' : 5,
+ '$LAST_SUBMATCH_RESULT' : 5,
+ '$^N' : 5,
+ '@LAST_MATCH_END' : 5,
+ '@+' : 5,
+ '%LAST_PAREN_MATCH' : 5,
+ '%+' : 5,
+ '@LAST_MATCH_START' : 5,
+ '@-' : 5,
+ '%LAST_MATCH_START' : 5,
+ '%-' : 5,
+ '$LAST_REGEXP_CODE_RESULT' : 5,
+ '$^R' : 5,
+ '${^RE_DEBUG_FLAGS}' : 5,
+ '${^RE_TRIE_MAXBUF}' : 5,
+ '$ARGV' : 5,
+ '@ARGV' : 5,
+ 'ARGV' : 5,
+ 'ARGVOUT' : 5,
+ '$OUTPUT_FIELD_SEPARATOR' : 5,
+ '$OFS' : 5,
+ '$,' : 5,
+ '$INPUT_LINE_NUMBER' : 5,
+ '$NR' : 5,
+ '$.' : 5,
+ '$INPUT_RECORD_SEPARATOR' : 5,
+ '$RS' : 5,
+ '$/' : 5,
+ '$OUTPUT_RECORD_SEPARATOR' : 5,
+ '$ORS' : 5,
+ '$\\' : 5,
+ '$OUTPUT_AUTOFLUSH' : 5,
+ '$|' : 5,
+ '$ACCUMULATOR' : 5,
+ '$^A' : 5,
+ '$FORMAT_FORMFEED' : 5,
+ '$^L' : 5,
+ '$FORMAT_PAGE_NUMBER' : 5,
+ '$%' : 5,
+ '$FORMAT_LINES_LEFT' : 5,
+ '$-' : 5,
+ '$FORMAT_LINE_BREAK_CHARACTERS' : 5,
+ '$:' : 5,
+ '$FORMAT_LINES_PER_PAGE' : 5,
+ '$=' : 5,
+ '$FORMAT_TOP_NAME' : 5,
+ '$^' : 5,
+ '$FORMAT_NAME' : 5,
+ '$~' : 5,
+ '${^CHILD_ERROR_NATIVE}' : 5,
+ '$EXTENDED_OS_ERROR' : 5,
+ '$^E' : 5,
+ '$EXCEPTIONS_BEING_CAUGHT' : 5,
+ '$^S' : 5,
+ '$WARNING' : 5,
+ '$^W' : 5,
+ '${^WARNING_BITS}' : 5,
+ '$OS_ERROR' : 5,
+ '$ERRNO' : 5,
+ '$!' : 5,
+ '%OS_ERROR' : 5,
+ '%ERRNO' : 5,
+ '%!' : 5,
+ '$CHILD_ERROR' : 5,
+ '$?' : 5,
+ '$EVAL_ERROR' : 5,
+ '$@' : 5,
+ '$OFMT' : 5,
+ '$#' : 5,
+ '$*' : 5,
+ '$ARRAY_BASE' : 5,
+ '$[' : 5,
+ '$OLD_PERL_VERSION' : 5,
+ '$]' : 5,
+ // PERL blocks
+ 'if' :[1,1],
+ elsif :[1,1],
+ 'else' :[1,1],
+ 'while' :[1,1],
+ unless :[1,1],
+ 'for' :[1,1],
+ foreach :[1,1],
+ // PERL functions
+ 'abs' :1, // - absolute value function
+ accept :1, // - accept an incoming socket connect
+ alarm :1, // - schedule a SIGALRM
+ 'atan2' :1, // - arctangent of Y/X in the range -PI to PI
+ bind :1, // - binds an address to a socket
+ binmode :1, // - prepare binary files for I/O
+ bless :1, // - create an object
+ bootstrap :1, //
+ 'break' :1, // - break out of a "given" block
+ caller :1, // - get context of the current subroutine call
+ chdir :1, // - change your current working directory
+ chmod :1, // - changes the permissions on a list of files
+ chomp :1, // - remove a trailing record separator from a string
+ chop :1, // - remove the last character from a string
+ chown :1, // - change the owership on a list of files
+ chr :1, // - get character this number represents
+ chroot :1, // - make directory new root for path lookups
+ close :1, // - close file (or pipe or socket) handle
+ closedir :1, // - close directory handle
+ connect :1, // - connect to a remote socket
+ 'continue' :[1,1], // - optional trailing block in a while or foreach
+ 'cos' :1, // - cosine function
+ crypt :1, // - one-way passwd-style encryption
+ dbmclose :1, // - breaks binding on a tied dbm file
+ dbmopen :1, // - create binding on a tied dbm file
+ 'default' :1, //
+ defined :1, // - test whether a value, variable, or function is defined
+ 'delete' :1, // - deletes a value from a hash
+ die :1, // - raise an exception or bail out
+ 'do' :1, // - turn a BLOCK into a TERM
+ dump :1, // - create an immediate core dump
+ each :1, // - retrieve the next key/value pair from a hash
+ endgrent :1, // - be done using group file
+ endhostent :1, // - be done using hosts file
+ endnetent :1, // - be done using networks file
+ endprotoent :1, // - be done using protocols file
+ endpwent :1, // - be done using passwd file
+ endservent :1, // - be done using services file
+ eof :1, // - test a filehandle for its end
+ 'eval' :1, // - catch exceptions or compile and run code
+ 'exec' :1, // - abandon this program to run another
+ exists :1, // - test whether a hash key is present
+ exit :1, // - terminate this program
+ 'exp' :1, // - raise I to a power
+ fcntl :1, // - file control system call
+ fileno :1, // - return file descriptor from filehandle
+ flock :1, // - lock an entire file with an advisory lock
+ fork :1, // - create a new process just like this one
+ format :1, // - declare a picture format with use by the write() function
+ formline :1, // - internal function used for formats
+ getc :1, // - get the next character from the filehandle
+ getgrent :1, // - get next group record
+ getgrgid :1, // - get group record given group user ID
+ getgrnam :1, // - get group record given group name
+ gethostbyaddr :1, // - get host record given its address
+ gethostbyname :1, // - get host record given name
+ gethostent :1, // - get next hosts record
+ getlogin :1, // - return who logged in at this tty
+ getnetbyaddr :1, // - get network record given its address
+ getnetbyname :1, // - get networks record given name
+ getnetent :1, // - get next networks record
+ getpeername :1, // - find the other end of a socket connection
+ getpgrp :1, // - get process group
+ getppid :1, // - get parent process ID
+ getpriority :1, // - get current nice value
+ getprotobyname :1, // - get protocol record given name
+ getprotobynumber :1, // - get protocol record numeric protocol
+ getprotoent :1, // - get next protocols record
+ getpwent :1, // - get next passwd record
+ getpwnam :1, // - get passwd record given user login name
+ getpwuid :1, // - get passwd record given user ID
+ getservbyname :1, // - get services record given its name
+ getservbyport :1, // - get services record given numeric port
+ getservent :1, // - get next services record
+ getsockname :1, // - retrieve the sockaddr for a given socket
+ getsockopt :1, // - get socket options on a given socket
+ given :1, //
+ glob :1, // - expand filenames using wildcards
+ gmtime :1, // - convert UNIX time into record or string using Greenwich time
+ 'goto' :1, // - create spaghetti code
+ grep :1, // - locate elements in a list test true against a given criterion
+ hex :1, // - convert a string to a hexadecimal number
+ 'import' :1, // - patch a module's namespace into your own
+ index :1, // - find a substring within a string
+ 'int' :1, // - get the integer portion of a number
+ ioctl :1, // - system-dependent device control system call
+ 'join' :1, // - join a list into a string using a separator
+ keys :1, // - retrieve list of indices from a hash
+ kill :1, // - send a signal to a process or process group
+ last :1, // - exit a block prematurely
+ lc :1, // - return lower-case version of a string
+ lcfirst :1, // - return a string with just the next letter in lower case
+ length :1, // - return the number of bytes in a string
+ 'link' :1, // - create a hard link in the filesytem
+ listen :1, // - register your socket as a server
+ local : 2, // - create a temporary value for a global variable (dynamic scoping)
+ localtime :1, // - convert UNIX time into record or string using local time
+ lock :1, // - get a thread lock on a variable, subroutine, or method
+ 'log' :1, // - retrieve the natural logarithm for a number
+ lstat :1, // - stat a symbolic link
+ m :null, // - match a string with a regular expression pattern
+ map :1, // - apply a change to a list to get back a new list with the changes
+ mkdir :1, // - create a directory
+ msgctl :1, // - SysV IPC message control operations
+ msgget :1, // - get SysV IPC message queue
+ msgrcv :1, // - receive a SysV IPC message from a message queue
+ msgsnd :1, // - send a SysV IPC message to a message queue
+ my : 2, // - declare and assign a local variable (lexical scoping)
+ 'new' :1, //
+ next :1, // - iterate a block prematurely
+ no :1, // - unimport some module symbols or semantics at compile time
+ oct :1, // - convert a string to an octal number
+ open :1, // - open a file, pipe, or descriptor
+ opendir :1, // - open a directory
+ ord :1, // - find a character's numeric representation
+ our : 2, // - declare and assign a package variable (lexical scoping)
+ pack :1, // - convert a list into a binary representation
+ 'package' :1, // - declare a separate global namespace
+ pipe :1, // - open a pair of connected filehandles
+ pop :1, // - remove the last element from an array and return it
+ pos :1, // - find or set the offset for the last/next m//g search
+ print :1, // - output a list to a filehandle
+ printf :1, // - output a formatted list to a filehandle
+ prototype :1, // - get the prototype (if any) of a subroutine
+ push :1, // - append one or more elements to an array
+ q :null, // - singly quote a string
+ qq :null, // - doubly quote a string
+ qr :null, // - Compile pattern
+ quotemeta :null, // - quote regular expression magic characters
+ qw :null, // - quote a list of words
+ qx :null, // - backquote quote a string
+ rand :1, // - retrieve the next pseudorandom number
+ read :1, // - fixed-length buffered input from a filehandle
+ readdir :1, // - get a directory from a directory handle
+ readline :1, // - fetch a record from a file
+ readlink :1, // - determine where a symbolic link is pointing
+ readpipe :1, // - execute a system command and collect standard output
+ recv :1, // - receive a message over a Socket
+ redo :1, // - start this loop iteration over again
+ ref :1, // - find out the type of thing being referenced
+ rename :1, // - change a filename
+ require :1, // - load in external functions from a library at runtime
+ reset :1, // - clear all variables of a given name
+ 'return' :1, // - get out of a function early
+ reverse :1, // - flip a string or a list
+ rewinddir :1, // - reset directory handle
+ rindex :1, // - right-to-left substring search
+ rmdir :1, // - remove a directory
+ s :null, // - replace a pattern with a string
+ say :1, // - print with newline
+ scalar :1, // - force a scalar context
+ seek :1, // - reposition file pointer for random-access I/O
+ seekdir :1, // - reposition directory pointer
+ select :1, // - reset default output or do I/O multiplexing
+ semctl :1, // - SysV semaphore control operations
+ semget :1, // - get set of SysV semaphores
+ semop :1, // - SysV semaphore operations
+ send :1, // - send a message over a socket
+ setgrent :1, // - prepare group file for use
+ sethostent :1, // - prepare hosts file for use
+ setnetent :1, // - prepare networks file for use
+ setpgrp :1, // - set the process group of a process
+ setpriority :1, // - set a process's nice value
+ setprotoent :1, // - prepare protocols file for use
+ setpwent :1, // - prepare passwd file for use
+ setservent :1, // - prepare services file for use
+ setsockopt :1, // - set some socket options
+ shift :1, // - remove the first element of an array, and return it
+ shmctl :1, // - SysV shared memory operations
+ shmget :1, // - get SysV shared memory segment identifier
+ shmread :1, // - read SysV shared memory
+ shmwrite :1, // - write SysV shared memory
+ shutdown :1, // - close down just half of a socket connection
+ 'sin' :1, // - return the sine of a number
+ sleep :1, // - block for some number of seconds
+ socket :1, // - create a socket
+ socketpair :1, // - create a pair of sockets
+ 'sort' :1, // - sort a list of values
+ splice :1, // - add or remove elements anywhere in an array
+ 'split' :1, // - split up a string using a regexp delimiter
+ sprintf :1, // - formatted print into a string
+ 'sqrt' :1, // - square root function
+ srand :1, // - seed the random number generator
+ stat :1, // - get a file's status information
+ state :1, // - declare and assign a state variable (persistent lexical scoping)
+ study :1, // - optimize input data for repeated searches
+ 'sub' :1, // - declare a subroutine, possibly anonymously
+ 'substr' :1, // - get or alter a portion of a stirng
+ symlink :1, // - create a symbolic link to a file
+ syscall :1, // - execute an arbitrary system call
+ sysopen :1, // - open a file, pipe, or descriptor
+ sysread :1, // - fixed-length unbuffered input from a filehandle
+ sysseek :1, // - position I/O pointer on handle used with sysread and syswrite
+ system :1, // - run a separate program
+ syswrite :1, // - fixed-length unbuffered output to a filehandle
+ tell :1, // - get current seekpointer on a filehandle
+ telldir :1, // - get current seekpointer on a directory handle
+ tie :1, // - bind a variable to an object class
+ tied :1, // - get a reference to the object underlying a tied variable
+ time :1, // - return number of seconds since 1970
+ times :1, // - return elapsed time for self and child processes
+ tr :null, // - transliterate a string
+ truncate :1, // - shorten a file
+ uc :1, // - return upper-case version of a string
+ ucfirst :1, // - return a string with just the next letter in upper case
+ umask :1, // - set file creation mode mask
+ undef :1, // - remove a variable or function definition
+ unlink :1, // - remove one link to a file
+ unpack :1, // - convert binary structure into normal perl variables
+ unshift :1, // - prepend more elements to the beginning of a list
+ untie :1, // - break a tie binding to a variable
+ use :1, // - load in a module at compile time
+ utime :1, // - set a file's last access and modify times
+ values :1, // - return a list of the values in a hash
+ vec :1, // - test or set particular bits in a string
+ wait :1, // - wait for any child process to die
+ waitpid :1, // - wait for a particular child process to die
+ wantarray :1, // - get void vs scalar vs list context of current subroutine call
+ warn :1, // - print debugging info
+ when :1, //
+ write :1, // - print a picture record
+ y :null}; // - transliterate a string
+
+ var RXstyle="string-2";
+ var RXmodifiers=/[goseximacplud]/; // NOTE: "m", "s", "y" and "tr" need to correct real modifiers for each regexp type
+
+ function tokenChain(stream,state,chain,style,tail){ // NOTE: chain.length > 2 is not working now (it's for s[...][...]geos;)
+ state.chain=null; // 12 3tail
+ state.style=null;
+ state.tail=null;
+ state.tokenize=function(stream,state){
+ var e=false,c,i=0;
+ while(c=stream.next()){
+ if(c===chain[i]&&!e){
+ if(chain[++i]!==undefined){
+ state.chain=chain[i];
+ state.style=style;
+ state.tail=tail;}
+ else if(tail)
+ stream.eatWhile(tail);
+ state.tokenize=tokenPerl;
+ return style;}
+ e=!e&&c=="\\";}
+ return style;};
+ return state.tokenize(stream,state);}
+
+ function tokenSOMETHING(stream,state,string){
+ state.tokenize=function(stream,state){
+ if(stream.string==string)
+ state.tokenize=tokenPerl;
+ stream.skipToEnd();
+ return "string";};
+ return state.tokenize(stream,state);}
+
+ function tokenPerl(stream,state){
+ if(stream.eatSpace())
+ return null;
+ if(state.chain)
+ return tokenChain(stream,state,state.chain,state.style,state.tail);
+ if(stream.match(/^\-?[\d\.]/,false))
+ if(stream.match(/^(\-?(\d*\.\d+(e[+-]?\d+)?|\d+\.\d*)|0x[\da-fA-F]+|0b[01]+|\d+(e[+-]?\d+)?)/))
+ return 'number';
+ if(stream.match(/^<<(?=\w)/)){ // NOTE: <"],RXstyle,RXmodifiers);}
+ if(/[\^'"!~\/]/.test(c)){
+ eatSuffix(stream, 1);
+ return tokenChain(stream,state,[stream.eat(c)],RXstyle,RXmodifiers);}}
+ else if(c=="q"){
+ c=look(stream, 1);
+ if(c=="("){
+ eatSuffix(stream, 2);
+ return tokenChain(stream,state,[")"],"string");}
+ if(c=="["){
+ eatSuffix(stream, 2);
+ return tokenChain(stream,state,["]"],"string");}
+ if(c=="{"){
+ eatSuffix(stream, 2);
+ return tokenChain(stream,state,["}"],"string");}
+ if(c=="<"){
+ eatSuffix(stream, 2);
+ return tokenChain(stream,state,[">"],"string");}
+ if(/[\^'"!~\/]/.test(c)){
+ eatSuffix(stream, 1);
+ return tokenChain(stream,state,[stream.eat(c)],"string");}}
+ else if(c=="w"){
+ c=look(stream, 1);
+ if(c=="("){
+ eatSuffix(stream, 2);
+ return tokenChain(stream,state,[")"],"bracket");}
+ if(c=="["){
+ eatSuffix(stream, 2);
+ return tokenChain(stream,state,["]"],"bracket");}
+ if(c=="{"){
+ eatSuffix(stream, 2);
+ return tokenChain(stream,state,["}"],"bracket");}
+ if(c=="<"){
+ eatSuffix(stream, 2);
+ return tokenChain(stream,state,[">"],"bracket");}
+ if(/[\^'"!~\/]/.test(c)){
+ eatSuffix(stream, 1);
+ return tokenChain(stream,state,[stream.eat(c)],"bracket");}}
+ else if(c=="r"){
+ c=look(stream, 1);
+ if(c=="("){
+ eatSuffix(stream, 2);
+ return tokenChain(stream,state,[")"],RXstyle,RXmodifiers);}
+ if(c=="["){
+ eatSuffix(stream, 2);
+ return tokenChain(stream,state,["]"],RXstyle,RXmodifiers);}
+ if(c=="{"){
+ eatSuffix(stream, 2);
+ return tokenChain(stream,state,["}"],RXstyle,RXmodifiers);}
+ if(c=="<"){
+ eatSuffix(stream, 2);
+ return tokenChain(stream,state,[">"],RXstyle,RXmodifiers);}
+ if(/[\^'"!~\/]/.test(c)){
+ eatSuffix(stream, 1);
+ return tokenChain(stream,state,[stream.eat(c)],RXstyle,RXmodifiers);}}
+ else if(/[\^'"!~\/(\[{<]/.test(c)){
+ if(c=="("){
+ eatSuffix(stream, 1);
+ return tokenChain(stream,state,[")"],"string");}
+ if(c=="["){
+ eatSuffix(stream, 1);
+ return tokenChain(stream,state,["]"],"string");}
+ if(c=="{"){
+ eatSuffix(stream, 1);
+ return tokenChain(stream,state,["}"],"string");}
+ if(c=="<"){
+ eatSuffix(stream, 1);
+ return tokenChain(stream,state,[">"],"string");}
+ if(/[\^'"!~\/]/.test(c)){
+ return tokenChain(stream,state,[stream.eat(c)],"string");}}}}
+ if(ch=="m"){
+ var c=look(stream, -2);
+ if(!(c&&/\w/.test(c))){
+ c=stream.eat(/[(\[{<\^'"!~\/]/);
+ if(c){
+ if(/[\^'"!~\/]/.test(c)){
+ return tokenChain(stream,state,[c],RXstyle,RXmodifiers);}
+ if(c=="("){
+ return tokenChain(stream,state,[")"],RXstyle,RXmodifiers);}
+ if(c=="["){
+ return tokenChain(stream,state,["]"],RXstyle,RXmodifiers);}
+ if(c=="{"){
+ return tokenChain(stream,state,["}"],RXstyle,RXmodifiers);}
+ if(c=="<"){
+ return tokenChain(stream,state,[">"],RXstyle,RXmodifiers);}}}}
+ if(ch=="s"){
+ var c=/[\/>\]})\w]/.test(look(stream, -2));
+ if(!c){
+ c=stream.eat(/[(\[{<\^'"!~\/]/);
+ if(c){
+ if(c=="[")
+ return tokenChain(stream,state,["]","]"],RXstyle,RXmodifiers);
+ if(c=="{")
+ return tokenChain(stream,state,["}","}"],RXstyle,RXmodifiers);
+ if(c=="<")
+ return tokenChain(stream,state,[">",">"],RXstyle,RXmodifiers);
+ if(c=="(")
+ return tokenChain(stream,state,[")",")"],RXstyle,RXmodifiers);
+ return tokenChain(stream,state,[c,c],RXstyle,RXmodifiers);}}}
+ if(ch=="y"){
+ var c=/[\/>\]})\w]/.test(look(stream, -2));
+ if(!c){
+ c=stream.eat(/[(\[{<\^'"!~\/]/);
+ if(c){
+ if(c=="[")
+ return tokenChain(stream,state,["]","]"],RXstyle,RXmodifiers);
+ if(c=="{")
+ return tokenChain(stream,state,["}","}"],RXstyle,RXmodifiers);
+ if(c=="<")
+ return tokenChain(stream,state,[">",">"],RXstyle,RXmodifiers);
+ if(c=="(")
+ return tokenChain(stream,state,[")",")"],RXstyle,RXmodifiers);
+ return tokenChain(stream,state,[c,c],RXstyle,RXmodifiers);}}}
+ if(ch=="t"){
+ var c=/[\/>\]})\w]/.test(look(stream, -2));
+ if(!c){
+ c=stream.eat("r");if(c){
+ c=stream.eat(/[(\[{<\^'"!~\/]/);
+ if(c){
+ if(c=="[")
+ return tokenChain(stream,state,["]","]"],RXstyle,RXmodifiers);
+ if(c=="{")
+ return tokenChain(stream,state,["}","}"],RXstyle,RXmodifiers);
+ if(c=="<")
+ return tokenChain(stream,state,[">",">"],RXstyle,RXmodifiers);
+ if(c=="(")
+ return tokenChain(stream,state,[")",")"],RXstyle,RXmodifiers);
+ return tokenChain(stream,state,[c,c],RXstyle,RXmodifiers);}}}}
+ if(ch=="`"){
+ return tokenChain(stream,state,[ch],"variable-2");}
+ if(ch=="/"){
+ if(!/~\s*$/.test(prefix(stream)))
+ return "operator";
+ else
+ return tokenChain(stream,state,[ch],RXstyle,RXmodifiers);}
+ if(ch=="$"){
+ var p=stream.pos;
+ if(stream.eatWhile(/\d/)||stream.eat("{")&&stream.eatWhile(/\d/)&&stream.eat("}"))
+ return "variable-2";
+ else
+ stream.pos=p;}
+ if(/[$@%]/.test(ch)){
+ var p=stream.pos;
+ if(stream.eat("^")&&stream.eat(/[A-Z]/)||!/[@$%&]/.test(look(stream, -2))&&stream.eat(/[=|\\\-#?@;:&`~\^!\[\]*'"$+.,\/<>()]/)){
+ var c=stream.current();
+ if(PERL[c])
+ return "variable-2";}
+ stream.pos=p;}
+ if(/[$@%&]/.test(ch)){
+ if(stream.eatWhile(/[\w$\[\]]/)||stream.eat("{")&&stream.eatWhile(/[\w$\[\]]/)&&stream.eat("}")){
+ var c=stream.current();
+ if(PERL[c])
+ return "variable-2";
+ else
+ return "variable";}}
+ if(ch=="#"){
+ if(look(stream, -2)!="$"){
+ stream.skipToEnd();
+ return "comment";}}
+ if(/[:+\-\^*$&%@=<>!?|\/~\.]/.test(ch)){
+ var p=stream.pos;
+ stream.eatWhile(/[:+\-\^*$&%@=<>!?|\/~\.]/);
+ if(PERL[stream.current()])
+ return "operator";
+ else
+ stream.pos=p;}
+ if(ch=="_"){
+ if(stream.pos==1){
+ if(suffix(stream, 6)=="_END__"){
+ return tokenChain(stream,state,['\0'],"comment");}
+ else if(suffix(stream, 7)=="_DATA__"){
+ return tokenChain(stream,state,['\0'],"variable-2");}
+ else if(suffix(stream, 7)=="_C__"){
+ return tokenChain(stream,state,['\0'],"string");}}}
+ if(/\w/.test(ch)){
+ var p=stream.pos;
+ if(look(stream, -2)=="{"&&(look(stream, 0)=="}"||stream.eatWhile(/\w/)&&look(stream, 0)=="}"))
+ return "string";
+ else
+ stream.pos=p;}
+ if(/[A-Z]/.test(ch)){
+ var l=look(stream, -2);
+ var p=stream.pos;
+ stream.eatWhile(/[A-Z_]/);
+ if(/[\da-z]/.test(look(stream, 0))){
+ stream.pos=p;}
+ else{
+ var c=PERL[stream.current()];
+ if(!c)
+ return "meta";
+ if(c[1])
+ c=c[0];
+ if(l!=":"){
+ if(c==1)
+ return "keyword";
+ else if(c==2)
+ return "def";
+ else if(c==3)
+ return "atom";
+ else if(c==4)
+ return "operator";
+ else if(c==5)
+ return "variable-2";
+ else
+ return "meta";}
+ else
+ return "meta";}}
+ if(/[a-zA-Z_]/.test(ch)){
+ var l=look(stream, -2);
+ stream.eatWhile(/\w/);
+ var c=PERL[stream.current()];
+ if(!c)
+ return "meta";
+ if(c[1])
+ c=c[0];
+ if(l!=":"){
+ if(c==1)
+ return "keyword";
+ else if(c==2)
+ return "def";
+ else if(c==3)
+ return "atom";
+ else if(c==4)
+ return "operator";
+ else if(c==5)
+ return "variable-2";
+ else
+ return "meta";}
+ else
+ return "meta";}
+ return null;}
+
+ return {
+ startState: function() {
+ return {
+ tokenize: tokenPerl,
+ chain: null,
+ style: null,
+ tail: null
+ };
+ },
+ token: function(stream, state) {
+ return (state.tokenize || tokenPerl)(stream, state);
+ },
+ lineComment: '#'
+ };
+});
+
+CodeMirror.registerHelper("wordChars", "perl", /[\w$]/);
+
+CodeMirror.defineMIME("text/x-perl", "perl");
+
+// it's like "peek", but need for look-ahead or look-behind if index < 0
+function look(stream, c){
+ return stream.string.charAt(stream.pos+(c||0));
+}
+
+// return a part of prefix of current stream from current position
+function prefix(stream, c){
+ if(c){
+ var x=stream.pos-c;
+ return stream.string.substr((x>=0?x:0),c);}
+ else{
+ return stream.string.substr(0,stream.pos-1);
+ }
+}
+
+// return a part of suffix of current stream from current position
+function suffix(stream, c){
+ var y=stream.string.length;
+ var x=y-stream.pos+1;
+ return stream.string.substr(stream.pos,(c&&c=(y=stream.string.length-1))
+ stream.pos=y;
+ else
+ stream.pos=x;
+}
+
+});
diff --git a/www/code/codemirror-5.7/mode/php/index.html b/www/code/codemirror-5.7/mode/php/index.html
new file mode 100644
index 000000000..adf6b1be2
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/php/index.html
@@ -0,0 +1,64 @@
+
+
+CodeMirror: PHP mode
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/www/code/codemirror-5.7/mode/php/php.js b/www/code/codemirror-5.7/mode/php/php.js
new file mode 100644
index 000000000..22494467b
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/php/php.js
@@ -0,0 +1,234 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+ if (typeof exports == "object" && typeof module == "object") // CommonJS
+ mod(require("../../lib/codemirror"), require("../htmlmixed/htmlmixed"), require("../clike/clike"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror", "../htmlmixed/htmlmixed", "../clike/clike"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+ "use strict";
+
+ function keywords(str) {
+ var obj = {}, words = str.split(" ");
+ for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+ return obj;
+ }
+
+ // Helper for phpString
+ function matchSequence(list, end, escapes) {
+ if (list.length == 0) return phpString(end);
+ return function (stream, state) {
+ var patterns = list[0];
+ for (var i = 0; i < patterns.length; i++) if (stream.match(patterns[i][0])) {
+ state.tokenize = matchSequence(list.slice(1), end);
+ return patterns[i][1];
+ }
+ state.tokenize = phpString(end, escapes);
+ return "string";
+ };
+ }
+ function phpString(closing, escapes) {
+ return function(stream, state) { return phpString_(stream, state, closing, escapes); };
+ }
+ function phpString_(stream, state, closing, escapes) {
+ // "Complex" syntax
+ if (escapes !== false && stream.match("${", false) || stream.match("{$", false)) {
+ state.tokenize = null;
+ return "string";
+ }
+
+ // Simple syntax
+ if (escapes !== false && stream.match(/^\$[a-zA-Z_][a-zA-Z0-9_]*/)) {
+ // After the variable name there may appear array or object operator.
+ if (stream.match("[", false)) {
+ // Match array operator
+ state.tokenize = matchSequence([
+ [["[", null]],
+ [[/\d[\w\.]*/, "number"],
+ [/\$[a-zA-Z_][a-zA-Z0-9_]*/, "variable-2"],
+ [/[\w\$]+/, "variable"]],
+ [["]", null]]
+ ], closing, escapes);
+ }
+ if (stream.match(/\-\>\w/, false)) {
+ // Match object operator
+ state.tokenize = matchSequence([
+ [["->", null]],
+ [[/[\w]+/, "variable"]]
+ ], closing, escapes);
+ }
+ return "variable-2";
+ }
+
+ var escaped = false;
+ // Normal string
+ while (!stream.eol() &&
+ (escaped || escapes === false ||
+ (!stream.match("{$", false) &&
+ !stream.match(/^(\$[a-zA-Z_][a-zA-Z0-9_]*|\$\{)/, false)))) {
+ if (!escaped && stream.match(closing)) {
+ state.tokenize = null;
+ state.tokStack.pop(); state.tokStack.pop();
+ break;
+ }
+ escaped = stream.next() == "\\" && !escaped;
+ }
+ return "string";
+ }
+
+ var phpKeywords = "abstract and array as break case catch 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 trait try use var while xor " +
+ "die echo empty exit eval include include_once isset list require require_once return " +
+ "print unset __halt_compiler self static parent yield insteadof finally";
+ var phpAtoms = "true false null TRUE FALSE NULL __CLASS__ __DIR__ __FILE__ __LINE__ __METHOD__ __FUNCTION__ __NAMESPACE__ __TRAIT__";
+ var phpBuiltin = "func_num_args func_get_arg func_get_args strlen strcmp strncmp strcasecmp strncasecmp each error_reporting define defined trigger_error user_error set_error_handler restore_error_handler get_declared_classes get_loaded_extensions extension_loaded get_extension_funcs debug_backtrace constant bin2hex hex2bin sleep usleep time mktime gmmktime strftime gmstrftime strtotime date gmdate getdate localtime checkdate flush wordwrap htmlspecialchars htmlentities html_entity_decode md5 md5_file crc32 getimagesize image_type_to_mime_type phpinfo phpversion phpcredits strnatcmp strnatcasecmp substr_count strspn strcspn strtok strtoupper strtolower strpos strrpos strrev hebrev hebrevc nl2br basename dirname pathinfo stripslashes stripcslashes strstr stristr strrchr str_shuffle str_word_count strcoll substr substr_replace quotemeta ucfirst ucwords strtr addslashes addcslashes rtrim str_replace str_repeat count_chars chunk_split trim ltrim strip_tags similar_text explode implode setlocale localeconv parse_str str_pad chop strchr sprintf printf vprintf vsprintf sscanf fscanf parse_url urlencode urldecode rawurlencode rawurldecode readlink linkinfo link unlink exec system escapeshellcmd escapeshellarg passthru shell_exec proc_open proc_close rand srand getrandmax mt_rand mt_srand mt_getrandmax base64_decode base64_encode abs ceil floor round is_finite is_nan is_infinite bindec hexdec octdec decbin decoct dechex base_convert number_format fmod ip2long long2ip getenv putenv getopt microtime gettimeofday getrusage uniqid quoted_printable_decode set_time_limit get_cfg_var magic_quotes_runtime set_magic_quotes_runtime get_magic_quotes_gpc get_magic_quotes_runtime import_request_variables error_log serialize unserialize memory_get_usage var_dump var_export debug_zval_dump print_r highlight_file show_source highlight_string ini_get ini_get_all ini_set ini_alter ini_restore get_include_path set_include_path restore_include_path setcookie header headers_sent connection_aborted connection_status ignore_user_abort parse_ini_file is_uploaded_file move_uploaded_file intval floatval doubleval strval gettype settype is_null is_resource is_bool is_long is_float is_int is_integer is_double is_real is_numeric is_string is_array is_object is_scalar ereg ereg_replace eregi eregi_replace split spliti join sql_regcase dl pclose popen readfile rewind rmdir umask fclose feof fgetc fgets fgetss fread fopen fpassthru ftruncate fstat fseek ftell fflush fwrite fputs mkdir rename copy tempnam tmpfile file file_get_contents file_put_contents stream_select stream_context_create stream_context_set_params stream_context_set_option stream_context_get_options stream_filter_prepend stream_filter_append fgetcsv flock get_meta_tags stream_set_write_buffer set_file_buffer set_socket_blocking stream_set_blocking socket_set_blocking stream_get_meta_data stream_register_wrapper stream_wrapper_register stream_set_timeout socket_set_timeout socket_get_status realpath fnmatch fsockopen pfsockopen pack unpack get_browser crypt opendir closedir chdir getcwd rewinddir readdir dir glob fileatime filectime filegroup fileinode filemtime fileowner fileperms filesize filetype file_exists is_writable is_writeable is_readable is_executable is_file is_dir is_link stat lstat chown touch clearstatcache mail ob_start ob_flush ob_clean ob_end_flush ob_end_clean ob_get_flush ob_get_clean ob_get_length ob_get_level ob_get_status ob_get_contents ob_implicit_flush ob_list_handlers ksort krsort natsort natcasesort asort arsort sort rsort usort uasort uksort shuffle array_walk count end prev next reset current key min max in_array array_search extract compact array_fill range array_multisort array_push array_pop array_shift array_unshift array_splice array_slice array_merge array_merge_recursive array_keys array_values array_count_values array_reverse array_reduce array_pad array_flip array_change_key_case array_rand array_unique array_intersect array_intersect_assoc array_diff array_diff_assoc array_sum array_filter array_map array_chunk array_key_exists pos sizeof key_exists assert assert_options version_compare ftok str_rot13 aggregate session_name session_module_name session_save_path session_id session_regenerate_id session_decode session_register session_unregister session_is_registered session_encode session_start session_destroy session_unset session_set_save_handler session_cache_limiter session_cache_expire session_set_cookie_params session_get_cookie_params session_write_close preg_match preg_match_all preg_replace preg_replace_callback preg_split preg_quote preg_grep overload ctype_alnum ctype_alpha ctype_cntrl ctype_digit ctype_lower ctype_graph ctype_print ctype_punct ctype_space ctype_upper ctype_xdigit virtual apache_request_headers apache_note apache_lookup_uri apache_child_terminate apache_setenv apache_response_headers apache_get_version getallheaders mysql_connect mysql_pconnect mysql_close mysql_select_db mysql_create_db mysql_drop_db mysql_query mysql_unbuffered_query mysql_db_query mysql_list_dbs mysql_list_tables mysql_list_fields mysql_list_processes mysql_error mysql_errno mysql_affected_rows mysql_insert_id mysql_result mysql_num_rows mysql_num_fields mysql_fetch_row mysql_fetch_array mysql_fetch_assoc mysql_fetch_object mysql_data_seek mysql_fetch_lengths mysql_fetch_field mysql_field_seek mysql_free_result mysql_field_name mysql_field_table mysql_field_len mysql_field_type mysql_field_flags mysql_escape_string mysql_real_escape_string mysql_stat mysql_thread_id mysql_client_encoding mysql_get_client_info mysql_get_host_info mysql_get_proto_info mysql_get_server_info mysql_info mysql mysql_fieldname mysql_fieldtable mysql_fieldlen mysql_fieldtype mysql_fieldflags mysql_selectdb mysql_createdb mysql_dropdb mysql_freeresult mysql_numfields mysql_numrows mysql_listdbs mysql_listtables mysql_listfields mysql_db_name mysql_dbname mysql_tablename mysql_table_name pg_connect pg_pconnect pg_close pg_connection_status pg_connection_busy pg_connection_reset pg_host pg_dbname pg_port pg_tty pg_options pg_ping pg_query pg_send_query pg_cancel_query pg_fetch_result pg_fetch_row pg_fetch_assoc pg_fetch_array pg_fetch_object pg_fetch_all pg_affected_rows pg_get_result pg_result_seek pg_result_status pg_free_result pg_last_oid pg_num_rows pg_num_fields pg_field_name pg_field_num pg_field_size pg_field_type pg_field_prtlen pg_field_is_null pg_get_notify pg_get_pid pg_result_error pg_last_error pg_last_notice pg_put_line pg_end_copy pg_copy_to pg_copy_from pg_trace pg_untrace pg_lo_create pg_lo_unlink pg_lo_open pg_lo_close pg_lo_read pg_lo_write pg_lo_read_all pg_lo_import pg_lo_export pg_lo_seek pg_lo_tell pg_escape_string pg_escape_bytea pg_unescape_bytea pg_client_encoding pg_set_client_encoding pg_meta_data pg_convert pg_insert pg_update pg_delete pg_select pg_exec pg_getlastoid pg_cmdtuples pg_errormessage pg_numrows pg_numfields pg_fieldname pg_fieldsize pg_fieldtype pg_fieldnum pg_fieldprtlen pg_fieldisnull pg_freeresult pg_result pg_loreadall pg_locreate pg_lounlink pg_loopen pg_loclose pg_loread pg_lowrite pg_loimport pg_loexport http_response_code get_declared_traits getimagesizefromstring socket_import_stream stream_set_chunk_size trait_exists header_register_callback class_uses session_status session_register_shutdown echo print global static exit array empty eval isset unset die include require include_once require_once json_decode json_encode json_last_error json_last_error_msg curl_close curl_copy_handle curl_errno curl_error curl_escape curl_exec curl_file_create curl_getinfo curl_init curl_multi_add_handle curl_multi_close curl_multi_exec curl_multi_getcontent curl_multi_info_read curl_multi_init curl_multi_remove_handle curl_multi_select curl_multi_setopt curl_multi_strerror curl_pause curl_reset curl_setopt_array curl_setopt curl_share_close curl_share_init curl_share_setopt curl_strerror curl_unescape curl_version mysqli_affected_rows mysqli_autocommit mysqli_change_user mysqli_character_set_name mysqli_close mysqli_commit mysqli_connect_errno mysqli_connect_error mysqli_connect mysqli_data_seek mysqli_debug mysqli_dump_debug_info mysqli_errno mysqli_error_list mysqli_error mysqli_fetch_all mysqli_fetch_array mysqli_fetch_assoc mysqli_fetch_field_direct mysqli_fetch_field mysqli_fetch_fields mysqli_fetch_lengths mysqli_fetch_object mysqli_fetch_row mysqli_field_count mysqli_field_seek mysqli_field_tell mysqli_free_result mysqli_get_charset mysqli_get_client_info mysqli_get_client_stats mysqli_get_client_version mysqli_get_connection_stats mysqli_get_host_info mysqli_get_proto_info mysqli_get_server_info mysqli_get_server_version mysqli_info mysqli_init mysqli_insert_id mysqli_kill mysqli_more_results mysqli_multi_query mysqli_next_result mysqli_num_fields mysqli_num_rows mysqli_options mysqli_ping mysqli_prepare mysqli_query mysqli_real_connect mysqli_real_escape_string mysqli_real_query mysqli_reap_async_query mysqli_refresh mysqli_rollback mysqli_select_db mysqli_set_charset mysqli_set_local_infile_default mysqli_set_local_infile_handler mysqli_sqlstate mysqli_ssl_set mysqli_stat mysqli_stmt_init mysqli_store_result mysqli_thread_id mysqli_thread_safe mysqli_use_result mysqli_warning_count";
+ CodeMirror.registerHelper("hintWords", "php", [phpKeywords, phpAtoms, phpBuiltin].join(" ").split(" "));
+ CodeMirror.registerHelper("wordChars", "php", /[\w$]/);
+
+ var phpConfig = {
+ name: "clike",
+ helperType: "php",
+ keywords: keywords(phpKeywords),
+ blockKeywords: keywords("catch do else elseif for foreach if switch try while finally"),
+ defKeywords: keywords("class function interface namespace trait"),
+ atoms: keywords(phpAtoms),
+ builtin: keywords(phpBuiltin),
+ multiLineStrings: true,
+ hooks: {
+ "$": function(stream) {
+ stream.eatWhile(/[\w\$_]/);
+ return "variable-2";
+ },
+ "<": function(stream, state) {
+ var before;
+ if (before = stream.match(/<<\s*/)) {
+ var quoted = stream.eat(/['"]/);
+ stream.eatWhile(/[\w\.]/);
+ var delim = stream.current().slice(before[0].length + (quoted ? 2 : 1));
+ if (quoted) stream.eat(quoted);
+ if (delim) {
+ (state.tokStack || (state.tokStack = [])).push(delim, 0);
+ state.tokenize = phpString(delim, quoted != "'");
+ return "string";
+ }
+ }
+ return false;
+ },
+ "#": function(stream) {
+ while (!stream.eol() && !stream.match("?>", false)) stream.next();
+ return "comment";
+ },
+ "/": function(stream) {
+ if (stream.eat("/")) {
+ while (!stream.eol() && !stream.match("?>", false)) stream.next();
+ return "comment";
+ }
+ return false;
+ },
+ '"': function(_stream, state) {
+ (state.tokStack || (state.tokStack = [])).push('"', 0);
+ state.tokenize = phpString('"');
+ return "string";
+ },
+ "{": function(_stream, state) {
+ if (state.tokStack && state.tokStack.length)
+ state.tokStack[state.tokStack.length - 1]++;
+ return false;
+ },
+ "}": function(_stream, state) {
+ if (state.tokStack && state.tokStack.length > 0 &&
+ !--state.tokStack[state.tokStack.length - 1]) {
+ state.tokenize = phpString(state.tokStack[state.tokStack.length - 2]);
+ }
+ return false;
+ }
+ }
+ };
+
+ CodeMirror.defineMode("php", function(config, parserConfig) {
+ var htmlMode = CodeMirror.getMode(config, "text/html");
+ var phpMode = CodeMirror.getMode(config, phpConfig);
+
+ function dispatch(stream, state) {
+ var isPHP = state.curMode == phpMode;
+ if (stream.sol() && state.pending && state.pending != '"' && state.pending != "'") state.pending = null;
+ if (!isPHP) {
+ if (stream.match(/^<\?\w*/)) {
+ state.curMode = phpMode;
+ if (!state.php) state.php = CodeMirror.startState(phpMode, htmlMode.indent(state.html, ""))
+ state.curState = state.php;
+ return "meta";
+ }
+ if (state.pending == '"' || state.pending == "'") {
+ while (!stream.eol() && stream.next() != state.pending) {}
+ var style = "string";
+ } else if (state.pending && stream.pos < state.pending.end) {
+ stream.pos = state.pending.end;
+ var style = state.pending.style;
+ } else {
+ var style = htmlMode.token(stream, state.curState);
+ }
+ if (state.pending) state.pending = null;
+ var cur = stream.current(), openPHP = cur.search(/<\?/), m;
+ if (openPHP != -1) {
+ if (style == "string" && (m = cur.match(/[\'\"]$/)) && !/\?>/.test(cur)) state.pending = m[0];
+ else state.pending = {end: stream.pos, style: style};
+ stream.backUp(cur.length - openPHP);
+ }
+ return style;
+ } else if (isPHP && state.php.tokenize == null && stream.match("?>")) {
+ state.curMode = htmlMode;
+ state.curState = state.html;
+ if (!state.php.context.prev) state.php = null;
+ return "meta";
+ } else {
+ return phpMode.token(stream, state.curState);
+ }
+ }
+
+ return {
+ startState: function() {
+ var html = CodeMirror.startState(htmlMode)
+ var php = parserConfig.startOpen ? CodeMirror.startState(phpMode) : null
+ return {html: html,
+ php: php,
+ curMode: parserConfig.startOpen ? phpMode : htmlMode,
+ curState: parserConfig.startOpen ? php : html,
+ pending: null};
+ },
+
+ copyState: function(state) {
+ var html = state.html, htmlNew = CodeMirror.copyState(htmlMode, html),
+ php = state.php, phpNew = php && CodeMirror.copyState(phpMode, php), cur;
+ if (state.curMode == htmlMode) cur = htmlNew;
+ else cur = phpNew;
+ return {html: htmlNew, php: phpNew, curMode: state.curMode, curState: cur,
+ pending: state.pending};
+ },
+
+ 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);
+ },
+
+ blockCommentStart: "/*",
+ blockCommentEnd: "*/",
+ lineComment: "//",
+
+ innerMode: function(state) { return {state: state.curState, mode: state.curMode}; }
+ };
+ }, "htmlmixed", "clike");
+
+ CodeMirror.defineMIME("application/x-httpd-php", "php");
+ CodeMirror.defineMIME("application/x-httpd-php-open", {name: "php", startOpen: true});
+ CodeMirror.defineMIME("text/x-php", phpConfig);
+});
diff --git a/www/code/codemirror-5.7/mode/php/test.js b/www/code/codemirror-5.7/mode/php/test.js
new file mode 100644
index 000000000..e2ecefc18
--- /dev/null
+++ b/www/code/codemirror-5.7/mode/php/test.js
@@ -0,0 +1,154 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function() {
+ var mode = CodeMirror.getMode({indentUnit: 2}, "php");
+ function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1)); }
+
+ MT('simple_test',
+ '[meta ]');
+
+ MT('variable_interpolation_non_alphanumeric',
+ '[meta $/$\\$}$\\\"$:$;$?$|$[[$]]$+$=aaa"]',
+ '[meta ?>]');
+
+ MT('variable_interpolation_digits',
+ '[meta ]');
+
+ MT('variable_interpolation_simple_syntax_1',
+ '[meta ]');
+
+ MT('variable_interpolation_simple_syntax_2',
+ '[meta ]');
+
+ MT('variable_interpolation_simple_syntax_3',
+ '[meta [variable aaaaa][string .aaaaaa"];',
+ '[keyword echo] [string "aaa][variable-2 $aaaa][string ->][variable-2 $aaaaa][string .aaaaaa"];',
+ '[keyword echo] [string "aaa][variable-2 $aaaa]->[variable aaaaa][string [[2]].aaaaaa"];',
+ '[keyword echo] [string "aaa][variable-2 $aaaa]->[variable aaaaa][string ->aaaa2.aaaaaa"];',
+ '[meta ?>]');
+
+ MT('variable_interpolation_escaping',
+ '[meta aaa.aaa"];',
+ '[keyword echo] [string "aaa\\$aaaa[[2]]aaa.aaa"];',
+ '[keyword echo] [string "aaa\\$aaaa[[asd]]aaa.aaa"];',
+ '[keyword echo] [string "aaa{\\$aaaa->aaa.aaa"];',
+ '[keyword echo] [string "aaa{\\$aaaa[[2]]aaa.aaa"];',
+ '[keyword echo] [string "aaa{\\aaaaa[[asd]]aaa.aaa"];',
+ '[keyword echo] [string "aaa\\${aaaa->aaa.aaa"];',
+ '[keyword echo] [string "aaa\\${aaaa[[2]]aaa.aaa"];',
+ '[keyword echo] [string "aaa\\${aaaa[[asd]]aaa.aaa"];',
+ '[meta ?>]');
+
+ MT('variable_interpolation_complex_syntax_1',
+ '[meta aaa.aaa"];',
+ '[keyword echo] [string "aaa][variable-2 $]{[variable-2 $aaaa]}[string ->aaa.aaa"];',
+ '[keyword echo] [string "aaa][variable-2 $]{[variable-2 $aaaa][[',' [number 42]',']]}[string ->aaa.aaa"];',
+ '[keyword echo] [string "aaa][variable-2 $]{[variable aaaa][meta ?>]aaaaaa');
+
+ MT('variable_interpolation_complex_syntax_2',
+ '[meta } $aaaaaa.aaa"];',
+ '[keyword echo] [string "][variable-2 $]{[variable aaa][comment /*}?>*/][[',' [string "aaa][variable-2 $aaa][string {}][variable-2 $]{[variable aaa]}[string "]',']]}[string ->aaa.aaa"];',
+ '[keyword echo] [string "][variable-2 $]{[variable aaa][comment /*} } $aaa } */]}[string ->aaa.aaa"];');
+
+
+ function build_recursive_monsters(nt, t, n){
+ var monsters = [t];
+ for (var i = 1; i <= n; ++i)
+ monsters[i] = nt.join(monsters[i - 1]);
+ return monsters;
+ }
+
+ var m1 = build_recursive_monsters(
+ ['[string "][variable-2 $]{[variable aaa] [operator +] ', '}[string "]'],
+ '[comment /* }?>} */] [string "aaa][variable-2 $aaa][string .aaa"]',
+ 10
+ );
+
+ MT('variable_interpolation_complex_syntax_3_1',
+ '[meta ]');
+
+ var m2 = build_recursive_monsters(
+ ['[string "a][variable-2 $]{[variable aaa] [operator +] ', ' [operator +] ', '}[string .a"]'],
+ '[comment /* }?>{{ */] [string "a?>}{{aa][variable-2 $aaa][string .a}a?>a"]',
+ 5
+ );
+
+ MT('variable_interpolation_complex_syntax_3_2',
+ '[meta ]');
+
+ function build_recursive_monsters_2(mf1, mf2, nt, t, n){
+ var monsters = [t];
+ for (var i = 1; i <= n; ++i)
+ monsters[i] = nt[0] + mf1[i - 1] + nt[1] + mf2[i - 1] + nt[2] + monsters[i - 1] + nt[3];
+ return monsters;
+ }
+
+ var m3 = build_recursive_monsters_2(
+ m1,
+ m2,
+ ['[string "a][variable-2 $]{[variable aaa] [operator +] ', ' [operator +] ', ' [operator +] ', '}[string .a"]'],
+ '[comment /* }?>{{ */] [string "a?>}{{aa][variable-2 $aaa][string .a}a?>a"]',
+ 4
+ );
+
+ MT('variable_interpolation_complex_syntax_3_3',
+ '[meta ]');
+
+ MT("variable_interpolation_heredoc",
+ "[meta
+
+CodeMirror: Pig Latin mode
+
+
+
+
+
+
+
+
+
+
+
NGINX mode
+ + + +MIME types defined: text/nginx.
NTriples mode
+ + + +MIME types defined: text/n-triples.
Octave mode
+ + + + +MIME types defined: text/x-octave.
Oz mode
+ +MIME type defined: text/x-oz.
Pascal mode
+ + + + + + +MIME types defined: text/x-pascal.
PEG.js Mode
+ + +The PEG.js Mode
+Created by Forbes Lindesay.
+Perl mode
+ + + + + + +MIME types defined: text/x-perl.
PHP mode
+ + + + +Simple HTML/PHP mode based on + the C-like mode. Depends on XML, + JavaScript, CSS, HTMLMixed, and C-like modes.
+ +MIME types defined: application/x-httpd-php (HTML with PHP code), text/x-php (plain, non-wrapped PHP code).
Pig Latin mode
+ + + + ++ Simple mode that handles Pig Latin language. +
+ +MIME type defined: text/x-pig
+ (PIG code)
+