codemirror-rails 5.3 → 5.4

data/vendor/assets/javascripts/codemirror/modes/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");
+})();

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

@@ -0,0 +1,83 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+// Factor syntax highlight - simple mode
+//
+// by Dimage Sapelkin (https://github.com/kerabromsmu)
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"), require("../../addon/mode/simple"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror", "../../addon/mode/simple"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  CodeMirror.defineSimpleMode("factor", {
+    // The start state contains the rules that are intially used
+    start: [
+      // comments
+      {regex: /#?!.*/, token: "comment"},
+      // strings """, multiline --> state
+      {regex: /"""/, token: "string", next: "string3"},
+      {regex: /"/, token: "string", next: "string"},
+      // numbers: dec, hex, unicode, bin, fractional, complex
+      {regex: /(?:[+-]?)(?:0x[\d,a-f]+)|(?:0o[0-7]+)|(?:0b[0,1]+)|(?:\d+.?\d*)/, token: "number"},
+      //{regex: /[+-]?/} //fractional
+      // definition: defining word, defined word, etc
+      {regex: /(\:)(\s+)(\S+)(\s+)(\()/, token: ["keyword", null, "def", null, "keyword"], next: "stack"},
+      // vocabulary using --> state
+      {regex: /USING\:/, token: "keyword", next: "vocabulary"},
+      // vocabulary definition/use
+      {regex: /(USE\:|IN\:)(\s+)(\S+)/, token: ["keyword", null, "variable-2"]},
+      // <constructors>
+      {regex: /<\S+>/, token: "builtin"},
+      // "keywords", incl. ; t f . [ ] { } defining words
+      {regex: /;|t|f|if|\.|\[|\]|\{|\}|MAIN:/, token: "keyword"},
+      // any id (?)
+      {regex: /\S+/, token: "variable"},
+
+      {
+        regex: /./,
+        token: null
+      }
+    ],
+    vocabulary: [
+      {regex: /;/, token: "keyword", next: "start"},
+      {regex: /\S+/, token: "variable-2"},
+      {
+        regex: /./,
+        token: null
+      }
+    ],
+    string: [
+      {regex: /(?:[^\\]|\\.)*?"/, token: "string", next: "start"},
+      {regex: /.*/, token: "string"}
+    ],
+    string3: [
+      {regex: /(?:[^\\]|\\.)*?"""/, token: "string", next: "start"},
+      {regex: /.*/, token: "string"}
+    ],
+    stack: [
+      {regex: /\)/, token: "meta", next: "start"},
+      {regex: /--/, token: "meta"},
+      {regex: /\S+/, token: "variable-3"},
+      {
+        regex: /./,
+        token: null
+      }
+    ],
+    // The meta property contains global information about the mode. It
+    // can contain properties like lineComment, which are supported by
+    // all modes, and also directives like dontIndentStates, which are
+    // specific to simple modes.
+    meta: {
+      dontIndentStates: ["start", "vocabulary", "string", "string3", "stack"],
+      lineComment: [ "!", "#!" ]
+    }
+  });
+
+  CodeMirror.defineMIME("text/x-factor", "factor");
+});

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

