puffer_pages 0.1.1 → 0.5.0

data/app/assets/javascripts/puffer/codemirror/javascript.js

@@ -1,6 +1,9 @@
+// TODO actually recognize syntax of TypeScript constructs
+
 CodeMirror.defineMode("javascript", function(config, parserConfig) {
   var indentUnit = config.indentUnit;
   var jsonMode = parserConfig.json;
+  var isTS = parserConfig.typescript;
 
   // Tokenizer
 
@@ -8,7 +11,8 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
     function kw(type) {return {type: type, style: "keyword"};}
     var A = kw("keyword a"), B = kw("keyword b"), C = kw("keyword c");
     var operator = kw("operator"), atom = {type: "atom", style: "atom"};
-    return {
+    
+    var jsKeywords = {
       "if": A, "while": A, "with": A, "else": B, "do": B, "try": B, "finally": B,
       "return": C, "break": C, "continue": C, "new": C, "delete": C, "throw": C,
       "var": kw("var"), "const": kw("var"), "let": kw("var"),
@@ -17,6 +21,35 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
       "in": operator, "typeof": operator, "instanceof": operator,
       "true": atom, "false": atom, "null": atom, "undefined": atom, "NaN": atom, "Infinity": atom
     };
+
+    // 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"),
+        "class": kw("class"),
+        "extends": kw("extends"),
+        "constructor": kw("constructor"),
+
+        // scope modifiers
+        "public": kw("public"),
+        "private": kw("private"),
+        "protected": kw("protected"),
+        "static": kw("static"),
+
+        "super": kw("super"),
+
+        // types
+        "string": type, "number": type, "bool": type, "any": type
+      };
+
+      for (var attr in tsKeywords) {
+        jsKeywords[attr] = tsKeywords[attr];
+      }
+    }
+
+    return jsKeywords;
   }();
 
   var isOperatorChar = /[+\-*&%=<>!?|]/;
@@ -54,7 +87,7 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
       stream.eatWhile(/[\da-f]/i);
       return ret("number", "number");
     }      
-    else if (/\d/.test(ch)) {
+    else if (/\d/.test(ch) || ch == "-" && stream.eat(/\d/)) {
       stream.match(/^\d*(?:\.\d*)?(?:[eE][+\-]?\d+)?/);
       return ret("number", "number");
     }
@@ -66,10 +99,11 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
         stream.skipToEnd();
         return ret("comment", "comment");
       }
