From 01685c255fda6e13f1cd2980130d2e388d52125c Mon Sep 17 00:00:00 2001
From: Wu Cheng-Han
Date: Sat, 4 Jul 2015 11:31:01 +0800
Subject: Updated codemirror to 5.4.0

---
 public/vendor/codemirror/mode/elm/elm.js | 205 +++++++++++++++++++++++++++++++
 1 file changed, 205 insertions(+)
 create mode 100755 public/vendor/codemirror/mode/elm/elm.js

(limited to 'public/vendor/codemirror/mode/elm/elm.js')

diff --git a/public/vendor/codemirror/mode/elm/elm.js b/public/vendor/codemirror/mode/elm/elm.js
new file mode 100755
index 00000000..7124c50a
--- /dev/null
+++ b/public/vendor/codemirror/mode/elm/elm.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("elm", function() {
+
+    function switchState(source, setState, f) {
+      setState(f);
+      return f(source, setState);
+    }
+
+    // These should all be Unicode extended, as per the Haskell 2010 report
+    var smallRE = /[a-z_]/;
+    var largeRE = /[A-Z]/;
+    var digitRE = /[0-9]/;
+    var hexitRE = /[0-9A-Fa-f]/;
+    var octitRE = /[0-7]/;
+    var idRE = /[a-z_A-Z0-9\']/;
+    var symbolRE = /[-!#$%&*+.\/<=>?@\\^|~:\u03BB\u2192]/;
+    var specialRE = /[(),;[\]`{}]/;
+    var whiteCharRE = /[ \t\v\f]/; // newlines are handled in tokenizer
+
+    function normal() {
+      return function (source, setState) {
+        if (source.eatWhile(whiteCharRE)) {
+          return null;
+        }
+
+        var ch = source.next();
+        if (specialRE.test(ch)) {
+          if (ch == '{' && source.eat('-')) {
+            var t = "comment";
+            if (source.eat('#')) t = "meta";
+            return switchState(source, setState, ncomment(t, 1));
+          }
+          return null;
+        }
+
+        if (ch == '\'') {
+          if (source.eat('\\'))
+            source.next();  // should handle other escapes here
+          else
+            source.next();
+
+          if (source.eat('\''))
+            return "string";
+          return "error";
+        }
+
+        if (ch == '"') {
+          return switchState(source, setState, stringLiteral);
+        }
+
+        if (largeRE.test(ch)) {
+          source.eatWhile(idRE);
+          if (source.eat('.'))
+            return "qualifier";
+          return "variable-2";
+        }
+
+        if (smallRE.test(ch)) {
+          var isDef = source.pos === 1;
+          source.eatWhile(idRE);
+          return isDef ? "variable-3" : "variable";
+        }
+
+        if (digitRE.test(ch)) {
+          if (ch == '0') {
+            if (source.eat(/[xX]/)) {
+              source.eatWhile(hexitRE); // should require at least 1
+              return "integer";
+            }
+            if (source.eat(/[oO]/)) {
+              source.eatWhile(octitRE); // should require at least 1
+              return "number";
+            }
+          }
+          source.eatWhile(digitRE);
+          var t = "number";
+          if (source.eat('.')) {
+            t = "number";
+            source.eatWhile(digitRE); // should require at least 1
+          }
+          if (source.eat(/[eE]/)) {
+            t = "number";
+            source.eat(/[-+]/);
+            source.eatWhile(digitRE); // should require at least 1
+          }
+          return t;
+        }
+
+        if (symbolRE.test(ch)) {
+          if (ch == '-' && source.eat(/-/)) {
+            source.eatWhile(/-/);
+            if (!source.eat(symbolRE)) {
+              source.skipToEnd();
+              return "comment";
+            }
+          }
+          source.eatWhile(symbolRE);
+          return "builtin";
+        }
+
+        return "error";
+      }
+    }
+
+    function ncomment(type, nest) {
+      if (nest == 0) {
+        return normal();
+      }
+      return function(source, setState) {
+        var currNest = nest;
+        while (!source.eol()) {
+          var ch = source.next();
+          if (ch == '{' && source.eat('-')) {
+            ++currNest;
+          } else if (ch == '-' && source.eat('}')) {
+            --currNest;
+            if (currNest == 0) {
+              setState(normal());
+              return type;
+            }
+          }
+        }
+        setState(ncomment(type, currNest));
+        return type;
+      }
+    }
+
+    function stringLiteral(source, setState) {
+      while (!source.eol()) {
+        var ch = source.next();
+        if (ch == '"') {
+          setState(normal());
+          return "string";
+        }
+        if (ch == '\\') {
+          if (source.eol() || source.eat(whiteCharRE)) {
+            setState(stringGap);
+            return "string";
+          }
+          if (!source.eat('&')) source.next(); // should handle other escapes here
+        }
+      }
+      setState(normal());
+      return "error";
+    }
+
+    function stringGap(source, setState) {
+      if (source.eat('\\')) {
+        return switchState(source, setState, stringLiteral);
+      }
+      source.next();
+      setState(normal());
+      return "error";
+    }
+
+
+    var wellKnownWords = (function() {
+      var wkw = {};
+
+      var keywords = [
+        "case", "of", "as",
+        "if", "then", "else",
+        "let", "in",
+        "infix", "infixl", "infixr",
+        "type", "alias",
+        "input", "output", "foreign", "loopback",
+        "module", "where", "import", "exposing",
+        "_", "..", "|", ":", "=", "\\", "\"", "->", "<-"
+      ];
+
+      for (var i = keywords.length; i--;)
+        wkw[keywords[i]] = "keyword";
+
+      return wkw;
+    })();
+
+
+
+    return {
+      startState: function ()  { return { f: normal() }; },
+      copyState:  function (s) { return { f: s.f }; },
+
+      token: function(stream, state) {
+        var t = state.f(stream, function(s) { state.f = s; });
+        var w = stream.current();
+        return (wellKnownWords.hasOwnProperty(w)) ? wellKnownWords[w] : t;
+      }
+    };
+
+  });
+
+  CodeMirror.defineMIME("text/x-elm", "elm");
+})();
-- 
cgit v1.2.3