+Dylan mode
+
+
+
+
+
+
+ MIME types defined: text/x-dylan.
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/ebnf/ebnf.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/ebnf/ebnf.js
new file mode 100644
index 0000000..6b51aba
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/ebnf/ebnf.js
@@ -0,0 +1,195 @@
+// 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("ebnf", function (config) {
+ var commentType = {slash: 0, parenthesis: 1};
+ var stateType = {comment: 0, _string: 1, characterClass: 2};
+ var bracesMode = null;
+
+ if (config.bracesMode)
+ bracesMode = CodeMirror.getMode(config, config.bracesMode);
+
+ return {
+ startState: function () {
+ return {
+ stringType: null,
+ commentType: null,
+ braced: 0,
+ lhs: true,
+ localState: null,
+ stack: [],
+ inDefinition: false
+ };
+ },
+ token: function (stream, state) {
+ if (!stream) return;
+
+ //check for state changes
+ if (state.stack.length === 0) {
+ //strings
+ if ((stream.peek() == '"') || (stream.peek() == "'")) {
+ state.stringType = stream.peek();
+ stream.next(); // Skip quote
+ state.stack.unshift(stateType._string);
+ } else if (stream.match(/^\/\*/)) { //comments starting with /*
+ state.stack.unshift(stateType.comment);
+ state.commentType = commentType.slash;
+ } else if (stream.match(/^\(\*/)) { //comments starting with (*
+ state.stack.unshift(stateType.comment);
+ state.commentType = commentType.parenthesis;
+ }
+ }
+
+ //return state
+ //stack has
+ switch (state.stack[0]) {
+ case stateType._string:
+ while (state.stack[0] === stateType._string && !stream.eol()) {
+ if (stream.peek() === state.stringType) {
+ stream.next(); // Skip quote
+ state.stack.shift(); // Clear flag
+ } else if (stream.peek() === "\\") {
+ stream.next();
+ stream.next();
+ } else {
+ stream.match(/^.[^\\\"\']*/);
+ }
+ }
+ return state.lhs ? "property string" : "string"; // Token style
+
+ case stateType.comment:
+ while (state.stack[0] === stateType.comment && !stream.eol()) {
+ if (state.commentType === commentType.slash && stream.match(/\*\//)) {
+ state.stack.shift(); // Clear flag
+ state.commentType = null;
+ } else if (state.commentType === commentType.parenthesis && stream.match(/\*\)/)) {
+ state.stack.shift(); // Clear flag
+ state.commentType = null;
+ } else {
+ stream.match(/^.[^\*]*/);
+ }
+ }
+ return "comment";
+
+ case stateType.characterClass:
+ while (state.stack[0] === stateType.characterClass && !stream.eol()) {
+ if (!(stream.match(/^[^\]\\]+/) || stream.match(/^\\./))) {
+ state.stack.shift();
+ }
+ }
+ return "operator";
+ }
+
+ var peek = stream.peek();
+
+ if (bracesMode !== null && (state.braced || peek === "{")) {
+ if (state.localState === null)
+ state.localState = bracesMode.startState();
+
+ var token = bracesMode.token(stream, state.localState),
+ text = stream.current();
+
+ if (!token) {
+ for (var i = 0; i < text.length; i++) {
+ if (text[i] === "{") {
+ if (state.braced === 0) {
+ token = "matchingbracket";
+ }
+ state.braced++;
+ } else if (text[i] === "}") {
+ state.braced--;
+ if (state.braced === 0) {
+ token = "matchingbracket";
+ }
+ }
+ }
+ }
+ return token;
+ }
+
+ //no stack
+ switch (peek) {
+ case "[":
+ stream.next();
+ state.stack.unshift(stateType.characterClass);
+ return "bracket";
+ case ":":
+ case "|":
+ case ";":
+ stream.next();
+ return "operator";
+ case "%":
+ if (stream.match("%%")) {
+ return "header";
+ } else if (stream.match(/[%][A-Za-z]+/)) {
+ return "keyword";
+ } else if (stream.match(/[%][}]/)) {
+ return "matchingbracket";
+ }
+ break;
+ case "/":
+ if (stream.match(/[\/][A-Za-z]+/)) {
+ return "keyword";
+ }
+ case "\\":
+ if (stream.match(/[\][a-z]+/)) {
+ return "string-2";
+ }
+ case ".":
+ if (stream.match(".")) {
+ return "atom";
+ }
+ case "*":
+ case "-":
+ case "+":
+ case "^":
+ if (stream.match(peek)) {
+ return "atom";
+ }
+ case "$":
+ if (stream.match("$$")) {
+ return "builtin";
+ } else if (stream.match(/[$][0-9]+/)) {
+ return "variable-3";
+ }
+ case "<":
+ if (stream.match(/<<[a-zA-Z_]+>>/)) {
+ return "builtin";
+ }
+ }
+
+ if (stream.match(/^\/\//)) {
+ stream.skipToEnd();
+ return "comment";
+ } else if (stream.match(/return/)) {
+ return "operator";
+ } else if (stream.match(/^[a-zA-Z_][a-zA-Z0-9_]*/)) {
+ if (stream.match(/(?=[\(.])/)) {
+ return "variable";
+ } else if (stream.match(/(?=[\s\n]*[:=])/)) {
+ return "def";
+ }
+ return "variable-2";
+ } else if (["[", "]", "(", ")"].indexOf(stream.peek()) != -1) {
+ stream.next();
+ return "bracket";
+ } else if (!stream.eatSpace()) {
+ stream.next();
+ }
+ return null;
+ }
+ };
+ });
+
+ CodeMirror.defineMIME("text/x-ebnf", "ebnf");
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/ebnf/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/ebnf/index.html
new file mode 100644
index 0000000..1384562
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/ebnf/index.html
@@ -0,0 +1,102 @@
+
+
+
+
+Fortran mode
+
+
+
+
+
+
+ MIME types defined: text/x-Fortran.
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/gas/gas.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/gas/gas.js
new file mode 100644
index 0000000..0c74bed
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/gas/gas.js
@@ -0,0 +1,345 @@
+// 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("gas", function(_config, parserConfig) {
+ 'use strict';
+
+ // If an architecture is specified, its initialization function may
+ // populate this array with custom parsing functions which will be
+ // tried in the event that the standard functions do not find a match.
+ var custom = [];
+
+ // The symbol used to start a line comment changes based on the target
+ // architecture.
+ // If no architecture is pased in "parserConfig" then only multiline
+ // comments will have syntax support.
+ var lineCommentStartSymbol = "";
+
+ // These directives are architecture independent.
+ // Machine specific directives should go in their respective
+ // architecture initialization function.
+ // Reference:
+ // http://sourceware.org/binutils/docs/as/Pseudo-Ops.html#Pseudo-Ops
+ var directives = {
+ ".abort" : "builtin",
+ ".align" : "builtin",
+ ".altmacro" : "builtin",
+ ".ascii" : "builtin",
+ ".asciz" : "builtin",
+ ".balign" : "builtin",
+ ".balignw" : "builtin",
+ ".balignl" : "builtin",
+ ".bundle_align_mode" : "builtin",
+ ".bundle_lock" : "builtin",
+ ".bundle_unlock" : "builtin",
+ ".byte" : "builtin",
+ ".cfi_startproc" : "builtin",
+ ".comm" : "builtin",
+ ".data" : "builtin",
+ ".def" : "builtin",
+ ".desc" : "builtin",
+ ".dim" : "builtin",
+ ".double" : "builtin",
+ ".eject" : "builtin",
+ ".else" : "builtin",
+ ".elseif" : "builtin",
+ ".end" : "builtin",
+ ".endef" : "builtin",
+ ".endfunc" : "builtin",
+ ".endif" : "builtin",
+ ".equ" : "builtin",
+ ".equiv" : "builtin",
+ ".eqv" : "builtin",
+ ".err" : "builtin",
+ ".error" : "builtin",
+ ".exitm" : "builtin",
+ ".extern" : "builtin",
+ ".fail" : "builtin",
+ ".file" : "builtin",
+ ".fill" : "builtin",
+ ".float" : "builtin",
+ ".func" : "builtin",
+ ".global" : "builtin",
+ ".gnu_attribute" : "builtin",
+ ".hidden" : "builtin",
+ ".hword" : "builtin",
+ ".ident" : "builtin",
+ ".if" : "builtin",
+ ".incbin" : "builtin",
+ ".include" : "builtin",
+ ".int" : "builtin",
+ ".internal" : "builtin",
+ ".irp" : "builtin",
+ ".irpc" : "builtin",
+ ".lcomm" : "builtin",
+ ".lflags" : "builtin",
+ ".line" : "builtin",
+ ".linkonce" : "builtin",
+ ".list" : "builtin",
+ ".ln" : "builtin",
+ ".loc" : "builtin",
+ ".loc_mark_labels" : "builtin",
+ ".local" : "builtin",
+ ".long" : "builtin",
+ ".macro" : "builtin",
+ ".mri" : "builtin",
+ ".noaltmacro" : "builtin",
+ ".nolist" : "builtin",
+ ".octa" : "builtin",
+ ".offset" : "builtin",
+ ".org" : "builtin",
+ ".p2align" : "builtin",
+ ".popsection" : "builtin",
+ ".previous" : "builtin",
+ ".print" : "builtin",
+ ".protected" : "builtin",
+ ".psize" : "builtin",
+ ".purgem" : "builtin",
+ ".pushsection" : "builtin",
+ ".quad" : "builtin",
+ ".reloc" : "builtin",
+ ".rept" : "builtin",
+ ".sbttl" : "builtin",
+ ".scl" : "builtin",
+ ".section" : "builtin",
+ ".set" : "builtin",
+ ".short" : "builtin",
+ ".single" : "builtin",
+ ".size" : "builtin",
+ ".skip" : "builtin",
+ ".sleb128" : "builtin",
+ ".space" : "builtin",
+ ".stab" : "builtin",
+ ".string" : "builtin",
+ ".struct" : "builtin",
+ ".subsection" : "builtin",
+ ".symver" : "builtin",
+ ".tag" : "builtin",
+ ".text" : "builtin",
+ ".title" : "builtin",
+ ".type" : "builtin",
+ ".uleb128" : "builtin",
+ ".val" : "builtin",
+ ".version" : "builtin",
+ ".vtable_entry" : "builtin",
+ ".vtable_inherit" : "builtin",
+ ".warning" : "builtin",
+ ".weak" : "builtin",
+ ".weakref" : "builtin",
+ ".word" : "builtin"
+ };
+
+ var registers = {};
+
+ function x86(_parserConfig) {
+ lineCommentStartSymbol = "#";
+
+ registers.ax = "variable";
+ registers.eax = "variable-2";
+ registers.rax = "variable-3";
+
+ registers.bx = "variable";
+ registers.ebx = "variable-2";
+ registers.rbx = "variable-3";
+
+ registers.cx = "variable";
+ registers.ecx = "variable-2";
+ registers.rcx = "variable-3";
+
+ registers.dx = "variable";
+ registers.edx = "variable-2";
+ registers.rdx = "variable-3";
+
+ registers.si = "variable";
+ registers.esi = "variable-2";
+ registers.rsi = "variable-3";
+
+ registers.di = "variable";
+ registers.edi = "variable-2";
+ registers.rdi = "variable-3";
+
+ registers.sp = "variable";
+ registers.esp = "variable-2";
+ registers.rsp = "variable-3";
+
+ registers.bp = "variable";
+ registers.ebp = "variable-2";
+ registers.rbp = "variable-3";
+
+ registers.ip = "variable";
+ registers.eip = "variable-2";
+ registers.rip = "variable-3";
+
+ registers.cs = "keyword";
+ registers.ds = "keyword";
+ registers.ss = "keyword";
+ registers.es = "keyword";
+ registers.fs = "keyword";
+ registers.gs = "keyword";
+ }
+
+ function armv6(_parserConfig) {
+ // Reference:
+ // http://infocenter.arm.com/help/topic/com.arm.doc.qrc0001l/QRC0001_UAL.pdf
+ // http://infocenter.arm.com/help/topic/com.arm.doc.ddi0301h/DDI0301H_arm1176jzfs_r0p7_trm.pdf
+ lineCommentStartSymbol = "@";
+ directives.syntax = "builtin";
+
+ registers.r0 = "variable";
+ registers.r1 = "variable";
+ registers.r2 = "variable";
+ registers.r3 = "variable";
+ registers.r4 = "variable";
+ registers.r5 = "variable";
+ registers.r6 = "variable";
+ registers.r7 = "variable";
+ registers.r8 = "variable";
+ registers.r9 = "variable";
+ registers.r10 = "variable";
+ registers.r11 = "variable";
+ registers.r12 = "variable";
+
+ registers.sp = "variable-2";
+ registers.lr = "variable-2";
+ registers.pc = "variable-2";
+ registers.r13 = registers.sp;
+ registers.r14 = registers.lr;
+ registers.r15 = registers.pc;
+
+ custom.push(function(ch, stream) {
+ if (ch === '#') {
+ stream.eatWhile(/\w/);
+ return "number";
+ }
+ });
+ }
+
+ var arch = (parserConfig.architecture || "x86").toLowerCase();
+ if (arch === "x86") {
+ x86(parserConfig);
+ } else if (arch === "arm" || arch === "armv6") {
+ armv6(parserConfig);
+ }
+
+ function nextUntilUnescaped(stream, end) {
+ var escaped = false, next;
+ while ((next = stream.next()) != null) {
+ if (next === end && !escaped) {
+ return false;
+ }
+ escaped = !escaped && next === "\\";
+ }
+ return escaped;
+ }
+
+ function clikeComment(stream, state) {
+ var maybeEnd = false, ch;
+ while ((ch = stream.next()) != null) {
+ if (ch === "/" && maybeEnd) {
+ state.tokenize = null;
+ break;
+ }
+ maybeEnd = (ch === "*");
+ }
+ return "comment";
+ }
+
+ return {
+ startState: function() {
+ return {
+ tokenize: null
+ };
+ },
+
+ token: function(stream, state) {
+ if (state.tokenize) {
+ return state.tokenize(stream, state);
+ }
+
+ if (stream.eatSpace()) {
+ return null;
+ }
+
+ var style, cur, ch = stream.next();
+
+ if (ch === "/") {
+ if (stream.eat("*")) {
+ state.tokenize = clikeComment;
+ return clikeComment(stream, state);
+ }
+ }
+
+ if (ch === lineCommentStartSymbol) {
+ stream.skipToEnd();
+ return "comment";
+ }
+
+ if (ch === '"') {
+ nextUntilUnescaped(stream, '"');
+ return "string";
+ }
+
+ if (ch === '.') {
+ stream.eatWhile(/\w/);
+ cur = stream.current().toLowerCase();
+ style = directives[cur];
+ return style || null;
+ }
+
+ if (ch === '=') {
+ stream.eatWhile(/\w/);
+ return "tag";
+ }
+
+ if (ch === '{') {
+ return "braket";
+ }
+
+ if (ch === '}') {
+ return "braket";
+ }
+
+ if (/\d/.test(ch)) {
+ if (ch === "0" && stream.eat("x")) {
+ stream.eatWhile(/[0-9a-fA-F]/);
+ return "number";
+ }
+ stream.eatWhile(/\d/);
+ return "number";
+ }
+
+ if (/\w/.test(ch)) {
+ stream.eatWhile(/\w/);
+ if (stream.eat(":")) {
+ return 'tag';
+ }
+ cur = stream.current().toLowerCase();
+ style = registers[cur];
+ return style || null;
+ }
+
+ for (var i = 0; i < custom.length; i++) {
+ style = custom[i](ch, stream, state);
+ if (style) {
+ return style;
+ }
+ }
+ },
+
+ lineComment: lineCommentStartSymbol,
+ blockCommentStart: "/*",
+ blockCommentEnd: "*/"
+ };
+});
+
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/gas/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/gas/index.html
new file mode 100644
index 0000000..df75ca2
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/gas/index.html
@@ -0,0 +1,68 @@
+
+
+= 0; i--) cx.cc.push(arguments[i]);
+ }
+ function cont() {
+ pass.apply(null, arguments);
+ return true;
+ }
+ function register(varname) {
+ var state = cx.state;
+ if (state.context) {
+ cx.marked = "def";
+ for (var v = state.localVars; v; v = v.next)
+ if (v.name == varname) return;
+ state.localVars = {name: varname, next: state.localVars};
+ }
+ }
+
+ // Combinators
+
+ var defaultVars = {name: "this", next: null};
+ function pushcontext() {
+ if (!cx.state.context) cx.state.localVars = defaultVars;
+ cx.state.context = {prev: cx.state.context, vars: cx.state.localVars};
+ }
+ function popcontext() {
+ cx.state.localVars = cx.state.context.vars;
+ cx.state.context = cx.state.context.prev;
+ }
+ function pushlex(type, info) {
+ var result = function() {
+ var state = cx.state;
+ state.lexical = new HaxeLexical(state.indented, cx.stream.column(), type, null, state.lexical, info);
+ };
+ result.lex = true;
+ return result;
+ }
+ function poplex() {
+ var state = cx.state;
+ if (state.lexical.prev) {
+ if (state.lexical.type == ")")
+ state.indented = state.lexical.indented;
+ state.lexical = state.lexical.prev;
+ }
+ }
+ poplex.lex = true;
+
+ function expect(wanted) {
+ function f(type) {
+ if (type == wanted) return cont();
+ else if (wanted == ";") return pass();
+ else return cont(f);
+ };
+ return f;
+ }
+
+ function statement(type) {
+ if (type == "@") return cont(metadef);
+ if (type == "var") return cont(pushlex("vardef"), vardef1, expect(";"), poplex);
+ if (type == "keyword a") return cont(pushlex("form"), expression, statement, poplex);
+ if (type == "keyword b") return cont(pushlex("form"), statement, poplex);
+ if (type == "{") return cont(pushlex("}"), pushcontext, block, poplex, popcontext);
+ if (type == ";") return cont();
+ if (type == "attribute") return cont(maybeattribute);
+ if (type == "function") return cont(functiondef);
+ if (type == "for") return cont(pushlex("form"), expect("("), pushlex(")"), forspec1, expect(")"),
+ poplex, statement, poplex);
+ if (type == "variable") return cont(pushlex("stat"), maybelabel);
+ if (type == "switch") return cont(pushlex("form"), expression, pushlex("}", "switch"), expect("{"),
+ block, poplex, poplex);
+ if (type == "case") return cont(expression, expect(":"));
+ if (type == "default") return cont(expect(":"));
+ if (type == "catch") return cont(pushlex("form"), pushcontext, expect("("), funarg, expect(")"),
+ statement, poplex, popcontext);
+ if (type == "import") return cont(importdef, expect(";"));
+ if (type == "typedef") return cont(typedef);
+ return pass(pushlex("stat"), expression, expect(";"), poplex);
+ }
+ function expression(type) {
+ if (atomicTypes.hasOwnProperty(type)) return cont(maybeoperator);
+ if (type == "function") return cont(functiondef);
+ if (type == "keyword c") return cont(maybeexpression);
+ if (type == "(") return cont(pushlex(")"), maybeexpression, expect(")"), poplex, maybeoperator);
+ if (type == "operator") return cont(expression);
+ if (type == "[") return cont(pushlex("]"), commasep(expression, "]"), poplex, maybeoperator);
+ if (type == "{") return cont(pushlex("}"), commasep(objprop, "}"), poplex, maybeoperator);
+ return cont();
+ }
+ function maybeexpression(type) {
+ if (type.match(/[;\}\)\],]/)) return pass();
+ return pass(expression);
+ }
+
+ function maybeoperator(type, value) {
+ if (type == "operator" && /\+\+|--/.test(value)) return cont(maybeoperator);
+ if (type == "operator" || type == ":") return cont(expression);
+ if (type == ";") return;
+ if (type == "(") return cont(pushlex(")"), commasep(expression, ")"), poplex, maybeoperator);
+ if (type == ".") return cont(property, maybeoperator);
+ if (type == "[") return cont(pushlex("]"), expression, expect("]"), poplex, maybeoperator);
+ }
+
+ function maybeattribute(type) {
+ if (type == "attribute") return cont(maybeattribute);
+ if (type == "function") return cont(functiondef);
+ if (type == "var") return cont(vardef1);
+ }
+
+ function metadef(type) {
+ if(type == ":") return cont(metadef);
+ if(type == "variable") return cont(metadef);
+ if(type == "(") return cont(pushlex(")"), commasep(metaargs, ")"), poplex, statement);
+ }
+ function metaargs(type) {
+ if(type == "variable") return cont();
+ }
+
+ function importdef (type, value) {
+ if(type == "variable" && /[A-Z]/.test(value.charAt(0))) { registerimport(value); return cont(); }
+ else if(type == "variable" || type == "property" || type == "." || value == "*") return cont(importdef);
+ }
+
+ function typedef (type, value)
+ {
+ if(type == "variable" && /[A-Z]/.test(value.charAt(0))) { registerimport(value); return cont(); }
+ else if (type == "type" && /[A-Z]/.test(value.charAt(0))) { return cont(); }
+ }
+
+ function maybelabel(type) {
+ if (type == ":") return cont(poplex, statement);
+ return pass(maybeoperator, expect(";"), poplex);
+ }
+ function property(type) {
+ if (type == "variable") {cx.marked = "property"; return cont();}
+ }
+ function objprop(type) {
+ if (type == "variable") cx.marked = "property";
+ if (atomicTypes.hasOwnProperty(type)) return cont(expect(":"), expression);
+ }
+ function commasep(what, end) {
+ function proceed(type) {
+ if (type == ",") return cont(what, proceed);
+ if (type == end) return cont();
+ return cont(expect(end));
+ }
+ return function(type) {
+ if (type == end) return cont();
+ else return pass(what, proceed);
+ };
+ }
+ function block(type) {
+ if (type == "}") return cont();
+ return pass(statement, block);
+ }
+ function vardef1(type, value) {
+ if (type == "variable"){register(value); return cont(typeuse, vardef2);}
+ return cont();
+ }
+ function vardef2(type, value) {
+ if (value == "=") return cont(expression, vardef2);
+ if (type == ",") return cont(vardef1);
+ }
+ function forspec1(type, value) {
+ if (type == "variable") {
+ register(value);
+ }
+ return cont(pushlex(")"), pushcontext, forin, expression, poplex, statement, popcontext);
+ }
+ function forin(_type, value) {
+ if (value == "in") return cont();
+ }
+ function functiondef(type, value) {
+ if (type == "variable") {register(value); return cont(functiondef);}
+ if (value == "new") return cont(functiondef);
+ if (type == "(") return cont(pushlex(")"), pushcontext, commasep(funarg, ")"), poplex, typeuse, statement, popcontext);
+ }
+ function typeuse(type) {
+ if(type == ":") return cont(typestring);
+ }
+ function typestring(type) {
+ if(type == "type") return cont();
+ if(type == "variable") return cont();
+ if(type == "{") return cont(pushlex("}"), commasep(typeprop, "}"), poplex);
+ }
+ function typeprop(type) {
+ if(type == "variable") return cont(typeuse);
+ }
+ function funarg(type, value) {
+ if (type == "variable") {register(value); return cont(typeuse);}
+ }
+
+ // Interface
+
+ return {
+ startState: function(basecolumn) {
+ var defaulttypes = ["Int", "Float", "String", "Void", "Std", "Bool", "Dynamic", "Array"];
+ return {
+ tokenize: haxeTokenBase,
+ reAllowed: true,
+ kwAllowed: true,
+ cc: [],
+ lexical: new HaxeLexical((basecolumn || 0) - indentUnit, 0, "block", false),
+ localVars: parserConfig.localVars,
+ importedtypes: defaulttypes,
+ context: parserConfig.localVars && {vars: parserConfig.localVars},
+ indented: 0
+ };
+ },
+
+ token: function(stream, state) {
+ if (stream.sol()) {
+ if (!state.lexical.hasOwnProperty("align"))
+ state.lexical.align = false;
+ state.indented = stream.indentation();
+ }
+ if (stream.eatSpace()) return null;
+ var style = state.tokenize(stream, state);
+ if (type == "comment") return style;
+ state.reAllowed = !!(type == "operator" || type == "keyword c" || type.match(/^[\[{}\(,;:]$/));
+ state.kwAllowed = type != '.';
+ return parseHaxe(state, style, type, content, stream);
+ },
+
+ indent: function(state, textAfter) {
+ if (state.tokenize != haxeTokenBase) return 0;
+ var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical;
+ if (lexical.type == "stat" && firstChar == "}") lexical = lexical.prev;
+ var type = lexical.type, closing = firstChar == type;
+ if (type == "vardef") return lexical.indented + 4;
+ else if (type == "form" && firstChar == "{") return lexical.indented;
+ else if (type == "stat" || type == "form") return lexical.indented + indentUnit;
+ else if (lexical.info == "switch" && !closing)
+ return lexical.indented + (/^(?:case|default)\b/.test(textAfter) ? indentUnit : 2 * indentUnit);
+ else if (lexical.align) return lexical.column + (closing ? 0 : 1);
+ else return lexical.indented + (closing ? 0 : indentUnit);
+ },
+
+ electricChars: "{}",
+ blockCommentStart: "/*",
+ blockCommentEnd: "*/",
+ lineComment: "//"
+ };
+});
+
+CodeMirror.defineMIME("text/x-haxe", "haxe");
+
+CodeMirror.defineMode("hxml", function () {
+
+ return {
+ startState: function () {
+ return {
+ define: false,
+ inString: false
+ };
+ },
+ token: function (stream, state) {
+ var ch = stream.peek();
+ var sol = stream.sol();
+
+ ///* comments */
+ if (ch == "#") {
+ stream.skipToEnd();
+ return "comment";
+ }
+ if (sol && ch == "-") {
+ var style = "variable-2";
+
+ stream.eat(/-/);
+
+ if (stream.peek() == "-") {
+ stream.eat(/-/);
+ style = "keyword a";
+ }
+
+ if (stream.peek() == "D") {
+ stream.eat(/[D]/);
+ style = "keyword c";
+ state.define = true;
+ }
+
+ stream.eatWhile(/[A-Z]/i);
+ return style;
+ }
+
+ var ch = stream.peek();
+
+ if (state.inString == false && ch == "'") {
+ state.inString = true;
+ ch = stream.next();
+ }
+
+ if (state.inString == true) {
+ if (stream.skipTo("'")) {
+
+ } else {
+ stream.skipToEnd();
+ }
+
+ if (stream.peek() == "'") {
+ stream.next();
+ state.inString = false;
+ }
+
+ return "string";
+ }
+
+ stream.next();
+ return null;
+ },
+ lineComment: "#"
+ };
+});
+
+CodeMirror.defineMIME("text/x-hxml", "hxml");
+
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/haxe/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/haxe/index.html
new file mode 100644
index 0000000..d415b5e
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/haxe/index.html
@@ -0,0 +1,124 @@
+
+
+CodeMirror: Haxe mode
+
+
+
+
+
+
+
+
+
+
+Haxe mode
+
+
+
+
+
+
+ MIME types defined: text/x-haxe, text/x-hxml.
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/htmlembedded/htmlembedded.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/htmlembedded/htmlembedded.js
new file mode 100644
index 0000000..e8f7ba8
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/htmlembedded/htmlembedded.js
@@ -0,0 +1,86 @@
+// 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"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror", "../htmlmixed/htmlmixed"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("htmlembedded", function(config, parserConfig) {
+
+ //config settings
+ var scriptStartRegex = parserConfig.scriptStartRegex || /^<%/i,
+ scriptEndRegex = parserConfig.scriptEndRegex || /^%>/i;
+
+ //inner modes
+ var scriptingMode, htmlMixedMode;
+
+ //tokenizer when in html mode
+ function htmlDispatch(stream, state) {
+ if (stream.match(scriptStartRegex, false)) {
+ state.token=scriptingDispatch;
+ return scriptingMode.token(stream, state.scriptState);
+ }
+ else
+ return htmlMixedMode.token(stream, state.htmlState);
+ }
+
+ //tokenizer when in scripting mode
+ function scriptingDispatch(stream, state) {
+ if (stream.match(scriptEndRegex, false)) {
+ state.token=htmlDispatch;
+ return htmlMixedMode.token(stream, state.htmlState);
+ }
+ else
+ return scriptingMode.token(stream, state.scriptState);
+ }
+
+
+ return {
+ startState: function() {
+ scriptingMode = scriptingMode || CodeMirror.getMode(config, parserConfig.scriptingModeSpec);
+ htmlMixedMode = htmlMixedMode || CodeMirror.getMode(config, "htmlmixed");
+ return {
+ token : parserConfig.startOpen ? scriptingDispatch : htmlDispatch,
+ htmlState : CodeMirror.startState(htmlMixedMode),
+ scriptState : CodeMirror.startState(scriptingMode)
+ };
+ },
+
+ token: function(stream, state) {
+ return state.token(stream, state);
+ },
+
+ indent: function(state, textAfter) {
+ if (state.token == htmlDispatch)
+ return htmlMixedMode.indent(state.htmlState, textAfter);
+ else if (scriptingMode.indent)
+ return scriptingMode.indent(state.scriptState, textAfter);
+ },
+
+ copyState: function(state) {
+ return {
+ token : state.token,
+ htmlState : CodeMirror.copyState(htmlMixedMode, state.htmlState),
+ scriptState : CodeMirror.copyState(scriptingMode, state.scriptState)
+ };
+ },
+
+ innerMode: function(state) {
+ if (state.token == scriptingDispatch) return {state: state.scriptState, mode: scriptingMode};
+ else return {state: state.htmlState, mode: htmlMixedMode};
+ }
+ };
+}, "htmlmixed");
+
+CodeMirror.defineMIME("application/x-ejs", { name: "htmlembedded", scriptingModeSpec:"javascript"});
+CodeMirror.defineMIME("application/x-aspx", { name: "htmlembedded", scriptingModeSpec:"text/x-csharp"});
+CodeMirror.defineMIME("application/x-jsp", { name: "htmlembedded", scriptingModeSpec:"text/x-java"});
+CodeMirror.defineMIME("application/x-erb", { name: "htmlembedded", scriptingModeSpec:"ruby"});
+
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/htmlembedded/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/htmlembedded/index.html
new file mode 100644
index 0000000..93d01c4
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/htmlembedded/index.html
@@ -0,0 +1,58 @@
+
+
+CodeMirror: Html Embedded Scripts mode
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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)
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/htmlmixed/htmlmixed.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/htmlmixed/htmlmixed.js
new file mode 100644
index 0000000..1cc438f
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/htmlmixed/htmlmixed.js
@@ -0,0 +1,121 @@
+// 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("../xml/xml"), require("../javascript/javascript"), require("../css/css"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror", "../xml/xml", "../javascript/javascript", "../css/css"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("htmlmixed", function(config, parserConfig) {
+ var htmlMode = CodeMirror.getMode(config, {name: "xml",
+ htmlMode: true,
+ multilineTagIndentFactor: parserConfig.multilineTagIndentFactor,
+ multilineTagIndentPastTag: parserConfig.multilineTagIndentPastTag});
+ var cssMode = CodeMirror.getMode(config, "css");
+
+ var scriptTypes = [], scriptTypesConf = parserConfig && parserConfig.scriptTypes;
+ scriptTypes.push({matches: /^(?:text|application)\/(?:x-)?(?:java|ecma)script$|^$/i,
+ mode: CodeMirror.getMode(config, "javascript")});
+ if (scriptTypesConf) for (var i = 0; i < scriptTypesConf.length; ++i) {
+ var conf = scriptTypesConf[i];
+ scriptTypes.push({matches: conf.matches, mode: conf.mode && CodeMirror.getMode(config, conf.mode)});
+ }
+ scriptTypes.push({matches: /./,
+ mode: CodeMirror.getMode(config, "text/plain")});
+
+ function html(stream, state) {
+ var tagName = state.htmlState.tagName;
+ if (tagName) tagName = tagName.toLowerCase();
+ var style = htmlMode.token(stream, state.htmlState);
+ if (tagName == "script" && /\btag\b/.test(style) && stream.current() == ">") {
+ // Script block: mode to change to depends on type attribute
+ var scriptType = stream.string.slice(Math.max(0, stream.pos - 100), stream.pos).match(/\btype\s*=\s*("[^"]+"|'[^']+'|\S+)[^<]*$/i);
+ scriptType = scriptType ? scriptType[1] : "";
+ if (scriptType && /[\"\']/.test(scriptType.charAt(0))) scriptType = scriptType.slice(1, scriptType.length - 1);
+ for (var i = 0; i < scriptTypes.length; ++i) {
+ var tp = scriptTypes[i];
+ if (typeof tp.matches == "string" ? scriptType == tp.matches : tp.matches.test(scriptType)) {
+ if (tp.mode) {
+ state.token = script;
+ state.localMode = tp.mode;
+ state.localState = tp.mode.startState && tp.mode.startState(htmlMode.indent(state.htmlState, ""));
+ }
+ break;
+ }
+ }
+ } else if (tagName == "style" && /\btag\b/.test(style) && stream.current() == ">") {
+ state.token = css;
+ state.localMode = cssMode;
+ state.localState = cssMode.startState(htmlMode.indent(state.htmlState, ""));
+ }
+ return style;
+ }
+ function maybeBackup(stream, pat, style) {
+ var cur = stream.current();
+ var close = cur.search(pat), m;
+ if (close > -1) stream.backUp(cur.length - close);
+ else if (m = cur.match(/<\/?$/)) {
+ stream.backUp(cur.length);
+ if (!stream.match(pat, false)) stream.match(cur);
+ }
+ return style;
+ }
+ function script(stream, state) {
+ if (stream.match(/^<\/\s*script\s*>/i, false)) {
+ state.token = html;
+ state.localState = state.localMode = null;
+ return null;
+ }
+ return maybeBackup(stream, /<\/\s*script\s*>/,
+ state.localMode.token(stream, state.localState));
+ }
+ function css(stream, state) {
+ if (stream.match(/^<\/\s*style\s*>/i, false)) {
+ state.token = html;
+ state.localState = state.localMode = null;
+ return null;
+ }
+ return maybeBackup(stream, /<\/\s*style\s*>/,
+ cssMode.token(stream, state.localState));
+ }
+
+ return {
+ startState: function() {
+ var state = htmlMode.startState();
+ return {token: html, localMode: null, localState: null, htmlState: state};
+ },
+
+ copyState: function(state) {
+ if (state.localState)
+ var local = CodeMirror.copyState(state.localMode, state.localState);
+ return {token: state.token, localMode: state.localMode, localState: local,
+ htmlState: CodeMirror.copyState(htmlMode, state.htmlState)};
+ },
+
+ token: function(stream, state) {
+ return state.token(stream, state);
+ },
+
+ indent: function(state, textAfter) {
+ if (!state.localMode || /^\s*<\//.test(textAfter))
+ return htmlMode.indent(state.htmlState, textAfter);
+ else if (state.localMode.indent)
+ return state.localMode.indent(state.localState, textAfter);
+ else
+ return CodeMirror.Pass;
+ },
+
+ innerMode: function(state) {
+ return {state: state.localState || state.htmlState, mode: state.localMode || htmlMode};
+ }
+ };
+}, "xml", "javascript", "css");
+
+CodeMirror.defineMIME("text/html", "htmlmixed");
+
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/htmlmixed/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/htmlmixed/index.html
new file mode 100644
index 0000000..f94df9e
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/htmlmixed/index.html
@@ -0,0 +1,89 @@
+
+
+CodeMirror: HTML mixed mode
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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).
+
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/http/http.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/http/http.js
new file mode 100644
index 0000000..9a3c5f9
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/http/http.js
@@ -0,0 +1,113 @@
+// 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("http", function() {
+ function failFirstLine(stream, state) {
+ stream.skipToEnd();
+ state.cur = header;
+ return "error";
+ }
+
+ function start(stream, state) {
+ if (stream.match(/^HTTP\/\d\.\d/)) {
+ state.cur = responseStatusCode;
+ return "keyword";
+ } else if (stream.match(/^[A-Z]+/) && /[ \t]/.test(stream.peek())) {
+ state.cur = requestPath;
+ return "keyword";
+ } else {
+ return failFirstLine(stream, state);
+ }
+ }
+
+ function responseStatusCode(stream, state) {
+ var code = stream.match(/^\d+/);
+ if (!code) return failFirstLine(stream, state);
+
+ state.cur = responseStatusText;
+ var status = Number(code[0]);
+ if (status >= 100 && status < 200) {
+ return "positive informational";
+ } else if (status >= 200 && status < 300) {
+ return "positive success";
+ } else if (status >= 300 && status < 400) {
+ return "positive redirect";
+ } else if (status >= 400 && status < 500) {
+ return "negative client-error";
+ } else if (status >= 500 && status < 600) {
+ return "negative server-error";
+ } else {
+ return "error";
+ }
+ }
+
+ function responseStatusText(stream, state) {
+ stream.skipToEnd();
+ state.cur = header;
+ return null;
+ }
+
+ function requestPath(stream, state) {
+ stream.eatWhile(/\S/);
+ state.cur = requestProtocol;
+ return "string-2";
+ }
+
+ function requestProtocol(stream, state) {
+ if (stream.match(/^HTTP\/\d\.\d$/)) {
+ state.cur = header;
+ return "keyword";
+ } else {
+ return failFirstLine(stream, state);
+ }
+ }
+
+ function header(stream) {
+ if (stream.sol() && !stream.eat(/[ \t]/)) {
+ if (stream.match(/^.*?:/)) {
+ return "atom";
+ } else {
+ stream.skipToEnd();
+ return "error";
+ }
+ } else {
+ stream.skipToEnd();
+ return "string";
+ }
+ }
+
+ function body(stream) {
+ stream.skipToEnd();
+ return null;
+ }
+
+ return {
+ token: function(stream, state) {
+ var cur = state.cur;
+ if (cur != header && cur != body && stream.eatSpace()) return null;
+ return cur(stream, state);
+ },
+
+ blankLine: function(state) {
+ state.cur = body;
+ },
+
+ startState: function() {
+ return {cur: start};
+ }
+ };
+});
+
+CodeMirror.defineMIME("message/http", "http");
+
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/http/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/http/index.html
new file mode 100644
index 0000000..0b8d531
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/http/index.html
@@ -0,0 +1,45 @@
+
+
+CodeMirror: HTTP mode
+
+
+
+
+
+
+
+
+
+
+HTTP mode
+
+
+
+
+
+
+ MIME types defined: message/http.
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/idl/idl.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/idl/idl.js
new file mode 100644
index 0000000..07308d7
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/idl/idl.js
@@ -0,0 +1,290 @@
+// 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";
+
+ function wordRegexp(words) {
+ return new RegExp('^((' + words.join(')|(') + '))\\b', 'i');
+ };
+
+ var builtinArray = [
+ 'a_correlate', 'abs', 'acos', 'adapt_hist_equal', 'alog',
+ 'alog2', 'alog10', 'amoeba', 'annotate', 'app_user_dir',
+ 'app_user_dir_query', 'arg_present', 'array_equal', 'array_indices',
+ 'arrow', 'ascii_template', 'asin', 'assoc', 'atan',
+ 'axis', 'axis', 'bandpass_filter', 'bandreject_filter', 'barplot',
+ 'bar_plot', 'beseli', 'beselj', 'beselk', 'besely',
+ 'beta', 'biginteger', 'bilinear', 'bin_date', 'binary_template',
+ 'bindgen', 'binomial', 'bit_ffs', 'bit_population', 'blas_axpy',
+ 'blk_con', 'boolarr', 'boolean', 'boxplot', 'box_cursor',
+ 'breakpoint', 'broyden', 'bubbleplot', 'butterworth', 'bytarr',
+ 'byte', 'byteorder', 'bytscl', 'c_correlate', 'calendar',
+ 'caldat', 'call_external', 'call_function', 'call_method',
+ 'call_procedure', 'canny', 'catch', 'cd', 'cdf', 'ceil',
+ 'chebyshev', 'check_math', 'chisqr_cvf', 'chisqr_pdf', 'choldc',
+ 'cholsol', 'cindgen', 'cir_3pnt', 'clipboard', 'close',
+ 'clust_wts', 'cluster', 'cluster_tree', 'cmyk_convert', 'code_coverage',
+ 'color_convert', 'color_exchange', 'color_quan', 'color_range_map',
+ 'colorbar', 'colorize_sample', 'colormap_applicable',
+ 'colormap_gradient', 'colormap_rotation', 'colortable',
+ 'comfit', 'command_line_args', 'common', 'compile_opt', 'complex',
+ 'complexarr', 'complexround', 'compute_mesh_normals', 'cond', 'congrid',
+ 'conj', 'constrained_min', 'contour', 'contour', 'convert_coord',
+ 'convol', 'convol_fft', 'coord2to3', 'copy_lun', 'correlate',
+ 'cos', 'cosh', 'cpu', 'cramer', 'createboxplotdata',
+ 'create_cursor', 'create_struct', 'create_view', 'crossp', 'crvlength',
+ 'ct_luminance', 'cti_test', 'cursor', 'curvefit', 'cv_coord',
+ 'cvttobm', 'cw_animate', 'cw_animate_getp', 'cw_animate_load',
+ 'cw_animate_run', 'cw_arcball', 'cw_bgroup', 'cw_clr_index',
+ 'cw_colorsel', 'cw_defroi', 'cw_field', 'cw_filesel', 'cw_form',
+ 'cw_fslider', 'cw_light_editor', 'cw_light_editor_get',
+ 'cw_light_editor_set', 'cw_orient', 'cw_palette_editor',
+ 'cw_palette_editor_get', 'cw_palette_editor_set', 'cw_pdmenu',
+ 'cw_rgbslider', 'cw_tmpl', 'cw_zoom', 'db_exists',
+ 'dblarr', 'dcindgen', 'dcomplex', 'dcomplexarr', 'define_key',
+ 'define_msgblk', 'define_msgblk_from_file', 'defroi', 'defsysv',
+ 'delvar', 'dendro_plot', 'dendrogram', 'deriv', 'derivsig',
+ 'determ', 'device', 'dfpmin', 'diag_matrix', 'dialog_dbconnect',
+ 'dialog_message', 'dialog_pickfile', 'dialog_printersetup',
+ 'dialog_printjob', 'dialog_read_image',
+ 'dialog_write_image', 'dictionary', 'digital_filter', 'dilate', 'dindgen',
+ 'dissolve', 'dist', 'distance_measure', 'dlm_load', 'dlm_register',
+ 'doc_library', 'double', 'draw_roi', 'edge_dog', 'efont',
+ 'eigenql', 'eigenvec', 'ellipse', 'elmhes', 'emboss',
+ 'empty', 'enable_sysrtn', 'eof', 'eos', 'erase',
+ 'erf', 'erfc', 'erfcx', 'erode', 'errorplot',
+ 'errplot', 'estimator_filter', 'execute', 'exit', 'exp',
+ 'expand', 'expand_path', 'expint', 'extrac', 'extract_slice',
+ 'f_cvf', 'f_pdf', 'factorial', 'fft', 'file_basename',
+ 'file_chmod', 'file_copy', 'file_delete', 'file_dirname',
+ 'file_expand_path', 'file_gunzip', 'file_gzip', 'file_info',
+ 'file_lines', 'file_link', 'file_mkdir', 'file_move',
+ 'file_poll_input', 'file_readlink', 'file_same',
+ 'file_search', 'file_tar', 'file_test', 'file_untar', 'file_unzip',
+ 'file_which', 'file_zip', 'filepath', 'findgen', 'finite',
+ 'fix', 'flick', 'float', 'floor', 'flow3',
+ 'fltarr', 'flush', 'format_axis_values', 'forward_function', 'free_lun',
+ 'fstat', 'fulstr', 'funct', 'function', 'fv_test',
+ 'fx_root', 'fz_roots', 'gamma', 'gamma_ct', 'gauss_cvf',
+ 'gauss_pdf', 'gauss_smooth', 'gauss2dfit', 'gaussfit',
+ 'gaussian_function', 'gaussint', 'get_drive_list', 'get_dxf_objects',
+ 'get_kbrd', 'get_login_info',
+ 'get_lun', 'get_screen_size', 'getenv', 'getwindows', 'greg2jul',
+ 'grib', 'grid_input', 'grid_tps', 'grid3', 'griddata',
+ 'gs_iter', 'h_eq_ct', 'h_eq_int', 'hanning', 'hash',
+ 'hdf', 'hdf5', 'heap_free', 'heap_gc', 'heap_nosave',
+ 'heap_refcount', 'heap_save', 'help', 'hilbert', 'hist_2d',
+ 'hist_equal', 'histogram', 'hls', 'hough', 'hqr',
+ 'hsv', 'i18n_multibytetoutf8',
+ 'i18n_multibytetowidechar', 'i18n_utf8tomultibyte',
+ 'i18n_widechartomultibyte',
+ 'ibeta', 'icontour', 'iconvertcoord', 'idelete', 'identity',
+ 'idl_base64', 'idl_container', 'idl_validname',
+ 'idlexbr_assistant', 'idlitsys_createtool',
+ 'idlunit', 'iellipse', 'igamma', 'igetcurrent', 'igetdata',
+ 'igetid', 'igetproperty', 'iimage', 'image', 'image_cont',
+ 'image_statistics', 'image_threshold', 'imaginary', 'imap', 'indgen',
+ 'int_2d', 'int_3d', 'int_tabulated', 'intarr', 'interpol',
+ 'interpolate', 'interval_volume', 'invert', 'ioctl', 'iopen',
+ 'ir_filter', 'iplot', 'ipolygon', 'ipolyline', 'iputdata',
+ 'iregister', 'ireset', 'iresolve', 'irotate', 'isa',
+ 'isave', 'iscale', 'isetcurrent', 'isetproperty', 'ishft',
+ 'isocontour', 'isosurface', 'isurface', 'itext', 'itranslate',
+ 'ivector', 'ivolume', 'izoom', 'journal', 'json_parse',
+ 'json_serialize', 'jul2greg', 'julday', 'keyword_set', 'krig2d',
+ 'kurtosis', 'kw_test', 'l64indgen', 'la_choldc', 'la_cholmprove',
+ 'la_cholsol', 'la_determ', 'la_eigenproblem', 'la_eigenql', 'la_eigenvec',
+ 'la_elmhes', 'la_gm_linear_model', 'la_hqr', 'la_invert',
+ 'la_least_square_equality', 'la_least_squares', 'la_linear_equation',
+ 'la_ludc', 'la_lumprove', 'la_lusol',
+ 'la_svd', 'la_tridc', 'la_trimprove', 'la_triql', 'la_trired',
+ 'la_trisol', 'label_date', 'label_region', 'ladfit', 'laguerre',
+ 'lambda', 'lambdap', 'lambertw', 'laplacian', 'least_squares_filter',
+ 'leefilt', 'legend', 'legendre', 'linbcg', 'lindgen',
+ 'linfit', 'linkimage', 'list', 'll_arc_distance', 'lmfit',
+ 'lmgr', 'lngamma', 'lnp_test', 'loadct', 'locale_get',
+ 'logical_and', 'logical_or', 'logical_true', 'lon64arr', 'lonarr',
+ 'long', 'long64', 'lsode', 'lu_complex', 'ludc',
+ 'lumprove', 'lusol', 'm_correlate', 'machar', 'make_array',
+ 'make_dll', 'make_rt', 'map', 'mapcontinents', 'mapgrid',
+ 'map_2points', 'map_continents', 'map_grid', 'map_image', 'map_patch',
+ 'map_proj_forward', 'map_proj_image', 'map_proj_info',
+ 'map_proj_init', 'map_proj_inverse',
+ 'map_set', 'matrix_multiply', 'matrix_power', 'max', 'md_test',
+ 'mean', 'meanabsdev', 'mean_filter', 'median', 'memory',
+ 'mesh_clip', 'mesh_decimate', 'mesh_issolid',
+ 'mesh_merge', 'mesh_numtriangles',
+ 'mesh_obj', 'mesh_smooth', 'mesh_surfacearea',
+ 'mesh_validate', 'mesh_volume',
+ 'message', 'min', 'min_curve_surf', 'mk_html_help', 'modifyct',
+ 'moment', 'morph_close', 'morph_distance',
+ 'morph_gradient', 'morph_hitormiss',
+ 'morph_open', 'morph_thin', 'morph_tophat', 'multi', 'n_elements',
+ 'n_params', 'n_tags', 'ncdf', 'newton', 'noise_hurl',
+ 'noise_pick', 'noise_scatter', 'noise_slur', 'norm', 'obj_class',
+ 'obj_destroy', 'obj_hasmethod', 'obj_isa', 'obj_new', 'obj_valid',
+ 'objarr', 'on_error', 'on_ioerror', 'online_help', 'openr',
+ 'openu', 'openw', 'oplot', 'oploterr', 'orderedhash',
+ 'p_correlate', 'parse_url', 'particle_trace', 'path_cache', 'path_sep',
+ 'pcomp', 'plot', 'plot3d', 'plot', 'plot_3dbox',
+ 'plot_field', 'ploterr', 'plots', 'polar_contour', 'polar_surface',
+ 'polyfill', 'polyshade', 'pnt_line', 'point_lun', 'polarplot',
+ 'poly', 'poly_2d', 'poly_area', 'poly_fit', 'polyfillv',
+ 'polygon', 'polyline', 'polywarp', 'popd', 'powell',
+ 'pref_commit', 'pref_get', 'pref_set', 'prewitt', 'primes',
+ 'print', 'printf', 'printd', 'pro', 'product',
+ 'profile', 'profiler', 'profiles', 'project_vol', 'ps_show_fonts',
+ 'psafm', 'pseudo', 'ptr_free', 'ptr_new', 'ptr_valid',
+ 'ptrarr', 'pushd', 'qgrid3', 'qhull', 'qromb',
+ 'qromo', 'qsimp', 'query_*', 'query_ascii', 'query_bmp',
+ 'query_csv', 'query_dicom', 'query_gif', 'query_image', 'query_jpeg',
+ 'query_jpeg2000', 'query_mrsid', 'query_pict', 'query_png', 'query_ppm',
+ 'query_srf', 'query_tiff', 'query_video', 'query_wav', 'r_correlate',
+ 'r_test', 'radon', 'randomn', 'randomu', 'ranks',
+ 'rdpix', 'read', 'readf', 'read_ascii', 'read_binary',
+ 'read_bmp', 'read_csv', 'read_dicom', 'read_gif', 'read_image',
+ 'read_interfile', 'read_jpeg', 'read_jpeg2000', 'read_mrsid', 'read_pict',
+ 'read_png', 'read_ppm', 'read_spr', 'read_srf', 'read_sylk',
+ 'read_tiff', 'read_video', 'read_wav', 'read_wave', 'read_x11_bitmap',
+ 'read_xwd', 'reads', 'readu', 'real_part', 'rebin',
+ 'recall_commands', 'recon3', 'reduce_colors', 'reform', 'region_grow',
+ 'register_cursor', 'regress', 'replicate',
+ 'replicate_inplace', 'resolve_all',
+ 'resolve_routine', 'restore', 'retall', 'return', 'reverse',
+ 'rk4', 'roberts', 'rot', 'rotate', 'round',
+ 'routine_filepath', 'routine_info', 'rs_test', 's_test', 'save',
+ 'savgol', 'scale3', 'scale3d', 'scatterplot', 'scatterplot3d',
+ 'scope_level', 'scope_traceback', 'scope_varfetch',
+ 'scope_varname', 'search2d',
+ 'search3d', 'sem_create', 'sem_delete', 'sem_lock', 'sem_release',
+ 'set_plot', 'set_shading', 'setenv', 'sfit', 'shade_surf',
+ 'shade_surf_irr', 'shade_volume', 'shift', 'shift_diff', 'shmdebug',
+ 'shmmap', 'shmunmap', 'shmvar', 'show3', 'showfont',
+ 'signum', 'simplex', 'sin', 'sindgen', 'sinh',
+ 'size', 'skewness', 'skip_lun', 'slicer3', 'slide_image',
+ 'smooth', 'sobel', 'socket', 'sort', 'spawn',
+ 'sph_4pnt', 'sph_scat', 'spher_harm', 'spl_init', 'spl_interp',
+ 'spline', 'spline_p', 'sprsab', 'sprsax', 'sprsin',
+ 'sprstp', 'sqrt', 'standardize', 'stddev', 'stop',
+ 'strarr', 'strcmp', 'strcompress', 'streamline', 'streamline',
+ 'stregex', 'stretch', 'string', 'strjoin', 'strlen',
+ 'strlowcase', 'strmatch', 'strmessage', 'strmid', 'strpos',
+ 'strput', 'strsplit', 'strtrim', 'struct_assign', 'struct_hide',
+ 'strupcase', 'surface', 'surface', 'surfr', 'svdc',
+ 'svdfit', 'svsol', 'swap_endian', 'swap_endian_inplace', 'symbol',
+ 'systime', 't_cvf', 't_pdf', 't3d', 'tag_names',
+ 'tan', 'tanh', 'tek_color', 'temporary', 'terminal_size',
+ 'tetra_clip', 'tetra_surface', 'tetra_volume', 'text', 'thin',
+ 'thread', 'threed', 'tic', 'time_test2', 'timegen',
+ 'timer', 'timestamp', 'timestamptovalues', 'tm_test', 'toc',
+ 'total', 'trace', 'transpose', 'tri_surf', 'triangulate',
+ 'trigrid', 'triql', 'trired', 'trisol', 'truncate_lun',
+ 'ts_coef', 'ts_diff', 'ts_fcast', 'ts_smooth', 'tv',
+ 'tvcrs', 'tvlct', 'tvrd', 'tvscl', 'typename',
+ 'uindgen', 'uint', 'uintarr', 'ul64indgen', 'ulindgen',
+ 'ulon64arr', 'ulonarr', 'ulong', 'ulong64', 'uniq',
+ 'unsharp_mask', 'usersym', 'value_locate', 'variance', 'vector',
+ 'vector_field', 'vel', 'velovect', 'vert_t3d', 'voigt',
+ 'volume', 'voronoi', 'voxel_proj', 'wait', 'warp_tri',
+ 'watershed', 'wdelete', 'wf_draw', 'where', 'widget_base',
+ 'widget_button', 'widget_combobox', 'widget_control',
+ 'widget_displaycontextmenu', 'widget_draw',
+ 'widget_droplist', 'widget_event', 'widget_info',
+ 'widget_label', 'widget_list',
+ 'widget_propertysheet', 'widget_slider', 'widget_tab',
+ 'widget_table', 'widget_text',
+ 'widget_tree', 'widget_tree_move', 'widget_window',
+ 'wiener_filter', 'window',
+ 'window', 'write_bmp', 'write_csv', 'write_gif', 'write_image',
+ 'write_jpeg', 'write_jpeg2000', 'write_nrif', 'write_pict', 'write_png',
+ 'write_ppm', 'write_spr', 'write_srf', 'write_sylk', 'write_tiff',
+ 'write_video', 'write_wav', 'write_wave', 'writeu', 'wset',
+ 'wshow', 'wtn', 'wv_applet', 'wv_cwt', 'wv_cw_wavelet',
+ 'wv_denoise', 'wv_dwt', 'wv_fn_coiflet',
+ 'wv_fn_daubechies', 'wv_fn_gaussian',
+ 'wv_fn_haar', 'wv_fn_morlet', 'wv_fn_paul',
+ 'wv_fn_symlet', 'wv_import_data',
+ 'wv_import_wavelet', 'wv_plot3d_wps', 'wv_plot_multires',
+ 'wv_pwt', 'wv_tool_denoise',
+ 'xbm_edit', 'xdisplayfile', 'xdxf', 'xfont', 'xinteranimate',
+ 'xloadct', 'xmanager', 'xmng_tmpl', 'xmtool', 'xobjview',
+ 'xobjview_rotate', 'xobjview_write_image',
+ 'xpalette', 'xpcolor', 'xplot3d',
+ 'xregistered', 'xroi', 'xsq_test', 'xsurface', 'xvaredit',
+ 'xvolume', 'xvolume_rotate', 'xvolume_write_image',
+ 'xyouts', 'zlib_compress', 'zlib_uncompress', 'zoom', 'zoom_24'
+ ];
+ var builtins = wordRegexp(builtinArray);
+
+ var keywordArray = [
+ 'begin', 'end', 'endcase', 'endfor',
+ 'endwhile', 'endif', 'endrep', 'endforeach',
+ 'break', 'case', 'continue', 'for',
+ 'foreach', 'goto', 'if', 'then', 'else',
+ 'repeat', 'until', 'switch', 'while',
+ 'do', 'pro', 'function'
+ ];
+ var keywords = wordRegexp(keywordArray);
+
+ CodeMirror.registerHelper("hintWords", "idl", builtinArray.concat(keywordArray));
+
+ var identifiers = new RegExp('^[_a-z\xa1-\uffff][_a-z0-9\xa1-\uffff]*', 'i');
+
+ var singleOperators = /[+\-*&=<>\/@#~$]/;
+ var boolOperators = new RegExp('(and|or|eq|lt|le|gt|ge|ne|not)', 'i');
+
+ function tokenBase(stream) {
+ // whitespaces
+ if (stream.eatSpace()) return null;
+
+ // Handle one line Comments
+ if (stream.match(';')) {
+ stream.skipToEnd();
+ return 'comment';
+ }
+
+ // Handle Number Literals
+ if (stream.match(/^[0-9\.+-]/, false)) {
+ if (stream.match(/^[+-]?0x[0-9a-fA-F]+/))
+ return 'number';
+ if (stream.match(/^[+-]?\d*\.\d+([EeDd][+-]?\d+)?/))
+ return 'number';
+ if (stream.match(/^[+-]?\d+([EeDd][+-]?\d+)?/))
+ 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(boolOperators)) {
+ return 'operator'; }
+
+ // Handle non-detected items
+ stream.next();
+ return null;
+ };
+
+ CodeMirror.defineMode('idl', function() {
+ return {
+ token: function(stream) {
+ return tokenBase(stream);
+ }
+ };
+ });
+
+ CodeMirror.defineMIME('text/x-idl', 'idl');
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/idl/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/idl/index.html
new file mode 100644
index 0000000..4c169e2
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/idl/index.html
@@ -0,0 +1,64 @@
+
+
+CodeMirror: IDL mode
+
+
+
+
+
+
+
+
+
+
+IDL mode
+
+
+
+
+ MIME types defined: text/x-idl.
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/index.html
new file mode 100644
index 0000000..04167a5
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/index.html
@@ -0,0 +1,134 @@
+
+
+CodeMirror: Language Modes
+
+
+
+
+
+
+
+ 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.
+
+
+
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/jade/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/jade/index.html
new file mode 100644
index 0000000..e534981
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/jade/index.html
@@ -0,0 +1,70 @@
+
+
+CodeMirror: Jade Templating Mode
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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.
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/jade/jade.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/jade/jade.js
new file mode 100644
index 0000000..96fadb1
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/jade/jade.js
@@ -0,0 +1,590 @@
+// 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"), require("../css/css"), require("../htmlmixed/htmlmixed"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror", "../javascript/javascript", "../css/css", "../htmlmixed/htmlmixed"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode('jade', function (config) {
+ // token types
+ var KEYWORD = 'keyword';
+ var DOCTYPE = 'meta';
+ var ID = 'builtin';
+ var CLASS = 'qualifier';
+
+ var ATTRS_NEST = {
+ '{': '}',
+ '(': ')',
+ '[': ']'
+ };
+
+ var jsMode = CodeMirror.getMode(config, 'javascript');
+
+ function State() {
+ this.javaScriptLine = false;
+ this.javaScriptLineExcludesColon = false;
+
+ this.javaScriptArguments = false;
+ this.javaScriptArgumentsDepth = 0;
+
+ this.isInterpolating = false;
+ this.interpolationNesting = 0;
+
+ this.jsState = jsMode.startState();
+
+ this.restOfLine = '';
+
+ this.isIncludeFiltered = false;
+ this.isEach = false;
+
+ this.lastTag = '';
+ this.scriptType = '';
+
+ // Attributes Mode
+ this.isAttrs = false;
+ this.attrsNest = [];
+ this.inAttributeName = true;
+ this.attributeIsType = false;
+ this.attrValue = '';
+
+ // Indented Mode
+ this.indentOf = Infinity;
+ this.indentToken = '';
+
+ this.innerMode = null;
+ this.innerState = null;
+
+ this.innerModeForLine = false;
+ }
+ /**
+ * Safely copy a state
+ *
+ * @return {State}
+ */
+ State.prototype.copy = function () {
+ var res = new State();
+ res.javaScriptLine = this.javaScriptLine;
+ res.javaScriptLineExcludesColon = this.javaScriptLineExcludesColon;
+ res.javaScriptArguments = this.javaScriptArguments;
+ res.javaScriptArgumentsDepth = this.javaScriptArgumentsDepth;
+ res.isInterpolating = this.isInterpolating;
+ res.interpolationNesting = this.intpolationNesting;
+
+ res.jsState = CodeMirror.copyState(jsMode, this.jsState);
+
+ res.innerMode = this.innerMode;
+ if (this.innerMode && this.innerState) {
+ res.innerState = CodeMirror.copyState(this.innerMode, this.innerState);
+ }
+
+ res.restOfLine = this.restOfLine;
+
+ res.isIncludeFiltered = this.isIncludeFiltered;
+ res.isEach = this.isEach;
+ res.lastTag = this.lastTag;
+ res.scriptType = this.scriptType;
+ res.isAttrs = this.isAttrs;
+ res.attrsNest = this.attrsNest.slice();
+ res.inAttributeName = this.inAttributeName;
+ res.attributeIsType = this.attributeIsType;
+ res.attrValue = this.attrValue;
+ res.indentOf = this.indentOf;
+ res.indentToken = this.indentToken;
+
+ res.innerModeForLine = this.innerModeForLine;
+
+ return res;
+ };
+
+ function javaScript(stream, state) {
+ if (stream.sol()) {
+ // if javaScriptLine was set at end of line, ignore it
+ state.javaScriptLine = false;
+ state.javaScriptLineExcludesColon = false;
+ }
+ if (state.javaScriptLine) {
+ if (state.javaScriptLineExcludesColon && stream.peek() === ':') {
+ state.javaScriptLine = false;
+ state.javaScriptLineExcludesColon = false;
+ return;
+ }
+ var tok = jsMode.token(stream, state.jsState);
+ if (stream.eol()) state.javaScriptLine = false;
+ return tok || true;
+ }
+ }
+ function javaScriptArguments(stream, state) {
+ if (state.javaScriptArguments) {
+ if (state.javaScriptArgumentsDepth === 0 && stream.peek() !== '(') {
+ state.javaScriptArguments = false;
+ return;
+ }
+ if (stream.peek() === '(') {
+ state.javaScriptArgumentsDepth++;
+ } else if (stream.peek() === ')') {
+ state.javaScriptArgumentsDepth--;
+ }
+ if (state.javaScriptArgumentsDepth === 0) {
+ state.javaScriptArguments = false;
+ return;
+ }
+
+ var tok = jsMode.token(stream, state.jsState);
+ return tok || true;
+ }
+ }
+
+ function yieldStatement(stream) {
+ if (stream.match(/^yield\b/)) {
+ return 'keyword';
+ }
+ }
+
+ function doctype(stream) {
+ if (stream.match(/^(?:doctype) *([^\n]+)?/)) {
+ return DOCTYPE;
+ }
+ }
+
+ function interpolation(stream, state) {
+ if (stream.match('#{')) {
+ state.isInterpolating = true;
+ state.interpolationNesting = 0;
+ return 'punctuation';
+ }
+ }
+
+ function interpolationContinued(stream, state) {
+ if (state.isInterpolating) {
+ if (stream.peek() === '}') {
+ state.interpolationNesting--;
+ if (state.interpolationNesting < 0) {
+ stream.next();
+ state.isInterpolating = false;
+ return 'puncutation';
+ }
+ } else if (stream.peek() === '{') {
+ state.interpolationNesting++;
+ }
+ return jsMode.token(stream, state.jsState) || true;
+ }
+ }
+
+ function caseStatement(stream, state) {
+ if (stream.match(/^case\b/)) {
+ state.javaScriptLine = true;
+ return KEYWORD;
+ }
+ }
+
+ function when(stream, state) {
+ if (stream.match(/^when\b/)) {
+ state.javaScriptLine = true;
+ state.javaScriptLineExcludesColon = true;
+ return KEYWORD;
+ }
+ }
+
+ function defaultStatement(stream) {
+ if (stream.match(/^default\b/)) {
+ return KEYWORD;
+ }
+ }
+
+ function extendsStatement(stream, state) {
+ if (stream.match(/^extends?\b/)) {
+ state.restOfLine = 'string';
+ return KEYWORD;
+ }
+ }
+
+ function append(stream, state) {
+ if (stream.match(/^append\b/)) {
+ state.restOfLine = 'variable';
+ return KEYWORD;
+ }
+ }
+ function prepend(stream, state) {
+ if (stream.match(/^prepend\b/)) {
+ state.restOfLine = 'variable';
+ return KEYWORD;
+ }
+ }
+ function block(stream, state) {
+ if (stream.match(/^block\b *(?:(prepend|append)\b)?/)) {
+ state.restOfLine = 'variable';
+ return KEYWORD;
+ }
+ }
+
+ function include(stream, state) {
+ if (stream.match(/^include\b/)) {
+ state.restOfLine = 'string';
+ return KEYWORD;
+ }
+ }
+
+ function includeFiltered(stream, state) {
+ if (stream.match(/^include:([a-zA-Z0-9\-]+)/, false) && stream.match('include')) {
+ state.isIncludeFiltered = true;
+ return KEYWORD;
+ }
+ }
+
+ function includeFilteredContinued(stream, state) {
+ if (state.isIncludeFiltered) {
+ var tok = filter(stream, state);
+ state.isIncludeFiltered = false;
+ state.restOfLine = 'string';
+ return tok;
+ }
+ }
+
+ function mixin(stream, state) {
+ if (stream.match(/^mixin\b/)) {
+ state.javaScriptLine = true;
+ return KEYWORD;
+ }
+ }
+
+ function call(stream, state) {
+ if (stream.match(/^\+([-\w]+)/)) {
+ if (!stream.match(/^\( *[-\w]+ *=/, false)) {
+ state.javaScriptArguments = true;
+ state.javaScriptArgumentsDepth = 0;
+ }
+ return 'variable';
+ }
+ if (stream.match(/^\+#{/, false)) {
+ stream.next();
+ state.mixinCallAfter = true;
+ return interpolation(stream, state);
+ }
+ }
+ function callArguments(stream, state) {
+ if (state.mixinCallAfter) {
+ state.mixinCallAfter = false;
+ if (!stream.match(/^\( *[-\w]+ *=/, false)) {
+ state.javaScriptArguments = true;
+ state.javaScriptArgumentsDepth = 0;
+ }
+ return true;
+ }
+ }
+
+ function conditional(stream, state) {
+ if (stream.match(/^(if|unless|else if|else)\b/)) {
+ state.javaScriptLine = true;
+ return KEYWORD;
+ }
+ }
+
+ function each(stream, state) {
+ if (stream.match(/^(- *)?(each|for)\b/)) {
+ state.isEach = true;
+ return KEYWORD;
+ }
+ }
+ function eachContinued(stream, state) {
+ if (state.isEach) {
+ if (stream.match(/^ in\b/)) {
+ state.javaScriptLine = true;
+ state.isEach = false;
+ return KEYWORD;
+ } else if (stream.sol() || stream.eol()) {
+ state.isEach = false;
+ } else if (stream.next()) {
+ while (!stream.match(/^ in\b/, false) && stream.next());
+ return 'variable';
+ }
+ }
+ }
+
+ function whileStatement(stream, state) {
+ if (stream.match(/^while\b/)) {
+ state.javaScriptLine = true;
+ return KEYWORD;
+ }
+ }
+
+ function tag(stream, state) {
+ var captures;
+ if (captures = stream.match(/^(\w(?:[-:\w]*\w)?)\/?/)) {
+ state.lastTag = captures[1].toLowerCase();
+ if (state.lastTag === 'script') {
+ state.scriptType = 'application/javascript';
+ }
+ return 'tag';
+ }
+ }
+
+ function filter(stream, state) {
+ if (stream.match(/^:([\w\-]+)/)) {
+ var innerMode;
+ if (config && config.innerModes) {
+ innerMode = config.innerModes(stream.current().substring(1));
+ }
+ if (!innerMode) {
+ innerMode = stream.current().substring(1);
+ }
+ if (typeof innerMode === 'string') {
+ innerMode = CodeMirror.getMode(config, innerMode);
+ }
+ setInnerMode(stream, state, innerMode);
+ return 'atom';
+ }
+ }
+
+ function code(stream, state) {
+ if (stream.match(/^(!?=|-)/)) {
+ state.javaScriptLine = true;
+ return 'punctuation';
+ }
+ }
+
+ function id(stream) {
+ if (stream.match(/^#([\w-]+)/)) {
+ return ID;
+ }
+ }
+
+ function className(stream) {
+ if (stream.match(/^\.([\w-]+)/)) {
+ return CLASS;
+ }
+ }
+
+ function attrs(stream, state) {
+ if (stream.peek() == '(') {
+ stream.next();
+ state.isAttrs = true;
+ state.attrsNest = [];
+ state.inAttributeName = true;
+ state.attrValue = '';
+ state.attributeIsType = false;
+ return 'punctuation';
+ }
+ }
+
+ function attrsContinued(stream, state) {
+ if (state.isAttrs) {
+ if (ATTRS_NEST[stream.peek()]) {
+ state.attrsNest.push(ATTRS_NEST[stream.peek()]);
+ }
+ if (state.attrsNest[state.attrsNest.length - 1] === stream.peek()) {
+ state.attrsNest.pop();
+ } else if (stream.eat(')')) {
+ state.isAttrs = false;
+ return 'punctuation';
+ }
+ if (state.inAttributeName && stream.match(/^[^=,\)!]+/)) {
+ if (stream.peek() === '=' || stream.peek() === '!') {
+ state.inAttributeName = false;
+ state.jsState = jsMode.startState();
+ if (state.lastTag === 'script' && stream.current().trim().toLowerCase() === 'type') {
+ state.attributeIsType = true;
+ } else {
+ state.attributeIsType = false;
+ }
+ }
+ return 'attribute';
+ }
+
+ var tok = jsMode.token(stream, state.jsState);
+ if (state.attributeIsType && tok === 'string') {
+ state.scriptType = stream.current().toString();
+ }
+ if (state.attrsNest.length === 0 && (tok === 'string' || tok === 'variable' || tok === 'keyword')) {
+ try {
+ Function('', 'var x ' + state.attrValue.replace(/,\s*$/, '').replace(/^!/, ''));
+ state.inAttributeName = true;
+ state.attrValue = '';
+ stream.backUp(stream.current().length);
+ return attrsContinued(stream, state);
+ } catch (ex) {
+ //not the end of an attribute
+ }
+ }
+ state.attrValue += stream.current();
+ return tok || true;
+ }
+ }
+
+ function attributesBlock(stream, state) {
+ if (stream.match(/^&attributes\b/)) {
+ state.javaScriptArguments = true;
+ state.javaScriptArgumentsDepth = 0;
+ return 'keyword';
+ }
+ }
+
+ function indent(stream) {
+ if (stream.sol() && stream.eatSpace()) {
+ return 'indent';
+ }
+ }
+
+ function comment(stream, state) {
+ if (stream.match(/^ *\/\/(-)?([^\n]*)/)) {
+ state.indentOf = stream.indentation();
+ state.indentToken = 'comment';
+ return 'comment';
+ }
+ }
+
+ function colon(stream) {
+ if (stream.match(/^: */)) {
+ return 'colon';
+ }
+ }
+
+ function text(stream, state) {
+ if (stream.match(/^(?:\| ?| )([^\n]+)/)) {
+ return 'string';
+ }
+ if (stream.match(/^(<[^\n]*)/, false)) {
+ // html string
+ setInnerMode(stream, state, 'htmlmixed');
+ state.innerModeForLine = true;
+ return innerMode(stream, state, true);
+ }
+ }
+
+ function dot(stream, state) {
+ if (stream.eat('.')) {
+ var innerMode = null;
+ if (state.lastTag === 'script' && state.scriptType.toLowerCase().indexOf('javascript') != -1) {
+ innerMode = state.scriptType.toLowerCase().replace(/"|'/g, '');
+ } else if (state.lastTag === 'style') {
+ innerMode = 'css';
+ }
+ setInnerMode(stream, state, innerMode);
+ return 'dot';
+ }
+ }
+
+ function fail(stream) {
+ stream.next();
+ return null;
+ }
+
+
+ function setInnerMode(stream, state, mode) {
+ mode = CodeMirror.mimeModes[mode] || mode;
+ mode = config.innerModes ? config.innerModes(mode) || mode : mode;
+ mode = CodeMirror.mimeModes[mode] || mode;
+ mode = CodeMirror.getMode(config, mode);
+ state.indentOf = stream.indentation();
+
+ if (mode && mode.name !== 'null') {
+ state.innerMode = mode;
+ } else {
+ state.indentToken = 'string';
+ }
+ }
+ function innerMode(stream, state, force) {
+ if (stream.indentation() > state.indentOf || (state.innerModeForLine && !stream.sol()) || force) {
+ if (state.innerMode) {
+ if (!state.innerState) {
+ state.innerState = state.innerMode.startState ? state.innerMode.startState(stream.indentation()) : {};
+ }
+ return stream.hideFirstChars(state.indentOf + 2, function () {
+ return state.innerMode.token(stream, state.innerState) || true;
+ });
+ } else {
+ stream.skipToEnd();
+ return state.indentToken;
+ }
+ } else if (stream.sol()) {
+ state.indentOf = Infinity;
+ state.indentToken = null;
+ state.innerMode = null;
+ state.innerState = null;
+ }
+ }
+ function restOfLine(stream, state) {
+ if (stream.sol()) {
+ // if restOfLine was set at end of line, ignore it
+ state.restOfLine = '';
+ }
+ if (state.restOfLine) {
+ stream.skipToEnd();
+ var tok = state.restOfLine;
+ state.restOfLine = '';
+ return tok;
+ }
+ }
+
+
+ function startState() {
+ return new State();
+ }
+ function copyState(state) {
+ return state.copy();
+ }
+ /**
+ * Get the next token in the stream
+ *
+ * @param {Stream} stream
+ * @param {State} state
+ */
+ function nextToken(stream, state) {
+ var tok = innerMode(stream, state)
+ || restOfLine(stream, state)
+ || interpolationContinued(stream, state)
+ || includeFilteredContinued(stream, state)
+ || eachContinued(stream, state)
+ || attrsContinued(stream, state)
+ || javaScript(stream, state)
+ || javaScriptArguments(stream, state)
+ || callArguments(stream, state)
+
+ || yieldStatement(stream, state)
+ || doctype(stream, state)
+ || interpolation(stream, state)
+ || caseStatement(stream, state)
+ || when(stream, state)
+ || defaultStatement(stream, state)
+ || extendsStatement(stream, state)
+ || append(stream, state)
+ || prepend(stream, state)
+ || block(stream, state)
+ || include(stream, state)
+ || includeFiltered(stream, state)
+ || mixin(stream, state)
+ || call(stream, state)
+ || conditional(stream, state)
+ || each(stream, state)
+ || whileStatement(stream, state)
+ || tag(stream, state)
+ || filter(stream, state)
+ || code(stream, state)
+ || id(stream, state)
+ || className(stream, state)
+ || attrs(stream, state)
+ || attributesBlock(stream, state)
+ || indent(stream, state)
+ || text(stream, state)
+ || comment(stream, state)
+ || colon(stream, state)
+ || dot(stream, state)
+ || fail(stream, state);
+
+ return tok === true ? null : tok;
+ }
+ return {
+ startState: startState,
+ copyState: copyState,
+ token: nextToken
+ };
+});
+
+CodeMirror.defineMIME('text/x-jade', 'jade');
+
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/javascript/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/javascript/index.html
new file mode 100644
index 0000000..592a133
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/javascript/index.html
@@ -0,0 +1,114 @@
+
+
+CodeMirror: JavaScript mode
+
+
+
+
+
+
+
+
+
+
+
+
+
+JavaScript mode
+
+
+
+
+
+
+
+ JavaScript mode supports several configuration options:
+
+ json which will set the mode to expect JSON
+ data rather than a JavaScript program.jsonld which will set the mode to expect
+ JSON-LD linked data rather
+ than a JavaScript program (demo).typescript which will activate additional
+ syntax highlighting and some other things for TypeScript code
+ (demo).statementIndent which (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.
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/javascript/javascript.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/javascript/javascript.js
new file mode 100644
index 0000000..3f05ac4
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/javascript/javascript.js
@@ -0,0 +1,692 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// TODO actually recognize syntax of TypeScript constructs
+
+(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("javascript", function(config, parserConfig) {
+ var indentUnit = config.indentUnit;
+ var statementIndent = parserConfig.statementIndent;
+ var jsonldMode = parserConfig.jsonld;
+ var jsonMode = parserConfig.json || jsonldMode;
+ var isTS = parserConfig.typescript;
+ var wordRE = parserConfig.wordCharacters || /[\w$\xa1-\uffff]/;
+
+ // Tokenizer
+
+ var keywords = function(){
+ function kw(type) {return {type: type, style: "keyword"};}
+ var A = kw("keyword a"), B = kw("keyword b"), C = kw("keyword c");
+ var operator = kw("operator"), atom = {type: "atom", style: "atom"};
+
+ var jsKeywords = {
+ "if": kw("if"), "while": A, "with": A, "else": B, "do": B, "try": B, "finally": B,
+ "return": C, "break": C, "continue": C, "new": C, "delete": C, "throw": C, "debugger": C,
+ "var": kw("var"), "const": kw("var"), "let": kw("var"),
+ "function": kw("function"), "catch": kw("catch"),
+ "for": kw("for"), "switch": kw("switch"), "case": kw("case"), "default": kw("default"),
+ "in": operator, "typeof": operator, "instanceof": operator,
+ "true": atom, "false": atom, "null": atom, "undefined": atom, "NaN": atom, "Infinity": atom,
+ "this": kw("this"), "module": kw("module"), "class": kw("class"), "super": kw("atom"),
+ "yield": C, "export": kw("export"), "import": kw("import"), "extends": C
+ };
+
+ // Extend the 'normal' keywords with the TypeScript language extensions
+ if (isTS) {
+ var type = {type: "variable", style: "variable-3"};
+ var tsKeywords = {
+ // object-like things
+ "interface": kw("interface"),
+ "extends": kw("extends"),
+ "constructor": kw("constructor"),
+
+ // scope modifiers
+ "public": kw("public"),
+ "private": kw("private"),
+ "protected": kw("protected"),
+ "static": kw("static"),
+
+ // types
+ "string": type, "number": type, "bool": type, "any": type
+ };
+
+ for (var attr in tsKeywords) {
+ jsKeywords[attr] = tsKeywords[attr];
+ }
+ }
+
+ return jsKeywords;
+ }();
+
+ var isOperatorChar = /[+\-*&%=<>!?|~^]/;
+ var isJsonldKeyword = /^@(context|id|value|language|type|container|list|set|reverse|index|base|vocab|graph)"/;
+
+ function readRegexp(stream) {
+ var escaped = false, next, inSet = false;
+ while ((next = stream.next()) != null) {
+ if (!escaped) {
+ if (next == "/" && !inSet) return;
+ if (next == "[") inSet = true;
+ else if (inSet && next == "]") inSet = false;
+ }
+ escaped = !escaped && next == "\\";
+ }
+ }
+
+ // Used as scratch variables to communicate multiple values without
+ // consing up tons of objects.
+ var type, content;
+ function ret(tp, style, cont) {
+ type = tp; content = cont;
+ return style;
+ }
+ function tokenBase(stream, state) {
+ var ch = stream.next();
+ if (ch == '"' || ch == "'") {
+ state.tokenize = tokenString(ch);
+ return state.tokenize(stream, state);
+ } else if (ch == "." && stream.match(/^\d+(?:[eE][+\-]?\d+)?/)) {
+ return ret("number", "number");
+ } else if (ch == "." && stream.match("..")) {
+ return ret("spread", "meta");
+ } else if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
+ return ret(ch);
+ } else if (ch == "=" && stream.eat(">")) {
+ return ret("=>", "operator");
+ } else if (ch == "0" && stream.eat(/x/i)) {
+ stream.eatWhile(/[\da-f]/i);
+ return ret("number", "number");
+ } else if (/\d/.test(ch)) {
+ stream.match(/^\d*(?:\.\d*)?(?:[eE][+\-]?\d+)?/);
+ return ret("number", "number");
+ } else if (ch == "/") {
+ if (stream.eat("*")) {
+ state.tokenize = tokenComment;
+ return tokenComment(stream, state);
+ } else if (stream.eat("/")) {
+ stream.skipToEnd();
+ return ret("comment", "comment");
+ } else if (state.lastType == "operator" || state.lastType == "keyword c" ||
+ state.lastType == "sof" || /^[\[{}\(,;:]$/.test(state.lastType)) {
+ readRegexp(stream);
+ stream.match(/^\b(([gimyu])(?![gimyu]*\2))+\b/);
+ return ret("regexp", "string-2");
+ } else {
+ stream.eatWhile(isOperatorChar);
+ return ret("operator", "operator", stream.current());
+ }
+ } else if (ch == "`") {
+ state.tokenize = tokenQuasi;
+ return tokenQuasi(stream, state);
+ } else if (ch == "#") {
+ stream.skipToEnd();
+ return ret("error", "error");
+ } else if (isOperatorChar.test(ch)) {
+ stream.eatWhile(isOperatorChar);
+ return ret("operator", "operator", stream.current());
+ } else if (wordRE.test(ch)) {
+ stream.eatWhile(wordRE);
+ var word = stream.current(), known = keywords.propertyIsEnumerable(word) && keywords[word];
+ return (known && state.lastType != ".") ? ret(known.type, known.style, word) :
+ ret("variable", "variable", word);
+ }
+ }
+
+ function tokenString(quote) {
+ return function(stream, state) {
+ var escaped = false, next;
+ if (jsonldMode && stream.peek() == "@" && stream.match(isJsonldKeyword)){
+ state.tokenize = tokenBase;
+ return ret("jsonld-keyword", "meta");
+ }
+ while ((next = stream.next()) != null) {
+ if (next == quote && !escaped) break;
+ escaped = !escaped && next == "\\";
+ }
+ if (!escaped) state.tokenize = tokenBase;
+ return ret("string", "string");
+ };
+ }
+
+ function tokenComment(stream, state) {
+ var maybeEnd = false, ch;
+ while (ch = stream.next()) {
+ if (ch == "/" && maybeEnd) {
+ state.tokenize = tokenBase;
+ break;
+ }
+ maybeEnd = (ch == "*");
+ }
+ return ret("comment", "comment");
+ }
+
+ function tokenQuasi(stream, state) {
+ var escaped = false, next;
+ while ((next = stream.next()) != null) {
+ if (!escaped && (next == "`" || next == "$" && stream.eat("{"))) {
+ state.tokenize = tokenBase;
+ break;
+ }
+ escaped = !escaped && next == "\\";
+ }
+ return ret("quasi", "string-2", stream.current());
+ }
+
+ var brackets = "([{}])";
+ // This is a crude lookahead trick to try and notice that we're
+ // parsing the argument patterns for a fat-arrow function before we
+ // actually hit the arrow token. It only works if the arrow is on
+ // the same line as the arguments and there's no strange noise
+ // (comments) in between. Fallback is to only notice when we hit the
+ // arrow, and not declare the arguments as locals for the arrow
+ // body.
+ function findFatArrow(stream, state) {
+ if (state.fatArrowAt) state.fatArrowAt = null;
+ var arrow = stream.string.indexOf("=>", stream.start);
+ if (arrow < 0) return;
+
+ var depth = 0, sawSomething = false;
+ for (var pos = arrow - 1; pos >= 0; --pos) {
+ var ch = stream.string.charAt(pos);
+ var bracket = brackets.indexOf(ch);
+ if (bracket >= 0 && bracket < 3) {
+ if (!depth) { ++pos; break; }
+ if (--depth == 0) break;
+ } else if (bracket >= 3 && bracket < 6) {
+ ++depth;
+ } else if (wordRE.test(ch)) {
+ sawSomething = true;
+ } else if (/["'\/]/.test(ch)) {
+ return;
+ } else if (sawSomething && !depth) {
+ ++pos;
+ break;
+ }
+ }
+ if (sawSomething && !depth) state.fatArrowAt = pos;
+ }
+
+ // Parser
+
+ var atomicTypes = {"atom": true, "number": true, "variable": true, "string": true, "regexp": true, "this": true, "jsonld-keyword": true};
+
+ function JSLexical(indented, column, type, align, prev, info) {
+ this.indented = indented;
+ this.column = column;
+ this.type = type;
+ this.prev = prev;
+ this.info = info;
+ if (align != null) this.align = align;
+ }
+
+ function inScope(state, varname) {
+ for (var v = state.localVars; v; v = v.next)
+ if (v.name == varname) return true;
+ for (var cx = state.context; cx; cx = cx.prev) {
+ for (var v = cx.vars; v; v = v.next)
+ if (v.name == varname) return true;
+ }
+ }
+
+ function parseJS(state, style, type, content, stream) {
+ var cc = state.cc;
+ // Communicate our context to the combinators.
+ // (Less wasteful than consing up a hundred closures on every call.)
+ cx.state = state; cx.stream = stream; cx.marked = null, cx.cc = cc; cx.style = style;
+
+ if (!state.lexical.hasOwnProperty("align"))
+ state.lexical.align = true;
+
+ while(true) {
+ var combinator = cc.length ? cc.pop() : jsonMode ? expression : statement;
+ if (combinator(type, content)) {
+ while(cc.length && cc[cc.length - 1].lex)
+ cc.pop()();
+ if (cx.marked) return cx.marked;
+ if (type == "variable" && inScope(state, content)) return "variable-2";
+ return style;
+ }
+ }
+ }
+
+ // Combinator utils
+
+ var cx = {state: null, column: null, marked: null, cc: null};
+ function pass() {
+ for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]);
+ }
+ function cont() {
+ pass.apply(null, arguments);
+ return true;
+ }
+ function register(varname) {
+ function inList(list) {
+ for (var v = list; v; v = v.next)
+ if (v.name == varname) return true;
+ return false;
+ }
+ var state = cx.state;
+ if (state.context) {
+ cx.marked = "def";
+ if (inList(state.localVars)) return;
+ state.localVars = {name: varname, next: state.localVars};
+ } else {
+ if (inList(state.globalVars)) return;
+ if (parserConfig.globalVars)
+ state.globalVars = {name: varname, next: state.globalVars};
+ }
+ }
+
+ // Combinators
+
+ var defaultVars = {name: "this", next: {name: "arguments"}};
+ function pushcontext() {
+ cx.state.context = {prev: cx.state.context, vars: cx.state.localVars};
+ cx.state.localVars = defaultVars;
+ }
+ function popcontext() {
+ cx.state.localVars = cx.state.context.vars;
+ cx.state.context = cx.state.context.prev;
+ }
+ function pushlex(type, info) {
+ var result = function() {
+ var state = cx.state, indent = state.indented;
+ if (state.lexical.type == "stat") indent = state.lexical.indented;
+ else for (var outer = state.lexical; outer && outer.type == ")" && outer.align; outer = outer.prev)
+ indent = outer.indented;
+ state.lexical = new JSLexical(indent, cx.stream.column(), type, null, state.lexical, info);
+ };
+ result.lex = true;
+ return result;
+ }
+ function poplex() {
+ var state = cx.state;
+ if (state.lexical.prev) {
+ if (state.lexical.type == ")")
+ state.indented = state.lexical.indented;
+ state.lexical = state.lexical.prev;
+ }
+ }
+ poplex.lex = true;
+
+ function expect(wanted) {
+ function exp(type) {
+ if (type == wanted) return cont();
+ else if (wanted == ";") return pass();
+ else return cont(exp);
+ };
+ return exp;
+ }
+
+ function statement(type, value) {
+ if (type == "var") return cont(pushlex("vardef", value.length), vardef, expect(";"), poplex);
+ if (type == "keyword a") return cont(pushlex("form"), expression, statement, poplex);
+ if (type == "keyword b") return cont(pushlex("form"), statement, poplex);
+ if (type == "{") return cont(pushlex("}"), block, poplex);
+ if (type == ";") return cont();
+ if (type == "if") {
+ if (cx.state.lexical.info == "else" && cx.state.cc[cx.state.cc.length - 1] == poplex)
+ cx.state.cc.pop()();
+ return cont(pushlex("form"), expression, statement, poplex, maybeelse);
+ }
+ if (type == "function") return cont(functiondef);
+ if (type == "for") return cont(pushlex("form"), forspec, statement, poplex);
+ if (type == "variable") return cont(pushlex("stat"), maybelabel);
+ if (type == "switch") return cont(pushlex("form"), expression, pushlex("}", "switch"), expect("{"),
+ block, poplex, poplex);
+ if (type == "case") return cont(expression, expect(":"));
+ if (type == "default") return cont(expect(":"));
+ if (type == "catch") return cont(pushlex("form"), pushcontext, expect("("), funarg, expect(")"),
+ statement, poplex, popcontext);
+ if (type == "module") return cont(pushlex("form"), pushcontext, afterModule, popcontext, poplex);
+ if (type == "class") return cont(pushlex("form"), className, poplex);
+ if (type == "export") return cont(pushlex("form"), afterExport, poplex);
+ if (type == "import") return cont(pushlex("form"), afterImport, poplex);
+ return pass(pushlex("stat"), expression, expect(";"), poplex);
+ }
+ function expression(type) {
+ return expressionInner(type, false);
+ }
+ function expressionNoComma(type) {
+ return expressionInner(type, true);
+ }
+ function expressionInner(type, noComma) {
+ if (cx.state.fatArrowAt == cx.stream.start) {
+ var body = noComma ? arrowBodyNoComma : arrowBody;
+ if (type == "(") return cont(pushcontext, pushlex(")"), commasep(pattern, ")"), poplex, expect("=>"), body, popcontext);
+ else if (type == "variable") return pass(pushcontext, pattern, expect("=>"), body, popcontext);
+ }
+
+ var maybeop = noComma ? maybeoperatorNoComma : maybeoperatorComma;
+ if (atomicTypes.hasOwnProperty(type)) return cont(maybeop);
+ if (type == "function") return cont(functiondef, maybeop);
+ if (type == "keyword c") return cont(noComma ? maybeexpressionNoComma : maybeexpression);
+ if (type == "(") return cont(pushlex(")"), maybeexpression, comprehension, expect(")"), poplex, maybeop);
+ if (type == "operator" || type == "spread") return cont(noComma ? expressionNoComma : expression);
+ if (type == "[") return cont(pushlex("]"), arrayLiteral, poplex, maybeop);
+ if (type == "{") return contCommasep(objprop, "}", null, maybeop);
+ if (type == "quasi") { return pass(quasi, maybeop); }
+ return cont();
+ }
+ function maybeexpression(type) {
+ if (type.match(/[;\}\)\],]/)) return pass();
+ return pass(expression);
+ }
+ function maybeexpressionNoComma(type) {
+ if (type.match(/[;\}\)\],]/)) return pass();
+ return pass(expressionNoComma);
+ }
+
+ function maybeoperatorComma(type, value) {
+ if (type == ",") return cont(expression);
+ return maybeoperatorNoComma(type, value, false);
+ }
+ function maybeoperatorNoComma(type, value, noComma) {
+ var me = noComma == false ? maybeoperatorComma : maybeoperatorNoComma;
+ var expr = noComma == false ? expression : expressionNoComma;
+ if (type == "=>") return cont(pushcontext, noComma ? arrowBodyNoComma : arrowBody, popcontext);
+ if (type == "operator") {
+ if (/\+\+|--/.test(value)) return cont(me);
+ if (value == "?") return cont(expression, expect(":"), expr);
+ return cont(expr);
+ }
+ if (type == "quasi") { return pass(quasi, me); }
+ if (type == ";") return;
+ if (type == "(") return contCommasep(expressionNoComma, ")", "call", me);
+ if (type == ".") return cont(property, me);
+ if (type == "[") return cont(pushlex("]"), maybeexpression, expect("]"), poplex, me);
+ }
+ function quasi(type, value) {
+ if (type != "quasi") return pass();
+ if (value.slice(value.length - 2) != "${") return cont(quasi);
+ return cont(expression, continueQuasi);
+ }
+ function continueQuasi(type) {
+ if (type == "}") {
+ cx.marked = "string-2";
+ cx.state.tokenize = tokenQuasi;
+ return cont(quasi);
+ }
+ }
+ function arrowBody(type) {
+ findFatArrow(cx.stream, cx.state);
+ return pass(type == "{" ? statement : expression);
+ }
+ function arrowBodyNoComma(type) {
+ findFatArrow(cx.stream, cx.state);
+ return pass(type == "{" ? statement : expressionNoComma);
+ }
+ function maybelabel(type) {
+ if (type == ":") return cont(poplex, statement);
+ return pass(maybeoperatorComma, expect(";"), poplex);
+ }
+ function property(type) {
+ if (type == "variable") {cx.marked = "property"; return cont();}
+ }
+ function objprop(type, value) {
+ if (type == "variable" || cx.style == "keyword") {
+ cx.marked = "property";
+ if (value == "get" || value == "set") return cont(getterSetter);
+ return cont(afterprop);
+ } else if (type == "number" || type == "string") {
+ cx.marked = jsonldMode ? "property" : (cx.style + " property");
+ return cont(afterprop);
+ } else if (type == "jsonld-keyword") {
+ return cont(afterprop);
+ } else if (type == "[") {
+ return cont(expression, expect("]"), afterprop);
+ }
+ }
+ function getterSetter(type) {
+ if (type != "variable") return pass(afterprop);
+ cx.marked = "property";
+ return cont(functiondef);
+ }
+ function afterprop(type) {
+ if (type == ":") return cont(expressionNoComma);
+ if (type == "(") return pass(functiondef);
+ }
+ function commasep(what, end) {
+ function proceed(type) {
+ if (type == ",") {
+ var lex = cx.state.lexical;
+ if (lex.info == "call") lex.pos = (lex.pos || 0) + 1;
+ return cont(what, proceed);
+ }
+ if (type == end) return cont();
+ return cont(expect(end));
+ }
+ return function(type) {
+ if (type == end) return cont();
+ return pass(what, proceed);
+ };
+ }
+ function contCommasep(what, end, info) {
+ for (var i = 3; i < arguments.length; i++)
+ cx.cc.push(arguments[i]);
+ return cont(pushlex(end, info), commasep(what, end), poplex);
+ }
+ function block(type) {
+ if (type == "}") return cont();
+ return pass(statement, block);
+ }
+ function maybetype(type) {
+ if (isTS && type == ":") return cont(typedef);
+ }
+ function typedef(type) {
+ if (type == "variable"){cx.marked = "variable-3"; return cont();}
+ }
+ function vardef() {
+ return pass(pattern, maybetype, maybeAssign, vardefCont);
+ }
+ function pattern(type, value) {
+ if (type == "variable") { register(value); return cont(); }
+ if (type == "[") return contCommasep(pattern, "]");
+ if (type == "{") return contCommasep(proppattern, "}");
+ }
+ function proppattern(type, value) {
+ if (type == "variable" && !cx.stream.match(/^\s*:/, false)) {
+ register(value);
+ return cont(maybeAssign);
+ }
+ if (type == "variable") cx.marked = "property";
+ return cont(expect(":"), pattern, maybeAssign);
+ }
+ function maybeAssign(_type, value) {
+ if (value == "=") return cont(expressionNoComma);
+ }
+ function vardefCont(type) {
+ if (type == ",") return cont(vardef);
+ }
+ function maybeelse(type, value) {
+ if (type == "keyword b" && value == "else") return cont(pushlex("form", "else"), statement, poplex);
+ }
+ function forspec(type) {
+ if (type == "(") return cont(pushlex(")"), forspec1, expect(")"), poplex);
+ }
+ function forspec1(type) {
+ if (type == "var") return cont(vardef, expect(";"), forspec2);
+ if (type == ";") return cont(forspec2);
+ if (type == "variable") return cont(formaybeinof);
+ return pass(expression, expect(";"), forspec2);
+ }
+ function formaybeinof(_type, value) {
+ if (value == "in" || value == "of") { cx.marked = "keyword"; return cont(expression); }
+ return cont(maybeoperatorComma, forspec2);
+ }
+ function forspec2(type, value) {
+ if (type == ";") return cont(forspec3);
+ if (value == "in" || value == "of") { cx.marked = "keyword"; return cont(expression); }
+ return pass(expression, expect(";"), forspec3);
+ }
+ function forspec3(type) {
+ if (type != ")") cont(expression);
+ }
+ function functiondef(type, value) {
+ if (value == "*") {cx.marked = "keyword"; return cont(functiondef);}
+ if (type == "variable") {register(value); return cont(functiondef);}
+ if (type == "(") return cont(pushcontext, pushlex(")"), commasep(funarg, ")"), poplex, statement, popcontext);
+ }
+ function funarg(type) {
+ if (type == "spread") return cont(funarg);
+ return pass(pattern, maybetype);
+ }
+ function className(type, value) {
+ if (type == "variable") {register(value); return cont(classNameAfter);}
+ }
+ function classNameAfter(type, value) {
+ if (value == "extends") return cont(expression, classNameAfter);
+ if (type == "{") return cont(pushlex("}"), classBody, poplex);
+ }
+ function classBody(type, value) {
+ if (type == "variable" || cx.style == "keyword") {
+ cx.marked = "property";
+ if (value == "get" || value == "set") return cont(classGetterSetter, functiondef, classBody);
+ return cont(functiondef, classBody);
+ }
+ if (value == "*") {
+ cx.marked = "keyword";
+ return cont(classBody);
+ }
+ if (type == ";") return cont(classBody);
+ if (type == "}") return cont();
+ }
+ function classGetterSetter(type) {
+ if (type != "variable") return pass();
+ cx.marked = "property";
+ return cont();
+ }
+ function afterModule(type, value) {
+ if (type == "string") return cont(statement);
+ if (type == "variable") { register(value); return cont(maybeFrom); }
+ }
+ function afterExport(_type, value) {
+ if (value == "*") { cx.marked = "keyword"; return cont(maybeFrom, expect(";")); }
+ if (value == "default") { cx.marked = "keyword"; return cont(expression, expect(";")); }
+ return pass(statement);
+ }
+ function afterImport(type) {
+ if (type == "string") return cont();
+ return pass(importSpec, maybeFrom);
+ }
+ function importSpec(type, value) {
+ if (type == "{") return contCommasep(importSpec, "}");
+ if (type == "variable") register(value);
+ return cont();
+ }
+ function maybeFrom(_type, value) {
+ if (value == "from") { cx.marked = "keyword"; return cont(expression); }
+ }
+ function arrayLiteral(type) {
+ if (type == "]") return cont();
+ return pass(expressionNoComma, maybeArrayComprehension);
+ }
+ function maybeArrayComprehension(type) {
+ if (type == "for") return pass(comprehension, expect("]"));
+ if (type == ",") return cont(commasep(maybeexpressionNoComma, "]"));
+ return pass(commasep(expressionNoComma, "]"));
+ }
+ function comprehension(type) {
+ if (type == "for") return cont(forspec, comprehension);
+ if (type == "if") return cont(expression, comprehension);
+ }
+
+ function isContinuedStatement(state, textAfter) {
+ return state.lastType == "operator" || state.lastType == "," ||
+ isOperatorChar.test(textAfter.charAt(0)) ||
+ /[,.]/.test(textAfter.charAt(0));
+ }
+
+ // Interface
+
+ return {
+ startState: function(basecolumn) {
+ var state = {
+ tokenize: tokenBase,
+ lastType: "sof",
+ cc: [],
+ lexical: new JSLexical((basecolumn || 0) - indentUnit, 0, "block", false),
+ localVars: parserConfig.localVars,
+ context: parserConfig.localVars && {vars: parserConfig.localVars},
+ indented: 0
+ };
+ if (parserConfig.globalVars && typeof parserConfig.globalVars == "object")
+ state.globalVars = parserConfig.globalVars;
+ return state;
+ },
+
+ token: function(stream, state) {
+ if (stream.sol()) {
+ if (!state.lexical.hasOwnProperty("align"))
+ state.lexical.align = false;
+ state.indented = stream.indentation();
+ findFatArrow(stream, state);
+ }
+ if (state.tokenize != tokenComment && stream.eatSpace()) return null;
+ var style = state.tokenize(stream, state);
+ if (type == "comment") return style;
+ state.lastType = type == "operator" && (content == "++" || content == "--") ? "incdec" : type;
+ return parseJS(state, style, type, content, stream);
+ },
+
+ indent: function(state, textAfter) {
+ if (state.tokenize == tokenComment) return CodeMirror.Pass;
+ if (state.tokenize != tokenBase) return 0;
+ var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical;
+ // Kludge to prevent 'maybelse' from blocking lexical scope pops
+ if (!/^\s*else\b/.test(textAfter)) for (var i = state.cc.length - 1; i >= 0; --i) {
+ var c = state.cc[i];
+ if (c == poplex) lexical = lexical.prev;
+ else if (c != maybeelse) break;
+ }
+ if (lexical.type == "stat" && firstChar == "}") lexical = lexical.prev;
+ if (statementIndent && lexical.type == ")" && lexical.prev.type == "stat")
+ lexical = lexical.prev;
+ var type = lexical.type, closing = firstChar == type;
+
+ if (type == "vardef") return lexical.indented + (state.lastType == "operator" || state.lastType == "," ? lexical.info + 1 : 0);
+ else if (type == "form" && firstChar == "{") return lexical.indented;
+ else if (type == "form") return lexical.indented + indentUnit;
+ else if (type == "stat")
+ return lexical.indented + (isContinuedStatement(state, textAfter) ? statementIndent || indentUnit : 0);
+ else if (lexical.info == "switch" && !closing && parserConfig.doubleIndentSwitch != false)
+ return lexical.indented + (/^(?:case|default)\b/.test(textAfter) ? indentUnit : 2 * indentUnit);
+ else if (lexical.align) return lexical.column + (closing ? 0 : 1);
+ else return lexical.indented + (closing ? 0 : indentUnit);
+ },
+
+ electricInput: /^\s*(?:case .*?:|default:|\{|\})$/,
+ blockCommentStart: jsonMode ? null : "/*",
+ blockCommentEnd: jsonMode ? null : "*/",
+ lineComment: jsonMode ? null : "//",
+ fold: "brace",
+
+ helperType: jsonMode ? "json" : "javascript",
+ jsonldMode: jsonldMode,
+ jsonMode: jsonMode
+ };
+});
+
+CodeMirror.registerHelper("wordChars", "javascript", /[\w$]/);
+
+CodeMirror.defineMIME("text/javascript", "javascript");
+CodeMirror.defineMIME("text/ecmascript", "javascript");
+CodeMirror.defineMIME("application/javascript", "javascript");
+CodeMirror.defineMIME("application/x-javascript", "javascript");
+CodeMirror.defineMIME("application/ecmascript", "javascript");
+CodeMirror.defineMIME("application/json", {name: "javascript", json: true});
+CodeMirror.defineMIME("application/x-json", {name: "javascript", json: true});
+CodeMirror.defineMIME("application/ld+json", {name: "javascript", jsonld: true});
+CodeMirror.defineMIME("text/typescript", { name: "javascript", typescript: true });
+CodeMirror.defineMIME("application/typescript", { name: "javascript", typescript: true });
+
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/javascript/json-ld.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/javascript/json-ld.html
new file mode 100644
index 0000000..3a37f0b
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/javascript/json-ld.html
@@ -0,0 +1,72 @@
+
+
+CodeMirror: JSON-LD mode
+
+
+
+
+
+
+
+
+
+
+
+
+
+JSON-LD mode
+
+
+
+
+
+
+ This is a specialization of the JavaScript mode.
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/javascript/test.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/javascript/test.js
new file mode 100644
index 0000000..91b0e89
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/javascript/test.js
@@ -0,0 +1,200 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function() {
+ var mode = CodeMirror.getMode({indentUnit: 2}, "javascript");
+ function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1)); }
+
+ MT("locals",
+ "[keyword function] [variable foo]([def a], [def b]) { [keyword var] [def c] [operator =] [number 10]; [keyword return] [variable-2 a] [operator +] [variable-2 c] [operator +] [variable d]; }");
+
+ MT("comma-and-binop",
+ "[keyword function](){ [keyword var] [def x] [operator =] [number 1] [operator +] [number 2], [def y]; }");
+
+ MT("destructuring",
+ "([keyword function]([def a], [[[def b], [def c] ]]) {",
+ " [keyword let] {[def d], [property foo]: [def c][operator =][number 10], [def x]} [operator =] [variable foo]([variable-2 a]);",
+ " [[[variable-2 c], [variable y] ]] [operator =] [variable-2 c];",
+ "})();");
+
+ MT("class_body",
+ "[keyword class] [variable Foo] {",
+ " [property constructor]() {}",
+ " [property sayName]() {",
+ " [keyword return] [string-2 `foo${][variable foo][string-2 }oo`];",
+ " }",
+ "}");
+
+ MT("class",
+ "[keyword class] [variable Point] [keyword extends] [variable SuperThing] {",
+ " [property get] [property prop]() { [keyword return] [number 24]; }",
+ " [property constructor]([def x], [def y]) {",
+ " [keyword super]([string 'something']);",
+ " [keyword this].[property x] [operator =] [variable-2 x];",
+ " }",
+ "}");
+
+ MT("module",
+ "[keyword module] [string 'foo'] {",
+ " [keyword export] [keyword let] [def x] [operator =] [number 42];",
+ " [keyword export] [keyword *] [keyword from] [string 'somewhere'];",
+ "}");
+
+ MT("import",
+ "[keyword function] [variable foo]() {",
+ " [keyword import] [def $] [keyword from] [string 'jquery'];",
+ " [keyword module] [def crypto] [keyword from] [string 'crypto'];",
+ " [keyword import] { [def encrypt], [def decrypt] } [keyword from] [string 'crypto'];",
+ "}");
+
+ MT("const",
+ "[keyword function] [variable f]() {",
+ " [keyword const] [[ [def a], [def b] ]] [operator =] [[ [number 1], [number 2] ]];",
+ "}");
+
+ MT("for/of",
+ "[keyword for]([keyword let] [variable of] [keyword of] [variable something]) {}");
+
+ MT("generator",
+ "[keyword function*] [variable repeat]([def n]) {",
+ " [keyword for]([keyword var] [def i] [operator =] [number 0]; [variable-2 i] [operator <] [variable-2 n]; [operator ++][variable-2 i])",
+ " [keyword yield] [variable-2 i];",
+ "}");
+
+ MT("quotedStringAddition",
+ "[keyword let] [variable f] [operator =] [variable a] [operator +] [string 'fatarrow'] [operator +] [variable c];");
+
+ MT("quotedFatArrow",
+ "[keyword let] [variable f] [operator =] [variable a] [operator +] [string '=>'] [operator +] [variable c];");
+
+ MT("fatArrow",
+ "[variable array].[property filter]([def a] [operator =>] [variable-2 a] [operator +] [number 1]);",
+ "[variable a];", // No longer in scope
+ "[keyword let] [variable f] [operator =] ([[ [def a], [def b] ]], [def c]) [operator =>] [variable-2 a] [operator +] [variable-2 c];",
+ "[variable c];");
+
+ MT("spread",
+ "[keyword function] [variable f]([def a], [meta ...][def b]) {",
+ " [variable something]([variable-2 a], [meta ...][variable-2 b]);",
+ "}");
+
+ MT("comprehension",
+ "[keyword function] [variable f]() {",
+ " [[([variable x] [operator +] [number 1]) [keyword for] ([keyword var] [def x] [keyword in] [variable y]) [keyword if] [variable pred]([variable-2 x]) ]];",
+ " ([variable u] [keyword for] ([keyword var] [def u] [keyword of] [variable generateValues]()) [keyword if] ([variable-2 u].[property color] [operator ===] [string 'blue']));",
+ "}");
+
+ MT("quasi",
+ "[variable re][string-2 `fofdlakj${][variable x] [operator +] ([variable re][string-2 `foo`]) [operator +] [number 1][string-2 }fdsa`] [operator +] [number 2]");
+
+ MT("quasi_no_function",
+ "[variable x] [operator =] [string-2 `fofdlakj${][variable x] [operator +] [string-2 `foo`] [operator +] [number 1][string-2 }fdsa`] [operator +] [number 2]");
+
+ MT("indent_statement",
+ "[keyword var] [variable x] [operator =] [number 10]",
+ "[variable x] [operator +=] [variable y] [operator +]",
+ " [atom Infinity]",
+ "[keyword debugger];");
+
+ MT("indent_if",
+ "[keyword if] ([number 1])",
+ " [keyword break];",
+ "[keyword else] [keyword if] ([number 2])",
+ " [keyword continue];",
+ "[keyword else]",
+ " [number 10];",
+ "[keyword if] ([number 1]) {",
+ " [keyword break];",
+ "} [keyword else] [keyword if] ([number 2]) {",
+ " [keyword continue];",
+ "} [keyword else] {",
+ " [number 10];",
+ "}");
+
+ MT("indent_for",
+ "[keyword for] ([keyword var] [variable i] [operator =] [number 0];",
+ " [variable i] [operator <] [number 100];",
+ " [variable i][operator ++])",
+ " [variable doSomething]([variable i]);",
+ "[keyword debugger];");
+
+ MT("indent_c_style",
+ "[keyword function] [variable foo]()",
+ "{",
+ " [keyword debugger];",
+ "}");
+
+ MT("indent_else",
+ "[keyword for] (;;)",
+ " [keyword if] ([variable foo])",
+ " [keyword if] ([variable bar])",
+ " [number 1];",
+ " [keyword else]",
+ " [number 2];",
+ " [keyword else]",
+ " [number 3];");
+
+ MT("indent_funarg",
+ "[variable foo]([number 10000],",
+ " [keyword function]([def a]) {",
+ " [keyword debugger];",
+ "};");
+
+ MT("indent_below_if",
+ "[keyword for] (;;)",
+ " [keyword if] ([variable foo])",
+ " [number 1];",
+ "[number 2];");
+
+ MT("multilinestring",
+ "[keyword var] [variable x] [operator =] [string 'foo\\]",
+ "[string bar'];");
+
+ MT("scary_regexp",
+ "[string-2 /foo[[/]]bar/];");
+
+ MT("indent_strange_array",
+ "[keyword var] [variable x] [operator =] [[",
+ " [number 1],,",
+ " [number 2],",
+ "]];",
+ "[number 10];");
+
+ var jsonld_mode = CodeMirror.getMode(
+ {indentUnit: 2},
+ {name: "javascript", jsonld: true}
+ );
+ function LD(name) {
+ test.mode(name, jsonld_mode, Array.prototype.slice.call(arguments, 1));
+ }
+
+ LD("json_ld_keywords",
+ '{',
+ ' [meta "@context"]: {',
+ ' [meta "@base"]: [string "http://example.com"],',
+ ' [meta "@vocab"]: [string "http://xmlns.com/foaf/0.1/"],',
+ ' [property "likesFlavor"]: {',
+ ' [meta "@container"]: [meta "@list"]',
+ ' [meta "@reverse"]: [string "@beFavoriteOf"]',
+ ' },',
+ ' [property "nick"]: { [meta "@container"]: [meta "@set"] },',
+ ' [property "nick"]: { [meta "@container"]: [meta "@index"] }',
+ ' },',
+ ' [meta "@graph"]: [[ {',
+ ' [meta "@id"]: [string "http://dbpedia.org/resource/John_Lennon"],',
+ ' [property "name"]: [string "John Lennon"],',
+ ' [property "modified"]: {',
+ ' [meta "@value"]: [string "2010-05-29T14:17:39+02:00"],',
+ ' [meta "@type"]: [string "http://www.w3.org/2001/XMLSchema#dateTime"]',
+ ' }',
+ ' } ]]',
+ '}');
+
+ LD("json_ld_fake",
+ '{',
+ ' [property "@fake"]: [string "@fake"],',
+ ' [property "@contextual"]: [string "@identifier"],',
+ ' [property "user@domain.com"]: [string "@graphical"],',
+ ' [property "@ID"]: [string "@@ID"]',
+ '}');
+})();
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/javascript/typescript.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/javascript/typescript.html
new file mode 100644
index 0000000..2cfc538
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/javascript/typescript.html
@@ -0,0 +1,61 @@
+
+
+CodeMirror: TypeScript mode
+
+
+
+
+
+
+
+
+
+
+TypeScript mode
+
+
+
+
+
+
+ This is a specialization of the JavaScript mode.
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/jinja2/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/jinja2/index.html
new file mode 100644
index 0000000..5a70e91
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/jinja2/index.html
@@ -0,0 +1,54 @@
+
+
+CodeMirror: Jinja2 mode
+
+
+
+
+
+
+
+
+
+
+Jinja2 mode
+
+
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/jinja2/jinja2.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/jinja2/jinja2.js
new file mode 100644
index 0000000..ed19558
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/jinja2/jinja2.js
@@ -0,0 +1,142 @@
+// 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("jinja2", function() {
+ var keywords = ["and", "as", "block", "endblock", "by", "cycle", "debug", "else", "elif",
+ "extends", "filter", "endfilter", "firstof", "for",
+ "endfor", "if", "endif", "ifchanged", "endifchanged",
+ "ifequal", "endifequal", "ifnotequal",
+ "endifnotequal", "in", "include", "load", "not", "now", "or",
+ "parsed", "regroup", "reversed", "spaceless",
+ "endspaceless", "ssi", "templatetag", "openblock",
+ "closeblock", "openvariable", "closevariable",
+ "openbrace", "closebrace", "opencomment",
+ "closecomment", "widthratio", "url", "with", "endwith",
+ "get_current_language", "trans", "endtrans", "noop", "blocktrans",
+ "endblocktrans", "get_available_languages",
+ "get_current_language_bidi", "plural"],
+ operator = /^[+\-*&%=<>!?|~^]/,
+ sign = /^[:\[\(\{]/,
+ atom = ["true", "false"],
+ number = /^(\d[+\-\*\/])?\d+(\.\d+)?/;
+
+ keywords = new RegExp("((" + keywords.join(")|(") + "))\\b");
+ atom = new RegExp("((" + atom.join(")|(") + "))\\b");
+
+ function tokenBase (stream, state) {
+ var ch = stream.peek();
+
+ //Comment
+ if (state.incomment) {
+ if(!stream.skipTo("#}")) {
+ stream.skipToEnd();
+ } else {
+ stream.eatWhile(/\#|}/);
+ state.incomment = false;
+ }
+ return "comment";
+ //Tag
+ } else if (state.intag) {
+ //After operator
+ if(state.operator) {
+ state.operator = false;
+ if(stream.match(atom)) {
+ return "atom";
+ }
+ if(stream.match(number)) {
+ return "number";
+ }
+ }
+ //After sign
+ if(state.sign) {
+ state.sign = false;
+ if(stream.match(atom)) {
+ return "atom";
+ }
+ if(stream.match(number)) {
+ return "number";
+ }
+ }
+
+ if(state.instring) {
+ if(ch == state.instring) {
+ state.instring = false;
+ }
+ stream.next();
+ return "string";
+ } else if(ch == "'" || ch == '"') {
+ state.instring = ch;
+ stream.next();
+ return "string";
+ } else if(stream.match(state.intag + "}") || stream.eat("-") && stream.match(state.intag + "}")) {
+ state.intag = false;
+ return "tag";
+ } else if(stream.match(operator)) {
+ state.operator = true;
+ return "operator";
+ } else if(stream.match(sign)) {
+ state.sign = true;
+ } else {
+ if(stream.eat(" ") || stream.sol()) {
+ if(stream.match(keywords)) {
+ return "keyword";
+ }
+ if(stream.match(atom)) {
+ return "atom";
+ }
+ if(stream.match(number)) {
+ return "number";
+ }
+ if(stream.sol()) {
+ stream.next();
+ }
+ } else {
+ stream.next();
+ }
+
+ }
+ return "variable";
+ } else if (stream.eat("{")) {
+ if (ch = stream.eat("#")) {
+ state.incomment = true;
+ if(!stream.skipTo("#}")) {
+ stream.skipToEnd();
+ } else {
+ stream.eatWhile(/\#|}/);
+ state.incomment = false;
+ }
+ return "comment";
+ //Open tag
+ } else if (ch = stream.eat(/\{|%/)) {
+ //Cache close tag
+ state.intag = ch;
+ if(ch == "{") {
+ state.intag = "}";
+ }
+ stream.eat("-");
+ return "tag";
+ }
+ }
+ stream.next();
+ };
+
+ return {
+ startState: function () {
+ return {tokenize: tokenBase};
+ },
+ token: function (stream, state) {
+ return state.tokenize(stream, state);
+ }
+ };
+ });
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/julia/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/julia/index.html
new file mode 100644
index 0000000..e1492c2
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/julia/index.html
@@ -0,0 +1,195 @@
+
+
+CodeMirror: Julia mode
+
+
+
+
+
+
+
+
+
+
+Julia mode
+
+
+
+
+ MIME types defined: text/x-julia.
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/julia/julia.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/julia/julia.js
new file mode 100644
index 0000000..e854988
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/julia/julia.js
@@ -0,0 +1,301 @@
+// 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("julia", function(_conf, parserConf) {
+ var ERRORCLASS = 'error';
+
+ function wordRegexp(words) {
+ return new RegExp("^((" + words.join(")|(") + "))\\b");
+ }
+
+ var operators = parserConf.operators || /^\.?[|&^\\%*+\-<>!=\/]=?|\?|~|:|\$|\.[<>]|<<=?|>>>?=?|\.[<>=]=|->?|\/\/|\bin\b/;
+ var delimiters = parserConf.delimiters || /^[;,()[\]{}]/;
+ var identifiers = parserConf.identifiers|| /^[_A-Za-z\u00A1-\uFFFF][_A-Za-z0-9\u00A1-\uFFFF]*!*/;
+ var blockOpeners = ["begin", "function", "type", "immutable", "let", "macro", "for", "while", "quote", "if", "else", "elseif", "try", "finally", "catch", "do"];
+ var blockClosers = ["end", "else", "elseif", "catch", "finally"];
+ var keywordList = ['if', 'else', 'elseif', 'while', 'for', 'begin', 'let', 'end', 'do', 'try', 'catch', 'finally', 'return', 'break', 'continue', 'global', 'local', 'const', 'export', 'import', 'importall', 'using', 'function', 'macro', 'module', 'baremodule', 'type', 'immutable', 'quote', 'typealias', 'abstract', 'bitstype', 'ccall'];
+ var builtinList = ['true', 'false', 'enumerate', 'open', 'close', 'nothing', 'NaN', 'Inf', 'print', 'println', 'Int', 'Int8', 'Uint8', 'Int16', 'Uint16', 'Int32', 'Uint32', 'Int64', 'Uint64', 'Int128', 'Uint128', 'Bool', 'Char', 'Float16', 'Float32', 'Float64', 'Array', 'Vector', 'Matrix', 'String', 'UTF8String', 'ASCIIString', 'error', 'warn', 'info', '@printf'];
+
+ //var stringPrefixes = new RegExp("^[br]?('|\")")
+ var stringPrefixes = /^(`|'|"{3}|([br]?"))/;
+ var keywords = wordRegexp(keywordList);
+ var builtins = wordRegexp(builtinList);
+ var openers = wordRegexp(blockOpeners);
+ var closers = wordRegexp(blockClosers);
+ var macro = /^@[_A-Za-z][_A-Za-z0-9]*/;
+ var symbol = /^:[_A-Za-z][_A-Za-z0-9]*/;
+ var indentInfo = null;
+
+ function in_array(state) {
+ var ch = cur_scope(state);
+ if(ch=="[" || ch=="{") {
+ return true;
+ }
+ else {
+ return false;
+ }
+ }
+
+ function cur_scope(state) {
+ if(state.scopes.length==0) {
+ return null;
+ }
+ return state.scopes[state.scopes.length - 1];
+ }
+
+ // tokenizers
+ function tokenBase(stream, state) {
+ // Handle scope changes
+ var leaving_expr = state.leaving_expr;
+ if(stream.sol()) {
+ leaving_expr = false;
+ }
+ state.leaving_expr = false;
+ if(leaving_expr) {
+ if(stream.match(/^'+/)) {
+ return 'operator';
+ }
+
+ }
+
+ if(stream.match(/^\.{2,3}/)) {
+ return 'operator';
+ }
+
+ if (stream.eatSpace()) {
+ return null;
+ }
+
+ var ch = stream.peek();
+ // Handle Comments
+ if (ch === '#') {
+ stream.skipToEnd();
+ return 'comment';
+ }
+ if(ch==='[') {
+ state.scopes.push("[");
+ }
+
+ if(ch==='{') {
+ state.scopes.push("{");
+ }
+
+ var scope=cur_scope(state);
+
+ if(scope==='[' && ch===']') {
+ state.scopes.pop();
+ state.leaving_expr=true;
+ }
+
+ if(scope==='{' && ch==='}') {
+ state.scopes.pop();
+ state.leaving_expr=true;
+ }
+
+ if(ch===')') {
+ state.leaving_expr = true;
+ }
+
+ var match;
+ if(!in_array(state) && (match=stream.match(openers, false))) {
+ state.scopes.push(match);
+ }
+
+ if(!in_array(state) && stream.match(closers, false)) {
+ state.scopes.pop();
+ }
+
+ if(in_array(state)) {
+ if(stream.match(/^end/)) {
+ return 'number';
+ }
+
+ }
+
+ if(stream.match(/^=>/)) {
+ return 'operator';
+ }
+
+
+ // Handle Number Literals
+ if (stream.match(/^[0-9\.]/, false)) {
+ var imMatcher = RegExp(/^im\b/);
+ var floatLiteral = false;
+ // Floats
+ if (stream.match(/^\d*\.(?!\.)\d+([ef][\+\-]?\d+)?/i)) { floatLiteral = true; }
+ if (stream.match(/^\d+\.(?!\.)\d*/)) { floatLiteral = true; }
+ if (stream.match(/^\.\d+/)) { floatLiteral = true; }
+ if (floatLiteral) {
+ // Float literals may be "imaginary"
+ stream.match(imMatcher);
+ state.leaving_expr = true;
+ return 'number';
+ }
+ // Integers
+ var intLiteral = false;
+ // Hex
+ if (stream.match(/^0x[0-9a-f]+/i)) { intLiteral = true; }
+ // Binary
+ if (stream.match(/^0b[01]+/i)) { intLiteral = true; }
+ // Octal
+ if (stream.match(/^0o[0-7]+/i)) { intLiteral = true; }
+ // Decimal
+ if (stream.match(/^[1-9]\d*(e[\+\-]?\d+)?/)) {
+ intLiteral = true;
+ }
+ // Zero by itself with no other piece of number.
+ if (stream.match(/^0(?![\dx])/i)) { intLiteral = true; }
+ if (intLiteral) {
+ // Integer literals may be "long"
+ stream.match(imMatcher);
+ state.leaving_expr = true;
+ return 'number';
+ }
+ }
+
+ if(stream.match(/^(::)|(<:)/)) {
+ return 'operator';
+ }
+
+ // Handle symbols
+ if(!leaving_expr && stream.match(symbol)) {
+ return 'string';
+ }
+
+ // Handle operators and Delimiters
+ if (stream.match(operators)) {
+ return 'operator';
+ }
+
+
+ // Handle Strings
+ if (stream.match(stringPrefixes)) {
+ state.tokenize = tokenStringFactory(stream.current());
+ return state.tokenize(stream, state);
+ }
+
+ if (stream.match(macro)) {
+ return 'meta';
+ }
+
+
+ if (stream.match(delimiters)) {
+ return null;
+ }
+
+ if (stream.match(keywords)) {
+ return 'keyword';
+ }
+
+ if (stream.match(builtins)) {
+ return 'builtin';
+ }
+
+
+ if (stream.match(identifiers)) {
+ state.leaving_expr=true;
+ return 'variable';
+ }
+ // Handle non-detected items
+ stream.next();
+ return ERRORCLASS;
+ }
+
+ function tokenStringFactory(delimiter) {
+ while ('rub'.indexOf(delimiter.charAt(0).toLowerCase()) >= 0) {
+ delimiter = delimiter.substr(1);
+ }
+ var singleline = delimiter.length == 1;
+ var OUTCLASS = 'string';
+
+ function tokenString(stream, state) {
+ while (!stream.eol()) {
+ stream.eatWhile(/[^'"\\]/);
+ if (stream.eat('\\')) {
+ stream.next();
+ if (singleline && stream.eol()) {
+ return OUTCLASS;
+ }
+ } else if (stream.match(delimiter)) {
+ state.tokenize = tokenBase;
+ return OUTCLASS;
+ } else {
+ stream.eat(/['"]/);
+ }
+ }
+ if (singleline) {
+ if (parserConf.singleLineStringErrors) {
+ return ERRORCLASS;
+ } else {
+ state.tokenize = tokenBase;
+ }
+ }
+ return OUTCLASS;
+ }
+ tokenString.isString = true;
+ return tokenString;
+ }
+
+ function tokenLexer(stream, state) {
+ indentInfo = null;
+ var style = state.tokenize(stream, state);
+ var current = stream.current();
+
+ // Handle '.' connected identifiers
+ if (current === '.') {
+ style = stream.match(identifiers, false) ? null : ERRORCLASS;
+ if (style === null && state.lastStyle === 'meta') {
+ // Apply 'meta' style to '.' connected identifiers when
+ // appropriate.
+ style = 'meta';
+ }
+ return style;
+ }
+
+ return style;
+ }
+
+ var external = {
+ startState: function() {
+ return {
+ tokenize: tokenBase,
+ scopes: [],
+ leaving_expr: false
+ };
+ },
+
+ token: function(stream, state) {
+ var style = tokenLexer(stream, state);
+ state.lastStyle = style;
+ return style;
+ },
+
+ indent: function(state, textAfter) {
+ var delta = 0;
+ if(textAfter=="end" || textAfter=="]" || textAfter=="}" || textAfter=="else" || textAfter=="elseif" || textAfter=="catch" || textAfter=="finally") {
+ delta = -1;
+ }
+ return (state.scopes.length + delta) * 4;
+ },
+
+ lineComment: "#",
+ fold: "indent",
+ electricChars: "edlsifyh]}"
+ };
+ return external;
+});
+
+
+CodeMirror.defineMIME("text/x-julia", "julia");
+
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/kotlin/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/kotlin/index.html
new file mode 100644
index 0000000..859e109
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/kotlin/index.html
@@ -0,0 +1,89 @@
+
+
+CodeMirror: Kotlin mode
+
+
+
+
+
+
+
+
+
+
+Kotlin mode
+
+
+
+
+
+ Mode for Kotlin (http://kotlin.jetbrains.org/)
+ Developed by Hadi Hariri (https://github.com/hhariri).
+ MIME type defined: text/x-kotlin.
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/kotlin/kotlin.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/kotlin/kotlin.js
new file mode 100644
index 0000000..73c84f6
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/kotlin/kotlin.js
@@ -0,0 +1,280 @@
+// 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("kotlin", function (config, parserConfig) {
+ function words(str) {
+ var obj = {}, words = str.split(" ");
+ for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+ return obj;
+ }
+
+ var multiLineStrings = parserConfig.multiLineStrings;
+
+ var keywords = words(
+ "package continue return object while break class data trait throw super" +
+ " when type this else This try val var fun for is in if do as true false null get set");
+ var softKeywords = words("import" +
+ " where by get set abstract enum open annotation override private public internal" +
+ " protected catch out vararg inline finally final ref");
+ var blockKeywords = words("catch class do else finally for if where try while enum");
+ var atoms = words("null true false this");
+
+ var curPunc;
+
+ function tokenBase(stream, state) {
+ var ch = stream.next();
+ if (ch == '"' || ch == "'") {
+ return startString(ch, stream, state);
+ }
+ // Wildcard import w/o trailing semicolon (import smth.*)
+ if (ch == "." && stream.eat("*")) {
+ return "word";
+ }
+ if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
+ curPunc = ch;
+ return null;
+ }
+ if (/\d/.test(ch)) {
+ if (stream.eat(/eE/)) {
+ stream.eat(/\+\-/);
+ stream.eatWhile(/\d/);
+ }
+ return "number";
+ }
+ if (ch == "/") {
+ if (stream.eat("*")) {
+ state.tokenize.push(tokenComment);
+ return tokenComment(stream, state);
+ }
+ if (stream.eat("/")) {
+ stream.skipToEnd();
+ return "comment";
+ }
+ if (expectExpression(state.lastToken)) {
+ return startString(ch, stream, state);
+ }
+ }
+ // Commented
+ if (ch == "-" && stream.eat(">")) {
+ curPunc = "->";
+ return null;
+ }
+ if (/[\-+*&%=<>!?|\/~]/.test(ch)) {
+ stream.eatWhile(/[\-+*&%=<>|~]/);
+ return "operator";
+ }
+ stream.eatWhile(/[\w\$_]/);
+
+ var cur = stream.current();
+ if (atoms.propertyIsEnumerable(cur)) {
+ return "atom";
+ }
+ if (softKeywords.propertyIsEnumerable(cur)) {
+ if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
+ return "softKeyword";
+ }
+
+ if (keywords.propertyIsEnumerable(cur)) {
+ if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
+ return "keyword";
+ }
+ return "word";
+ }
+
+ tokenBase.isBase = true;
+
+ function startString(quote, stream, state) {
+ var tripleQuoted = false;
+ if (quote != "/" && stream.eat(quote)) {
+ if (stream.eat(quote)) tripleQuoted = true;
+ else return "string";
+ }
+ function t(stream, state) {
+ var escaped = false, next, end = !tripleQuoted;
+
+ while ((next = stream.next()) != null) {
+ if (next == quote && !escaped) {
+ if (!tripleQuoted) {
+ break;
+ }
+ if (stream.match(quote + quote)) {
+ end = true;
+ break;
+ }
+ }
+
+ if (quote == '"' && next == "$" && !escaped && stream.eat("{")) {
+ state.tokenize.push(tokenBaseUntilBrace());
+ return "string";
+ }
+
+ if (next == "$" && !escaped && !stream.eat(" ")) {
+ state.tokenize.push(tokenBaseUntilSpace());
+ return "string";
+ }
+ escaped = !escaped && next == "\\";
+ }
+ if (multiLineStrings)
+ state.tokenize.push(t);
+ if (end) state.tokenize.pop();
+ return "string";
+ }
+
+ state.tokenize.push(t);
+ return t(stream, state);
+ }
+
+ function tokenBaseUntilBrace() {
+ var depth = 1;
+
+ function t(stream, state) {
+ if (stream.peek() == "}") {
+ depth--;
+ if (depth == 0) {
+ state.tokenize.pop();
+ return state.tokenize[state.tokenize.length - 1](stream, state);
+ }
+ } else if (stream.peek() == "{") {
+ depth++;
+ }
+ return tokenBase(stream, state);
+ }
+
+ t.isBase = true;
+ return t;
+ }
+
+ function tokenBaseUntilSpace() {
+ function t(stream, state) {
+ if (stream.eat(/[\w]/)) {
+ var isWord = stream.eatWhile(/[\w]/);
+ if (isWord) {
+ state.tokenize.pop();
+ return "word";
+ }
+ }
+ state.tokenize.pop();
+ return "string";
+ }
+
+ t.isBase = true;
+ return t;
+ }
+
+ function tokenComment(stream, state) {
+ var maybeEnd = false, ch;
+ while (ch = stream.next()) {
+ if (ch == "/" && maybeEnd) {
+ state.tokenize.pop();
+ break;
+ }
+ maybeEnd = (ch == "*");
+ }
+ return "comment";
+ }
+
+ function expectExpression(last) {
+ return !last || last == "operator" || last == "->" || /[\.\[\{\(,;:]/.test(last) ||
+ last == "newstatement" || last == "keyword" || last == "proplabel";
+ }
+
+ function Context(indented, column, type, align, prev) {
+ this.indented = indented;
+ this.column = column;
+ this.type = type;
+ this.align = align;
+ this.prev = prev;
+ }
+
+ function pushContext(state, col, type) {
+ return state.context = new Context(state.indented, col, type, null, state.context);
+ }
+
+ function popContext(state) {
+ var t = state.context.type;
+ if (t == ")" || t == "]" || t == "}")
+ state.indented = state.context.indented;
+ return state.context = state.context.prev;
+ }
+
+ // Interface
+
+ return {
+ startState: function (basecolumn) {
+ return {
+ tokenize: [tokenBase],
+ context: new Context((basecolumn || 0) - config.indentUnit, 0, "top", false),
+ indented: 0,
+ startOfLine: true,
+ lastToken: null
+ };
+ },
+
+ token: function (stream, state) {
+ var ctx = state.context;
+ if (stream.sol()) {
+ if (ctx.align == null) ctx.align = false;
+ state.indented = stream.indentation();
+ state.startOfLine = true;
+ // Automatic semicolon insertion
+ if (ctx.type == "statement" && !expectExpression(state.lastToken)) {
+ popContext(state);
+ ctx = state.context;
+ }
+ }
+ if (stream.eatSpace()) return null;
+ curPunc = null;
+ var style = state.tokenize[state.tokenize.length - 1](stream, state);
+ if (style == "comment") return style;
+ if (ctx.align == null) ctx.align = true;
+ if ((curPunc == ";" || curPunc == ":") && ctx.type == "statement") popContext(state);
+ // Handle indentation for {x -> \n ... }
+ else if (curPunc == "->" && ctx.type == "statement" && ctx.prev.type == "}") {
+ popContext(state);
+ state.context.align = false;
+ }
+ else if (curPunc == "{") pushContext(state, stream.column(), "}");
+ else if (curPunc == "[") pushContext(state, stream.column(), "]");
+ else if (curPunc == "(") pushContext(state, stream.column(), ")");
+ else if (curPunc == "}") {
+ while (ctx.type == "statement") ctx = popContext(state);
+ if (ctx.type == "}") ctx = popContext(state);
+ while (ctx.type == "statement") ctx = popContext(state);
+ }
+ else if (curPunc == ctx.type) popContext(state);
+ else if (ctx.type == "}" || ctx.type == "top" || (ctx.type == "statement" && curPunc == "newstatement"))
+ pushContext(state, stream.column(), "statement");
+ state.startOfLine = false;
+ state.lastToken = curPunc || style;
+ return style;
+ },
+
+ indent: function (state, textAfter) {
+ if (!state.tokenize[state.tokenize.length - 1].isBase) return 0;
+ var firstChar = textAfter && textAfter.charAt(0), ctx = state.context;
+ if (ctx.type == "statement" && !expectExpression(state.lastToken)) ctx = ctx.prev;
+ var closing = firstChar == ctx.type;
+ if (ctx.type == "statement") {
+ return ctx.indented + (firstChar == "{" ? 0 : config.indentUnit);
+ }
+ else if (ctx.align) return ctx.column + (closing ? 0 : 1);
+ else return ctx.indented + (closing ? 0 : config.indentUnit);
+ },
+
+ electricChars: "{}"
+ };
+});
+
+CodeMirror.defineMIME("text/x-kotlin", "kotlin");
+
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/livescript/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/livescript/index.html
new file mode 100644
index 0000000..f415479
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/livescript/index.html
@@ -0,0 +1,459 @@
+
+
+CodeMirror: LiveScript mode
+
+
+
+
+
+
+
+
+
+
+
+LiveScript mode
+
+
+
+ MIME types defined: text/x-livescript.
+
+ The LiveScript mode was written by Kenneth Bentley.
+
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/livescript/livescript.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/livescript/livescript.js
new file mode 100644
index 0000000..55882ef
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/livescript/livescript.js
@@ -0,0 +1,280 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+/**
+ * Link to the project's GitHub page:
+ * https://github.com/duralog/CodeMirror
+ */
+
+(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('livescript', function(){
+ var tokenBase = function(stream, state) {
+ var next_rule = state.next || "start";
+ if (next_rule) {
+ state.next = state.next;
+ var nr = Rules[next_rule];
+ if (nr.splice) {
+ for (var i$ = 0; i$ < nr.length; ++i$) {
+ var r = nr[i$], m;
+ if (r.regex && (m = stream.match(r.regex))) {
+ state.next = r.next || state.next;
+ return r.token;
+ }
+ }
+ stream.next();
+ return 'error';
+ }
+ if (stream.match(r = Rules[next_rule])) {
+ if (r.regex && stream.match(r.regex)) {
+ state.next = r.next;
+ return r.token;
+ } else {
+ stream.next();
+ return 'error';
+ }
+ }
+ }
+ stream.next();
+ return 'error';
+ };
+ var external = {
+ startState: function(){
+ return {
+ next: 'start',
+ lastToken: null
+ };
+ },
+ token: function(stream, state){
+ while (stream.pos == stream.start)
+ var style = tokenBase(stream, state);
+ state.lastToken = {
+ style: style,
+ indent: stream.indentation(),
+ content: stream.current()
+ };
+ return style.replace(/\./g, ' ');
+ },
+ indent: function(state){
+ var indentation = state.lastToken.indent;
+ if (state.lastToken.content.match(indenter)) {
+ indentation += 2;
+ }
+ return indentation;
+ }
+ };
+ return external;
+ });
+
+ var identifier = '(?![\\d\\s])[$\\w\\xAA-\\uFFDC](?:(?!\\s)[$\\w\\xAA-\\uFFDC]|-[A-Za-z])*';
+ var indenter = RegExp('(?:[({[=:]|[-~]>|\\b(?:e(?:lse|xport)|d(?:o|efault)|t(?:ry|hen)|finally|import(?:\\s*all)?|const|var|let|new|catch(?:\\s*' + identifier + ')?))\\s*$');
+ var keywordend = '(?![$\\w]|-[A-Za-z]|\\s*:(?![:=]))';
+ var stringfill = {
+ token: 'string',
+ regex: '.+'
+ };
+ var Rules = {
+ start: [
+ {
+ token: 'comment.doc',
+ regex: '/\\*',
+ next: 'comment'
+ }, {
+ token: 'comment',
+ regex: '#.*'
+ }, {
+ token: 'keyword',
+ regex: '(?:t(?:h(?:is|row|en)|ry|ypeof!?)|c(?:on(?:tinue|st)|a(?:se|tch)|lass)|i(?:n(?:stanceof)?|mp(?:ort(?:\\s+all)?|lements)|[fs])|d(?:e(?:fault|lete|bugger)|o)|f(?:or(?:\\s+own)?|inally|unction)|s(?:uper|witch)|e(?:lse|x(?:tends|port)|val)|a(?:nd|rguments)|n(?:ew|ot)|un(?:less|til)|w(?:hile|ith)|o[fr]|return|break|let|var|loop)' + keywordend
+ }, {
+ token: 'constant.language',
+ regex: '(?:true|false|yes|no|on|off|null|void|undefined)' + keywordend
+ }, {
+ token: 'invalid.illegal',
+ regex: '(?:p(?:ackage|r(?:ivate|otected)|ublic)|i(?:mplements|nterface)|enum|static|yield)' + keywordend
+ }, {
+ token: 'language.support.class',
+ regex: '(?:R(?:e(?:gExp|ferenceError)|angeError)|S(?:tring|yntaxError)|E(?:rror|valError)|Array|Boolean|Date|Function|Number|Object|TypeError|URIError)' + keywordend
+ }, {
+ token: 'language.support.function',
+ regex: '(?:is(?:NaN|Finite)|parse(?:Int|Float)|Math|JSON|(?:en|de)codeURI(?:Component)?)' + keywordend
+ }, {
+ token: 'variable.language',
+ regex: '(?:t(?:hat|il|o)|f(?:rom|allthrough)|it|by|e)' + keywordend
+ }, {
+ token: 'identifier',
+ regex: identifier + '\\s*:(?![:=])'
+ }, {
+ token: 'variable',
+ regex: identifier
+ }, {
+ token: 'keyword.operator',
+ regex: '(?:\\.{3}|\\s+\\?)'
+ }, {
+ token: 'keyword.variable',
+ regex: '(?:@+|::|\\.\\.)',
+ next: 'key'
+ }, {
+ token: 'keyword.operator',
+ regex: '\\.\\s*',
+ next: 'key'
+ }, {
+ token: 'string',
+ regex: '\\\\\\S[^\\s,;)}\\]]*'
+ }, {
+ token: 'string.doc',
+ regex: '\'\'\'',
+ next: 'qdoc'
+ }, {
+ token: 'string.doc',
+ regex: '"""',
+ next: 'qqdoc'
+ }, {
+ token: 'string',
+ regex: '\'',
+ next: 'qstring'
+ }, {
+ token: 'string',
+ regex: '"',
+ next: 'qqstring'
+ }, {
+ token: 'string',
+ regex: '`',
+ next: 'js'
+ }, {
+ token: 'string',
+ regex: '<\\[',
+ next: 'words'
+ }, {
+ token: 'string.regex',
+ regex: '//',
+ next: 'heregex'
+ }, {
+ token: 'string.regex',
+ regex: '\\/(?:[^[\\/\\n\\\\]*(?:(?:\\\\.|\\[[^\\]\\n\\\\]*(?:\\\\.[^\\]\\n\\\\]*)*\\])[^[\\/\\n\\\\]*)*)\\/[gimy$]{0,4}',
+ next: 'key'
+ }, {
+ token: 'constant.numeric',
+ regex: '(?:0x[\\da-fA-F][\\da-fA-F_]*|(?:[2-9]|[12]\\d|3[0-6])r[\\da-zA-Z][\\da-zA-Z_]*|(?:\\d[\\d_]*(?:\\.\\d[\\d_]*)?|\\.\\d[\\d_]*)(?:e[+-]?\\d[\\d_]*)?[\\w$]*)'
+ }, {
+ token: 'lparen',
+ regex: '[({[]'
+ }, {
+ token: 'rparen',
+ regex: '[)}\\]]',
+ next: 'key'
+ }, {
+ token: 'keyword.operator',
+ regex: '\\S+'
+ }, {
+ token: 'text',
+ regex: '\\s+'
+ }
+ ],
+ heregex: [
+ {
+ token: 'string.regex',
+ regex: '.*?//[gimy$?]{0,4}',
+ next: 'start'
+ }, {
+ token: 'string.regex',
+ regex: '\\s*#{'
+ }, {
+ token: 'comment.regex',
+ regex: '\\s+(?:#.*)?'
+ }, {
+ token: 'string.regex',
+ regex: '\\S+'
+ }
+ ],
+ key: [
+ {
+ token: 'keyword.operator',
+ regex: '[.?@!]+'
+ }, {
+ token: 'identifier',
+ regex: identifier,
+ next: 'start'
+ }, {
+ token: 'text',
+ regex: '',
+ next: 'start'
+ }
+ ],
+ comment: [
+ {
+ token: 'comment.doc',
+ regex: '.*?\\*/',
+ next: 'start'
+ }, {
+ token: 'comment.doc',
+ regex: '.+'
+ }
+ ],
+ qdoc: [
+ {
+ token: 'string',
+ regex: ".*?'''",
+ next: 'key'
+ }, stringfill
+ ],
+ qqdoc: [
+ {
+ token: 'string',
+ regex: '.*?"""',
+ next: 'key'
+ }, stringfill
+ ],
+ qstring: [
+ {
+ token: 'string',
+ regex: '[^\\\\\']*(?:\\\\.[^\\\\\']*)*\'',
+ next: 'key'
+ }, stringfill
+ ],
+ qqstring: [
+ {
+ token: 'string',
+ regex: '[^\\\\"]*(?:\\\\.[^\\\\"]*)*"',
+ next: 'key'
+ }, stringfill
+ ],
+ js: [
+ {
+ token: 'string',
+ regex: '[^\\\\`]*(?:\\\\.[^\\\\`]*)*`',
+ next: 'key'
+ }, stringfill
+ ],
+ words: [
+ {
+ token: 'string',
+ regex: '.*?\\]>',
+ next: 'key'
+ }, stringfill
+ ]
+ };
+ for (var idx in Rules) {
+ var r = Rules[idx];
+ if (r.splice) {
+ for (var i = 0, len = r.length; i < len; ++i) {
+ var rr = r[i];
+ if (typeof rr.regex === 'string') {
+ Rules[idx][i].regex = new RegExp('^' + rr.regex);
+ }
+ }
+ } else if (typeof rr.regex === 'string') {
+ Rules[idx].regex = new RegExp('^' + r.regex);
+ }
+ }
+
+ CodeMirror.defineMIME('text/x-livescript', 'livescript');
+
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/lua/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/lua/index.html
new file mode 100644
index 0000000..fc98b94
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/lua/index.html
@@ -0,0 +1,85 @@
+
+
+CodeMirror: Lua mode
+
+
+
+
+
+
+
+
+
+
+
+
+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.
+
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/lua/lua.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/lua/lua.js
new file mode 100644
index 0000000..0b19abd
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/lua/lua.js
@@ -0,0 +1,159 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// LUA mode. Ported to CodeMirror 2 from Franciszek Wawrzak's
+// CodeMirror 1 mode.
+// highlights keywords, strings, comments (no leveling supported! ("[==[")), tokens, basic indenting
+
+(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("lua", function(config, parserConfig) {
+ var indentUnit = config.indentUnit;
+
+ function prefixRE(words) {
+ return new RegExp("^(?:" + words.join("|") + ")", "i");
+ }
+ function wordRE(words) {
+ return new RegExp("^(?:" + words.join("|") + ")$", "i");
+ }
+ var specials = wordRE(parserConfig.specials || []);
+
+ // long list of standard functions from lua manual
+ var builtins = wordRE([
+ "_G","_VERSION","assert","collectgarbage","dofile","error","getfenv","getmetatable","ipairs","load",
+ "loadfile","loadstring","module","next","pairs","pcall","print","rawequal","rawget","rawset","require",
+ "select","setfenv","setmetatable","tonumber","tostring","type","unpack","xpcall",
+
+ "coroutine.create","coroutine.resume","coroutine.running","coroutine.status","coroutine.wrap","coroutine.yield",
+
+ "debug.debug","debug.getfenv","debug.gethook","debug.getinfo","debug.getlocal","debug.getmetatable",
+ "debug.getregistry","debug.getupvalue","debug.setfenv","debug.sethook","debug.setlocal","debug.setmetatable",
+ "debug.setupvalue","debug.traceback",
+
+ "close","flush","lines","read","seek","setvbuf","write",
+
+ "io.close","io.flush","io.input","io.lines","io.open","io.output","io.popen","io.read","io.stderr","io.stdin",
+ "io.stdout","io.tmpfile","io.type","io.write",
+
+ "math.abs","math.acos","math.asin","math.atan","math.atan2","math.ceil","math.cos","math.cosh","math.deg",
+ "math.exp","math.floor","math.fmod","math.frexp","math.huge","math.ldexp","math.log","math.log10","math.max",
+ "math.min","math.modf","math.pi","math.pow","math.rad","math.random","math.randomseed","math.sin","math.sinh",
+ "math.sqrt","math.tan","math.tanh",
+
+ "os.clock","os.date","os.difftime","os.execute","os.exit","os.getenv","os.remove","os.rename","os.setlocale",
+ "os.time","os.tmpname",
+
+ "package.cpath","package.loaded","package.loaders","package.loadlib","package.path","package.preload",
+ "package.seeall",
+
+ "string.byte","string.char","string.dump","string.find","string.format","string.gmatch","string.gsub",
+ "string.len","string.lower","string.match","string.rep","string.reverse","string.sub","string.upper",
+
+ "table.concat","table.insert","table.maxn","table.remove","table.sort"
+ ]);
+ var keywords = wordRE(["and","break","elseif","false","nil","not","or","return",
+ "true","function", "end", "if", "then", "else", "do",
+ "while", "repeat", "until", "for", "in", "local" ]);
+
+ var indentTokens = wordRE(["function", "if","repeat","do", "\\(", "{"]);
+ var dedentTokens = wordRE(["end", "until", "\\)", "}"]);
+ var dedentPartial = prefixRE(["end", "until", "\\)", "}", "else", "elseif"]);
+
+ function readBracket(stream) {
+ var level = 0;
+ while (stream.eat("=")) ++level;
+ stream.eat("[");
+ return level;
+ }
+
+ function normal(stream, state) {
+ var ch = stream.next();
+ if (ch == "-" && stream.eat("-")) {
+ if (stream.eat("[") && stream.eat("["))
+ return (state.cur = bracketed(readBracket(stream), "comment"))(stream, state);
+ stream.skipToEnd();
+ return "comment";
+ }
+ if (ch == "\"" || ch == "'")
+ return (state.cur = string(ch))(stream, state);
+ if (ch == "[" && /[\[=]/.test(stream.peek()))
+ return (state.cur = bracketed(readBracket(stream), "string"))(stream, state);
+ if (/\d/.test(ch)) {
+ stream.eatWhile(/[\w.%]/);
+ return "number";
+ }
+ if (/[\w_]/.test(ch)) {
+ stream.eatWhile(/[\w\\\-_.]/);
+ return "variable";
+ }
+ return null;
+ }
+
+ function bracketed(level, style) {
+ return function(stream, state) {
+ var curlev = null, ch;
+ while ((ch = stream.next()) != null) {
+ if (curlev == null) {if (ch == "]") curlev = 0;}
+ else if (ch == "=") ++curlev;
+ else if (ch == "]" && curlev == level) { state.cur = normal; break; }
+ else curlev = null;
+ }
+ return style;
+ };
+ }
+
+ function string(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.cur = normal;
+ return "string";
+ };
+ }
+
+ return {
+ startState: function(basecol) {
+ return {basecol: basecol || 0, indentDepth: 0, cur: normal};
+ },
+
+ token: function(stream, state) {
+ if (stream.eatSpace()) return null;
+ var style = state.cur(stream, state);
+ var word = stream.current();
+ if (style == "variable") {
+ if (keywords.test(word)) style = "keyword";
+ else if (builtins.test(word)) style = "builtin";
+ else if (specials.test(word)) style = "variable-2";
+ }
+ if ((style != "comment") && (style != "string")){
+ if (indentTokens.test(word)) ++state.indentDepth;
+ else if (dedentTokens.test(word)) --state.indentDepth;
+ }
+ return style;
+ },
+
+ indent: function(state, textAfter) {
+ var closing = dedentPartial.test(textAfter);
+ return state.basecol + indentUnit * (state.indentDepth - (closing ? 1 : 0));
+ },
+
+ lineComment: "--",
+ blockCommentStart: "--[[",
+ blockCommentEnd: "]]"
+ };
+});
+
+CodeMirror.defineMIME("text/x-lua", "lua");
+
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/markdown/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/markdown/index.html
new file mode 100644
index 0000000..c3bb8df
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/markdown/index.html
@@ -0,0 +1,359 @@
+
+
+CodeMirror: Markdown mode
+
+
+
+
+
+
+
+
+
+
+
+
+Markdown mode
+
+
+
+
+ Optionally depends on the XML mode for properly highlighted inline XML blocks.
+
+ MIME types defined: text/x-markdown.
+
+ Parsing/Highlighting Tests: normal, verbose.
+
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/markdown/markdown.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/markdown/markdown.js
new file mode 100644
index 0000000..3c80311
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/markdown/markdown.js
@@ -0,0 +1,765 @@
+// 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("../xml/xml"), require("../meta"));
+ else if (typeof define == "function" && define.amd) // AMD
+ define(["../../lib/codemirror", "../xml/xml", "../meta"], mod);
+ else // Plain browser env
+ mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+
+CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
+
+ var htmlFound = CodeMirror.modes.hasOwnProperty("xml");
+ var htmlMode = CodeMirror.getMode(cmCfg, htmlFound ? {name: "xml", htmlMode: true} : "text/plain");
+
+ function getMode(name) {
+ if (CodeMirror.findModeByName) {
+ var found = CodeMirror.findModeByName(name);
+ if (found) name = found.mime || found.mimes[0];
+ }
+ var mode = CodeMirror.getMode(cmCfg, name);
+ return mode.name == "null" ? null : mode;
+ }
+
+ // Should characters that affect highlighting be highlighted separate?
+ // Does not include characters that will be output (such as `1.` and `-` for lists)
+ if (modeCfg.highlightFormatting === undefined)
+ modeCfg.highlightFormatting = false;
+
+ // Maximum number of nested blockquotes. Set to 0 for infinite nesting.
+ // Excess `>` will emit `error` token.
+ if (modeCfg.maxBlockquoteDepth === undefined)
+ modeCfg.maxBlockquoteDepth = 0;
+
+ // Should underscores in words open/close em/strong?
+ if (modeCfg.underscoresBreakWords === undefined)
+ modeCfg.underscoresBreakWords = true;
+
+ // Turn on fenced code blocks? ("```" to start/end)
+ if (modeCfg.fencedCodeBlocks === undefined) modeCfg.fencedCodeBlocks = false;
+
+ // Turn on task lists? ("- [ ] " and "- [x] ")
+ if (modeCfg.taskLists === undefined) modeCfg.taskLists = false;
+
+ // Turn on strikethrough syntax
+ if (modeCfg.strikethrough === undefined)
+ modeCfg.strikethrough = false;
+
+ var codeDepth = 0;
+
+ var header = 'header'
+ , code = 'comment'
+ , quote = 'quote'
+ , list1 = 'variable-2'
+ , list2 = 'variable-3'
+ , list3 = 'keyword'
+ , hr = 'hr'
+ , image = 'tag'
+ , formatting = 'formatting'
+ , linkinline = 'link'
+ , linkemail = 'link'
+ , linktext = 'link'
+ , linkhref = 'string'
+ , em = 'em'
+ , strong = 'strong'
+ , strikethrough = 'strikethrough';
+
+ var hrRE = /^([*\-=_])(?:\s*\1){2,}\s*$/
+ , ulRE = /^[*\-+]\s+/
+ , olRE = /^[0-9]+\.\s+/
+ , taskListRE = /^\[(x| )\](?=\s)/ // Must follow ulRE or olRE
+ , atxHeaderRE = /^#+/
+ , setextHeaderRE = /^(?:\={1,}|-{1,})$/
+ , textRE = /^[^#!\[\]*_\\<>` "'(~]+/;
+
+ function switchInline(stream, state, f) {
+ state.f = state.inline = f;
+ return f(stream, state);
+ }
+
+ function switchBlock(stream, state, f) {
+ state.f = state.block = f;
+ return f(stream, state);
+ }
+
+
+ // Blocks
+
+ function blankLine(state) {
+ // Reset linkTitle state
+ state.linkTitle = false;
+ // Reset EM state
+ state.em = false;
+ // Reset STRONG state
+ state.strong = false;
+ // Reset strikethrough state
+ state.strikethrough = false;
+ // Reset state.quote
+ state.quote = 0;
+ if (!htmlFound && state.f == htmlBlock) {
+ state.f = inlineNormal;
+ state.block = blockNormal;
+ }
+ // Reset state.trailingSpace
+ state.trailingSpace = 0;
+ state.trailingSpaceNewLine = false;
+ // Mark this line as blank
+ state.thisLineHasContent = false;
+ return null;
+ }
+
+ function blockNormal(stream, state) {
+
+ var sol = stream.sol();
+
+ var prevLineIsList = (state.list !== false);
+ if (state.list !== false && state.indentationDiff >= 0) { // Continued list
+ if (state.indentationDiff < 4) { // Only adjust indentation if *not* a code block
+ state.indentation -= state.indentationDiff;
+ }
+ state.list = null;
+ } else if (state.list !== false && state.indentation > 0) {
+ state.list = null;
+ state.listDepth = Math.floor(state.indentation / 4);
+ } else if (state.list !== false) { // No longer a list
+ state.list = false;
+ state.listDepth = 0;
+ }
+
+ var match = null;
+ if (state.indentationDiff >= 4) {
+ state.indentation -= 4;
+ stream.skipToEnd();
+ return code;
+ } else if (stream.eatSpace()) {
+ return null;
+ } else if (match = stream.match(atxHeaderRE)) {
+ state.header = match[0].length <= 6 ? match[0].length : 6;
+ if (modeCfg.highlightFormatting) state.formatting = "header";
+ state.f = state.inline;
+ return getType(state);
+ } else if (state.prevLineHasContent && (match = stream.match(setextHeaderRE))) {
+ state.header = match[0].charAt(0) == '=' ? 1 : 2;
+ if (modeCfg.highlightFormatting) state.formatting = "header";
+ state.f = state.inline;
+ return getType(state);
+ } else if (stream.eat('>')) {
+ state.indentation++;
+ state.quote = sol ? 1 : state.quote + 1;
+ if (modeCfg.highlightFormatting) state.formatting = "quote";
+ stream.eatSpace();
+ return getType(state);
+ } else if (stream.peek() === '[') {
+ return switchInline(stream, state, footnoteLink);
+ } else if (stream.match(hrRE, true)) {
+ return hr;
+ } else if ((!state.prevLineHasContent || prevLineIsList) && (stream.match(ulRE, false) || stream.match(olRE, false))) {
+ var listType = null;
+ if (stream.match(ulRE, true)) {
+ listType = 'ul';
+ } else {
+ stream.match(olRE, true);
+ listType = 'ol';
+ }
+ state.indentation += 4;
+ state.list = true;
+ state.listDepth++;
+ if (modeCfg.taskLists && stream.match(taskListRE, false)) {
+ state.taskList = true;
+ }
+ state.f = state.inline;
+ if (modeCfg.highlightFormatting) state.formatting = ["list", "list-" + listType];
+ return getType(state);
+ } else if (modeCfg.fencedCodeBlocks && stream.match(/^```[ \t]*([\w+#]*)/, true)) {
+ // try switching mode
+ state.localMode = getMode(RegExp.$1);
+ if (state.localMode) state.localState = state.localMode.startState();
+ state.f = state.block = local;
+ if (modeCfg.highlightFormatting) state.formatting = "code-block";
+ state.code = true;
+ return getType(state);
+ }
+
+ return switchInline(stream, state, state.inline);
+ }
+
+ function htmlBlock(stream, state) {
+ var style = htmlMode.token(stream, state.htmlState);
+ if ((htmlFound && state.htmlState.tagStart === null && !state.htmlState.context) ||
+ (state.md_inside && stream.current().indexOf(">") > -1)) {
+ state.f = inlineNormal;
+ state.block = blockNormal;
+ state.htmlState = null;
+ }
+ return style;
+ }
+
+ function local(stream, state) {
+ if (stream.sol() && stream.match("```", false)) {
+ state.localMode = state.localState = null;
+ state.f = state.block = leavingLocal;
+ return null;
+ } else if (state.localMode) {
+ return state.localMode.token(stream, state.localState);
+ } else {
+ stream.skipToEnd();
+ return code;
+ }
+ }
+
+ function leavingLocal(stream, state) {
+ stream.match("```");
+ state.block = blockNormal;
+ state.f = inlineNormal;
+ if (modeCfg.highlightFormatting) state.formatting = "code-block";
+ state.code = true;
+ var returnType = getType(state);
+ state.code = false;
+ return returnType;
+ }
+
+ // Inline
+ function getType(state) {
+ var styles = [];
+
+ if (state.formatting) {
+ styles.push(formatting);
+
+ if (typeof state.formatting === "string") state.formatting = [state.formatting];
+
+ for (var i = 0; i < state.formatting.length; i++) {
+ styles.push(formatting + "-" + state.formatting[i]);
+
+ if (state.formatting[i] === "header") {
+ styles.push(formatting + "-" + state.formatting[i] + "-" + state.header);
+ }
+
+ // Add `formatting-quote` and `formatting-quote-#` for blockquotes
+ // Add `error` instead if the maximum blockquote nesting depth is passed
+ if (state.formatting[i] === "quote") {
+ if (!modeCfg.maxBlockquoteDepth || modeCfg.maxBlockquoteDepth >= state.quote) {
+ styles.push(formatting + "-" + state.formatting[i] + "-" + state.quote);
+ } else {
+ styles.push("error");
+ }
+ }
+ }
+ }
+
+ if (state.taskOpen) {
+ styles.push("meta");
+ return styles.length ? styles.join(' ') : null;
+ }
+ if (state.taskClosed) {
+ styles.push("property");
+ return styles.length ? styles.join(' ') : null;
+ }
+
+ if (state.linkHref) {
+ styles.push(linkhref);
+ return styles.length ? styles.join(' ') : null;
+ }
+
+ if (state.strong) { styles.push(strong); }
+ if (state.em) { styles.push(em); }
+ if (state.strikethrough) { styles.push(strikethrough); }
+
+ if (state.linkText) { styles.push(linktext); }
+
+ if (state.code) { styles.push(code); }
+
+ if (state.header) { styles.push(header); styles.push(header + "-" + state.header); }
+
+ if (state.quote) {
+ styles.push(quote);
+
+ // Add `quote-#` where the maximum for `#` is modeCfg.maxBlockquoteDepth
+ if (!modeCfg.maxBlockquoteDepth || modeCfg.maxBlockquoteDepth >= state.quote) {
+ styles.push(quote + "-" + state.quote);
+ } else {
+ styles.push(quote + "-" + modeCfg.maxBlockquoteDepth);
+ }
+ }
+
+ if (state.list !== false) {
+ var listMod = (state.listDepth - 1) % 3;
+ if (!listMod) {
+ styles.push(list1);
+ } else if (listMod === 1) {
+ styles.push(list2);
+ } else {
+ styles.push(list3);
+ }
+ }
+
+ if (state.trailingSpaceNewLine) {
+ styles.push("trailing-space-new-line");
+ } else if (state.trailingSpace) {
+ styles.push("trailing-space-" + (state.trailingSpace % 2 ? "a" : "b"));
+ }
+
+ return styles.length ? styles.join(' ') : null;
+ }
+
+ function handleText(stream, state) {
+ if (stream.match(textRE, true)) {
+ return getType(state);
+ }
+ return undefined;
+ }
+
+ function inlineNormal(stream, state) {
+ var style = state.text(stream, state);
+ if (typeof style !== 'undefined')
+ return style;
+
+ if (state.list) { // List marker (*, +, -, 1., etc)
+ state.list = null;
+ return getType(state);
+ }
+
+ if (state.taskList) {
+ var taskOpen = stream.match(taskListRE, true)[1] !== "x";
+ if (taskOpen) state.taskOpen = true;
+ else state.taskClosed = true;
+ if (modeCfg.highlightFormatting) state.formatting = "task";
+ state.taskList = false;
+ return getType(state);
+ }
+
+ state.taskOpen = false;
+ state.taskClosed = false;
+
+ if (state.header && stream.match(/^#+$/, true)) {
+ if (modeCfg.highlightFormatting) state.formatting = "header";
+ return getType(state);
+ }
+
+ // Get sol() value now, before character is consumed
+ var sol = stream.sol();
+
+ var ch = stream.next();
+
+ if (ch === '\\') {
+ stream.next();
+ if (modeCfg.highlightFormatting) {
+ var type = getType(state);
+ return type ? type + " formatting-escape" : "formatting-escape";
+ }
+ }
+
+ // Matches link titles present on next line
+ if (state.linkTitle) {
+ state.linkTitle = false;
+ var matchCh = ch;
+ if (ch === '(') {
+ matchCh = ')';
+ }
+ matchCh = (matchCh+'').replace(/([.?*+^$[\]\\(){}|-])/g, "\\$1");
+ var regex = '^\\s*(?:[^' + matchCh + '\\\\]+|\\\\\\\\|\\\\.)' + matchCh;
+ if (stream.match(new RegExp(regex), true)) {
+ return linkhref;
+ }
+ }
+
+ // If this block is changed, it may need to be updated in GFM mode
+ if (ch === '`') {
+ var previousFormatting = state.formatting;
+ if (modeCfg.highlightFormatting) state.formatting = "code";
+ var t = getType(state);
+ var before = stream.pos;
+ stream.eatWhile('`');
+ var difference = 1 + stream.pos - before;
+ if (!state.code) {
+ codeDepth = difference;
+ state.code = true;
+ return getType(state);
+ } else {
+ if (difference === codeDepth) { // Must be exact
+ state.code = false;
+ return t;
+ }
+ state.formatting = previousFormatting;
+ return getType(state);
+ }
+ } else if (state.code) {
+ return getType(state);
+ }
+
+ if (ch === '!' && stream.match(/\[[^\]]*\] ?(?:\(|\[)/, false)) {
+ stream.match(/\[[^\]]*\]/);
+ state.inline = state.f = linkHref;
+ return image;
+ }
+
+ if (ch === '[' && stream.match(/.*\](\(.*\)| ?\[.*\])/, false)) {
+ state.linkText = true;
+ if (modeCfg.highlightFormatting) state.formatting = "link";
+ return getType(state);
+ }
+
+ if (ch === ']' && state.linkText && stream.match(/\(.*\)| ?\[.*\]/, false)) {
+ if (modeCfg.highlightFormatting) state.formatting = "link";
+ var type = getType(state);
+ state.linkText = false;
+ state.inline = state.f = linkHref;
+ return type;
+ }
+
+ if (ch === '<' && stream.match(/^(https?|ftps?):\/\/(?:[^\\>]|\\.)+>/, false)) {
+ state.f = state.inline = linkInline;
+ if (modeCfg.highlightFormatting) state.formatting = "link";
+ var type = getType(state);
+ if (type){
+ type += " ";
+ } else {
+ type = "";
+ }
+ return type + linkinline;
+ }
+
+ if (ch === '<' && stream.match(/^[^> \\]+@(?:[^\\>]|\\.)+>/, false)) {
+ state.f = state.inline = linkInline;
+ if (modeCfg.highlightFormatting) state.formatting = "link";
+ var type = getType(state);
+ if (type){
+ type += " ";
+ } else {
+ type = "";
+ }
+ return type + linkemail;
+ }
+
+ if (ch === '<' && stream.match(/^\w/, false)) {
+ if (stream.string.indexOf(">") != -1) {
+ var atts = stream.string.substring(1,stream.string.indexOf(">"));
+ if (/markdown\s*=\s*('|"){0,1}1('|"){0,1}/.test(atts)) {
+ state.md_inside = true;
+ }
+ }
+ stream.backUp(1);
+ state.htmlState = CodeMirror.startState(htmlMode);
+ return switchBlock(stream, state, htmlBlock);
+ }
+
+ if (ch === '<' && stream.match(/^\/\w*?>/)) {
+ state.md_inside = false;
+ return "tag";
+ }
+
+ var ignoreUnderscore = false;
+ if (!modeCfg.underscoresBreakWords) {
+ if (ch === '_' && stream.peek() !== '_' && stream.match(/(\w)/, false)) {
+ var prevPos = stream.pos - 2;
+ if (prevPos >= 0) {
+ var prevCh = stream.string.charAt(prevPos);
+ if (prevCh !== '_' && prevCh.match(/(\w)/, false)) {
+ ignoreUnderscore = true;
+ }
+ }
+ }
+ }
+ if (ch === '*' || (ch === '_' && !ignoreUnderscore)) {
+ if (sol && stream.peek() === ' ') {
+ // Do nothing, surrounded by newline and space
+ } else if (state.strong === ch && stream.eat(ch)) { // Remove STRONG
+ if (modeCfg.highlightFormatting) state.formatting = "strong";
+ var t = getType(state);
+ state.strong = false;
+ return t;
+ } else if (!state.strong && stream.eat(ch)) { // Add STRONG
+ state.strong = ch;
+ if (modeCfg.highlightFormatting) state.formatting = "strong";
+ return getType(state);
+ } else if (state.em === ch) { // Remove EM
+ if (modeCfg.highlightFormatting) state.formatting = "em";
+ var t = getType(state);
+ state.em = false;
+ return t;
+ } else if (!state.em) { // Add EM
+ state.em = ch;
+ if (modeCfg.highlightFormatting) state.formatting = "em";
+ return getType(state);
+ }
+ } else if (ch === ' ') {
+ if (stream.eat('*') || stream.eat('_')) { // Probably surrounded by spaces
+ if (stream.peek() === ' ') { // Surrounded by spaces, ignore
+ return getType(state);
+ } else { // Not surrounded by spaces, back up pointer
+ stream.backUp(1);
+ }
+ }
+ }
+
+ if (modeCfg.strikethrough) {
+ if (ch === '~' && stream.eatWhile(ch)) {
+ if (state.strikethrough) {// Remove strikethrough
+ if (modeCfg.highlightFormatting) state.formatting = "strikethrough";
+ var t = getType(state);
+ state.strikethrough = false;
+ return t;
+ } else if (stream.match(/^[^\s]/, false)) {// Add strikethrough
+ state.strikethrough = true;
+ if (modeCfg.highlightFormatting) state.formatting = "strikethrough";
+ return getType(state);
+ }
+ } else if (ch === ' ') {
+ if (stream.match(/^~~/, true)) { // Probably surrounded by space
+ if (stream.peek() === ' ') { // Surrounded by spaces, ignore
+ return getType(state);
+ } else { // Not surrounded by spaces, back up pointer
+ stream.backUp(2);
+ }
+ }
+ }
+ }
+
+ if (ch === ' ') {
+ if (stream.match(/ +$/, false)) {
+ state.trailingSpace++;
+ } else if (state.trailingSpace) {
+ state.trailingSpaceNewLine = true;
+ }
+ }
+
+ return getType(state);
+ }
+
+ function linkInline(stream, state) {
+ var ch = stream.next();
+
+ if (ch === ">") {
+ state.f = state.inline = inlineNormal;
+ if (modeCfg.highlightFormatting) state.formatting = "link";
+ var type = getType(state);
+ if (type){
+ type += " ";
+ } else {
+ type = "";
+ }
+ return type + linkinline;
+ }
+
+ stream.match(/^[^>]+/, true);
+
+ return linkinline;
+ }
+
+ function linkHref(stream, state) {
+ // Check if space, and return NULL if so (to avoid marking the space)
+ if(stream.eatSpace()){
+ return null;
+ }
+ var ch = stream.next();
+ if (ch === '(' || ch === '[') {
+ state.f = state.inline = getLinkHrefInside(ch === "(" ? ")" : "]");
+ if (modeCfg.highlightFormatting) state.formatting = "link-string";
+ state.linkHref = true;
+ return getType(state);
+ }
+ return 'error';
+ }
+
+ function getLinkHrefInside(endChar) {
+ return function(stream, state) {
+ var ch = stream.next();
+
+ if (ch === endChar) {
+ state.f = state.inline = inlineNormal;
+ if (modeCfg.highlightFormatting) state.formatting = "link-string";
+ var returnState = getType(state);
+ state.linkHref = false;
+ return returnState;
+ }
+
+ if (stream.match(inlineRE(endChar), true)) {
+ stream.backUp(1);
+ }
+
+ state.linkHref = true;
+ return getType(state);
+ };
+ }
+
+ function footnoteLink(stream, state) {
+ if (stream.match(/^[^\]]*\]:/, false)) {
+ state.f = footnoteLinkInside;
+ stream.next(); // Consume [
+ if (modeCfg.highlightFormatting) state.formatting = "link";
+ state.linkText = true;
+ return getType(state);
+ }
+ return switchInline(stream, state, inlineNormal);
+ }
+
+ function footnoteLinkInside(stream, state) {
+ if (stream.match(/^\]:/, true)) {
+ state.f = state.inline = footnoteUrl;
+ if (modeCfg.highlightFormatting) state.formatting = "link";
+ var returnType = getType(state);
+ state.linkText = false;
+ return returnType;
+ }
+
+ stream.match(/^[^\]]+/, true);
+
+ return linktext;
+ }
+
+ function footnoteUrl(stream, state) {
+ // Check if space, and return NULL if so (to avoid marking the space)
+ if(stream.eatSpace()){
+ return null;
+ }
+ // Match URL
+ stream.match(/^[^\s]+/, true);
+ // Check for link title
+ if (stream.peek() === undefined) { // End of line, set flag to check next line
+ state.linkTitle = true;
+ } else { // More content on line, check if link title
+ stream.match(/^(?:\s+(?:"(?:[^"\\]|\\\\|\\.)+"|'(?:[^'\\]|\\\\|\\.)+'|\((?:[^)\\]|\\\\|\\.)+\)))?/, true);
+ }
+ state.f = state.inline = inlineNormal;
+ return linkhref;
+ }
+
+ var savedInlineRE = [];
+ function inlineRE(endChar) {
+ if (!savedInlineRE[endChar]) {
+ // Escape endChar for RegExp (taken from http://stackoverflow.com/a/494122/526741)
+ endChar = (endChar+'').replace(/([.?*+^$[\]\\(){}|-])/g, "\\$1");
+ // Match any non-endChar, escaped character, as well as the closing
+ // endChar.
+ savedInlineRE[endChar] = new RegExp('^(?:[^\\\\]|\\\\.)*?(' + endChar + ')');
+ }
+ return savedInlineRE[endChar];
+ }
+
+ var mode = {
+ startState: function() {
+ return {
+ f: blockNormal,
+
+ prevLineHasContent: false,
+ thisLineHasContent: false,
+
+ block: blockNormal,
+ htmlState: null,
+ indentation: 0,
+
+ inline: inlineNormal,
+ text: handleText,
+
+ formatting: false,
+ linkText: false,
+ linkHref: false,
+ linkTitle: false,
+ em: false,
+ strong: false,
+ header: 0,
+ taskList: false,
+ list: false,
+ listDepth: 0,
+ quote: 0,
+ trailingSpace: 0,
+ trailingSpaceNewLine: false,
+ strikethrough: false
+ };
+ },
+
+ copyState: function(s) {
+ return {
+ f: s.f,
+
+ prevLineHasContent: s.prevLineHasContent,
+ thisLineHasContent: s.thisLineHasContent,
+
+ block: s.block,
+ htmlState: s.htmlState && CodeMirror.copyState(htmlMode, s.htmlState),
+ indentation: s.indentation,
+
+ localMode: s.localMode,
+ localState: s.localMode ? CodeMirror.copyState(s.localMode, s.localState) : null,
+
+ inline: s.inline,
+ text: s.text,
+ formatting: false,
+ linkTitle: s.linkTitle,
+ em: s.em,
+ strong: s.strong,
+ strikethrough: s.strikethrough,
+ header: s.header,
+ taskList: s.taskList,
+ list: s.list,
+ listDepth: s.listDepth,
+ quote: s.quote,
+ trailingSpace: s.trailingSpace,
+ trailingSpaceNewLine: s.trailingSpaceNewLine,
+ md_inside: s.md_inside
+ };
+ },
+
+ token: function(stream, state) {
+
+ // Reset state.formatting
+ state.formatting = false;
+
+ if (stream.sol()) {
+ var forceBlankLine = !!state.header;
+
+ // Reset state.header
+ state.header = 0;
+
+ if (stream.match(/^\s*$/, true) || forceBlankLine) {
+ state.prevLineHasContent = false;
+ blankLine(state);
+ return forceBlankLine ? this.token(stream, state) : null;
+ } else {
+ state.prevLineHasContent = state.thisLineHasContent;
+ state.thisLineHasContent = true;
+ }
+
+ // Reset state.taskList
+ state.taskList = false;
+
+ // Reset state.code
+ state.code = false;
+
+ // Reset state.trailingSpace
+ state.trailingSpace = 0;
+ state.trailingSpaceNewLine = false;
+
+ state.f = state.block;
+ var indentation = stream.match(/^\s*/, true)[0].replace(/\t/g, ' ').length;
+ var difference = Math.floor((indentation - state.indentation) / 4) * 4;
+ if (difference > 4) difference = 4;
+ var adjustedIndentation = state.indentation + difference;
+ state.indentationDiff = adjustedIndentation - state.indentation;
+ state.indentation = adjustedIndentation;
+ if (indentation > 0) return null;
+ }
+ return state.f(stream, state);
+ },
+
+ innerMode: function(state) {
+ if (state.block == htmlBlock) return {state: state.htmlState, mode: htmlMode};
+ if (state.localState) return {state: state.localState, mode: state.localMode};
+ return {state: state, mode: mode};
+ },
+
+ blankLine: blankLine,
+
+ getType: getType,
+
+ fold: "markdown"
+ };
+ return mode;
+}, "xml");
+
+CodeMirror.defineMIME("text/x-markdown", "markdown");
+
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/markdown/test.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/markdown/test.js
new file mode 100644
index 0000000..96ca1ae
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/markdown/test.js
@@ -0,0 +1,754 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function() {
+ var mode = CodeMirror.getMode({tabSize: 4}, "markdown");
+ function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arguments, 1)); }
+ var modeHighlightFormatting = CodeMirror.getMode({tabSize: 4}, {name: "markdown", highlightFormatting: true});
+ function FT(name) { test.mode(name, modeHighlightFormatting, Array.prototype.slice.call(arguments, 1)); }
+
+ FT("formatting_emAsterisk",
+ "[em&formatting&formatting-em *][em foo][em&formatting&formatting-em *]");
+
+ FT("formatting_emUnderscore",
+ "[em&formatting&formatting-em _][em foo][em&formatting&formatting-em _]");
+
+ FT("formatting_strongAsterisk",
+ "[strong&formatting&formatting-strong **][strong foo][strong&formatting&formatting-strong **]");
+
+ FT("formatting_strongUnderscore",
+ "[strong&formatting&formatting-strong __][strong foo][strong&formatting&formatting-strong __]");
+
+ FT("formatting_codeBackticks",
+ "[comment&formatting&formatting-code `][comment foo][comment&formatting&formatting-code `]");
+
+ FT("formatting_doubleBackticks",
+ "[comment&formatting&formatting-code ``][comment foo ` bar][comment&formatting&formatting-code ``]");
+
+ FT("formatting_atxHeader",
+ "[header&header-1&formatting&formatting-header&formatting-header-1 #][header&header-1 foo # bar ][header&header-1&formatting&formatting-header&formatting-header-1 #]");
+
+ FT("formatting_setextHeader",
+ "foo",
+ "[header&header-1&formatting&formatting-header&formatting-header-1 =]");
+
+ FT("formatting_blockquote",
+ "[quote"e-1&formatting&formatting-quote&formatting-quote-1 > ][quote"e-1 foo]");
+
+ FT("formatting_list",
+ "[variable-2&formatting&formatting-list&formatting-list-ul - ][variable-2 foo]");
+ FT("formatting_list",
+ "[variable-2&formatting&formatting-list&formatting-list-ol 1. ][variable-2 foo]");
+
+ FT("formatting_link",
+ "[link&formatting&formatting-link [][link foo][link&formatting&formatting-link ]]][string&formatting&formatting-link-string (][string http://example.com/][string&formatting&formatting-link-string )]");
+
+ FT("formatting_linkReference",
+ "[link&formatting&formatting-link [][link foo][link&formatting&formatting-link ]]][string&formatting&formatting-link-string [][string bar][string&formatting&formatting-link-string ]]]",
+ "[link&formatting&formatting-link [][link bar][link&formatting&formatting-link ]]:] [string http://example.com/]");
+
+ FT("formatting_linkWeb",
+ "[link&formatting&formatting-link <][link http://example.com/][link&formatting&formatting-link >]");
+
+ FT("formatting_linkEmail",
+ "[link&formatting&formatting-link <][link user@example.com][link&formatting&formatting-link >]");
+
+ FT("formatting_escape",
+ "[formatting-escape \\*]");
+
+ MT("plainText",
+ "foo");
+
+ // Don't style single trailing space
+ MT("trailingSpace1",
+ "foo ");
+
+ // Two or more trailing spaces should be styled with line break character
+ MT("trailingSpace2",
+ "foo[trailing-space-a ][trailing-space-new-line ]");
+
+ MT("trailingSpace3",
+ "foo[trailing-space-a ][trailing-space-b ][trailing-space-new-line ]");
+
+ MT("trailingSpace4",
+ "foo[trailing-space-a ][trailing-space-b ][trailing-space-a ][trailing-space-new-line ]");
+
+ // Code blocks using 4 spaces (regardless of CodeMirror.tabSize value)
+ MT("codeBlocksUsing4Spaces",
+ " [comment foo]");
+
+ // Code blocks using 4 spaces with internal indentation
+ MT("codeBlocksUsing4SpacesIndentation",
+ " [comment bar]",
+ " [comment hello]",
+ " [comment world]",
+ " [comment foo]",
+ "bar");
+
+ // Code blocks using 4 spaces with internal indentation
+ MT("codeBlocksUsing4SpacesIndentation",
+ " foo",
+ " [comment bar]",
+ " [comment hello]",
+ " [comment world]");
+
+ // Code blocks should end even after extra indented lines
+ MT("codeBlocksWithTrailingIndentedLine",
+ " [comment foo]",
+ " [comment bar]",
+ " [comment baz]",
+ " ",
+ "hello");
+
+ // Code blocks using 1 tab (regardless of CodeMirror.indentWithTabs value)
+ MT("codeBlocksUsing1Tab",
+ "\t[comment foo]");
+
+ // Inline code using backticks
+ MT("inlineCodeUsingBackticks",
+ "foo [comment `bar`]");
+
+ // Block code using single backtick (shouldn't work)
+ MT("blockCodeSingleBacktick",
+ "[comment `]",
+ "foo",
+ "[comment `]");
+
+ // Unclosed backticks
+ // Instead of simply marking as CODE, it would be nice to have an
+ // incomplete flag for CODE, that is styled slightly different.
+ MT("unclosedBackticks",
+ "foo [comment `bar]");
+
+ // Per documentation: "To include a literal backtick character within a
+ // code span, you can use multiple backticks as the opening and closing
+ // delimiters"
+ MT("doubleBackticks",
+ "[comment ``foo ` bar``]");
+
+ // Tests based on Dingus
+ // http://daringfireball.net/projects/markdown/dingus
+ //
+ // Multiple backticks within an inline code block
+ MT("consecutiveBackticks",
+ "[comment `foo```bar`]");
+
+ // Multiple backticks within an inline code block with a second code block
+ MT("consecutiveBackticks",
+ "[comment `foo```bar`] hello [comment `world`]");
+
+ // Unclosed with several different groups of backticks
+ MT("unclosedBackticks",
+ "[comment ``foo ``` bar` hello]");
+
+ // Closed with several different groups of backticks
+ MT("closedBackticks",
+ "[comment ``foo ``` bar` hello``] world");
+
+ // atx headers
+ // http://daringfireball.net/projects/markdown/syntax#header
+
+ MT("atxH1",
+ "[header&header-1 # foo]");
+
+ MT("atxH2",
+ "[header&header-2 ## foo]");
+
+ MT("atxH3",
+ "[header&header-3 ### foo]");
+
+ MT("atxH4",
+ "[header&header-4 #### foo]");
+
+ MT("atxH5",
+ "[header&header-5 ##### foo]");
+
+ MT("atxH6",
+ "[header&header-6 ###### foo]");
+
+ // H6 - 7x '#' should still be H6, per Dingus
+ // http://daringfireball.net/projects/markdown/dingus
+ MT("atxH6NotH7",
+ "[header&header-6 ####### foo]");
+
+ // Inline styles should be parsed inside headers
+ MT("atxH1inline",
+ "[header&header-1 # foo ][header&header-1&em *bar*]");
+
+ // Setext headers - H1, H2
+ // Per documentation, "Any number of underlining =’s or -’s will work."
+ // http://daringfireball.net/projects/markdown/syntax#header
+ // Ideally, the text would be marked as `header` as well, but this is
+ // not really feasible at the moment. So, instead, we're testing against
+ // what works today, to avoid any regressions.
+ //
+ // Check if single underlining = works
+ MT("setextH1",
+ "foo",
+ "[header&header-1 =]");
+
+ // Check if 3+ ='s work
+ MT("setextH1",
+ "foo",
+ "[header&header-1 ===]");
+
+ // Check if single underlining - works
+ MT("setextH2",
+ "foo",
+ "[header&header-2 -]");
+
+ // Check if 3+ -'s work
+ MT("setextH2",
+ "foo",
+ "[header&header-2 ---]");
+
+ // Single-line blockquote with trailing space
+ MT("blockquoteSpace",
+ "[quote"e-1 > foo]");
+
+ // Single-line blockquote
+ MT("blockquoteNoSpace",
+ "[quote"e-1 >foo]");
+
+ // No blank line before blockquote
+ MT("blockquoteNoBlankLine",
+ "foo",
+ "[quote"e-1 > bar]");
+
+ // Nested blockquote
+ MT("blockquoteSpace",
+ "[quote"e-1 > foo]",
+ "[quote"e-1 >][quote"e-2 > foo]",
+ "[quote"e-1 >][quote"e-2 >][quote"e-3 > foo]");
+
+ // Single-line blockquote followed by normal paragraph
+ MT("blockquoteThenParagraph",
+ "[quote"e-1 >foo]",
+ "",
+ "bar");
+
+ // Multi-line blockquote (lazy mode)
+ MT("multiBlockquoteLazy",
+ "[quote"e-1 >foo]",
+ "[quote"e-1 bar]");
+
+ // Multi-line blockquote followed by normal paragraph (lazy mode)
+ MT("multiBlockquoteLazyThenParagraph",
+ "[quote"e-1 >foo]",
+ "[quote"e-1 bar]",
+ "",
+ "hello");
+
+ // Multi-line blockquote (non-lazy mode)
+ MT("multiBlockquote",
+ "[quote"e-1 >foo]",
+ "[quote"e-1 >bar]");
+
+ // Multi-line blockquote followed by normal paragraph (non-lazy mode)
+ MT("multiBlockquoteThenParagraph",
+ "[quote"e-1 >foo]",
+ "[quote"e-1 >bar]",
+ "",
+ "hello");
+
+ // Check list types
+
+ MT("listAsterisk",
+ "foo",
+ "bar",
+ "",
+ "[variable-2 * foo]",
+ "[variable-2 * bar]");
+
+ MT("listPlus",
+ "foo",
+ "bar",
+ "",
+ "[variable-2 + foo]",
+ "[variable-2 + bar]");
+
+ MT("listDash",
+ "foo",
+ "bar",
+ "",
+ "[variable-2 - foo]",
+ "[variable-2 - bar]");
+
+ MT("listNumber",
+ "foo",
+ "bar",
+ "",
+ "[variable-2 1. foo]",
+ "[variable-2 2. bar]");
+
+ // Lists require a preceding blank line (per Dingus)
+ MT("listBogus",
+ "foo",
+ "1. bar",
+ "2. hello");
+
+ // List after header
+ MT("listAfterHeader",
+ "[header&header-1 # foo]",
+ "[variable-2 - bar]");
+
+ // Formatting in lists (*)
+ MT("listAsteriskFormatting",
+ "[variable-2 * ][variable-2&em *foo*][variable-2 bar]",
+ "[variable-2 * ][variable-2&strong **foo**][variable-2 bar]",
+ "[variable-2 * ][variable-2&strong **][variable-2&em&strong *foo**][variable-2&em *][variable-2 bar]",
+ "[variable-2 * ][variable-2&comment `foo`][variable-2 bar]");
+
+ // Formatting in lists (+)
+ MT("listPlusFormatting",
+ "[variable-2 + ][variable-2&em *foo*][variable-2 bar]",
+ "[variable-2 + ][variable-2&strong **foo**][variable-2 bar]",
+ "[variable-2 + ][variable-2&strong **][variable-2&em&strong *foo**][variable-2&em *][variable-2 bar]",
+ "[variable-2 + ][variable-2&comment `foo`][variable-2 bar]");
+
+ // Formatting in lists (-)
+ MT("listDashFormatting",
+ "[variable-2 - ][variable-2&em *foo*][variable-2 bar]",
+ "[variable-2 - ][variable-2&strong **foo**][variable-2 bar]",
+ "[variable-2 - ][variable-2&strong **][variable-2&em&strong *foo**][variable-2&em *][variable-2 bar]",
+ "[variable-2 - ][variable-2&comment `foo`][variable-2 bar]");
+
+ // Formatting in lists (1.)
+ MT("listNumberFormatting",
+ "[variable-2 1. ][variable-2&em *foo*][variable-2 bar]",
+ "[variable-2 2. ][variable-2&strong **foo**][variable-2 bar]",
+ "[variable-2 3. ][variable-2&strong **][variable-2&em&strong *foo**][variable-2&em *][variable-2 bar]",
+ "[variable-2 4. ][variable-2&comment `foo`][variable-2 bar]");
+
+ // Paragraph lists
+ MT("listParagraph",
+ "[variable-2 * foo]",
+ "",
+ "[variable-2 * bar]");
+
+ // Multi-paragraph lists
+ //
+ // 4 spaces
+ MT("listMultiParagraph",
+ "[variable-2 * foo]",
+ "",
+ "[variable-2 * bar]",
+ "",
+ " [variable-2 hello]");
+
+ // 4 spaces, extra blank lines (should still be list, per Dingus)
+ MT("listMultiParagraphExtra",
+ "[variable-2 * foo]",
+ "",
+ "[variable-2 * bar]",
+ "",
+ "",
+ " [variable-2 hello]");
+
+ // 4 spaces, plus 1 space (should still be list, per Dingus)
+ MT("listMultiParagraphExtraSpace",
+ "[variable-2 * foo]",
+ "",
+ "[variable-2 * bar]",
+ "",
+ " [variable-2 hello]",
+ "",
+ " [variable-2 world]");
+
+ // 1 tab
+ MT("listTab",
+ "[variable-2 * foo]",
+ "",
+ "[variable-2 * bar]",
+ "",
+ "\t[variable-2 hello]");
+
+ // No indent
+ MT("listNoIndent",
+ "[variable-2 * foo]",
+ "",
+ "[variable-2 * bar]",
+ "",
+ "hello");
+
+ // Blockquote
+ MT("blockquote",
+ "[variable-2 * foo]",
+ "",
+ "[variable-2 * bar]",
+ "",
+ " [variable-2"e"e-1 > hello]");
+
+ // Code block
+ MT("blockquoteCode",
+ "[variable-2 * foo]",
+ "",
+ "[variable-2 * bar]",
+ "",
+ " [comment > hello]",
+ "",
+ " [variable-2 world]");
+
+ // Code block followed by text
+ MT("blockquoteCodeText",
+ "[variable-2 * foo]",
+ "",
+ " [variable-2 bar]",
+ "",
+ " [comment hello]",
+ "",
+ " [variable-2 world]");
+
+ // Nested list
+
+ MT("listAsteriskNested",
+ "[variable-2 * foo]",
+ "",
+ " [variable-3 * bar]");
+
+ MT("listPlusNested",
+ "[variable-2 + foo]",
+ "",
+ " [variable-3 + bar]");
+
+ MT("listDashNested",
+ "[variable-2 - foo]",
+ "",
+ " [variable-3 - bar]");
+
+ MT("listNumberNested",
+ "[variable-2 1. foo]",
+ "",
+ " [variable-3 2. bar]");
+
+ MT("listMixed",
+ "[variable-2 * foo]",
+ "",
+ " [variable-3 + bar]",
+ "",
+ " [keyword - hello]",
+ "",
+ " [variable-2 1. world]");
+
+ MT("listBlockquote",
+ "[variable-2 * foo]",
+ "",
+ " [variable-3 + bar]",
+ "",
+ " [quote"e-1&variable-3 > hello]");
+
+ MT("listCode",
+ "[variable-2 * foo]",
+ "",
+ " [variable-3 + bar]",
+ "",
+ " [comment hello]");
+
+ // Code with internal indentation
+ MT("listCodeIndentation",
+ "[variable-2 * foo]",
+ "",
+ " [comment bar]",
+ " [comment hello]",
+ " [comment world]",
+ " [comment foo]",
+ " [variable-2 bar]");
+
+ // List nesting edge cases
+ MT("listNested",
+ "[variable-2 * foo]",
+ "",
+ " [variable-3 * bar]",
+ "",
+ " [variable-2 hello]"
+ );
+ MT("listNested",
+ "[variable-2 * foo]",
+ "",
+ " [variable-3 * bar]",
+ "",
+ " [variable-3 * foo]"
+ );
+
+ // Code followed by text
+ MT("listCodeText",
+ "[variable-2 * foo]",
+ "",
+ " [comment bar]",
+ "",
+ "hello");
+
+ // Following tests directly from official Markdown documentation
+ // http://daringfireball.net/projects/markdown/syntax#hr
+
+ MT("hrSpace",
+ "[hr * * *]");
+
+ MT("hr",
+ "[hr ***]");
+
+ MT("hrLong",
+ "[hr *****]");
+
+ MT("hrSpaceDash",
+ "[hr - - -]");
+
+ MT("hrDashLong",
+ "[hr ---------------------------------------]");
+
+ // Inline link with title
+ MT("linkTitle",
+ "[link [[foo]]][string (http://example.com/ \"bar\")] hello");
+
+ // Inline link without title
+ MT("linkNoTitle",
+ "[link [[foo]]][string (http://example.com/)] bar");
+
+ // Inline link with image
+ MT("linkImage",
+ "[link [[][tag ![[foo]]][string (http://example.com/)][link ]]][string (http://example.com/)] bar");
+
+ // Inline link with Em
+ MT("linkEm",
+ "[link [[][link&em *foo*][link ]]][string (http://example.com/)] bar");
+
+ // Inline link with Strong
+ MT("linkStrong",
+ "[link [[][link&strong **foo**][link ]]][string (http://example.com/)] bar");
+
+ // Inline link with EmStrong
+ MT("linkEmStrong",
+ "[link [[][link&strong **][link&em&strong *foo**][link&em *][link ]]][string (http://example.com/)] bar");
+
+ // Image with title
+ MT("imageTitle",
+ "[tag ![[foo]]][string (http://example.com/ \"bar\")] hello");
+
+ // Image without title
+ MT("imageNoTitle",
+ "[tag ![[foo]]][string (http://example.com/)] bar");
+
+ // Image with asterisks
+ MT("imageAsterisks",
+ "[tag ![[*foo*]]][string (http://example.com/)] bar");
+
+ // Not a link. Should be normal text due to square brackets being used
+ // regularly in text, especially in quoted material, and no space is allowed
+ // between square brackets and parentheses (per Dingus).
+ MT("notALink",
+ "[[foo]] (bar)");
+
+ // Reference-style links
+ MT("linkReference",
+ "[link [[foo]]][string [[bar]]] hello");
+
+ // Reference-style links with Em
+ MT("linkReferenceEm",
+ "[link [[][link&em *foo*][link ]]][string [[bar]]] hello");
+
+ // Reference-style links with Strong
+ MT("linkReferenceStrong",
+ "[link [[][link&strong **foo**][link ]]][string [[bar]]] hello");
+
+ // Reference-style links with EmStrong
+ MT("linkReferenceEmStrong",
+ "[link [[][link&strong **][link&em&strong *foo**][link&em *][link ]]][string [[bar]]] hello");
+
+ // Reference-style links with optional space separator (per docuentation)
+ // "You can optionally use a space to separate the sets of brackets"
+ MT("linkReferenceSpace",
+ "[link [[foo]]] [string [[bar]]] hello");
+
+ // Should only allow a single space ("...use *a* space...")
+ MT("linkReferenceDoubleSpace",
+ "[[foo]] [[bar]] hello");
+
+ // Reference-style links with implicit link name
+ MT("linkImplicit",
+ "[link [[foo]]][string [[]]] hello");
+
+ // @todo It would be nice if, at some point, the document was actually
+ // checked to see if the referenced link exists
+
+ // Link label, for reference-style links (taken from documentation)
+
+ MT("labelNoTitle",
+ "[link [[foo]]:] [string http://example.com/]");
+
+ MT("labelIndented",
+ " [link [[foo]]:] [string http://example.com/]");
+
+ MT("labelSpaceTitle",
+ "[link [[foo bar]]:] [string http://example.com/ \"hello\"]");
+
+ MT("labelDoubleTitle",
+ "[link [[foo bar]]:] [string http://example.com/ \"hello\"] \"world\"");
+
+ MT("labelTitleDoubleQuotes",
+ "[link [[foo]]:] [string http://example.com/ \"bar\"]");
+
+ MT("labelTitleSingleQuotes",
+ "[link [[foo]]:] [string http://example.com/ 'bar']");
+
+ MT("labelTitleParenthese",
+ "[link [[foo]]:] [string http://example.com/ (bar)]");
+
+ MT("labelTitleInvalid",
+ "[link [[foo]]:] [string http://example.com/] bar");
+
+ MT("labelLinkAngleBrackets",
+ "[link [[foo]]:] [string \"bar\"]");
+
+ MT("labelTitleNextDoubleQuotes",
+ "[link [[foo]]:] [string http://example.com/]",
+ "[string \"bar\"] hello");
+
+ MT("labelTitleNextSingleQuotes",
+ "[link [[foo]]:] [string http://example.com/]",
+ "[string 'bar'] hello");
+
+ MT("labelTitleNextParenthese",
+ "[link [[foo]]:] [string http://example.com/]",
+ "[string (bar)] hello");
+
+ MT("labelTitleNextMixed",
+ "[link [[foo]]:] [string http://example.com/]",
+ "(bar\" hello");
+
+ MT("linkWeb",
+ "[link ] foo");
+
+ MT("linkWebDouble",
+ "[link ] foo [link ]");
+
+ MT("linkEmail",
+ "[link ] foo");
+
+ MT("linkEmailDouble",
+ "[link ] foo [link ]");
+
+ MT("emAsterisk",
+ "[em *foo*] bar");
+
+ MT("emUnderscore",
+ "[em _foo_] bar");
+
+ MT("emInWordAsterisk",
+ "foo[em *bar*]hello");
+
+ MT("emInWordUnderscore",
+ "foo[em _bar_]hello");
+
+ // Per documentation: "...surround an * or _ with spaces, it’ll be
+ // treated as a literal asterisk or underscore."
+
+ MT("emEscapedBySpaceIn",
+ "foo [em _bar _ hello_] world");
+
+ MT("emEscapedBySpaceOut",
+ "foo _ bar[em _hello_]world");
+
+ MT("emEscapedByNewline",
+ "foo",
+ "_ bar[em _hello_]world");
+
+ // Unclosed emphasis characters
+ // Instead of simply marking as EM / STRONG, it would be nice to have an
+ // incomplete flag for EM and STRONG, that is styled slightly different.
+ MT("emIncompleteAsterisk",
+ "foo [em *bar]");
+
+ MT("emIncompleteUnderscore",
+ "foo [em _bar]");
+
+ MT("strongAsterisk",
+ "[strong **foo**] bar");
+
+ MT("strongUnderscore",
+ "[strong __foo__] bar");
+
+ MT("emStrongAsterisk",
+ "[em *foo][em&strong **bar*][strong hello**] world");
+
+ MT("emStrongUnderscore",
+ "[em _foo][em&strong __bar_][strong hello__] world");
+
+ // "...same character must be used to open and close an emphasis span.""
+ MT("emStrongMixed",
+ "[em _foo][em&strong **bar*hello__ world]");
+
+ MT("emStrongMixed",
+ "[em *foo][em&strong __bar_hello** world]");
+
+ // These characters should be escaped:
+ // \ backslash
+ // ` backtick
+ // * asterisk
+ // _ underscore
+ // {} curly braces
+ // [] square brackets
+ // () parentheses
+ // # hash mark
+ // + plus sign
+ // - minus sign (hyphen)
+ // . dot
+ // ! exclamation mark
+
+ MT("escapeBacktick",
+ "foo \\`bar\\`");
+
+ MT("doubleEscapeBacktick",
+ "foo \\\\[comment `bar\\\\`]");
+
+ MT("escapeAsterisk",
+ "foo \\*bar\\*");
+
+ MT("doubleEscapeAsterisk",
+ "foo \\\\[em *bar\\\\*]");
+
+ MT("escapeUnderscore",
+ "foo \\_bar\\_");
+
+ MT("doubleEscapeUnderscore",
+ "foo \\\\[em _bar\\\\_]");
+
+ MT("escapeHash",
+ "\\# foo");
+
+ MT("doubleEscapeHash",
+ "\\\\# foo");
+
+ MT("escapeNewline",
+ "\\",
+ "[em *foo*]");
+
+
+ // Tests to make sure GFM-specific things aren't getting through
+
+ MT("taskList",
+ "[variable-2 * [ ]] bar]");
+
+ MT("fencedCodeBlocks",
+ "[comment ```]",
+ "foo",
+ "[comment ```]");
+
+ // Tests that require XML mode
+
+ MT("xmlMode",
+ "[tag&bracket <][tag div][tag&bracket >]",
+ "*foo*",
+ "[tag&bracket <][tag http://github.com][tag&bracket />]",
+ "[tag&bracket ]",
+ "[link ]");
+
+ MT("xmlModeWithMarkdownInside",
+ "[tag&bracket <][tag div] [attribute markdown]=[string 1][tag&bracket >]",
+ "[em *foo*]",
+ "[link ]",
+ "[tag ]",
+ "[link ]",
+ "[tag&bracket <][tag div][tag&bracket >]",
+ "[tag&bracket ]");
+
+})();
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/meta.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/meta.js
new file mode 100644
index 0000000..e110288
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/meta.js
@@ -0,0 +1,177 @@
+// 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.modeInfo = [
+ {name: "APL", mime: "text/apl", mode: "apl", ext: ["dyalog", "apl"]},
+ {name: "Asterisk", mime: "text/x-asterisk", mode: "asterisk", file: /^extensions\.conf$/i},
+ {name: "C", mime: "text/x-csrc", mode: "clike", ext: ["c", "h"]},
+ {name: "C++", mime: "text/x-c++src", mode: "clike", ext: ["cpp", "c++", "cc", "cxx", "hpp", "h++", "hh", "hxx"], alias: ["cpp"]},
+ {name: "Cobol", mime: "text/x-cobol", mode: "cobol", ext: ["cob", "cpy"]},
+ {name: "C#", mime: "text/x-csharp", mode: "clike", ext: ["cs"], alias: ["csharp"]},
+ {name: "Clojure", mime: "text/x-clojure", mode: "clojure", ext: ["clj"]},
+ {name: "CoffeeScript", mime: "text/x-coffeescript", mode: "coffeescript", ext: ["coffee"], alias: ["coffee", "coffee-script"]},
+ {name: "Common Lisp", mime: "text/x-common-lisp", mode: "commonlisp", ext: ["cl", "lisp", "el"], alias: ["lisp"]},
+ {name: "Cypher", mime: "application/x-cypher-query", mode: "cypher", ext: ["cyp", "cypher"]},
+ {name: "Cython", mime: "text/x-cython", mode: "python", ext: ["pyx", "pxd", "pxi"]},
+ {name: "CSS", mime: "text/css", mode: "css", ext: ["css"]},
+ {name: "CQL", mime: "text/x-cassandra", mode: "sql", ext: ["cql"]},
+ {name: "D", mime: "text/x-d", mode: "d", ext: ["d"]},
+ {name: "Dart", mimes: ["application/dart", "text/x-dart"], mode: "dart", ext: ["dart"]},
+ {name: "diff", mime: "text/x-diff", mode: "diff", ext: ["diff", "patch"]},
+ {name: "Django", mime: "text/x-django", mode: "django"},
+ {name: "Dockerfile", mime: "text/x-dockerfile", mode: "dockerfile", file: /^Dockerfile$/},
+ {name: "DTD", mime: "application/xml-dtd", mode: "dtd", ext: ["dtd"]},
+ {name: "Dylan", mime: "text/x-dylan", mode: "dylan", ext: ["dylan", "dyl", "intr"]},
+ {name: "EBNF", mime: "text/x-ebnf", mode: "ebnf"},
+ {name: "ECL", mime: "text/x-ecl", mode: "ecl", ext: ["ecl"]},
+ {name: "Eiffel", mime: "text/x-eiffel", mode: "eiffel", ext: ["e"]},
+ {name: "Embedded Javascript", mime: "application/x-ejs", mode: "htmlembedded", ext: ["ejs"]},
+ {name: "Embedded Ruby", mime: "application/x-erb", mode: "htmlembedded", ext: ["erb"]},
+ {name: "Erlang", mime: "text/x-erlang", mode: "erlang", ext: ["erl"]},
+ {name: "Forth", mime: "text/x-forth", mode: "forth", ext: ["forth", "fth", "4th"]},
+ {name: "Fortran", mime: "text/x-fortran", mode: "fortran", ext: ["f", "for", "f77", "f90"]},
+ {name: "F#", mime: "text/x-fsharp", mode: "mllike", ext: ["fs"], alias: ["fsharp"]},
+ {name: "Gas", mime: "text/x-gas", mode: "gas", ext: ["s"]},
+ {name: "Gherkin", mime: "text/x-feature", mode: "gherkin", ext: ["feature"]},
+ {name: "GitHub Flavored Markdown", mime: "text/x-gfm", mode: "gfm", file: /^(readme|contributing|history).md$/i},
+ {name: "Go", mime: "text/x-go", mode: "go", ext: ["go"]},
+ {name: "Groovy", mime: "text/x-groovy", mode: "groovy", ext: ["groovy"]},
+ {name: "HAML", mime: "text/x-haml", mode: "haml", ext: ["haml"]},
+ {name: "Haskell", mime: "text/x-haskell", mode: "haskell", ext: ["hs"]},
+ {name: "Haxe", mime: "text/x-haxe", mode: "haxe", ext: ["hx"]},
+ {name: "HXML", mime: "text/x-hxml", mode: "haxe", ext: ["hxml"]},
+ {name: "ASP.NET", mime: "application/x-aspx", mode: "htmlembedded", ext: ["aspx"], alias: ["asp", "aspx"]},
+ {name: "HTML", mime: "text/html", mode: "htmlmixed", ext: ["html", "htm"], alias: ["xhtml"]},
+ {name: "HTTP", mime: "message/http", mode: "http"},
+ {name: "IDL", mime: "text/x-idl", mode: "idl", ext: ["pro"]},
+ {name: "Jade", mime: "text/x-jade", mode: "jade", ext: ["jade"]},
+ {name: "Java", mime: "text/x-java", mode: "clike", ext: ["java"]},
+ {name: "Java Server Pages", mime: "application/x-jsp", mode: "htmlembedded", ext: ["jsp"], alias: ["jsp"]},
+ {name: "JavaScript", mimes: ["text/javascript", "text/ecmascript", "application/javascript", "application/x-javascript", "application/ecmascript"],
+ mode: "javascript", ext: ["js"], alias: ["ecmascript", "js", "node"]},
+ {name: "JSON", mimes: ["application/json", "application/x-json"], mode: "javascript", ext: ["json", "map"], alias: ["json5"]},
+ {name: "JSON-LD", mime: "application/ld+json", mode: "javascript", ext: ["jsonld"], alias: ["jsonld"]},
+ {name: "Jinja2", mime: "null", mode: "jinja2"},
+ {name: "Julia", mime: "text/x-julia", mode: "julia", ext: ["jl"]},
+ {name: "Kotlin", mime: "text/x-kotlin", mode: "kotlin", ext: ["kt"]},
+ {name: "LESS", mime: "text/x-less", mode: "css", ext: ["less"]},
+ {name: "LiveScript", mime: "text/x-livescript", mode: "livescript", ext: ["ls"], alias: ["ls"]},
+ {name: "Lua", mime: "text/x-lua", mode: "lua", ext: ["lua"]},
+ {name: "Markdown", mime: "text/x-markdown", mode: "markdown", ext: ["markdown", "md", "mkd"]},
+ {name: "mIRC", mime: "text/mirc", mode: "mirc"},
+ {name: "MariaDB SQL", mime: "text/x-mariadb", mode: "sql"},
+ {name: "Modelica", mime: "text/x-modelica", mode: "modelica", ext: ["mo"]},
+ {name: "MS SQL", mime: "text/x-mssql", mode: "sql"},
+ {name: "MySQL", mime: "text/x-mysql", mode: "sql"},
+ {name: "Nginx", mime: "text/x-nginx-conf", mode: "nginx", file: /nginx.*\.conf$/i},
+ {name: "NTriples", mime: "text/n-triples", mode: "ntriples", ext: ["nt"]},
+ {name: "Objective C", mime: "text/x-objectivec", mode: "clike", ext: ["m", "mm"]},
+ {name: "OCaml", mime: "text/x-ocaml", mode: "mllike", ext: ["ml", "mli", "mll", "mly"]},
+ {name: "Octave", mime: "text/x-octave", mode: "octave", ext: ["m"]},
+ {name: "Pascal", mime: "text/x-pascal", mode: "pascal", ext: ["p", "pas"]},
+ {name: "PEG.js", mime: "null", mode: "pegjs", ext: ["jsonld"]},
+ {name: "Perl", mime: "text/x-perl", mode: "perl", ext: ["pl", "pm"]},
+ {name: "PHP", mime: "application/x-httpd-php", mode: "php", ext: ["php", "php3", "php4", "php5", "phtml"]},
+ {name: "Pig", mime: "text/x-pig", mode: "pig", ext: ["pig"]},
+ {name: "Plain Text", mime: "text/plain", mode: "null", ext: ["txt", "text", "conf", "def", "list", "log"]},
+ {name: "PLSQL", mime: "text/x-plsql", mode: "sql", ext: ["pls"]},
+ {name: "Properties files", mime: "text/x-properties", mode: "properties", ext: ["properties", "ini", "in"], alias: ["ini", "properties"]},
+ {name: "Python", mime: "text/x-python", mode: "python", ext: ["py", "pyw"]},
+ {name: "Puppet", mime: "text/x-puppet", mode: "puppet", ext: ["pp"]},
+ {name: "Q", mime: "text/x-q", mode: "q", ext: ["q"]},
+ {name: "R", mime: "text/x-rsrc", mode: "r", ext: ["r"], alias: ["rscript"]},
+ {name: "reStructuredText", mime: "text/x-rst", mode: "rst", ext: ["rst"], alias: ["rst"]},
+ {name: "RPM Changes", mime: "text/x-rpm-changes", mode: "rpm"},
+ {name: "RPM Spec", mime: "text/x-rpm-spec", mode: "rpm", ext: ["spec"]},
+ {name: "Ruby", mime: "text/x-ruby", mode: "ruby", ext: ["rb"], alias: ["jruby", "macruby", "rake", "rb", "rbx"]},
+ {name: "Rust", mime: "text/x-rustsrc", mode: "rust", ext: ["rs"]},
+ {name: "Sass", mime: "text/x-sass", mode: "sass", ext: ["sass"]},
+ {name: "Scala", mime: "text/x-scala", mode: "clike", ext: ["scala"]},
+ {name: "Scheme", mime: "text/x-scheme", mode: "scheme", ext: ["scm", "ss"]},
+ {name: "SCSS", mime: "text/x-scss", mode: "css", ext: ["scss"]},
+ {name: "Shell", mime: "text/x-sh", mode: "shell", ext: ["sh", "ksh", "bash"], alias: ["bash", "sh", "zsh"]},
+ {name: "Sieve", mime: "application/sieve", mode: "sieve", ext: ["siv", "sieve"]},
+ {name: "Slim", mimes: ["text/x-slim", "application/x-slim"], mode: "slim", ext: ["slim"]},
+ {name: "Smalltalk", mime: "text/x-stsrc", mode: "smalltalk", ext: ["st"]},
+ {name: "Smarty", mime: "text/x-smarty", mode: "smarty", ext: ["tpl"]},
+ {name: "SmartyMixed", mime: "text/x-smarty", mode: "smartymixed"},
+ {name: "Solr", mime: "text/x-solr", mode: "solr"},
+ {name: "Soy", mime: "text/x-soy", mode: "soy", ext: ["soy"], alias: ["closure template"]},
+ {name: "SPARQL", mime: "application/sparql-query", mode: "sparql", ext: ["rq", "sparql"], alias: ["sparul"]},
+ {name: "Spreadsheet", mime: "text/x-spreadsheet", mode: "spreadsheet", alias: ["excel", "formula"]},
+ {name: "SQL", mime: "text/x-sql", mode: "sql", ext: ["sql"]},
+ {name: "MariaDB", mime: "text/x-mariadb", mode: "sql"},
+ {name: "sTeX", mime: "text/x-stex", mode: "stex"},
+ {name: "LaTeX", mime: "text/x-latex", mode: "stex", ext: ["text", "ltx"], alias: ["tex"]},
+ {name: "SystemVerilog", mime: "text/x-systemverilog", mode: "verilog", ext: ["v"]},
+ {name: "Tcl", mime: "text/x-tcl", mode: "tcl", ext: ["tcl"]},
+ {name: "Textile", mime: "text/x-textile", mode: "textile", ext: ["textile"]},
+ {name: "TiddlyWiki ", mime: "text/x-tiddlywiki", mode: "tiddlywiki"},
+ {name: "Tiki wiki", mime: "text/tiki", mode: "tiki"},
+ {name: "TOML", mime: "text/x-toml", mode: "toml", ext: ["toml"]},
+ {name: "Tornado", mime: "text/x-tornado", mode: "tornado"},
+ {name: "Turtle", mime: "text/turtle", mode: "turtle", ext: ["ttl"]},
+ {name: "TypeScript", mime: "application/typescript", mode: "javascript", ext: ["ts"], alias: ["ts"]},
+ {name: "VB.NET", mime: "text/x-vb", mode: "vb", ext: ["vb"]},
+ {name: "VBScript", mime: "text/vbscript", mode: "vbscript", ext: ["vbs"]},
+ {name: "Velocity", mime: "text/velocity", mode: "velocity", ext: ["vtl"]},
+ {name: "Verilog", mime: "text/x-verilog", mode: "verilog", ext: ["v"]},
+ {name: "XML", mimes: ["application/xml", "text/xml"], mode: "xml", ext: ["xml", "xsl", "xsd"], alias: ["rss", "wsdl", "xsd"]},
+ {name: "XQuery", mime: "application/xquery", mode: "xquery", ext: ["xy", "xquery"]},
+ {name: "YAML", mime: "text/x-yaml", mode: "yaml", ext: ["yaml"], alias: ["yml"]},
+ {name: "Z80", mime: "text/x-z80", mode: "z80", ext: ["z80"]}
+ ];
+ // Ensure all modes have a mime property for backwards compatibility
+ for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
+ var info = CodeMirror.modeInfo[i];
+ if (info.mimes) info.mime = info.mimes[0];
+ }
+
+ CodeMirror.findModeByMIME = function(mime) {
+ mime = mime.toLowerCase();
+ for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
+ var info = CodeMirror.modeInfo[i];
+ if (info.mime == mime) return info;
+ if (info.mimes) for (var j = 0; j < info.mimes.length; j++)
+ if (info.mimes[j] == mime) return info;
+ }
+ };
+
+ CodeMirror.findModeByExtension = function(ext) {
+ for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
+ var info = CodeMirror.modeInfo[i];
+ if (info.ext) for (var j = 0; j < info.ext.length; j++)
+ if (info.ext[j] == ext) return info;
+ }
+ };
+
+ CodeMirror.findModeByFileName = function(filename) {
+ for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
+ var info = CodeMirror.modeInfo[i];
+ if (info.file && info.file.test(filename)) return info;
+ }
+ var dot = filename.lastIndexOf(".");
+ var ext = dot > -1 && filename.substring(dot + 1, filename.length);
+ if (ext) return CodeMirror.findModeByExtension(ext);
+ };
+
+ CodeMirror.findModeByName = function(name) {
+ name = name.toLowerCase();
+ for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
+ var info = CodeMirror.modeInfo[i];
+ if (info.name.toLowerCase() == name) return info;
+ if (info.alias) for (var j = 0; j < info.alias.length; j++)
+ if (info.alias[j].toLowerCase() == name) return info;
+ }
+ };
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/mirc/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/mirc/index.html
new file mode 100644
index 0000000..fd2f34e
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/mirc/index.html
@@ -0,0 +1,160 @@
+
+
+CodeMirror: mIRC mode
+
+
+
+
+
+
+
+
+
+
+
+mIRC mode
+
+
+
+ MIME types defined: text/mirc.
+
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/mirc/mirc.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/mirc/mirc.js
new file mode 100644
index 0000000..f0d5c6a
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/mirc/mirc.js
@@ -0,0 +1,193 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+//mIRC mode by Ford_Lawnmower :: Based on Velocity mode by Steve O'Hara
+
+(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.defineMIME("text/mirc", "mirc");
+CodeMirror.defineMode("mirc", function() {
+ function parseWords(str) {
+ var obj = {}, words = str.split(" ");
+ for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+ return obj;
+ }
+ var specials = parseWords("$! $$ $& $? $+ $abook $abs $active $activecid " +
+ "$activewid $address $addtok $agent $agentname $agentstat $agentver " +
+ "$alias $and $anick $ansi2mirc $aop $appactive $appstate $asc $asctime " +
+ "$asin $atan $avoice $away $awaymsg $awaytime $banmask $base $bfind " +
+ "$binoff $biton $bnick $bvar $bytes $calc $cb $cd $ceil $chan $chanmodes " +
+ "$chantypes $chat $chr $cid $clevel $click $cmdbox $cmdline $cnick $color " +
+ "$com $comcall $comchan $comerr $compact $compress $comval $cos $count " +
+ "$cr $crc $creq $crlf $ctime $ctimer $ctrlenter $date $day $daylight " +
+ "$dbuh $dbuw $dccignore $dccport $dde $ddename $debug $decode $decompress " +
+ "$deltok $devent $dialog $did $didreg $didtok $didwm $disk $dlevel $dll " +
+ "$dllcall $dname $dns $duration $ebeeps $editbox $emailaddr $encode $error " +
+ "$eval $event $exist $feof $ferr $fgetc $file $filename $filtered $finddir " +
+ "$finddirn $findfile $findfilen $findtok $fline $floor $fopen $fread $fserve " +
+ "$fulladdress $fulldate $fullname $fullscreen $get $getdir $getdot $gettok $gmt " +
+ "$group $halted $hash $height $hfind $hget $highlight $hnick $hotline " +
+ "$hotlinepos $ial $ialchan $ibl $idle $iel $ifmatch $ignore $iif $iil " +
+ "$inelipse $ini $inmidi $inpaste $inpoly $input $inrect $inroundrect " +
+ "$insong $instok $int $inwave $ip $isalias $isbit $isdde $isdir $isfile " +
+ "$isid $islower $istok $isupper $keychar $keyrpt $keyval $knick $lactive " +
+ "$lactivecid $lactivewid $left $len $level $lf $line $lines $link $lock " +
+ "$lock $locked $log $logstamp $logstampfmt $longfn $longip $lower $ltimer " +
+ "$maddress $mask $matchkey $matchtok $md5 $me $menu $menubar $menucontext " +
+ "$menutype $mid $middir $mircdir $mircexe $mircini $mklogfn $mnick $mode " +
+ "$modefirst $modelast $modespl $mouse $msfile $network $newnick $nick $nofile " +
+ "$nopath $noqt $not $notags $notify $null $numeric $numok $oline $onpoly " +
+ "$opnick $or $ord $os $passivedcc $pic $play $pnick $port $portable $portfree " +
+ "$pos $prefix $prop $protect $puttok $qt $query $rand $r $rawmsg $read $readomo " +
+ "$readn $regex $regml $regsub $regsubex $remove $remtok $replace $replacex " +
+ "$reptok $result $rgb $right $round $scid $scon $script $scriptdir $scriptline " +
+ "$sdir $send $server $serverip $sfile $sha1 $shortfn $show $signal $sin " +
+ "$site $sline $snick $snicks $snotify $sock $sockbr $sockerr $sockname " +
+ "$sorttok $sound $sqrt $ssl $sreq $sslready $status $strip $str $stripped " +
+ "$syle $submenu $switchbar $tan $target $ticks $time $timer $timestamp " +
+ "$timestampfmt $timezone $tip $titlebar $toolbar $treebar $trust $ulevel " +
+ "$ulist $upper $uptime $url $usermode $v1 $v2 $var $vcmd $vcmdstat $vcmdver " +
+ "$version $vnick $vol $wid $width $wildsite $wildtok $window $wrap $xor");
+ var keywords = parseWords("abook ajinvite alias aline ame amsg anick aop auser autojoin avoice " +
+ "away background ban bcopy beep bread break breplace bset btrunc bunset bwrite " +
+ "channel clear clearall cline clipboard close cnick color comclose comopen " +
+ "comreg continue copy creq ctcpreply ctcps dcc dccserver dde ddeserver " +
+ "debug dec describe dialog did didtok disable disconnect dlevel dline dll " +
+ "dns dqwindow drawcopy drawdot drawfill drawline drawpic drawrect drawreplace " +
+ "drawrot drawsave drawscroll drawtext ebeeps echo editbox emailaddr enable " +
+ "events exit fclose filter findtext finger firewall flash flist flood flush " +
+ "flushini font fopen fseek fsend fserve fullname fwrite ghide gload gmove " +
+ "gopts goto gplay gpoint gqreq groups gshow gsize gstop gtalk gunload hadd " +
+ "halt haltdef hdec hdel help hfree hinc hload hmake hop hsave ial ialclear " +
+ "ialmark identd if ignore iline inc invite iuser join kick linesep links list " +
+ "load loadbuf localinfo log mdi me menubar mkdir mnick mode msg nick noop notice " +
+ "notify omsg onotice part partall pdcc perform play playctrl pop protect pvoice " +
+ "qme qmsg query queryn quit raw reload remini remote remove rename renwin " +
+ "reseterror resetidle return rlevel rline rmdir run ruser save savebuf saveini " +
+ "say scid scon server set showmirc signam sline sockaccept sockclose socklist " +
+ "socklisten sockmark sockopen sockpause sockread sockrename sockudp sockwrite " +
+ "sound speak splay sreq strip switchbar timer timestamp titlebar tnick tokenize " +
+ "toolbar topic tray treebar ulist unload unset unsetall updatenl url uwho " +
+ "var vcadd vcmd vcrem vol while whois window winhelp write writeint if isalnum " +
+ "isalpha isaop isavoice isban ischan ishop isignore isin isincs isletter islower " +
+ "isnotify isnum ison isop isprotect isreg isupper isvoice iswm iswmcs " +
+ "elseif else goto menu nicklist status title icon size option text edit " +
+ "button check radio box scroll list combo link tab item");
+ var functions = parseWords("if elseif else and not or eq ne in ni for foreach while switch");
+ var isOperatorChar = /[+\-*&%=<>!?^\/\|]/;
+ function chain(stream, state, f) {
+ state.tokenize = f;
+ return f(stream, state);
+ }
+ function tokenBase(stream, state) {
+ var beforeParams = state.beforeParams;
+ state.beforeParams = false;
+ var ch = stream.next();
+ if (/[\[\]{}\(\),\.]/.test(ch)) {
+ if (ch == "(" && beforeParams) state.inParams = true;
+ else if (ch == ")") state.inParams = false;
+ return null;
+ }
+ else if (/\d/.test(ch)) {
+ stream.eatWhile(/[\w\.]/);
+ return "number";
+ }
+ else if (ch == "\\") {
+ stream.eat("\\");
+ stream.eat(/./);
+ return "number";
+ }
+ else if (ch == "/" && stream.eat("*")) {
+ return chain(stream, state, tokenComment);
+ }
+ else if (ch == ";" && stream.match(/ *\( *\(/)) {
+ return chain(stream, state, tokenUnparsed);
+ }
+ else if (ch == ";" && !state.inParams) {
+ stream.skipToEnd();
+ return "comment";
+ }
+ else if (ch == '"') {
+ stream.eat(/"/);
+ return "keyword";
+ }
+ else if (ch == "$") {
+ stream.eatWhile(/[$_a-z0-9A-Z\.:]/);
+ if (specials && specials.propertyIsEnumerable(stream.current().toLowerCase())) {
+ return "keyword";
+ }
+ else {
+ state.beforeParams = true;
+ return "builtin";
+ }
+ }
+ else if (ch == "%") {
+ stream.eatWhile(/[^,^\s^\(^\)]/);
+ state.beforeParams = true;
+ return "string";
+ }
+ else if (isOperatorChar.test(ch)) {
+ stream.eatWhile(isOperatorChar);
+ return "operator";
+ }
+ else {
+ stream.eatWhile(/[\w\$_{}]/);
+ var word = stream.current().toLowerCase();
+ if (keywords && keywords.propertyIsEnumerable(word))
+ return "keyword";
+ if (functions && functions.propertyIsEnumerable(word)) {
+ state.beforeParams = true;
+ return "keyword";
+ }
+ 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 tokenUnparsed(stream, state) {
+ var maybeEnd = 0, ch;
+ while (ch = stream.next()) {
+ if (ch == ";" && maybeEnd == 2) {
+ state.tokenize = tokenBase;
+ break;
+ }
+ if (ch == ")")
+ maybeEnd++;
+ else if (ch != " ")
+ maybeEnd = 0;
+ }
+ return "meta";
+ }
+ return {
+ startState: function() {
+ return {
+ tokenize: tokenBase,
+ beforeParams: false,
+ inParams: false
+ };
+ },
+ token: function(stream, state) {
+ if (stream.eatSpace()) return null;
+ return state.tokenize(stream, state);
+ }
+ };
+});
+
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/mllike/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/mllike/index.html
new file mode 100644
index 0000000..5923af8
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/mllike/index.html
@@ -0,0 +1,179 @@
+
+
+CodeMirror: ML-like mode
+
+
+
+
+
+
+
+
+
+
+
+OCaml mode
+
+
+
+
+F# mode
+
+
+
+
+
+MIME types defined: text/x-ocaml (OCaml) and text/x-fsharp (F#).
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/mllike/mllike.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/mllike/mllike.js
new file mode 100644
index 0000000..04ab1c9
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/mllike/mllike.js
@@ -0,0 +1,205 @@
+// 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('mllike', function(_config, parserConfig) {
+ var words = {
+ 'let': 'keyword',
+ 'rec': 'keyword',
+ 'in': 'keyword',
+ 'of': 'keyword',
+ 'and': 'keyword',
+ 'if': 'keyword',
+ 'then': 'keyword',
+ 'else': 'keyword',
+ 'for': 'keyword',
+ 'to': 'keyword',
+ 'while': 'keyword',
+ 'do': 'keyword',
+ 'done': 'keyword',
+ 'fun': 'keyword',
+ 'function': 'keyword',
+ 'val': 'keyword',
+ 'type': 'keyword',
+ 'mutable': 'keyword',
+ 'match': 'keyword',
+ 'with': 'keyword',
+ 'try': 'keyword',
+ 'open': 'builtin',
+ 'ignore': 'builtin',
+ 'begin': 'keyword',
+ 'end': 'keyword'
+ };
+
+ var extraWords = parserConfig.extraWords || {};
+ for (var prop in extraWords) {
+ if (extraWords.hasOwnProperty(prop)) {
+ words[prop] = parserConfig.extraWords[prop];
+ }
+ }
+
+ function tokenBase(stream, state) {
+ var ch = stream.next();
+
+ if (ch === '"') {
+ state.tokenize = tokenString;
+ return state.tokenize(stream, state);
+ }
+ if (ch === '(') {
+ if (stream.eat('*')) {
+ state.commentLevel++;
+ state.tokenize = tokenComment;
+ return state.tokenize(stream, state);
+ }
+ }
+ if (ch === '~') {
+ stream.eatWhile(/\w/);
+ return 'variable-2';
+ }
+ if (ch === '`') {
+ stream.eatWhile(/\w/);
+ return 'quote';
+ }
+ if (ch === '/' && parserConfig.slashComments && stream.eat('/')) {
+ stream.skipToEnd();
+ return 'comment';
+ }
+ if (/\d/.test(ch)) {
+ stream.eatWhile(/[\d]/);
+ if (stream.eat('.')) {
+ stream.eatWhile(/[\d]/);
+ }
+ return 'number';
+ }
+ if ( /[+\-*&%=<>!?|]/.test(ch)) {
+ return 'operator';
+ }
+ stream.eatWhile(/\w/);
+ var cur = stream.current();
+ return words[cur] || 'variable';
+ }
+
+ function tokenString(stream, state) {
+ var next, end = false, escaped = false;
+ while ((next = stream.next()) != null) {
+ if (next === '"' && !escaped) {
+ end = true;
+ break;
+ }
+ escaped = !escaped && next === '\\';
+ }
+ if (end && !escaped) {
+ state.tokenize = tokenBase;
+ }
+ return 'string';
+ };
+
+ function tokenComment(stream, state) {
+ var prev, next;
+ while(state.commentLevel > 0 && (next = stream.next()) != null) {
+ if (prev === '(' && next === '*') state.commentLevel++;
+ if (prev === '*' && next === ')') state.commentLevel--;
+ prev = next;
+ }
+ if (state.commentLevel <= 0) {
+ state.tokenize = tokenBase;
+ }
+ return 'comment';
+ }
+
+ return {
+ startState: function() {return {tokenize: tokenBase, commentLevel: 0};},
+ token: function(stream, state) {
+ if (stream.eatSpace()) return null;
+ return state.tokenize(stream, state);
+ },
+
+ blockCommentStart: "(*",
+ blockCommentEnd: "*)",
+ lineComment: parserConfig.slashComments ? "//" : null
+ };
+});
+
+CodeMirror.defineMIME('text/x-ocaml', {
+ name: 'mllike',
+ extraWords: {
+ 'succ': 'keyword',
+ 'trace': 'builtin',
+ 'exit': 'builtin',
+ 'print_string': 'builtin',
+ 'print_endline': 'builtin',
+ 'true': 'atom',
+ 'false': 'atom',
+ 'raise': 'keyword'
+ }
+});
+
+CodeMirror.defineMIME('text/x-fsharp', {
+ name: 'mllike',
+ extraWords: {
+ 'abstract': 'keyword',
+ 'as': 'keyword',
+ 'assert': 'keyword',
+ 'base': 'keyword',
+ 'class': 'keyword',
+ 'default': 'keyword',
+ 'delegate': 'keyword',
+ 'downcast': 'keyword',
+ 'downto': 'keyword',
+ 'elif': 'keyword',
+ 'exception': 'keyword',
+ 'extern': 'keyword',
+ 'finally': 'keyword',
+ 'global': 'keyword',
+ 'inherit': 'keyword',
+ 'inline': 'keyword',
+ 'interface': 'keyword',
+ 'internal': 'keyword',
+ 'lazy': 'keyword',
+ 'let!': 'keyword',
+ 'member' : 'keyword',
+ 'module': 'keyword',
+ 'namespace': 'keyword',
+ 'new': 'keyword',
+ 'null': 'keyword',
+ 'override': 'keyword',
+ 'private': 'keyword',
+ 'public': 'keyword',
+ 'return': 'keyword',
+ 'return!': 'keyword',
+ 'select': 'keyword',
+ 'static': 'keyword',
+ 'struct': 'keyword',
+ 'upcast': 'keyword',
+ 'use': 'keyword',
+ 'use!': 'keyword',
+ 'val': 'keyword',
+ 'when': 'keyword',
+ 'yield': 'keyword',
+ 'yield!': 'keyword',
+
+ 'List': 'builtin',
+ 'Seq': 'builtin',
+ 'Map': 'builtin',
+ 'Set': 'builtin',
+ 'int': 'builtin',
+ 'string': 'builtin',
+ 'raise': 'builtin',
+ 'failwith': 'builtin',
+ 'not': 'builtin',
+ 'true': 'builtin',
+ 'false': 'builtin'
+ },
+ slashComments: true
+});
+
+});
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/modelica/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/modelica/index.html
new file mode 100644
index 0000000..408c3b1
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/modelica/index.html
@@ -0,0 +1,67 @@
+
+
+CodeMirror: Modelica mode
+
+
+
+
+
+
+
+
+
+
+
+
+
+Modelica mode
+
+
+
+
+
+ Simple mode that tries to handle Modelica as well as it can.
+
+ MIME types defined: text/x-modelica
+ (Modlica code).
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/modelica/modelica.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/modelica/modelica.js
new file mode 100644
index 0000000..77ec7a3
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/modelica/modelica.js
@@ -0,0 +1,245 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// Modelica support for CodeMirror, copyright (c) by Lennart Ochel
+
+(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("modelica", function(config, parserConfig) {
+
+ var indentUnit = config.indentUnit;
+ var keywords = parserConfig.keywords || {};
+ var builtin = parserConfig.builtin || {};
+ var atoms = parserConfig.atoms || {};
+
+ var isSingleOperatorChar = /[;=\(:\),{}.*<>+\-\/^\[\]]/;
+ var isDoubleOperatorChar = /(:=|<=|>=|==|<>|\.\+|\.\-|\.\*|\.\/|\.\^)/;
+ var isDigit = /[0-9]/;
+ var isNonDigit = /[_a-zA-Z]/;
+
+ function tokenLineComment(stream, state) {
+ stream.skipToEnd();
+ state.tokenize = null;
+ return "comment";
+ }
+
+ function tokenBlockComment(stream, state) {
+ var maybeEnd = false, ch;
+ while (ch = stream.next()) {
+ if (maybeEnd && ch == "/") {
+ state.tokenize = null;
+ break;
+ }
+ maybeEnd = (ch == "*");
+ }
+ return "comment";
+ }
+
+ function tokenString(stream, state) {
+ var escaped = false, ch;
+ while ((ch = stream.next()) != null) {
+ if (ch == '"' && !escaped) {
+ state.tokenize = null;
+ state.sol = false;
+ break;
+ }
+ escaped = !escaped && ch == "\\";
+ }
+
+ return "string";
+ }
+
+ function tokenIdent(stream, state) {
+ stream.eatWhile(isDigit);
+ while (stream.eat(isDigit) || stream.eat(isNonDigit)) { }
+
+
+ var cur = stream.current();
+
+ if(state.sol && (cur == "package" || cur == "model" || cur == "when" || cur == "connector")) state.level++;
+ else if(state.sol && cur == "end" && state.level > 0) state.level--;
+
+ state.tokenize = null;
+ state.sol = false;
+
+ if (keywords.propertyIsEnumerable(cur)) return "keyword";
+ else if (builtin.propertyIsEnumerable(cur)) return "builtin";
+ else if (atoms.propertyIsEnumerable(cur)) return "atom";
+ else return "variable";
+ }
+
+ function tokenQIdent(stream, state) {
+ while (stream.eat(/[^']/)) { }
+
+ state.tokenize = null;
+ state.sol = false;
+
+ if(stream.eat("'"))
+ return "variable";
+ else
+ return "error";
+ }
+
+ function tokenUnsignedNuber(stream, state) {
+ stream.eatWhile(isDigit);
+ if (stream.eat('.')) {
+ stream.eatWhile(isDigit);
+ }
+ if (stream.eat('e') || stream.eat('E')) {
+ if (!stream.eat('-'))
+ stream.eat('+');
+ stream.eatWhile(isDigit);
+ }
+
+ state.tokenize = null;
+ state.sol = false;
+ return "number";
+ }
+
+ // Interface
+ return {
+ startState: function() {
+ return {
+ tokenize: null,
+ level: 0,
+ sol: true
+ };
+ },
+
+ token: function(stream, state) {
+ if(state.tokenize != null) {
+ return state.tokenize(stream, state);
+ }
+
+ if(stream.sol()) {
+ state.sol = true;
+ }
+
+ // WHITESPACE
+ if(stream.eatSpace()) {
+ state.tokenize = null;
+ return null;
+ }
+
+ var ch = stream.next();
+
+ // LINECOMMENT
+ if(ch == '/' && stream.eat('/')) {
+ state.tokenize = tokenLineComment;
+ }
+ // BLOCKCOMMENT
+ else if(ch == '/' && stream.eat('*')) {
+ state.tokenize = tokenBlockComment;
+ }
+ // TWO SYMBOL TOKENS
+ else if(isDoubleOperatorChar.test(ch+stream.peek())) {
+ stream.next();
+ state.tokenize = null;
+ return "operator";
+ }
+ // SINGLE SYMBOL TOKENS
+ else if(isSingleOperatorChar.test(ch)) {
+ state.tokenize = null;
+ return "operator";
+ }
+ // IDENT
+ else if(isNonDigit.test(ch)) {
+ state.tokenize = tokenIdent;
+ }
+ // Q-IDENT
+ else if(ch == "'" && stream.peek() && stream.peek() != "'") {
+ state.tokenize = tokenQIdent;
+ }
+ // STRING
+ else if(ch == '"') {
+ state.tokenize = tokenString;
+ }
+ // UNSIGNED_NUBER
+ else if(isDigit.test(ch)) {
+ state.tokenize = tokenUnsignedNuber;
+ }
+ // ERROR
+ else {
+ state.tokenize = null;
+ return "error";
+ }
+
+ return state.tokenize(stream, state);
+ },
+
+ indent: function(state, textAfter) {
+ if (state.tokenize != null) return CodeMirror.Pass;
+
+ var level = state.level;
+ if(/(algorithm)/.test(textAfter)) level--;
+ if(/(equation)/.test(textAfter)) level--;
+ if(/(initial algorithm)/.test(textAfter)) level--;
+ if(/(initial equation)/.test(textAfter)) level--;
+ if(/(end)/.test(textAfter)) level--;
+
+ if(level > 0)
+ return indentUnit*level;
+ else
+ return 0;
+ },
+
+ blockCommentStart: "/*",
+ blockCommentEnd: "*/",
+ lineComment: "//"
+ };
+ });
+
+ function words(str) {
+ var obj = {}, words = str.split(" ");
+ for (var i=0; i
+
+CodeMirror: NGINX mode
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+NGINX mode
+
+
+
+ MIME types defined: text/nginx.
+
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/nginx/nginx.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/nginx/nginx.js
new file mode 100644
index 0000000..135b9cc
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/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/src/main/resources/static/lib/editormd/lib/codemirror/mode/ntriples/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/ntriples/index.html
new file mode 100644
index 0000000..1355e71
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/ntriples/index.html
@@ -0,0 +1,45 @@
+
+
+CodeMirror: NTriples mode
+
+
+
+
+
+
+
+
+
+
+NTriples mode
+
+
+
+ MIME types defined: text/n-triples.
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/ntriples/ntriples.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/ntriples/ntriples.js
new file mode 100644
index 0000000..0524b1e
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/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/src/main/resources/static/lib/editormd/lib/codemirror/mode/octave/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/octave/index.html
new file mode 100644
index 0000000..79df581
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/octave/index.html
@@ -0,0 +1,83 @@
+
+
+CodeMirror: Octave mode
+
+
+
+
+
+
+
+
+
+
+Octave mode
+
+
+
+
+ MIME types defined: text/x-octave.
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/octave/octave.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/octave/octave.js
new file mode 100644
index 0000000..a7bec03
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/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/src/main/resources/static/lib/editormd/lib/codemirror/mode/pascal/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/pascal/index.html
new file mode 100644
index 0000000..f8a99ad
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/pascal/index.html
@@ -0,0 +1,61 @@
+
+
+CodeMirror: Pascal mode
+
+
+
+
+
+
+
+
+
+
+Pascal mode
+
+
+
+
+
+
+ MIME types defined: text/x-pascal.
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/pascal/pascal.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/pascal/pascal.js
new file mode 100644
index 0000000..2d0c3d4
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/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/src/main/resources/static/lib/editormd/lib/codemirror/mode/pegjs/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/pegjs/index.html
new file mode 100644
index 0000000..0c74604
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/pegjs/index.html
@@ -0,0 +1,66 @@
+
+
+
+ CodeMirror: PEG.js Mode
+
+
+
+
+
+
+
+
+
+
+
+
+
+ PEG.js Mode
+
+
+ The PEG.js Mode
+ Created by Forbes Lindesay.
+
+
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/pegjs/pegjs.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/pegjs/pegjs.js
new file mode 100644
index 0000000..306e376
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/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/src/main/resources/static/lib/editormd/lib/codemirror/mode/perl/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/perl/index.html
new file mode 100644
index 0000000..8c1021c
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/perl/index.html
@@ -0,0 +1,75 @@
+
+
+CodeMirror: Perl mode
+
+
+
+
+
+
+
+
+
+
+Perl mode
+
+
+
+
+
+
+ MIME types defined: text/x-perl.
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/perl/perl.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/perl/perl.js
new file mode 100644
index 0000000..bef62bc
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/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/src/main/resources/static/lib/editormd/lib/codemirror/mode/php/index.html b/src/main/resources/static/lib/editormd/lib/codemirror/mode/php/index.html
new file mode 100644
index 0000000..adf6b1b
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/php/index.html
@@ -0,0 +1,64 @@
+
+
+CodeMirror: PHP mode
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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).
+
diff --git a/src/main/resources/static/lib/editormd/lib/codemirror/mode/php/php.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/php/php.js
new file mode 100644
index 0000000..e112d91
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/mode/php/php.js
@@ -0,0 +1,226 @@
+// 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 stringWithEscapes
+ function matchSequence(list, end) {
+ if (list.length == 0) return stringWithEscapes(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 = stringWithEscapes(end);
+ return "string";
+ };
+ }
+ function stringWithEscapes(closing) {
+ return function(stream, state) { return stringWithEscapes_(stream, state, closing); };
+ }
+ function stringWithEscapes_(stream, state, closing) {
+ // "Complex" syntax
+ if (stream.match("${", false) || stream.match("{$", false)) {
+ state.tokenize = null;
+ return "string";
+ }
+
+ // Simple syntax
+ if (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);
+ }
+ if (stream.match(/\-\>\w/, false)) {
+ // Match object operator
+ state.tokenize = matchSequence([
+ [["->", null]],
+ [[/[\w]+/, "variable"]]
+ ], closing);
+ }
+ return "variable-2";
+ }
+
+ var escaped = false;
+ // Normal string
+ while (!stream.eol() &&
+ (escaped || (!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 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"),
+ atoms: keywords(phpAtoms),
+ builtin: keywords(phpBuiltin),
+ multiLineStrings: true,
+ hooks: {
+ "$": function(stream) {
+ stream.eatWhile(/[\w\$_]/);
+ return "variable-2";
+ },
+ "<": function(stream, state) {
+ if (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 = stringWithEscapes('"');
+ 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 = stringWithEscapes(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;
+ 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;
+ return "meta";
+ } else {
+ return phpMode.token(stream, state.curState);
+ }
+ }
+
+ return {
+ startState: function() {
+ var html = CodeMirror.startState(htmlMode), php = CodeMirror.startState(phpMode);
+ 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 = 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/src/main/resources/static/lib/editormd/lib/codemirror/mode/php/test.js b/src/main/resources/static/lib/editormd/lib/codemirror/mode/php/test.js
new file mode 100644
index 0000000..e2ecefc
--- /dev/null
+++ b/src/main/resources/static/lib/editormd/lib/codemirror/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
+
+
+
+
+
+
+
+
+
+
+Pig Latin mode
+
+
+
+
+
+ Simple mode that handles Pig Latin language.
+
+
+ MIME type defined: text/x-pig
+ (PIG code)
+