-      else if (state.reAllowed) {
+      else if (state.lastType == "operator" || state.lastType == "keyword c" ||
+               /^[\[{}\(,;:]$/.test(state.lastType)) {
         nextUntilUnescaped(stream, "/");
         stream.eatWhile(/[gimy]/); // 'y' is "sticky" option in Mozilla
-        return ret("regexp", "string");
+        return ret("regexp", "string-2");
       }
       else {
         stream.eatWhile(isOperatorChar);
@@ -87,7 +121,7 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
     else {
       stream.eatWhile(/[\w\$_]/);
       var word = stream.current(), known = keywords.propertyIsEnumerable(word) && keywords[word];
-      return (known && state.kwAllowed) ? ret(known.type, known.style, word) :
+      return (known && state.lastType != ".") ? ret(known.type, known.style, word) :
                      ret("variable", "variable", word);
     }
   }
@@ -162,12 +196,19 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
     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";
-      for (var v = state.localVars; v; v = v.next)
-        if (v.name == varname) return;
+      if (inList(state.localVars)) return;
       state.localVars = {name: varname, next: state.localVars};
+    } else {
+      if (inList(state.globalVars)) return;
+      state.globalVars = {name: varname, next: state.globalVars};
     }
   }
 
@@ -175,8 +216,8 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
 
   var defaultVars = {name: "this", next: {name: "arguments"}};
   function pushcontext() {
-    if (!cx.state.context) cx.state.localVars = defaultVars;
     cx.state.context = {prev: cx.state.context, vars: cx.state.localVars};
+    cx.state.localVars = defaultVars;
   }
   function popcontext() {
     cx.state.localVars = cx.state.context.vars;
@@ -185,7 +226,7 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
   function pushlex(type, info) {
     var result = function() {
       var state = cx.state;
-      state.lexical = new JSLexical(state.indented, cx.stream.column(), type, null, state.lexical, info)
+      state.lexical = new JSLexical(state.indented, cx.stream.column(), type, null, state.lexical, info);
     };
     result.lex = true;
     return result;
@@ -230,7 +271,7 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
     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(")"), expression, expect(")"), poplex, maybeoperator);
+    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);
@@ -243,7 +284,7 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
     
   function maybeoperator(type, value) {
     if (type == "operator" && /\+\+|--/.test(value)) return cont(maybeoperator);
-    if (type == "operator") return cont(expression);
+    if (type == "operator" && value == "?") return cont(expression, expect(":"), expression);
     if (type == ";") return;
     if (type == "(") return cont(pushlex(")"), commasep(expression, ")"), poplex, maybeoperator);
     if (type == ".") return cont(property, maybeoperator);
@@ -275,21 +316,32 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
     if (type == "}") return cont();
     return pass(statement, block);
   }
+  function maybetype(type) {
+    if (type == ":") return cont(typedef);
+    return pass();
+  }
+  function typedef(type) {
+    if (type == "variable"){cx.marked = "variable-3"; return cont();}
+    return pass();
+  }
   function vardef1(type, value) {
-    if (type == "variable"){register(value); return cont(vardef2);}
-    return cont();
+    if (type == "variable") {
+      register(value);
+      return isTS ? cont(maybetype, vardef2) : cont(vardef2);
+    }
+    return pass();
   }
   function vardef2(type, value) {
     if (value == "=") return cont(expression, vardef2);
     if (type == ",") return cont(vardef1);
   }
   function forspec1(type) {
-    if (type == "var") return cont(vardef1, forspec2);
-    if (type == ";") return pass(forspec2);
+    if (type == "var") return cont(vardef1, expect(";"), forspec2);
+    if (type == ";") return cont(forspec2);
     if (type == "variable") return cont(formaybein);
-    return pass(forspec2);
+    return cont(forspec2);
   }
-  function formaybein(type, value) {
+  function formaybein(_type, value) {
     if (value == "in") return cont(expression);
     return cont(maybeoperator, forspec2);
   }
@@ -306,7 +358,7 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
     if (type == "(") return cont(pushlex(")"), pushcontext, commasep(funarg, ")"), poplex, statement, popcontext);
   }
   function funarg(type, value) {
-    if (type == "variable") {register(value); return cont();}
+    if (type == "variable") {register(value); return isTS ? cont(maybetype) : cont();}
   }
 
   // Interface
@@ -315,12 +367,12 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
     startState: function(basecolumn) {
       return {
         tokenize: jsTokenBase,
-        reAllowed: true,
-        kwAllowed: true,
+        lastType: null,
         cc: [],
         lexical: new JSLexical((basecolumn || 0) - indentUnit, 0, "block", false),
-        localVars: null,
-        context: null,
+        localVars: parserConfig.localVars,
+        globalVars: parserConfig.globalVars,
+        context: parserConfig.localVars && {vars: parserConfig.localVars},
         indented: 0
       };
     },
@@ -334,27 +386,37 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
       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 != '.';
+      state.lastType = type;
       return parseJS(state, style, type, content, stream);
     },
 
     indent: function(state, textAfter) {
+      if (state.tokenize == jsTokenComment) return CodeMirror.Pass;
       if (state.tokenize != jsTokenBase) return 0;
-      var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical,
-          type = lexical.type, closing = firstChar == type;
-      if (type == "vardef") return lexical.indented + 4;
+      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 + (state.lastType == "operator" || state.lastType == "," ? 4 : 0);
       else if (type == "form" && firstChar == "{") return lexical.indented;
-      else if (type == "stat" || type == "form") return lexical.indented + indentUnit;
+      else if (type == "form") return lexical.indented + indentUnit;
+      else if (type == "stat")
+        return lexical.indented + (state.lastType == "operator" || state.lastType == "," ? indentUnit : 0);
       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: ":{}"
+    electricChars: ":{}",
+
+    jsonMode: jsonMode
   };
 });
 
 CodeMirror.defineMIME("text/javascript", "javascript");
+CodeMirror.defineMIME("text/ecmascript", "javascript");
+CodeMirror.defineMIME("application/javascript", "javascript");
+CodeMirror.defineMIME("application/ecmascript", "javascript");
 CodeMirror.defineMIME("application/json", {name: "javascript", json: true});
+CodeMirror.defineMIME("text/typescript", { name: "javascript", typescript: true });
+CodeMirror.defineMIME("application/typescript", { name: "javascript", typescript: true });

data/app/assets/javascripts/puffer/codemirror/liquid.js

