codemirror-rails 2.22 → 2.23

data/vendor/assets/javascripts/codemirror/modes/properties.js

@@ -1,21 +1,23 @@
 CodeMirror.defineMode("properties", function() {
   return {
     token: function(stream, state) {
-      var sol = stream.sol();
+      var sol = stream.sol() || state.afterSection;
       var eol = stream.eol();
 
+      state.afterSection = false;
+
       if (sol) {
         if (state.nextMultiline) {
           state.inMultiline = true;
           state.nextMultiline = false;
         } else {
-          state.position = "key";
+          state.position = "def";
         }
       }
 
       if (eol && ! state.nextMultiline) {
         state.inMultiline = false;
-        state.position = "key";
+        state.position = "def";
       }
 
       if (sol) {
@@ -24,16 +26,18 @@ CodeMirror.defineMode("properties", function() {
 
       var ch = stream.next();
 
-      if (sol && (ch === "#" || ch === "!")) {
+      if (sol && (ch === "#" || ch === "!" || ch === ";")) {
         state.position = "comment";
         stream.skipToEnd();
         return "comment";
-
+      } else if (sol && ch === "[") {
+        state.afterSection = true;
+        stream.skipTo("]"); stream.eat("]");
+        return "header";
       } else if (ch === "=" || ch === ":") {
-        state.position = "value";
-        return "equals";
-
-      } else if (ch === "\\" && state.position === "value") {
+        state.position = "quote";
+        return null;
+      } else if (ch === "\\" && state.position === "quote") {
         if (stream.next() !== "u") {    // u = Unicode sequence \u1234
           // Multiline value
           state.nextMultiline = true;
@@ -45,9 +49,10 @@ CodeMirror.defineMode("properties", function() {
 
     startState: function() {
       return {
-        position : "key",       // Current position, "key", "value" or "comment"
+        position : "def",       // Current position, "def", "quote" or "comment"
         nextMultiline : false,  // Is the next line multiline value
-        inMultiline : false     // Is the current line a multiline value
+        inMultiline : false,    // Is the current line a multiline value
+        afterSection : false    // Did we just open a section
       };
     }
 
@@ -55,3 +60,4 @@ CodeMirror.defineMode("properties", function() {
 });
 
 CodeMirror.defineMIME("text/x-properties", "properties");
+CodeMirror.defineMIME("text/x-ini", "properties");

data/vendor/assets/javascripts/codemirror/modes/smarty.js

@@ -0,0 +1,148 @@
+CodeMirror.defineMode("smarty", function(config, parserConfig) {
+  var keyFuncs = ["debug", "extends", "function", "include", "literal"];
+  var last;
+  var regs = {
+    operatorChars: /[+\-*&%=<>!?]/,
+    validIdentifier: /[a-zA-Z0-9\_]/,
+    stringChar: /[\'\"]/
+  }
+  var leftDelim = (typeof config.mode.leftDelimiter != 'undefined') ? config.mode.leftDelimiter : "{";
+  var rightDelim = (typeof config.mode.rightDelimiter != 'undefined') ? config.mode.rightDelimiter : "}";
+  function ret(style, lst) { last = lst; return style; }
+
+
+  function tokenizer(stream, state) {
+    function chain(parser) {
+      state.tokenize = parser;
+      return parser(stream, state);
+    }
+
+    if (stream.match(leftDelim, true)) {
+      if (stream.eat("*")) {
+        return chain(inBlock("comment", "*" + rightDelim));
+      }
+      else {
+        state.tokenize = inSmarty;
+        return "tag";
+      }
+    }
+    else {
+      // I'd like to do an eatWhile() here, but I can't get it to eat only up to the rightDelim string/char
+      stream.next();
+      return null;
+    }
+  }
+
+  function inSmarty(stream, state) {
+    if (stream.match(rightDelim, true)) {
+      state.tokenize = tokenizer;
+      return ret("tag", null);
+    }
+
+    var ch = stream.next();
+    if (ch == "$") {
+      stream.eatWhile(regs.validIdentifier);
+      return ret("variable-2", "variable");
+    }
+    else if (ch == ".") {
+      return ret("operator", "property");
+    }
+    else if (regs.stringChar.test(ch)) {
+      state.tokenize = inAttribute(ch);
+      return ret("string", "string");
+    }
+    else if (regs.operatorChars.test(ch)) {
+      stream.eatWhile(regs.operatorChars);
+      return ret("operator", "operator");
+    }
+    else if (ch == "[" || ch == "]") {
+      return ret("bracket", "bracket");
+    }
+    else if (/\d/.test(ch)) {
+      stream.eatWhile(/\d/);
+      return ret("number", "number");
+    }
+    else {
+      if (state.last == "variable") {
+        if (ch == "@") {
+          stream.eatWhile(regs.validIdentifier);
+          return ret("property", "property");
+        }
+        else if (ch == "|") {
+          stream.eatWhile(regs.validIdentifier);
+          return ret("qualifier", "modifier");
+        }
+      }
+      else if (state.last == "whitespace") {
+        stream.eatWhile(regs.validIdentifier);
+        return ret("attribute", "modifier");
+      }
+      else if (state.last == "property") {
+        stream.eatWhile(regs.validIdentifier);
+        return ret("property", null);
+      }
+      else if (/\s/.test(ch)) {
+        last = "whitespace";
+        return null;
+      }
+
+      var str = "";
+      if (ch != "/") {
+    	str += ch;
+      }
+      var c = "";
+      while ((c = stream.eat(regs.validIdentifier))) {
+        str += c;
+      }
+      var i, j;
+      for (i=0, j=keyFuncs.length; i<j; i++) {
+        if (keyFuncs[i] == str) {
+          return ret("keyword", "keyword");
+        }
+      }
+      if (/\s/.test(ch)) {
+    	return null;
+      }
+      return ret("tag", "tag");
+    }
+  }
+
+  function inAttribute(quote) {
+    return function(stream, state) {
+      while (!stream.eol()) {
+        if (stream.next() == quote) {
+          state.tokenize = inSmarty;
+          break;
+        }
+      }
+      return "string";
+    };
+  }
+
+  function inBlock(style, terminator) {
+    return function(stream, state) {
+      while (!stream.eol()) {
+        if (stream.match(terminator)) {
+          state.tokenize = tokenizer;
+          break;
+        }
+        stream.next();
+      }
+      return style;
+    };
+  }
+
+  return {
+    startState: function() {
+      return { tokenize: tokenizer, mode: "smarty", last: null };
+    },
+    token: function(stream, state) {
+      var style = state.tokenize(stream, state);
+      state.last = last;
+      return style;
+    },
+    electricChars: ""
+  }
+});
+
+CodeMirror.defineMIME("text/x-smarty", "smarty");

data/vendor/assets/javascripts/codemirror/modes/stex.js

@@ -82,7 +82,7 @@ CodeMirror.defineMode("stex", function(cmCfg, modeCfg)
     }
 
     function normal(source, state) {
-	if (source.match(/^\\[a-z]+/)) {
+	if (source.match(/^\\[a-zA-Z@]+/)) {
 	    var cmdName = source.current();
 	    cmdName = cmdName.substr(1, cmdName.length-1);
 	    var plug = plugins[cmdName];
@@ -95,9 +95,22 @@ CodeMirror.defineMode("stex", function(cmCfg, modeCfg)
 	    return plug.style;
 	}
 
+        // escape characters 
+        if (source.match(/^\\[$&%#{}_]/)) {
+          return "tag";
+        }
+
+        // white space control characters
+        if (source.match(/^\\[,;!\/]/)) {
+          return "tag";
+        }
+
 	var ch = source.next();
 	if (ch == "%") {
-	    setState(state, inCComment);
+            // special case: % at end of its own line; stay in same state
+            if (!source.eol()) {
+              setState(state, inCComment);
+            }
 	    return "comment";
 	} 
 	else if (ch=='}' || ch==']') {

data/vendor/assets/javascripts/codemirror/modes/tiddlywiki.js

@@ -1,18 +1,18 @@
 /***
- |''Name''|tiddlywiki.js|
- |''Description''|Enables TiddlyWikiy syntax highlighting using CodeMirror2|
- |''Author''|PMario|
- |''Version''|0.1.6|
- |''Status''|''beta''|
- |''Source''|[[GitHub|https://github.com/pmario/CodeMirror2/blob/tw-syntax/mode/tiddlywiki]]|
- |''Documentation''|http://codemirror.tiddlyspace.com/|
- |''License''|[[MIT License|http://www.opensource.org/licenses/mit-license.php]]|
- |''CoreVersion''|2.5.0|
- |''Requires''|codemirror.js|
- |''Keywords''|syntax highlighting color code mirror codemirror|
- ! Info
- CoreVersion parameter is needed for TiddlyWiki only!
- ***/
+|''Name''|tiddlywiki.js|
+|''Description''|Enables TiddlyWikiy syntax highlighting using CodeMirror|
+|''Author''|PMario|
+|''Version''|0.1.7|
+|''Status''|''stable''|
+|''Source''|[[GitHub|https://github.com/pmario/CodeMirror2/blob/tw-syntax/mode/tiddlywiki]]|
+|''Documentation''|http://codemirror.tiddlyspace.com/|
+|''License''|[[MIT License|http://www.opensource.org/licenses/mit-license.php]]|
+|''CoreVersion''|2.5.0|
+|''Requires''|codemirror.js|
+|''Keywords''|syntax highlighting color code mirror codemirror|
+! Info
+CoreVersion parameter is needed for TiddlyWiki only!
+***/
 //{{{
 CodeMirror.defineMode("tiddlywiki", function (config, parserConfig) {
 	var indentUnit = config.indentUnit;
@@ -47,20 +47,20 @@ CodeMirror.defineMode("tiddlywiki", function (config, parserConfig) {
 	}();
 
 	var isSpaceName = /[\w_\-]/i,
-		reHR = /^\-\-\-\-+$/,
+		reHR = /^\-\-\-\-+$/,					// <hr>
 		reWikiCommentStart = /^\/\*\*\*$/,		// /***
 		reWikiCommentStop = /^\*\*\*\/$/,		// ***/
 		reBlockQuote = /^<<<$/,
 
-		reJsCodeStart = /^\/\/\{\{\{$/,			// //{{{
-		reJsCodeStop = /^\/\/\}\}\}$/,			// //}}}
-		reXmlCodeStart = /^<!--\{\{\{-->$/,
-		reXmlCodeStop = /^<!--\}\}\}-->$/,
+		reJsCodeStart = /^\/\/\{\{\{$/,			// //{{{ js block start
+		reJsCodeStop = /^\/\/\}\}\}$/,			// //}}} js stop
+		reXmlCodeStart = /^<!--\{\{\{-->$/,		// xml block start
+		reXmlCodeStop = /^<!--\}\}\}-->$/,		// xml stop
 
-		reCodeBlockStart = /^\{\{\{$/,
-		reCodeBlockStop = /^\}\}\}$/,
+		reCodeBlockStart = /^\{\{\{$/,			// {{{ TW text div block start
+		reCodeBlockStop = /^\}\}\}$/,			// }}} TW text stop
 
-		reCodeStart = /\{\{\{/,
+		reCodeStart = /\{\{\{/,					// {{{ code span start
 		reUntilCodeStop = /.*?\}\}\}/;
 
 	function chain(stream, state, f) {
@@ -95,9 +95,9 @@ CodeMirror.defineMode("tiddlywiki", function (config, parserConfig) {
 			
 		state.block = false;	// indicates the start of a code block.
 
-		ch = stream.peek(); // don't eat, to make match simpler
+		ch = stream.peek(); 	// don't eat, to make matching simpler
 		
-		// check start of  blocks    
+		// check start of  blocks
 		if (sol && /[<\/\*{}\-]/.test(ch)) {
 			if (stream.match(reCodeBlockStart)) {
 				state.block = true;
@@ -116,7 +116,7 @@ CodeMirror.defineMode("tiddlywiki", function (config, parserConfig) {
 				return ret('hr', 'hr');
 			}
 		} // sol
-		var ch = stream.next();
+		ch = stream.next();
 
 		if (sol && /[\/\*!#;:>|]/.test(ch)) {
 			if (ch == "!") { // tw header
@@ -131,11 +131,11 @@ CodeMirror.defineMode("tiddlywiki", function (config, parserConfig) {
 				stream.eatWhile('#');
 				return ret("list", "list");
 			}
-			if (ch == ";") { // tw list
+			if (ch == ";") { // definition list, term
 				stream.eatWhile(';');
 				return ret("list", "list");
 			}
-			if (ch == ":") { // tw list
+			if (ch == ":") { // definition list, description
 				stream.eatWhile(':');
 				return ret("list", "list");
 			}
@@ -162,6 +162,9 @@ CodeMirror.defineMode("tiddlywiki", function (config, parserConfig) {
 		if (ch == '"') {
 			return ret('string', 'string');
 		}
+		if (ch == '~') {	// _no_ CamelCase indicator should be bold
+			return ret('text', 'brace');
+		}
 		if (/[\[\]]/.test(ch)) { // check for [[..]]
 			if (stream.peek() == ch) {
 				stream.next();
@@ -189,9 +192,15 @@ CodeMirror.defineMode("tiddlywiki", function (config, parserConfig) {
 				return chain(stream, state, twTokenUnderline);
 			}
 		}
-		if (ch == "-") { // tw strikethrough TODO looks ugly .. different handling see below;
+		// strikethrough and mdash handling
+		if (ch == "-") {
 			if (stream.eat("-")) {
-				return chain(stream, state, twTokenStrike);
+				// if strikethrough looks ugly, change CSS.
+				if (stream.peek() != ' ')
+					return chain(stream, state, twTokenStrike);
+				// mdash
+				if (stream.peek() == ' ')
+					return ret('text', 'brace');
 			}
 		}
 		if (ch == "'") { // tw bold
@@ -208,6 +217,7 @@ CodeMirror.defineMode("tiddlywiki", function (config, parserConfig) {
 			return ret(ch);
 		}
 
+		// core macro handling
 		stream.eatWhile(/[\w\$_]/);
 		var word = stream.current(),
 			known = textwords.propertyIsEnumerable(word) && textwords[word];
@@ -301,8 +311,8 @@ CodeMirror.defineMode("tiddlywiki", function (config, parserConfig) {
 		return ret("text", "underlined");
 	}
 
-	// tw strike through text looks ugly 
-	// TODO just strike through the first and last 2 chars if possible.
+	// tw strike through text looks ugly
+	// change CSS if needed
 	function twTokenStrike(stream, state) {
 		var maybeEnd = false,
 			ch, nr;

data/vendor/assets/javascripts/codemirror/modes/vbscript.js

@@ -0,0 +1,26 @@
+CodeMirror.defineMode("vbscript", function() {
+  var regexVBScriptKeyword = /^(?:Call|Case|CDate|Clear|CInt|CLng|Const|CStr|Description|Dim|Do|Each|Else|ElseIf|End|Err|Error|Exit|False|For|Function|If|LCase|Loop|LTrim|Next|Nothing|Now|Number|On|Preserve|Quit|ReDim|Resume|RTrim|Select|Set|Sub|Then|To|Trim|True|UBound|UCase|Until|VbCr|VbCrLf|VbLf|VbTab)$/im;
+
+  return {
+    token: function(stream) {
+      if (stream.eatSpace()) return null;
+      var ch = stream.next();
+      if (ch == "'") {
+      	stream.skipToEnd();
+      	return "comment";
+      }
+      if (ch == '"') {
+      	stream.skipTo('"');
+      	return "string";
+      }
+
+      if (/\w/.test(ch)) {
+        stream.eatWhile(/\w/);
+        if (regexVBScriptKeyword.test(stream.current())) return "keyword";
+      }
+      return null;
+    }
+  };
+});
+
+CodeMirror.defineMIME("text/vbscript", "vbscript");

data/vendor/assets/javascripts/codemirror/modes/xml.js

@@ -264,4 +264,5 @@ CodeMirror.defineMode("xml", function(config, parserConfig) {
 });
 
 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});

data/vendor/assets/javascripts/codemirror/modes/xquery.js

@@ -0,0 +1,448 @@
+/*
+Copyright (C) 2011 by MarkLogic Corporation
+Author: Mike Brevoort <mike@brevoort.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+CodeMirror.defineMode("xquery", function(config, parserConfig) {
+
+  // The keywords object is set to the result of this self executing
+  // function. Each keyword is a property of the keywords object whose
+  // value is {type: atype, style: astyle}
+  var keywords = function(){
+    // conveinence functions used to build keywords object
+    function kw(type) {return {type: type, style: "keyword"};}
+    var A = kw("keyword a")
+      , B = kw("keyword b")
+      , C = kw("keyword c")
+      , operator = kw("operator")
+      , atom = {type: "atom", style: "atom"}
+      , punctuation = {type: "punctuation", style: ""}
+      , qualifier = {type: "axis_specifier", style: "qualifier"};
+    
+    // kwObj is what is return from this function at the end
+    var kwObj = {
+      'if': A, 'switch': A, 'while': A, 'for': A,
+      'else': B, 'then': B, 'try': B, 'finally': B, 'catch': B,
+      'element': C, 'attribute': C, 'let': C, 'implements': C, 'import': C, 'module': C, 'namespace': C, 
+      'return': C, 'super': C, 'this': C, 'throws': C, 'where': C, 'private': C,      
+      ',': punctuation,
+      'null': atom, 'fn:false()': atom, 'fn:true()': atom
+    };
+    
+    // a list of 'basic' keywords. For each add a property to kwObj with the value of 
+    // {type: basic[i], style: "keyword"} e.g. 'after' --> {type: "after", style: "keyword"}
+    var basic = ['after','ancestor','ancestor-or-self','and','as','ascending','assert','attribute','before',
+    'by','case','cast','child','comment','declare','default','define','descendant','descendant-or-self',
+    'descending','document','document-node','element','else','eq','every','except','external','following',
+    'following-sibling','follows','for','function','if','import','in','instance','intersect','item',
+    'let','module','namespace','node','node','of','only','or','order','parent','precedes','preceding',
+    'preceding-sibling','processing-instruction','ref','return','returns','satisfies','schema','schema-element',
+    'self','some','sortby','stable','text','then','to','treat','typeswitch','union','variable','version','where',
+    'xquery', 'empty-sequence'];
+    for(var i=0, l=basic.length; i < l; i++) { kwObj[basic[i]] = kw(basic[i])};
+    
+    // a list of types. For each add a property to kwObj with the value of 
+    // {type: "atom", style: "atom"}
+    var types = ['xs:string', 'xs:float', 'xs:decimal', 'xs:double', 'xs:integer', 'xs:boolean', 'xs:date', 'xs:dateTime', 
+    'xs:time', 'xs:duration', 'xs:dayTimeDuration', 'xs:time', 'xs:yearMonthDuration', 'numeric', 'xs:hexBinary', 
+    'xs:base64Binary', 'xs:anyURI', 'xs:QName', 'xs:byte','xs:boolean','xs:anyURI','xf:yearMonthDuration'];
+    for(var i=0, l=types.length; i < l; i++) { kwObj[types[i]] = atom;};
+    
+    // each operator will add a property to kwObj with value of {type: "operator", style: "keyword"}
+    var operators = ['eq', 'ne', 'lt', 'le', 'gt', 'ge', ':=', '=', '>', '>=', '<', '<=', '.', '|', '?', 'and', 'or', 'div', 'idiv', 'mod', '*', '/', '+', '-'];
+    for(var i=0, l=operators.length; i < l; i++) { kwObj[operators[i]] = operator;};
+    
+    // each axis_specifiers will add a property to kwObj with value of {type: "axis_specifier", style: "qualifier"}
+    var axis_specifiers = ["self::", "attribute::", "child::", "descendant::", "descendant-or-self::", "parent::", 
+    "ancestor::", "ancestor-or-self::", "following::", "preceding::", "following-sibling::", "preceding-sibling::"];
+    for(var i=0, l=axis_specifiers.length; i < l; i++) { kwObj[axis_specifiers[i]] = qualifier; };
+
+    return kwObj;
+  }();
+
+  // 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 chain(stream, state, f) {
+    state.tokenize = f;
+    return f(stream, state);
+  }
+  
+  // the primary mode tokenizer
+  function tokenBase(stream, state) {
+    var ch = stream.next(), 
+        mightBeFunction = false,
+        isEQName = isEQNameAhead(stream);
+    
+    // an XML tag (if not in some sub, chained tokenizer)
+    if (ch == "<") {
+      if(stream.match("!--", true))
+        return chain(stream, state, tokenXMLComment);
+        
+      if(stream.match("![CDATA", false)) {
+        state.tokenize = tokenCDATA;
+        return ret("tag", "tag");
+      }
+      
+      if(stream.match("?", false)) {
+        return chain(stream, state, tokenPreProcessing);
+      }
+      
+      var isclose = stream.eat("/");
+      stream.eatSpace();
+      var tagName = "", c;
+      while ((c = stream.eat(/[^\s\u00a0=<>\"\'\/?]/))) tagName += c;
+      
+      return chain(stream, state, tokenTag(tagName, isclose));
+    }
+    // start code block
+    else if(ch == "{") {
+      pushStateStack(state,{ type: "codeblock"});
+      return ret("", "");
+    }
+    // end code block
+    else if(ch == "}") {
+      popStateStack(state);
+      return ret("", "");
+    }
+    // if we're in an XML block
+    else if(isInXmlBlock(state)) {
+      if(ch == ">")
+        return ret("tag", "tag");
+      else if(ch == "/" && stream.eat(">")) {
+        popStateStack(state);
+        return ret("tag", "tag");
+      }
+      else  
+        return ret("word", "word");
+    }
+    // if a number
+    else if (/\d/.test(ch)) {
+      stream.match(/^\d*(?:\.\d*)?(?:E[+\-]?\d+)?/);
+      return ret("number", "atom");
+    }
+    // comment start
+    else if (ch === "(" && stream.eat(":")) {
+      pushStateStack(state, { type: "comment"});
+      return chain(stream, state, tokenComment);
+    }
+    // quoted string
+    else if (  !isEQName && (ch === '"' || ch === "'"))
+      return chain(stream, state, tokenString(ch));
+    // variable
+    else if(ch === "$") {
+      return chain(stream, state, tokenVariable);
+    }
+    // assignment
+    else if(ch ===":" && stream.eat("=")) {
+      return ret("operator", "keyword");
+    }
+    // open paren
+    else if(ch === "(") {
+      pushStateStack(state, { type: "paren"});
+      return ret("", "");
+    }
+    // close paren
+    else if(ch === ")") {
+      popStateStack(state);
+      return ret("", "");
+    }
+    // open paren
+    else if(ch === "[") {
+      pushStateStack(state, { type: "bracket"});
+      return ret("", "");
+    }
+    // close paren
+    else if(ch === "]") {
+      popStateStack(state);
+      return ret("", "");
+    }
+    else {
+      var known = keywords.propertyIsEnumerable(ch) && keywords[ch];
+
+      // if there's a EQName ahead, consume the rest of the string portion, it's likely a function
+      if(isEQName && ch === '\"') while(stream.next() !== '"'){}
+      if(isEQName && ch === '\'') while(stream.next() !== '\''){}
+      
+      // gobble up a word if the character is not known
+      if(!known) stream.eatWhile(/[\w\$_-]/);
+      
+      // gobble a colon in the case that is a lib func type call fn:doc
+      var foundColon = stream.eat(":")
+      
+      // if there's not a second colon, gobble another word. Otherwise, it's probably an axis specifier
+      // which should get matched as a keyword
+      if(!stream.eat(":") && foundColon) {
+        stream.eatWhile(/[\w\$_-]/);
+      }
+      // if the next non whitespace character is an open paren, this is probably a function (if not a keyword of other sort)
+      if(stream.match(/^[ \t]*\(/, false)) {
+        mightBeFunction = true;
+      }
+      // is the word a keyword?
+      var word = stream.current();
+      known = keywords.propertyIsEnumerable(word) && keywords[word];
+      
+      // if we think it's a function call but not yet known, 
+      // set style to variable for now for lack of something better
+      if(mightBeFunction && !known) known = {type: "function_call", style: "variable def"};
+      
+      // if the previous word was element, attribute, axis specifier, this word should be the name of that
+      if(isInXmlConstructor(state)) {
+        popStateStack(state);
+        return ret("word", "word", word);
+      }
+      // as previously checked, if the word is element,attribute, axis specifier, call it an "xmlconstructor" and 
+      // push the stack so we know to look for it on the next word
+      if(word == "element" || word == "attribute" || known.type == "axis_specifier") pushStateStack(state, {type: "xmlconstructor"});
+      
+      // if the word is known, return the details of that else just call this a generic 'word'
+      return known ? ret(known.type, known.style, word) :
+                     ret("word", "word", word);
+    }
+  }
+
+  // handle comments, including nested 
+  function tokenComment(stream, state) {
+    var maybeEnd = false, maybeNested = false, nestedCount = 0, ch;
+    while (ch = stream.next()) {
+      if (ch == ")" && maybeEnd) {
+        if(nestedCount > 0)
+          nestedCount--;
+        else {
+          popStateStack(state);
+          break;
+        }
+      }
+      else if(ch == ":" && maybeNested) {
+        nestedCount++;
+      }
+      maybeEnd = (ch == ":");
+      maybeNested = (ch == "(");
+    }
+    
+    return ret("comment", "comment");
+  }
+
+  // tokenizer for string literals
+  // optionally pass a tokenizer function to set state.tokenize back to when finished
+  function tokenString(quote, f) {
+    return function(stream, state) {
+      var ch;
+
+      if(isInString(state) && stream.current() == quote) {
+        popStateStack(state);
+        if(f) state.tokenize = f;
+        return ret("string", "string");
+      }
+
+      pushStateStack(state, { type: "string", name: quote, tokenize: tokenString(quote, f) });
+
+      // if we're in a string and in an XML block, allow an embedded code block
+      if(stream.match("{", false) && isInXmlAttributeBlock(state)) {
+        state.tokenize = tokenBase;
+        return ret("string", "string"); 
+      }
+
+      
+      while (ch = stream.next()) {
+        if (ch ==  quote) {
+          popStateStack(state);
+          if(f) state.tokenize = f;
+          break;
+        }
+        else {
+          // if we're in a string and in an XML block, allow an embedded code block in an attribute
+          if(stream.match("{", false) && isInXmlAttributeBlock(state)) {
+            state.tokenize = tokenBase;
+            return ret("string", "string"); 
+          }
+
+        }
+      }
+      
+      return ret("string", "string");
+    };
+  }
+  
+  // tokenizer for variables
+  function tokenVariable(stream, state) {
+    var isVariableChar = /[\w\$_-]/;
+
+    // a variable may start with a quoted EQName so if the next character is quote, consume to the next quote
+    if(stream.eat("\"")) {
+      while(stream.next() !== '\"'){};
+      stream.eat(":");
+    } else {
+      stream.eatWhile(isVariableChar);
+      if(!stream.match(":=", false)) stream.eat(":");
+    }
+    stream.eatWhile(isVariableChar);
+    state.tokenize = tokenBase;
+    return ret("variable", "variable");
+  }
+  
+  // tokenizer for XML tags
+  function tokenTag(name, isclose) {
+    return function(stream, state) {
+      stream.eatSpace();
+      if(isclose && stream.eat(">")) {
+        popStateStack(state);
+        state.tokenize = tokenBase;
+        return ret("tag", "tag");
+      }
+      // self closing tag without attributes?
+      if(!stream.eat("/"))
+        pushStateStack(state, { type: "tag", name: name, tokenize: tokenBase});
+      if(!stream.eat(">")) {
+        state.tokenize = tokenAttribute;
+        return ret("tag", "tag");
+      }
+      else {
+        state.tokenize = tokenBase;        
+      }
+      return ret("tag", "tag");
+    }
+  }
+
+  // tokenizer for XML attributes
+  function tokenAttribute(stream, state) {
+    var ch = stream.next();
+    
+    if(ch == "/" && stream.eat(">")) {
+      if(isInXmlAttributeBlock(state)) popStateStack(state);
+      if(isInXmlBlock(state)) popStateStack(state);
+      return ret("tag", "tag");
+    }
+    if(ch == ">") {
+      if(isInXmlAttributeBlock(state)) popStateStack(state);
+      return ret("tag", "tag");
+    }
+    if(ch == "=")
+      return ret("", "");
+    // quoted string
+    if (ch == '"' || ch == "'")
+      return chain(stream, state, tokenString(ch, tokenAttribute));
+
+    if(!isInXmlAttributeBlock(state)) 
+      pushStateStack(state, { type: "attribute", name: name, tokenize: tokenAttribute});
+
+    stream.eat(/[a-zA-Z_:]/);
+    stream.eatWhile(/[-a-zA-Z0-9_:.]/);
+    stream.eatSpace();
+
+    // the case where the attribute has not value and the tag was closed
+    if(stream.match(">", false) || stream.match("/", false)) {
+      popStateStack(state);
+      state.tokenize = tokenBase;      
+    }
+
+    return ret("attribute", "attribute");
+  }
+  
+  // handle comments, including nested 
+  function tokenXMLComment(stream, state) {
+    while (ch = stream.next()) {
+      if (ch == "-" && stream.match("->", true)) {
+        state.tokenize = tokenBase;        
+        return ret("comment", "comment");
+      }
+    }
+  }
+
+
+  // handle CDATA
+  function tokenCDATA(stream, state) {
+    while (ch = stream.next()) {
+      if (ch == "]" && stream.match("]", true)) {
+        state.tokenize = tokenBase;        
+        return ret("comment", "comment");
+      }
+    }
+  }
+
+  // handle preprocessing instructions
+  function tokenPreProcessing(stream, state) {
+    while (ch = stream.next()) {
+      if (ch == "?" && stream.match(">", true)) {
+        state.tokenize = tokenBase;        
+        return ret("comment", "comment meta");
+      }
+    }
+  }
+  
+  
+  // functions to test the current context of the state
+  function isInXmlBlock(state) { return isIn(state, "tag"); }
+  function isInXmlAttributeBlock(state) { return isIn(state, "attribute"); }
+  function isInCodeBlock(state) { return isIn(state, "codeblock"); }
+  function isInXmlConstructor(state) { return isIn(state, "xmlconstructor"); }
+  function isInString(state) { return isIn(state, "string"); }
+
+  function isEQNameAhead(stream) { 
+    // assume we've already eaten a quote (")
+    if(stream.current() === '"')
+      return stream.match(/^[^\"]+\"\:/, false);
+    else if(stream.current() === '\'')
+      return stream.match(/^[^\"]+\'\:/, false);
+    else
+      return false;
+  }
+  
+  function isIn(state, type) {
+    return (state.stack.length && state.stack[state.stack.length - 1].type == type);    
+  }
+  
+  function pushStateStack(state, newState) {
+    state.stack.push(newState);
+  }
+  
+  function popStateStack(state) {
+    var popped = state.stack.pop();
+    var reinstateTokenize = state.stack.length && state.stack[state.stack.length-1].tokenize
+    state.tokenize = reinstateTokenize || tokenBase;
+  }
+  
+  // the interface for the mode API
+  return {
+    startState: function(basecolumn) {
+      return {
+        tokenize: tokenBase,
+        cc: [],
+        stack: []
+      };
+    },
+
+    token: function(stream, state) {
+      if (stream.eatSpace()) return null;
+      var style = state.tokenize(stream, state);
+      return style;
+    }
+  };
+
+});
+
+CodeMirror.defineMIME("application/xquery", "xquery");