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