@@ -0,0 +1,185 @@
+(function(CodeMirror) {
+  inString = function(stream, state) {
+    var matched = stream.next();
+
+    while (stream.peek()) {
+      if (stream.match('}}') || stream.match('%}')) {
+        stream.backUp(2);
+        break;
+      } else if (stream.next() == matched) {
+        break;
+      }
+    }
+
+    return 'string';
+  }
+
+  CodeMirror.defineMode("liquid", function(config, parserConfig) {
+    var tagMode = CodeMirror.getMode(config, "liquid-tag");
+    var tagState = null;
+    var variableMode = CodeMirror.getMode(config, "liquid-variable");
+    var variableState = null;
+
+
+    var tokenize = function(stream, state) {
+      var token = null;
+
+      if (stream.match(/^\{\%\s*comment\s*\%\}/)) {
+        state.tokenizer = inComment;
+        token = "comment";
+      } else if (stream.match('{{')) {
+        variableState = variableMode.startState();
+        state.tokenizer = inVariable;
+        token = 'tag';
+      } else if (stream.match('{%')) {
+        tagState = tagMode.startState();
+        state.tokenizer = inTag;
+        token = 'tag';
+      } else {
+        stream.next();
+      }
+
+      return token;
+    }
+
+    var inComment = function(stream, state) {
+      if (stream.match(/^\{\%\s*endcomment\s*\%\}/)) {
+        state.tokenizer = tokenize;
+      } else {
+        stream.next();
+      }
+      return 'comment';
+    }
+
+    var inVariable = function(stream, state) {
+      var token = null;
+
+      if (stream.match('}}')) {
+        state.tokenizer = tokenize;
+        token = 'tag';
+      } else {
+        token = variableMode.token(stream, variableState);
+      }
+
+      return token;
+    }
+
+    var inTag = function(stream, state) {
+      var token = null;
+
+      if (stream.match('%}')) {
+        state.tokenizer = tokenize;
+        token = 'tag';
+      } else {
+        token = tagMode.token(stream, tagState);
+      }
+
+      return token;
+    }
+
+    return {
+      startState: function() {
+        return {tokenizer: tokenize, mode: null};
+      },
+      token: function(stream, state) {
+        return state.tokenizer(stream, state);
+      },
+      electricChars: ""
+    }
+  });
+
+  CodeMirror.defineMode("liquid-variable", function(config, parserConfig) {
+    var tokenize = function(stream, state) {
+      var token = null;
+
+      if (stream.peek() == '\'' || stream.peek() == '"') {
+        token = inString(stream, state);
+        state.filterParsing = false;
+      } else if (stream.match(/^-?\d+(:?\.(\d+))?/)) {
+        token = 'number';
+        state.filterParsing = false;
+      } else if (stream.peek() == '|') {
+        stream.next();
+        state.filterParsing = true;
+      } else if (stream.match(/^\w+/)) {
+        if (state.filterParsing) {
+          token = 'attribute';
+          state.filterParsing = false;
+        } else {
+          token = 'variable';
+        }
+      } else {
+        stream.next();
+      }
+
+      return token;
+    }
+
+    return {
+      startState: function() {
+        return {tokenizer: tokenize, filterParsing: false};
+      },
+      token: function(stream, state) {
+        return state.tokenizer(stream, state);
+      },
+      electricChars: ""
+    }
+  });
+
+  CodeMirror.defineMode("liquid-tag", function(config, parserConfig) {
+    var tokenize = function(stream, state) {
+      var token = null;
+
+      if (stream.peek() == '\'' || stream.peek() == '"') {
+        token = inString(stream, state);
+        if (state.translationTagParsed && !state.translationStringParsed) {
+          token = 'translation';
+        }
+        state.translationStringParsed = true;
+      } else if (stream.match(/^-?\d+(:?\.(\d+))?/)) {
+        token = 'number';
+        state.translationStringParsed = true;
+      } else if (stream.match(/^(nil|null|true|false|empty|blank)\s/)) {
+        token = 'builtin';
+        stream.backUp(1);
+        state.translationStringParsed = true;
+      } else if (stream.match(/^(==|!=|<>|>|<|>=|<=)/)) {
+        token = 'operator';
+        state.translationStringParsed = true;
+      } else if (stream.match(/^(in|contains)\s/)) {
+        token = 'operator';
+        stream.backUp(1);
+        state.translationStringParsed = true;
+      } else if (tag = stream.match(/^\w+/)) {
+        if (state.tagParsed) {
+          token = 'variable';
+          state.translationStringParsed = true;
+        } else {
+          token = 'keyword';
+          state.tagParsed = true;
+          if (tag == 't' || tag == 'translate') {
+            state.translationTagParsed = true;
+          }
+        }
+      } else {
+        stream.next();
+      }
+
+      return token;
+    }
+
+    return {
+      startState: function() {
+        return {tokenizer: tokenize, tagParsed: false, translationTagParsed: false, translationStringParsed: false};
+      },
+      token: function(stream, state) {
+        return state.tokenizer(stream, state);
+      },
+      electricChars: ""
+    }
+  });
+})(CodeMirror)
+
+CodeMirror.defineMIME("text/x-liquid", "liquid");
+CodeMirror.defineMIME("text/x-liquid-tag", "liquid-tag");
+CodeMirror.defineMIME("text/x-liquid-variable", "liquid-variable");