@@ -24,6 +24,7 @@ CodeMirror.defineMode("groovy", function(config) {
     "short static strictfp super switch synchronized threadsafe throw throws transient " +
     "try void volatile while");
   var blockKeywords = words("catch class do else finally for if switch try while enum interface def");
+  var standaloneKeywords = words("return break continue");
   var atoms = words("null true false this");
 
   var curPunc;
@@ -50,7 +51,7 @@ CodeMirror.defineMode("groovy", function(config) {
         stream.skipToEnd();
         return "comment";
       }
-      if (expectExpression(state.lastToken)) {
+      if (expectExpression(state.lastToken, false)) {
         return startString(ch, stream, state);
       }
     }
@@ -70,6 +71,7 @@ CodeMirror.defineMode("groovy", function(config) {
     if (atoms.propertyIsEnumerable(cur)) { return "atom"; }
     if (keywords.propertyIsEnumerable(cur)) {
       if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
+      else if (standaloneKeywords.propertyIsEnumerable(cur)) curPunc = "standalone";
       return "keyword";
     }
     return "variable";
@@ -132,9 +134,10 @@ CodeMirror.defineMode("groovy", function(config) {
     return "comment";
   }
 
-  function expectExpression(last) {
+  function expectExpression(last, newline) {
     return !last || last == "operator" || last == "->" || /[\.\[\{\(,;:]/.test(last) ||
-      last == "newstatement" || last == "keyword" || last == "proplabel";
+      last == "newstatement" || last == "keyword" || last == "proplabel" ||
+      (last == "standalone" && !newline);
   }
 
   function Context(indented, column, type, align, prev) {
@@ -174,7 +177,7 @@ CodeMirror.defineMode("groovy", function(config) {
         state.indented = stream.indentation();
         state.startOfLine = true;
         // Automatic semicolon insertion
-        if (ctx.type == "statement" && !expectExpression(state.lastToken)) {
+        if (ctx.type == "statement" && !expectExpression(state.lastToken, true)) {
           popContext(state); ctx = state.context;
         }
       }
@@ -209,7 +212,7 @@ CodeMirror.defineMode("groovy", function(config) {
     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;
+      if (ctx.type == "statement" && !expectExpression(state.lastToken, true)) 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);

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

@@ -482,8 +482,11 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
   function maybetype(type) {
     if (isTS && type == ":") return cont(typedef);
   }
+  function maybedefault(_, value) {
+    if (value == "=") return cont(expressionNoComma);
+  }
   function typedef(type) {
-    if (type == "variable"){cx.marked = "variable-3"; return cont();}
+    if (type == "variable") {cx.marked = "variable-3"; return cont();}
   }
   function vardef() {
     return pass(pattern, maybetype, maybeAssign, vardefCont);
@@ -538,7 +541,7 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
   }
   function funarg(type) {
     if (type == "spread") return cont(funarg);
-    return pass(pattern, maybetype);
+    return pass(pattern, maybetype, maybedefault);
   }
   function className(type, value) {
     if (type == "variable") {register(value); return cont(classNameAfter);}

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

@@ -21,7 +21,7 @@ CodeMirror.defineMode("kotlin", function (config, parserConfig) {
   var multiLineStrings = parserConfig.multiLineStrings;
 
   var keywords = words(
-          "package continue return object while break class data trait throw super" +
+          "package continue return object while break class data trait interface 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" +
@@ -272,7 +272,10 @@ CodeMirror.defineMode("kotlin", function (config, parserConfig) {
     },
 
     closeBrackets: {triples: "'\""},
-    electricChars: "{}"
+    electricChars: "{}",
+    blockCommentStart: "/*",
+    blockCommentEnd: "*/",
+    lineComment: "//"
   };
 });
 

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

@@ -68,12 +68,12 @@ CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
   ,   strong   = 'strong'
   ,   strikethrough = 'strikethrough';
 
-  var hrRE = /^([*\-=_])(?:\s*\1){2,}\s*$/
+  var hrRE = /^([*\-_])(?:\s*\1){2,}\s*$/
   ,   ulRE = /^[*\-+]\s+/
-  ,   olRE = /^[0-9]+\.\s+/
+  ,   olRE = /^[0-9]+([.)])\s+/
   ,   taskListRE = /^\[(x| )\](?=\s)/ // Must follow ulRE or olRE
-  ,   atxHeaderRE = /^#+ ?/
-  ,   setextHeaderRE = /^(?:\={1,}|-{1,})$/
+  ,   atxHeaderRE = /^(#+)(?: |$)/
+  ,   setextHeaderRE = /^ *(?:\={1,}|-{1,})\s*$/
   ,   textRE = /^[^#!\[\]*_\\<>` "'(~]+/;
 
   function switchInline(stream, state, f) {
@@ -100,6 +100,8 @@ CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
     state.strikethrough = false;
     // Reset state.quote
     state.quote = 0;
+    // Reset state.indentedCode
+    state.indentedCode = false;
     if (!htmlFound && state.f == htmlBlock) {
       state.f = inlineNormal;
       state.block = blockNormal;
@@ -116,7 +118,11 @@ CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
 
     var sol = stream.sol();
 
-    var prevLineIsList = state.list !== false;
+    var prevLineIsList = state.list !== false,
+        prevLineIsIndentedCode = state.indentedCode;
+
+    state.indentedCode = false;
+
     if (prevLineIsList) {
       if (state.indentationDiff >= 0) { // Continued list
         if (state.indentationDiff < 4) { // Only adjust indentation if *not* a code block
@@ -134,23 +140,27 @@ CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
 
     var match = null;
     if (state.indentationDiff >= 4) {
-      state.indentation -= 4;
       stream.skipToEnd();
-      return code;
+      if (prevLineIsIndentedCode || !state.prevLineHasContent) {
+        state.indentation -= 4;
+        state.indentedCode = true;
+        return code;
+      } else {
+        return null;
+      }
     } else if (stream.eatSpace()) {
       return null;
-    } else if (match = stream.match(atxHeaderRE)) {
-      state.header = Math.min(6, match[0].indexOf(" ") !== -1 ? match[0].length - 1 : match[0].length);
+    } else if ((match = stream.match(atxHeaderRE)) && match[1].length <= 6) {
+      state.header = match[1].length;
       if (modeCfg.highlightFormatting) state.formatting = "header";
       state.f = state.inline;
       return getType(state);
-    } else if (state.prevLineHasContent && (match = stream.match(setextHeaderRE))) {
+    } else if (state.prevLineHasContent && !state.quote && !prevLineIsList && !prevLineIsIndentedCode && (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();
@@ -158,6 +168,7 @@ CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
     } else if (stream.peek() === '[') {
       return switchInline(stream, state, footnoteLink);
     } else if (stream.match(hrRE, true)) {
+      state.hr = true;
       return hr;
     } else if ((!state.prevLineHasContent || prevLineIsList) && (stream.match(ulRE, false) || stream.match(olRE, false))) {
       var listType = null;
@@ -262,17 +273,16 @@ CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
     }
 
     if (state.linkHref) {
-      styles.push(linkhref);
-      return styles.length ? styles.join(' ') : null;
-    }
+      styles.push(linkhref, "url");
+    } else { // Only apply inline styles to non-url text
+      if (state.strong) { styles.push(strong); }
+      if (state.em) { styles.push(em); }
+      if (state.strikethrough) { styles.push(strikethrough); }
 
-    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.linkText) { styles.push(linktext); }
-
-    if (state.code) { styles.push(code); }
+      if (state.code) { styles.push(code); }
+    }
 
     if (state.header) { styles.push(header); styles.push(header + "-" + state.header); }
 
@@ -626,7 +636,7 @@ CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
       stream.match(/^(?:\s+(?:"(?:[^"\\]|\\\\|\\.)+"|'(?:[^'\\]|\\\\|\\.)+'|\((?:[^)\\]|\\\\|\\.)+\)))?/, true);
     }
     state.f = state.inline = inlineNormal;
-    return linkhref;
+    return linkhref + " url";
   }
 
   var savedInlineRE = [];
@@ -663,6 +673,7 @@ CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
         em: false,
         strong: false,
         header: 0,
+        hr: false,
         taskList: false,
         list: false,
         listDepth: 0,
@@ -695,10 +706,12 @@ CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
         strong: s.strong,
         strikethrough: s.strikethrough,
         header: s.header,
+        hr: s.hr,
         taskList: s.taskList,
         list: s.list,
         listDepth: s.listDepth,
         quote: s.quote,
+        indentedCode: s.indentedCode,
         trailingSpace: s.trailingSpace,
         trailingSpaceNewLine: s.trailingSpaceNewLine,
         md_inside: s.md_inside
@@ -711,10 +724,11 @@ CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
       state.formatting = false;
 
       if (stream.sol()) {
-        var forceBlankLine = !!state.header;
+        var forceBlankLine = !!state.header || state.hr;
 
-        // Reset state.header
+        // Reset state.header and state.hr
         state.header = 0;
+        state.hr = false;
 
         if (stream.match(/^\s*$/, true) || forceBlankLine) {
           state.prevLineHasContent = false;