data/app/assets/javascripts/puffer/codemirror/xml.js

@@ -1,11 +1,44 @@
 CodeMirror.defineMode("xml", function(config, parserConfig) {
   var indentUnit = config.indentUnit;
   var Kludges = parserConfig.htmlMode ? {
-    autoSelfClosers: {"br": true, "img": true, "hr": true, "link": true, "input": true,
-                      "meta": true, "col": true, "frame": true, "base": true, "area": true},
+    autoSelfClosers: {'area': true, 'base': true, 'br': true, 'col': true, 'command': true,
+                      'embed': true, 'frame': true, 'hr': true, 'img': true, 'input': true,
+                      'keygen': true, 'link': true, 'meta': true, 'param': true, 'source': true,
+                      'track': true, 'wbr': true},
+    implicitlyClosed: {'dd': true, 'li': true, 'optgroup': true, 'option': true, 'p': true,
+                       'rp': true, 'rt': true, 'tbody': true, 'td': true, 'tfoot': true,
+                       'th': true, 'tr': true},
+    contextGrabbers: {
+      'dd': {'dd': true, 'dt': true},
+      'dt': {'dd': true, 'dt': true},
+      'li': {'li': true},
+      'option': {'option': true, 'optgroup': true},
+      'optgroup': {'optgroup': true},
+      'p': {'address': true, 'article': true, 'aside': true, 'blockquote': true, 'dir': true,
+            'div': true, 'dl': true, 'fieldset': true, 'footer': true, 'form': true,
+            'h1': true, 'h2': true, 'h3': true, 'h4': true, 'h5': true, 'h6': true,
+            'header': true, 'hgroup': true, 'hr': true, 'menu': true, 'nav': true, 'ol': true,
+            'p': true, 'pre': true, 'section': true, 'table': true, 'ul': true},
+      'rp': {'rp': true, 'rt': true},
+      'rt': {'rp': true, 'rt': true},
+      'tbody': {'tbody': true, 'tfoot': true},
+      'td': {'td': true, 'th': true},
+      'tfoot': {'tbody': true},
+      'th': {'td': true, 'th': true},
+      'thead': {'tbody': true, 'tfoot': true},
+      'tr': {'tr': true}
+    },
     doNotIndent: {"pre": true},
-    allowUnquoted: true
-  } : {autoSelfClosers: {}, doNotIndent: {}, allowUnquoted: false};
+    allowUnquoted: true,
+    allowMissing: true
+  } : {
+    autoSelfClosers: {},
+    implicitlyClosed: {},
+    contextGrabbers: {},
+    doNotIndent: {},
+    allowUnquoted: false,
+    allowMissing: false
+  };
   var alignCDATA = parserConfig.alignCDATA;
 
   // Return variables for tokenizers
@@ -37,19 +70,28 @@ CodeMirror.defineMode("xml", function(config, parserConfig) {
         return "meta";
       }
       else {
-        type = stream.eat("/") ? "closeTag" : "openTag";
-        stream.eatSpace();
+        var isClose = stream.eat("/");
         tagName = "";
         var c;
         while ((c = stream.eat(/[^\s\u00a0=<>\"\'\/?]/))) tagName += c;
+        if (!tagName) return "error";
+        type = isClose ? "closeTag" : "openTag";
         state.tokenize = inTag;
         return "tag";
       }
     }
     else if (ch == "&") {
-      stream.eatWhile(/[^;]/);
-      stream.eat(";");
-      return "atom";
+      var ok;
+      if (stream.eat("#")) {
+        if (stream.eat("x")) {
+          ok = stream.eatWhile(/[a-fA-F\d]/) && stream.eat(";");          
+        } else {
+          ok = stream.eatWhile(/[\d]/) && stream.eat(";");
+        }
+      } else {
+        ok = stream.eatWhile(/[\w\.\-:]/) && stream.eat(";");
+      }
+      return ok ? "atom" : "error";
     }
     else {
       stream.eatWhile(/[^&<]/);
@@ -73,7 +115,7 @@ CodeMirror.defineMode("xml", function(config, parserConfig) {
       return state.tokenize(stream, state);
     }
     else {
-      stream.eatWhile(/[^\s\u00a0=<>\"\'\/?]/);
+      stream.eatWhile(/[^\s\u00a0=<>\"\']/);
       return "word";
     }
   }
@@ -153,7 +195,12 @@ CodeMirror.defineMode("xml", function(config, parserConfig) {
     } else if (type == "closeTag") {
       var err = false;
       if (curState.context) {
-        err = curState.context.tagName != tagName;
+        if (curState.context.tagName != tagName) {
+          if (Kludges.implicitlyClosed.hasOwnProperty(curState.context.tagName.toLowerCase())) {
+            popContext();
+          }
+          err = !curState.context || curState.context.tagName != tagName;
+        }
       } else {
         err = true;
       }
@@ -164,10 +211,18 @@ CodeMirror.defineMode("xml", function(config, parserConfig) {
   }
   function endtag(startOfLine) {
     return function(type) {
+      var tagName = curState.tagName;
+      curState.tagName = null;
       if (type == "selfcloseTag" ||
-          (type == "endTag" && Kludges.autoSelfClosers.hasOwnProperty(curState.tagName.toLowerCase())))
+          (type == "endTag" && Kludges.autoSelfClosers.hasOwnProperty(tagName.toLowerCase()))) {
+        maybePopContext(tagName.toLowerCase());
         return cont();
-      if (type == "endTag") {pushContext(curState.tagName, startOfLine); return cont();}
+      }
+      if (type == "endTag") {
+        maybePopContext(tagName.toLowerCase());
+        pushContext(tagName, startOfLine);
+        return cont();
+      }
       return cont();
     };
   }
@@ -177,19 +232,40 @@ CodeMirror.defineMode("xml", function(config, parserConfig) {
       if (type == "endTag") { popContext(); return cont(); }
       setStyle = "error";
       return cont(arguments.callee);
+    };
+  }
+  function maybePopContext(nextTagName) {
+    var parentTagName;
+    while (true) {
+      if (!curState.context) {
+        return;
+      }
+      parentTagName = curState.context.tagName.toLowerCase();
+      if (!Kludges.contextGrabbers.hasOwnProperty(parentTagName) ||
+          !Kludges.contextGrabbers[parentTagName].hasOwnProperty(nextTagName)) {
+        return;
+      }
+      popContext();
     }
   }
 
   function attributes(type) {
-    if (type == "word") {setStyle = "attribute"; return cont(attributes);}
+    if (type == "word") {setStyle = "attribute"; return cont(attribute, attributes);}
+    if (type == "endTag" || type == "selfcloseTag") return pass();
+    setStyle = "error";
+    return cont(attributes);
+  }
+  function attribute(type) {
     if (type == "equals") return cont(attvalue, attributes);
-    if (type == "string") {setStyle = "error"; return cont(attributes);}
-    return pass();
+    if (!Kludges.allowMissing) setStyle = "error";
+    else if (type == "word") setStyle = "attribute";
+    return (type == "endTag" || type == "selfcloseTag") ? pass() : cont();
   }
   function attvalue(type) {
-    if (type == "word" && Kludges.allowUnquoted) {setStyle = "string"; return cont();}
     if (type == "string") return cont(attvaluemaybe);
-    return pass();
+    if (type == "word" && Kludges.allowUnquoted) {setStyle = "string"; return cont();}
+    setStyle = "error";
+    return (type == "endTag" || type == "selfCloseTag") ? pass() : cont();
   }
   function attvaluemaybe(type) {
     if (type == "string") return cont(attvaluemaybe);
@@ -236,17 +312,13 @@ CodeMirror.defineMode("xml", function(config, parserConfig) {
       else return 0;
     },
 
-    compareStates: function(a, b) {
-      if (a.indented != b.indented || a.tokenize != b.tokenize) return false;
-      for (var ca = a.context, cb = b.context; ; ca = ca.prev, cb = cb.prev) {
-        if (!ca || !cb) return ca == cb;
-        if (ca.tagName != cb.tagName) return false;
-      }
-    },
+    electricChars: "/",
 
-    electricChars: "/"
+    configuration: parserConfig.htmlMode ? "html" : "xml"
   };
 });
 
+CodeMirror.defineMIME("text/xml", "xml");
 CodeMirror.defineMIME("application/xml", "xml");
-CodeMirror.defineMIME("text/html", {name: "xml", htmlMode: true});
+if (!CodeMirror.mimeModes.hasOwnProperty("text/html"))
+  CodeMirror.defineMIME("text/html", {name: "xml", htmlMode: true});