codemirror: bumped to version 5.49.2

rhodecode/public/js/mode/fcl/fcl.js

@@ -0,0 +1,173 b''
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: https://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("fcl", function(config) {
+  var indentUnit = config.indentUnit;
+
+  var keywords = {
+      "term": true,
+      "method": true, "accu": true,
+      "rule": true, "then": true, "is": true, "and": true, "or": true,
+      "if": true, "default": true
+  };
+
+  var start_blocks = {
+      "var_input": true,
+      "var_output": true,
+      "fuzzify": true,
+      "defuzzify": true,
+      "function_block": true,
+      "ruleblock": true
+  };
+
+  var end_blocks = {
+      "end_ruleblock": true,
+      "end_defuzzify": true,
+      "end_function_block": true,
+      "end_fuzzify": true,
+      "end_var": true
+  };
+
+  var atoms = {
+      "true": true, "false": true, "nan": true,
+      "real": true, "min": true, "max": true, "cog": true, "cogs": true
+  };
+
+  var isOperatorChar = /[+\-*&^%:=<>!|\/]/;
+
+  function tokenBase(stream, state) {
+    var ch = stream.next();
+
+    if (/[\d\.]/.test(ch)) {
+      if (ch == ".") {
+        stream.match(/^[0-9]+([eE][\-+]?[0-9]+)?/);
+      } else if (ch == "0") {
+        stream.match(/^[xX][0-9a-fA-F]+/) || stream.match(/^0[0-7]+/);
+      } else {
+        stream.match(/^[0-9]*\.?[0-9]*([eE][\-+]?[0-9]+)?/);
+      }
+      return "number";
+    }
+
+    if (ch == "/" || ch == "(") {
+      if (stream.eat("*")) {
+        state.tokenize = tokenComment;
+        return tokenComment(stream, state);
+      }
+      if (stream.eat("/")) {
+        stream.skipToEnd();
+        return "comment";
+      }
+    }
+    if (isOperatorChar.test(ch)) {
+      stream.eatWhile(isOperatorChar);
+      return "operator";
+    }
+    stream.eatWhile(/[\w\$_\xa1-\uffff]/);
+
+    var cur = stream.current().toLowerCase();
+    if (keywords.propertyIsEnumerable(cur) ||
+        start_blocks.propertyIsEnumerable(cur) ||
+        end_blocks.propertyIsEnumerable(cur)) {
+      return "keyword";
+    }
+    if (atoms.propertyIsEnumerable(cur)) return "atom";
+    return "variable";
+  }
+
+
+  function tokenComment(stream, state) {
+    var maybeEnd = false, ch;
+    while (ch = stream.next()) {
+      if ((ch == "/" || ch == ")") && maybeEnd) {
+        state.tokenize = tokenBase;
+        break;
+      }
+      maybeEnd = (ch == "*");
+    }
+    return "comment";
+  }
+
+  function Context(indented, column, type, align, prev) {
+    this.indented = indented;
+    this.column = column;
+    this.type = type;
+    this.align = align;
+    this.prev = prev;
+  }
+
+  function pushContext(state, col, type) {
+    return state.context = new Context(state.indented, col, type, null, state.context);
+  }
+
+  function popContext(state) {
+    if (!state.context.prev) return;
+    var t = state.context.type;
+    if (t == "end_block")
+      state.indented = state.context.indented;
+    return state.context = state.context.prev;
+  }
+
+  // Interface
+
+  return {
+    startState: function(basecolumn) {
+      return {
+        tokenize: null,
+        context: new Context((basecolumn || 0) - indentUnit, 0, "top", false),
+        indented: 0,
+        startOfLine: true
+      };
+    },
+
+    token: function(stream, state) {
+        var ctx = state.context;
+        if (stream.sol()) {
+            if (ctx.align == null) ctx.align = false;
+            state.indented = stream.indentation();
+            state.startOfLine = true;
+        }
+        if (stream.eatSpace()) return null;
+
+        var style = (state.tokenize || tokenBase)(stream, state);
+        if (style == "comment") return style;
+        if (ctx.align == null) ctx.align = true;
+
+        var cur = stream.current().toLowerCase();
+
+        if (start_blocks.propertyIsEnumerable(cur)) pushContext(state, stream.column(), "end_block");
+        else if (end_blocks.propertyIsEnumerable(cur))  popContext(state);
+
+        state.startOfLine = false;
+        return style;
+    },
+
+    indent: function(state, textAfter) {
+      if (state.tokenize != tokenBase && state.tokenize != null) return 0;
+      var ctx = state.context;
+
+      var closing = end_blocks.propertyIsEnumerable(textAfter);
+      if (ctx.align) return ctx.column + (closing ? 0 : 1);
+      else return ctx.indented + (closing ? 0 : indentUnit);
+    },
+
+    electricChars: "ryk",
+    fold: "brace",
+    blockCommentStart: "(*",
+    blockCommentEnd: "*)",
+    lineComment: "//"
+  };
+});
+
+CodeMirror.defineMIME("text/x-fcl", "fcl");
+});

rhodecode/public/css/codemirror.less

@@ -1,418 +1,438 b''
 /* BASICS */
 
 .CodeMirror {
   /* Set height, width, borders, and global font properties here */
   font-family: monospace;
   height: 300px;
   color: black;
+  direction: ltr;
   border-radius: @border-radius;
   border: @border-thickness solid @grey6;
   margin: 0 0 @padding;
 }
 
 /* PADDING */
 
 .CodeMirror-lines {
   padding: 4px 0; /* Vertical padding around content */
 }
-.CodeMirror pre {
+.CodeMirror pre.CodeMirror-line,
+.CodeMirror pre.CodeMirror-line-like {
   padding: 0 4px; /* Horizontal padding of content */
 }
 
 .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
   background-color: white; /* The little square between H and V scrollbars */
 }
 
 /* GUTTER */
 
 .CodeMirror-gutters {
   border-right: 1px solid #ddd;
   background-color: white;
   white-space: nowrap;
 }
 .CodeMirror-linenumbers {}
 .CodeMirror-linenumber {
   padding: 0 3px 0 5px;
   min-width: 20px;
   text-align: right;
   color: @grey4;
   white-space: nowrap;
 }
 
 .CodeMirror-guttermarker { color: black; }
 .CodeMirror-guttermarker-subtle { color: #999; }
 
 /* CURSOR */
 
-.CodeMirror div.CodeMirror-cursor {
+.CodeMirror-cursor {
   border-left: 1px solid black;
+  border-right: none;
+  width: 0;
 }
 /* Shown when moving in bi-directional text */
 .CodeMirror div.CodeMirror-secondarycursor {
   border-left: 1px solid silver;
 }
-.CodeMirror.cm-fat-cursor div.CodeMirror-cursor {
+.cm-fat-cursor .CodeMirror-cursor {
   width: auto;
-  border: 0;
+  border: 0 !important;
   background: @grey6;
 }
-.CodeMirror.cm-fat-cursor div.CodeMirror-cursors {
+.cm-fat-cursor div.CodeMirror-cursors {
   z-index: 1;
 }
-
+.cm-fat-cursor-mark {
+  background-color: rgba(20, 255, 20, 0.5);
+  -webkit-animation: blink 1.06s steps(1) infinite;
+  -moz-animation: blink 1.06s steps(1) infinite;
+  animation: blink 1.06s steps(1) infinite;
+}
 .cm-animate-fat-cursor {
   width: auto;
   border: 0;
   -webkit-animation: blink 1.06s steps(1) infinite;
   -moz-animation: blink 1.06s steps(1) infinite;
   animation: blink 1.06s steps(1) infinite;
+  background-color: #7e7;
 }
 @-moz-keyframes blink {
   0% { background: #7e7; }
   50% { background: none; }
   100% { background: #7e7; }
 }
 @-webkit-keyframes blink {
   0% { background: #7e7; }
   50% { background: none; }
   100% { background: #7e7; }
 }
 @keyframes blink {
   0% { background: #7e7; }
   50% { background: none; }
   100% { background: #7e7; }
 }
 
 /* Can style cursor different in overwrite (non-insert) mode */
-div.CodeMirror-overwrite div.CodeMirror-cursor {}
+.CodeMirror-overwrite .CodeMirror-cursor {}
 
 .cm-tab { display: inline-block; text-decoration: inherit; }
 
+.CodeMirror-rulers {
+  position: absolute;
+  left: 0; right: 0; top: -50px; bottom: 0;
+  overflow: hidden;
+}
 .CodeMirror-ruler {
   border-left: 1px solid #ccc;
+  top: 0; bottom: 0;
   position: absolute;
 }
 
 /* DEFAULT THEME */
 
 .cm-s-default .cm-header {color: blue;}
 .cm-s-default .cm-quote {color: #090;}
 .cm-negative {color: #d44;}
 .cm-positive {color: #292;}
 .cm-header, .cm-strong {font-weight: bold;}
 .cm-em {font-style: italic;}
 .cm-link {text-decoration: underline;}
 .cm-strikethrough {text-decoration: line-through;}
 
 .cm-s-default .cm-keyword {color: #708;}
 .cm-s-default .cm-atom {color: #219;}
 .cm-s-default .cm-number {color: #164;}
 .cm-s-default .cm-def {color: #00f;}
 .cm-s-default .cm-variable,
 .cm-s-default .cm-punctuation,
 .cm-s-default .cm-property,
 .cm-s-default .cm-operator {}
 .cm-s-default .cm-variable-2 {color: #05a;}
-.cm-s-default .cm-variable-3 {color: #085;}
+.cm-s-default .cm-variable-3, .cm-s-default .cm-type {color: #085;}
 .cm-s-default .cm-comment {color: #a50;}
 .cm-s-default .cm-string {color: #a11;}
 .cm-s-default .cm-string-2 {color: #f50;}
 .cm-s-default .cm-meta {color: #555;}
 .cm-s-default .cm-qualifier {color: #555;}
 .cm-s-default .cm-builtin {color: #30a;}
 .cm-s-default .cm-bracket {color: #997;}
 .cm-s-default .cm-tag {color: #170;}
 .cm-s-default .cm-attribute {color: #00c;}
 .cm-s-default .cm-hr {color: #999;}
 .cm-s-default .cm-link {color: #00c;}
 
 .cm-s-default .cm-error {color: #f00;}
 .cm-invalidchar {color: #f00;}
 
 .CodeMirror-composing { border-bottom: 2px solid; }
 
 /* Default styles for common addons */
 
-div.CodeMirror span.CodeMirror-matchingbracket {color: #0f0;}
-div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}
+div.CodeMirror span.CodeMirror-matchingbracket {color: #0b0;}
+div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #a22;}
 .CodeMirror-matchingtag { background: rgba(255, 150, 0, .3); }
 .CodeMirror-activeline-background {background: #e8f2ff;}
 
 /* STOP */
 
 /* The rest of this file contains styles related to the mechanics of
    the editor. You probably shouldn't touch them. */
 
 .CodeMirror {
   position: relative;
   overflow: hidden;
   background: white;
 }
 
 .CodeMirror-scroll {
   overflow: scroll !important; /* Things will break if this is overridden */
   /* 30px is the magic margin used to hide the element's real scrollbars */
   /* See overflow: hidden in .CodeMirror */
   margin-bottom: -30px; margin-right: -30px;
   padding-bottom: 30px;
   height: 100%;
   outline: none; /* Prevent dragging from highlighting the element */
   position: relative;
 }
 .CodeMirror-sizer {
   position: relative;
   border-right: 30px solid transparent;
 }
 
 /* The fake, visible scrollbars. Used to force redraw during scrolling
    before actual scrolling happens, thus preventing shaking and
    flickering artifacts. */
 .CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
   position: absolute;
   z-index: 6;
   display: none;
 }
 .CodeMirror-vscrollbar {
   right: 0; top: 0;
   overflow-x: hidden;
   overflow-y: scroll;
 }
 .CodeMirror-hscrollbar {
   bottom: 0; left: 0;
   overflow-y: hidden;
   overflow-x: scroll;
 }
 .CodeMirror-scrollbar-filler {
   right: 0; bottom: 0;
 }
 .CodeMirror-gutter-filler {
   left: 0; bottom: 0;
 }
 
 .CodeMirror-gutters {
   position: absolute; left: 0; top: 0;
+  min-height: 100%;
   z-index: 3;
 }
 .CodeMirror-gutter {
   white-space: normal;
   height: 100%;
   display: inline-block;
+  vertical-align: top;
   margin-bottom: -30px;
-  /* Hack to make IE7 behave */
-  *zoom:1;
-  *display:inline;
 }
 .CodeMirror-gutter-wrapper {
   position: absolute;
   z-index: 4;
+  background: none !important;
+  border: none !important;
   height: 100%;
 }
 .CodeMirror-gutter-background {
   position: absolute;
   top: 0; bottom: 0;
   z-index: 4;
 }
 .CodeMirror-gutter-elt {
   position: absolute;
   cursor: default;
   z-index: 4;
 }
 .CodeMirror-gutter-wrapper {
   -webkit-user-select: none;
   -moz-user-select: none;
   user-select: none;
 }
 
 .CodeMirror-lines {
   cursor: text;
   min-height: 1px; /* prevents collapsing before first draw */
 }
-.CodeMirror pre {
+.CodeMirror pre.CodeMirror-line,
+.CodeMirror pre.CodeMirror-line-like {
   /* Reset some styles that the rest of the page might have set */
   -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;
   border-width: 0;
   background: transparent;
   font-family: inherit;
   font-size: inherit;
   margin: 0;
   white-space: pre;
   word-wrap: normal;
   line-height: inherit;
   color: inherit;
   z-index: 2;
   position: relative;
   overflow: visible;
   -webkit-tap-highlight-color: transparent;
+  -webkit-font-variant-ligatures: contextual;
+  font-variant-ligatures: contextual;
 }
-.CodeMirror-wrap pre {
+.CodeMirror-wrap pre.CodeMirror-line,
+.CodeMirror-wrap pre.CodeMirror-line-like {
   word-wrap: break-word;
   white-space: pre-wrap;
   word-break: normal;
 }
 
 .CodeMirror-linebackground {
   position: absolute;
   left: 0; right: 0; top: 0; bottom: 0;
   z-index: 0;
 }
 
 .CodeMirror-linewidget {
   position: relative;
   z-index: 2;
+  padding: 0.1px; /* Force widget margins to stay inside of the container */
   overflow: auto;
 }
 
 .CodeMirror-widget {}
 
+.CodeMirror-rtl pre { direction: rtl; }
+
 .CodeMirror-code {
   outline: none;
 }
 
 /* Force content-box sizing for the elements where we expect it */
 .CodeMirror-scroll,
 .CodeMirror-sizer,
 .CodeMirror-gutter,
 .CodeMirror-gutters,
 .CodeMirror-linenumber {
   -moz-box-sizing: content-box;
   box-sizing: content-box;
 }
 
 .CodeMirror-measure {
   position: absolute;
   width: 100%;
   height: 0;
   overflow: hidden;
   visibility: hidden;
 }
 
-
-.CodeMirror div.CodeMirror-cursor {
+.CodeMirror-cursor {
   position: absolute;
+  pointer-events: none;
   border-right: none;
   width: 0;
 }
-
 .CodeMirror-measure pre { position: static; }
 
 div.CodeMirror-cursors {
   visibility: hidden;
   position: relative;
   z-index: 3;
 }
 div.CodeMirror-dragcursors {
   visibility: visible;
 }
 
 .CodeMirror-focused div.CodeMirror-cursors {
   visibility: visible;
 }
 
 .CodeMirror-selected { background: #d9d9d9; }
 .CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }
 .CodeMirror-crosshair { cursor: crosshair; }
 .CodeMirror-line::selection, .CodeMirror-line > span::selection, .CodeMirror-line > span > span::selection { background: #d7d4f0; }
 .CodeMirror-line::-moz-selection, .CodeMirror-line > span::-moz-selection, .CodeMirror-line > span > span::-moz-selection { background: #d7d4f0; }
 
 .cm-searching {
-  background: #ffa;
-  background: rgba(255, 255, 0, .4);
+  background-color: #ffa;
+  background-color: rgba(255, 255, 0, .4);
 }
 
-/* IE7 hack to prevent it from returning funny offsetTops on the spans */
-.CodeMirror span { *vertical-align: text-bottom; }
-
 /* Used to force a border model for a node */
 .cm-force-border { padding-right: .1px; }
 
 @media print {
   /* Hide the cursor when printing */
   .CodeMirror div.CodeMirror-cursors {
     visibility: hidden;
   }
 }
 
 /* See issue #2901 */
 .cm-tab-wrap-hack:after { content: ''; }
 
 /* Help users use markselection to safely style text background */
 span.CodeMirror-selectedtext { background: none; }
 
 /* codemirror autocomplete widget */
 .CodeMirror-hints {
   position: absolute;
   z-index: 10;
   overflow: hidden;
   list-style: none;
 
   margin: 0;
   padding: 0;
 
   border-radius: @border-radius;
   border: @border-thickness solid @rcblue;
 
   color: @rcblue;
   background-color: white;
   font-size: 95%;
 
   max-height: 20em;
   overflow-y: auto;
 }
 
 .CodeMirror-hint {
   margin: 0;
   padding: 4px 8px;
   max-width: 40em;
   white-space: pre;
   color: @rcblue;
   cursor: pointer;
 }
 
 .CodeMirror-hint-active {
   background: @rclightblue;
   color: @rcblue;
 }
 
 .CodeMirror-hint-entry {
   width: 38em;
   color: @rcblue;
 }
 
 .CodeMirror-hint-entry .gravatar {
   height: @gravatar-size;
   width: @gravatar-size;
   margin-right: 4px;
 }
 
 .CodeMirror-empty {
   border: @border-thickness solid @grey5;
 }
 
 .CodeMirror-focused {
   border: @border-thickness solid @grey5;
 }
 
 .CodeMirror-empty.CodeMirror-focused {
   border: @border-thickness solid @grey5;
 }
 
 .CodeMirror pre.CodeMirror-placeholder {
   color: @grey4;
 }
 
 /** RhodeCode Customizations **/
 
 .CodeMirror.cm-s-rc-input {
   border: @border-thickness solid @grey4;
 }
 
 .CodeMirror-code pre {
   border-right: 30px solid transparent;
   width: -webkit-fit-content;
   width: -moz-fit-content;
   width: fit-content;
 }
 .CodeMirror-wrap .CodeMirror-code pre {
   border-right: none;
   width: auto;
 }

rhodecode/public/js/mode/apl/apl.js

@@ -1,174 +1,174 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("apl", function() {
   var builtInOps = {
     ".": "innerProduct",
     "\\": "scan",
     "/": "reduce",
     "⌿": "reduce1Axis",
     "⍀": "scan1Axis",
     "¨": "each",
     "⍣": "power"
   };
   var builtInFuncs = {
     "+": ["conjugate", "add"],
     "−": ["negate", "subtract"],
     "×": ["signOf", "multiply"],
     "÷": ["reciprocal", "divide"],
     "⌈": ["ceiling", "greaterOf"],
     "⌊": ["floor", "lesserOf"],
     "∣": ["absolute", "residue"],
     "⍳": ["indexGenerate", "indexOf"],
     "?": ["roll", "deal"],
     "⋆": ["exponentiate", "toThePowerOf"],
     "⍟": ["naturalLog", "logToTheBase"],
     "○": ["piTimes", "circularFuncs"],
     "!": ["factorial", "binomial"],
     "⌹": ["matrixInverse", "matrixDivide"],
     "<": [null, "lessThan"],
     "≤": [null, "lessThanOrEqual"],
     "=": [null, "equals"],
     ">": [null, "greaterThan"],
     "≥": [null, "greaterThanOrEqual"],
     "≠": [null, "notEqual"],
     "≡": ["depth", "match"],
     "≢": [null, "notMatch"],
     "∈": ["enlist", "membership"],
     "⍷": [null, "find"],
     "∪": ["unique", "union"],
     "∩": [null, "intersection"],
     "∼": ["not", "without"],
     "∨": [null, "or"],
     "∧": [null, "and"],
     "⍱": [null, "nor"],
     "⍲": [null, "nand"],
     "⍴": ["shapeOf", "reshape"],
     ",": ["ravel", "catenate"],
     "⍪": [null, "firstAxisCatenate"],
     "⌽": ["reverse", "rotate"],
     "⊖": ["axis1Reverse", "axis1Rotate"],
     "⍉": ["transpose", null],
     "↑": ["first", "take"],
     "↓": [null, "drop"],
     "⊂": ["enclose", "partitionWithAxis"],
     "⊃": ["diclose", "pick"],
     "⌷": [null, "index"],
     "⍋": ["gradeUp", null],
     "⍒": ["gradeDown", null],
     "⊤": ["encode", null],
     "⊥": ["decode", null],
     "⍕": ["format", "formatByExample"],
     "⍎": ["execute", null],
     "⊣": ["stop", "left"],
     "⊢": ["pass", "right"]
   };
 
   var isOperator = /[\.\/⌿⍀¨⍣]/;
   var isNiladic = /⍬/;
   var isFunction = /[\+−×÷⌈⌊∣⍳\?⋆⍟○!⌹<≤=>≥≠≡≢∈⍷∪∩∼∨∧⍱⍲⍴,⍪⌽⊖⍉↑↓⊂⊃⌷⍋⍒⊤⊥⍕⍎⊣⊢]/;
   var isArrow = /←/;
   var isComment = /[⍝#].*$/;
 
   var stringEater = function(type) {
     var prev;
     prev = false;
     return function(c) {
       prev = c;
       if (c === type) {
         return prev === "\\";
       }
       return true;
     };
   };
   return {
     startState: function() {
       return {
         prev: false,
         func: false,
         op: false,
         string: false,
         escape: false
       };
     },
     token: function(stream, state) {
       var ch, funcName;
       if (stream.eatSpace()) {
         return null;
       }
       ch = stream.next();
       if (ch === '"' || ch === "'") {
         stream.eatWhile(stringEater(ch));
         stream.next();
         state.prev = true;
         return "string";
       }
       if (/[\[{\(]/.test(ch)) {
         state.prev = false;
         return null;
       }
       if (/[\]}\)]/.test(ch)) {
         state.prev = true;
         return null;
       }
       if (isNiladic.test(ch)) {
         state.prev = false;
         return "niladic";
       }
       if (/[¯\d]/.test(ch)) {
         if (state.func) {
           state.func = false;
           state.prev = false;
         } else {
           state.prev = true;
         }
         stream.eatWhile(/[\w\.]/);
         return "number";
       }
       if (isOperator.test(ch)) {
         return "operator apl-" + builtInOps[ch];
       }
       if (isArrow.test(ch)) {
         return "apl-arrow";
       }
       if (isFunction.test(ch)) {
         funcName = "apl-";
         if (builtInFuncs[ch] != null) {
           if (state.prev) {
             funcName += builtInFuncs[ch][1];
           } else {
             funcName += builtInFuncs[ch][0];
           }
         }
         state.func = true;
         state.prev = false;
         return "function " + funcName;
       }
       if (isComment.test(ch)) {
         stream.skipToEnd();
         return "comment";
       }
       if (ch === "∘" && stream.peek() === ".") {
         stream.next();
         return "function jot-dot";
       }
       stream.eatWhile(/[\w\$_]/);
       state.prev = true;
       return "keyword";
     }
   };
 });
 
 CodeMirror.defineMIME("text/apl", "apl");
 
 });

rhodecode/public/js/mode/asciiarmor/asciiarmor.js

@@ -1,73 +1,74 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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";
 
   function errorIfNotEmpty(stream) {
     var nonWS = stream.match(/^\s*\S/);
     stream.skipToEnd();
     return nonWS ? "error" : null;
   }
 
   CodeMirror.defineMode("asciiarmor", function() {
     return {
       token: function(stream, state) {
         var m;
         if (state.state == "top") {
           if (stream.sol() && (m = stream.match(/^-----BEGIN (.*)?-----\s*$/))) {
             state.state = "headers";
             state.type = m[1];
             return "tag";
           }
           return errorIfNotEmpty(stream);
         } else if (state.state == "headers") {
           if (stream.sol() && stream.match(/^\w+:/)) {
             state.state = "header";
             return "atom";
           } else {
             var result = errorIfNotEmpty(stream);
             if (result) state.state = "body";
             return result;
           }
         } else if (state.state == "header") {
           stream.skipToEnd();
           state.state = "headers";
           return "string";
         } else if (state.state == "body") {
           if (stream.sol() && (m = stream.match(/^-----END (.*)?-----\s*$/))) {
             if (m[1] != state.type) return "error";
             state.state = "end";
             return "tag";
           } else {
             if (stream.eatWhile(/[A-Za-z0-9+\/=]/)) {
               return null;
             } else {
               stream.next();
               return "error";
             }
           }
         } else if (state.state == "end") {
           return errorIfNotEmpty(stream);
         }
       },
       blankLine: function(state) {
         if (state.state == "headers") state.state = "body";
       },
       startState: function() {
         return {state: "top", type: null};
       }
     };
   });
 
   CodeMirror.defineMIME("application/pgp", "asciiarmor");
+  CodeMirror.defineMIME("application/pgp-encrypted", "asciiarmor");
   CodeMirror.defineMIME("application/pgp-keys", "asciiarmor");
   CodeMirror.defineMIME("application/pgp-signature", "asciiarmor");
 });

rhodecode/public/js/mode/asn.1/asn.1.js

@@ -1,204 +1,204 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("asn.1", function(config, parserConfig) {
     var indentUnit = config.indentUnit,
         keywords = parserConfig.keywords || {},
         cmipVerbs = parserConfig.cmipVerbs || {},
         compareTypes = parserConfig.compareTypes || {},
         status = parserConfig.status || {},
         tags = parserConfig.tags || {},
         storage = parserConfig.storage || {},
         modifier = parserConfig.modifier || {},
         accessTypes = parserConfig.accessTypes|| {},
         multiLineStrings = parserConfig.multiLineStrings,
         indentStatements = parserConfig.indentStatements !== false;
     var isOperatorChar = /[\|\^]/;
     var curPunc;
 
     function tokenBase(stream, state) {
       var ch = stream.next();
       if (ch == '"' || ch == "'") {
         state.tokenize = tokenString(ch);
         return state.tokenize(stream, state);
       }
       if (/[\[\]\(\){}:=,;]/.test(ch)) {
         curPunc = ch;
         return "punctuation";
       }
       if (ch == "-"){
         if (stream.eat("-")) {
           stream.skipToEnd();
           return "comment";
         }
       }
       if (/\d/.test(ch)) {
         stream.eatWhile(/[\w\.]/);
         return "number";
       }
       if (isOperatorChar.test(ch)) {
         stream.eatWhile(isOperatorChar);
         return "operator";
       }
 
       stream.eatWhile(/[\w\-]/);
       var cur = stream.current();
       if (keywords.propertyIsEnumerable(cur)) return "keyword";
       if (cmipVerbs.propertyIsEnumerable(cur)) return "variable cmipVerbs";
       if (compareTypes.propertyIsEnumerable(cur)) return "atom compareTypes";
       if (status.propertyIsEnumerable(cur)) return "comment status";
       if (tags.propertyIsEnumerable(cur)) return "variable-3 tags";
       if (storage.propertyIsEnumerable(cur)) return "builtin storage";
       if (modifier.propertyIsEnumerable(cur)) return "string-2 modifier";
       if (accessTypes.propertyIsEnumerable(cur)) return "atom accessTypes";
 
       return "variable";
     }
 
     function tokenString(quote) {
       return function(stream, state) {
         var escaped = false, next, end = false;
         while ((next = stream.next()) != null) {
           if (next == quote && !escaped){
             var afterNext = stream.peek();
             //look if the character if the quote is like the B in '10100010'B
             if (afterNext){
               afterNext = afterNext.toLowerCase();
               if(afterNext == "b" || afterNext == "h" || afterNext == "o")
                 stream.next();
             }
             end = true; break;
           }
           escaped = !escaped && next == "\\";
         }
         if (end || !(escaped || multiLineStrings))
           state.tokenize = null;
         return "string";
       };
     }
 
     function Context(indented, column, type, align, prev) {
       this.indented = indented;
       this.column = column;
       this.type = type;
       this.align = align;
       this.prev = prev;
     }
     function pushContext(state, col, type) {
       var indent = state.indented;
       if (state.context && state.context.type == "statement")
         indent = state.context.indented;
       return state.context = new Context(indent, col, type, null, state.context);
     }
     function popContext(state) {
       var t = state.context.type;
       if (t == ")" || t == "]" || t == "}")
         state.indented = state.context.indented;
       return state.context = state.context.prev;
     }
 
     //Interface
     return {
       startState: function(basecolumn) {
         return {
           tokenize: null,
           context: new Context((basecolumn || 0) - indentUnit, 0, "top", false),
           indented: 0,
           startOfLine: true
         };
       },
 
       token: function(stream, state) {
         var ctx = state.context;
         if (stream.sol()) {
           if (ctx.align == null) ctx.align = false;
           state.indented = stream.indentation();
           state.startOfLine = true;
         }
         if (stream.eatSpace()) return null;
         curPunc = null;
         var style = (state.tokenize || tokenBase)(stream, state);
         if (style == "comment") return style;
         if (ctx.align == null) ctx.align = true;
 
         if ((curPunc == ";" || curPunc == ":" || curPunc == ",")
             && ctx.type == "statement"){
           popContext(state);
         }
         else if (curPunc == "{") pushContext(state, stream.column(), "}");
         else if (curPunc == "[") pushContext(state, stream.column(), "]");
         else if (curPunc == "(") pushContext(state, stream.column(), ")");
         else if (curPunc == "}") {
           while (ctx.type == "statement") ctx = popContext(state);
           if (ctx.type == "}") ctx = popContext(state);
           while (ctx.type == "statement") ctx = popContext(state);
         }
         else if (curPunc == ctx.type) popContext(state);
         else if (indentStatements && (((ctx.type == "}" || ctx.type == "top")
             && curPunc != ';') || (ctx.type == "statement"
             && curPunc == "newstatement")))
           pushContext(state, stream.column(), "statement");
 
         state.startOfLine = false;
         return style;
       },
 
       electricChars: "{}",
       lineComment: "--",
       fold: "brace"
     };
   });
 
   function words(str) {
     var obj = {}, words = str.split(" ");
     for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
     return obj;
   }
 
   CodeMirror.defineMIME("text/x-ttcn-asn", {
     name: "asn.1",
     keywords: words("DEFINITIONS OBJECTS IF DERIVED INFORMATION ACTION" +
     " REPLY ANY NAMED CHARACTERIZED BEHAVIOUR REGISTERED" +
     " WITH AS IDENTIFIED CONSTRAINED BY PRESENT BEGIN" +
     " IMPORTS FROM UNITS SYNTAX MIN-ACCESS MAX-ACCESS" +
     " MINACCESS MAXACCESS REVISION STATUS DESCRIPTION" +
     " SEQUENCE SET COMPONENTS OF CHOICE DistinguishedName" +
     " ENUMERATED SIZE MODULE END INDEX AUGMENTS EXTENSIBILITY" +
     " IMPLIED EXPORTS"),
     cmipVerbs: words("ACTIONS ADD GET NOTIFICATIONS REPLACE REMOVE"),
     compareTypes: words("OPTIONAL DEFAULT MANAGED MODULE-TYPE MODULE_IDENTITY" +
     " MODULE-COMPLIANCE OBJECT-TYPE OBJECT-IDENTITY" +
     " OBJECT-COMPLIANCE MODE CONFIRMED CONDITIONAL" +
     " SUBORDINATE SUPERIOR CLASS TRUE FALSE NULL" +
     " TEXTUAL-CONVENTION"),
     status: words("current deprecated mandatory obsolete"),
     tags: words("APPLICATION AUTOMATIC EXPLICIT IMPLICIT PRIVATE TAGS" +
     " UNIVERSAL"),
     storage: words("BOOLEAN INTEGER OBJECT IDENTIFIER BIT OCTET STRING" +
     " UTCTime InterfaceIndex IANAifType CMIP-Attribute" +
     " REAL PACKAGE PACKAGES IpAddress PhysAddress" +
     " NetworkAddress BITS BMPString TimeStamp TimeTicks" +
     " TruthValue RowStatus DisplayString GeneralString" +
     " GraphicString IA5String NumericString" +
     " PrintableString SnmpAdminAtring TeletexString" +
     " UTF8String VideotexString VisibleString StringStore" +
     " ISO646String T61String UniversalString Unsigned32" +
     " Integer32 Gauge Gauge32 Counter Counter32 Counter64"),
     modifier: words("ATTRIBUTE ATTRIBUTES MANDATORY-GROUP MANDATORY-GROUPS" +
     " GROUP GROUPS ELEMENTS EQUALITY ORDERING SUBSTRINGS" +
     " DEFINED"),
     accessTypes: words("not-accessible accessible-for-notify read-only" +
     " read-create read-write"),
     multiLineStrings: true
   });
 });

rhodecode/public/js/mode/asterisk/asterisk.js

@@ -1,196 +1,220 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 /*
  * =====================================================================================
  *
  *       Filename:  mode/asterisk/asterisk.js
  *
  *    Description:  CodeMirror mode for Asterisk dialplan
  *
  *        Created:  05/17/2012 09:20:25 PM
- *       Revision:  none
+ *       Revision:  08/05/2019 AstLinux Project: Support block-comments
  *
  *         Author:  Stas Kobzar ([e-mail]),
  *        Company:  Modulis.ca Inc.
  *
  * =====================================================================================
  */
 
 (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("asterisk", function() {
   var atoms    = ["exten", "same", "include","ignorepat","switch"],
       dpcmd    = ["#include","#exec"],
       apps     = [
                   "addqueuemember","adsiprog","aelsub","agentlogin","agentmonitoroutgoing","agi",
                   "alarmreceiver","amd","answer","authenticate","background","backgrounddetect",
                   "bridge","busy","callcompletioncancel","callcompletionrequest","celgenuserevent",
                   "changemonitor","chanisavail","channelredirect","chanspy","clearhash","confbridge",
                   "congestion","continuewhile","controlplayback","dahdiacceptr2call","dahdibarge",
                   "dahdiras","dahdiscan","dahdisendcallreroutingfacility","dahdisendkeypadfacility",
                   "datetime","dbdel","dbdeltree","deadagi","dial","dictate","directory","disa",
                   "dumpchan","eagi","echo","endwhile","exec","execif","execiftime","exitwhile","extenspy",
                   "externalivr","festival","flash","followme","forkcdr","getcpeid","gosub","gosubif",
                   "goto","gotoif","gotoiftime","hangup","iax2provision","ices","importvar","incomplete",
                   "ivrdemo","jabberjoin","jabberleave","jabbersend","jabbersendgroup","jabberstatus",
                   "jack","log","macro","macroexclusive","macroexit","macroif","mailboxexists","meetme",
                   "meetmeadmin","meetmechanneladmin","meetmecount","milliwatt","minivmaccmess","minivmdelete",
                   "minivmgreet","minivmmwi","minivmnotify","minivmrecord","mixmonitor","monitor","morsecode",
                   "mp3player","mset","musiconhold","nbscat","nocdr","noop","odbc","odbc","odbcfinish",
                   "originate","ospauth","ospfinish","osplookup","ospnext","page","park","parkandannounce",
                   "parkedcall","pausemonitor","pausequeuemember","pickup","pickupchan","playback","playtones",
                   "privacymanager","proceeding","progress","queue","queuelog","raiseexception","read","readexten",
                   "readfile","receivefax","receivefax","receivefax","record","removequeuemember",
                   "resetcdr","retrydial","return","ringing","sayalpha","saycountedadj","saycountednoun",
                   "saycountpl","saydigits","saynumber","sayphonetic","sayunixtime","senddtmf","sendfax",
                   "sendfax","sendfax","sendimage","sendtext","sendurl","set","setamaflags",
                   "setcallerpres","setmusiconhold","sipaddheader","sipdtmfmode","sipremoveheader","skel",
                   "slastation","slatrunk","sms","softhangup","speechactivategrammar","speechbackground",
                   "speechcreate","speechdeactivategrammar","speechdestroy","speechloadgrammar","speechprocessingsound",
                   "speechstart","speechunloadgrammar","stackpop","startmusiconhold","stopmixmonitor","stopmonitor",
                   "stopmusiconhold","stopplaytones","system","testclient","testserver","transfer","tryexec",
                   "trysystem","unpausemonitor","unpausequeuemember","userevent","verbose","vmauthenticate",
                   "vmsayname","voicemail","voicemailmain","wait","waitexten","waitfornoise","waitforring",
                   "waitforsilence","waitmusiconhold","waituntil","while","zapateller"
                  ];
 
   function basicToken(stream,state){
     var cur = '';
     var ch = stream.next();
     // comment
+    if (state.blockComment) {
+      if (ch == "-" && stream.match("-;", true)) {
+        state.blockComment = false;
+      } else if (stream.skipTo("--;")) {
+        stream.next();
+        stream.next();
+        stream.next();
+        state.blockComment = false;
+      } else {
+        stream.skipToEnd();
+      }
+      return "comment";
+    }
     if(ch == ";") {
+      if (stream.match("--", true)) {
+        if (!stream.match("-", false)) {  // Except ;--- is not a block comment
+          state.blockComment = true;
+          return "comment";
+        }
+      }
       stream.skipToEnd();
       return "comment";
     }
     // context
     if(ch == '[') {
       stream.skipTo(']');
       stream.eat(']');
       return "header";
     }
     // string
     if(ch == '"') {
       stream.skipTo('"');
       return "string";
     }
     if(ch == "'") {
       stream.skipTo("'");
       return "string-2";
     }
     // dialplan commands
     if(ch == '#') {
       stream.eatWhile(/\w/);
       cur = stream.current();
       if(dpcmd.indexOf(cur) !== -1) {
         stream.skipToEnd();
         return "strong";
       }
     }
     // application args
     if(ch == '$'){
       var ch1 = stream.peek();
       if(ch1 == '{'){
         stream.skipTo('}');
         stream.eat('}');
         return "variable-3";
       }
     }
     // extension
     stream.eatWhile(/\w/);
     cur = stream.current();
     if(atoms.indexOf(cur) !== -1) {
       state.extenStart = true;
       switch(cur) {
         case 'same': state.extenSame = true; break;
         case 'include':
         case 'switch':
         case 'ignorepat':
           state.extenInclude = true;break;
         default:break;
       }
       return "atom";
     }
   }
 
   return {
     startState: function() {
       return {
+        blockComment: false,
         extenStart: false,
         extenSame:  false,
         extenInclude: false,
         extenExten: false,
         extenPriority: false,
         extenApplication: false
       };
     },
     token: function(stream, state) {
 
       var cur = '';
       if(stream.eatSpace()) return null;
       // extension started
       if(state.extenStart){
         stream.eatWhile(/[^\s]/);
         cur = stream.current();
         if(/^=>?$/.test(cur)){
           state.extenExten = true;
           state.extenStart = false;
           return "strong";
         } else {
           state.extenStart = false;
           stream.skipToEnd();
           return "error";
         }
       } else if(state.extenExten) {
         // set exten and priority
         state.extenExten = false;
         state.extenPriority = true;
         stream.eatWhile(/[^,]/);
         if(state.extenInclude) {
           stream.skipToEnd();
           state.extenPriority = false;
           state.extenInclude = false;
         }
         if(state.extenSame) {
           state.extenPriority = false;
           state.extenSame = false;
           state.extenApplication = true;
         }
         return "tag";
       } else if(state.extenPriority) {
         state.extenPriority = false;
         state.extenApplication = true;
         stream.next(); // get comma
         if(state.extenSame) return null;
         stream.eatWhile(/[^,]/);
         return "number";
       } else if(state.extenApplication) {
         stream.eatWhile(/,/);
         cur = stream.current();
         if(cur === ',') return null;
         stream.eatWhile(/\w/);
         cur = stream.current().toLowerCase();
         state.extenApplication = false;
         if(apps.indexOf(cur) !== -1){
           return "def strong";
         }
       } else{
         return basicToken(stream,state);
       }
 
       return null;
-    }
+    },
+
+    blockCommentStart: ";--",
+    blockCommentEnd: "--;",
+    lineComment: ";"
   };
 });
 
 CodeMirror.defineMIME("text/x-asterisk", "asterisk");
 
 });

rhodecode/public/js/mode/brainfuck/brainfuck.js

@@ -1,85 +1,85 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 // Brainfuck mode created by Michael Kaminsky https://github.com/mkaminsky11
 
 (function(mod) {
   if (typeof exports == "object" && typeof module == "object")
     mod(require("../../lib/codemirror"))
   else if (typeof define == "function" && define.amd)
     define(["../../lib/codemirror"], mod)
   else
     mod(CodeMirror)
 })(function(CodeMirror) {
   "use strict"
   var reserve = "><+-.,[]".split("");
   /*
   comments can be either:
   placed behind lines
 
         +++    this is a comment
 
   where reserved characters cannot be used
   or in a loop
   [
     this is ok to use [ ] and stuff
   ]
   or preceded by #
   */
   CodeMirror.defineMode("brainfuck", function() {
     return {
       startState: function() {
         return {
           commentLine: false,
           left: 0,
           right: 0,
           commentLoop: false
         }
       },
       token: function(stream, state) {
         if (stream.eatSpace()) return null
         if(stream.sol()){
           state.commentLine = false;
         }
         var ch = stream.next().toString();
         if(reserve.indexOf(ch) !== -1){
           if(state.commentLine === true){
             if(stream.eol()){
               state.commentLine = false;
             }
             return "comment";
           }
           if(ch === "]" || ch === "["){
             if(ch === "["){
               state.left++;
             }
             else{
               state.right++;
             }
             return "bracket";
           }
           else if(ch === "+" || ch === "-"){
             return "keyword";
           }
           else if(ch === "<" || ch === ">"){
             return "atom";
           }
           else if(ch === "." || ch === ","){
             return "def";
           }
         }
         else{
           state.commentLine = true;
           if(stream.eol()){
             state.commentLine = false;
           }
           return "comment";
         }
         if(stream.eol()){
           state.commentLine = false;
         }
       }
     };
   });
 CodeMirror.defineMIME("text/x-brainfuck","brainfuck")
 });

rhodecode/public/js/mode/clike/clike.js

@@ -1,772 +1,935 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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";
 
+function Context(indented, column, type, info, align, prev) {
+  this.indented = indented;
+  this.column = column;
+  this.type = type;
+  this.info = info;
+  this.align = align;
+  this.prev = prev;
+}
+function pushContext(state, col, type, info) {
+  var indent = state.indented;
+  if (state.context && state.context.type == "statement" && type != "statement")
+    indent = state.context.indented;
+  return state.context = new Context(indent, col, type, info, null, state.context);
+}
+function popContext(state) {
+  var t = state.context.type;
+  if (t == ")" || t == "]" || t == "}")
+    state.indented = state.context.indented;
+  return state.context = state.context.prev;
+}
+
+function typeBefore(stream, state, pos) {
+  if (state.prevToken == "variable" || state.prevToken == "type") return true;
+  if (/\S(?:[^- ]>|[*\]])\s*$|\*$/.test(stream.string.slice(0, pos))) return true;
+  if (state.typeAtEndOfLine && stream.column() == stream.indentation()) return true;
+}
+
+function isTopScope(context) {
+  for (;;) {
+    if (!context || context.type == "top") return true;
+    if (context.type == "}" && context.prev.info != "namespace") return false;
+    context = context.prev;
+  }
+}
+
 CodeMirror.defineMode("clike", function(config, parserConfig) {
   var indentUnit = config.indentUnit,
       statementIndentUnit = parserConfig.statementIndentUnit || indentUnit,
       dontAlignCalls = parserConfig.dontAlignCalls,
       keywords = parserConfig.keywords || {},
       types = parserConfig.types || {},
       builtin = parserConfig.builtin || {},
       blockKeywords = parserConfig.blockKeywords || {},
       defKeywords = parserConfig.defKeywords || {},
       atoms = parserConfig.atoms || {},
       hooks = parserConfig.hooks || {},
       multiLineStrings = parserConfig.multiLineStrings,
       indentStatements = parserConfig.indentStatements !== false,
       indentSwitch = parserConfig.indentSwitch !== false,
       namespaceSeparator = parserConfig.namespaceSeparator,
       isPunctuationChar = parserConfig.isPunctuationChar || /[\[\]{}\(\),;\:\.]/,
       numberStart = parserConfig.numberStart || /[\d\.]/,
       number = parserConfig.number || /^(?:0x[a-f\d]+|0b[01]+|(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?)(u|ll?|l|f)?/i,
       isOperatorChar = parserConfig.isOperatorChar || /[+\-*&%=<>!?|\/]/,
-      endStatement = parserConfig.endStatement || /^[;:,]$/;
+      isIdentifierChar = parserConfig.isIdentifierChar || /[\w\$_\xa1-\uffff]/,
+      // An optional function that takes a {string} token and returns true if it
+      // should be treated as a builtin.
+      isReservedIdentifier = parserConfig.isReservedIdentifier || false;
 
   var curPunc, isDefKeyword;
 
   function tokenBase(stream, state) {
     var ch = stream.next();
     if (hooks[ch]) {
       var result = hooks[ch](stream, state);
       if (result !== false) return result;
     }
     if (ch == '"' || ch == "'") {
       state.tokenize = tokenString(ch);
       return state.tokenize(stream, state);
     }
     if (isPunctuationChar.test(ch)) {
       curPunc = ch;
       return null;
     }
     if (numberStart.test(ch)) {
       stream.backUp(1)
       if (stream.match(number)) return "number"
       stream.next()
     }
     if (ch == "/") {
       if (stream.eat("*")) {
         state.tokenize = tokenComment;
         return tokenComment(stream, state);
       }
       if (stream.eat("/")) {
         stream.skipToEnd();
         return "comment";
       }
     }
     if (isOperatorChar.test(ch)) {
-      stream.eatWhile(isOperatorChar);
+      while (!stream.match(/^\/[\/*]/, false) && stream.eat(isOperatorChar)) {}
       return "operator";
     }
-    stream.eatWhile(/[\w\$_\xa1-\uffff]/);
+    stream.eatWhile(isIdentifierChar);
     if (namespaceSeparator) while (stream.match(namespaceSeparator))
-      stream.eatWhile(/[\w\$_\xa1-\uffff]/);
+      stream.eatWhile(isIdentifierChar);
 
     var cur = stream.current();
     if (contains(keywords, cur)) {
       if (contains(blockKeywords, cur)) curPunc = "newstatement";
       if (contains(defKeywords, cur)) isDefKeyword = true;
       return "keyword";
     }
-    if (contains(types, cur)) return "variable-3";
-    if (contains(builtin, cur)) {
+    if (contains(types, cur)) return "type";
+    if (contains(builtin, cur)
+        || (isReservedIdentifier && isReservedIdentifier(cur))) {
       if (contains(blockKeywords, cur)) curPunc = "newstatement";
       return "builtin";
     }
     if (contains(atoms, cur)) return "atom";
     return "variable";
   }
 
   function tokenString(quote) {
     return function(stream, state) {
       var escaped = false, next, end = false;
       while ((next = stream.next()) != null) {
         if (next == quote && !escaped) {end = true; break;}
         escaped = !escaped && next == "\\";
       }
       if (end || !(escaped || multiLineStrings))
         state.tokenize = null;
       return "string";
     };
   }
 
   function tokenComment(stream, state) {
     var maybeEnd = false, ch;
     while (ch = stream.next()) {
       if (ch == "/" && maybeEnd) {
         state.tokenize = null;
         break;
       }
       maybeEnd = (ch == "*");
     }
     return "comment";
   }
 
-  function Context(indented, column, type, align, prev) {
-    this.indented = indented;
-    this.column = column;
-    this.type = type;
-    this.align = align;
-    this.prev = prev;
-  }
-  function isStatement(type) {
-    return type == "statement" || type == "switchstatement" || type == "namespace";
-  }
-  function pushContext(state, col, type) {
-    var indent = state.indented;
-    if (state.context && isStatement(state.context.type) && !isStatement(type))
-      indent = state.context.indented;
-    return state.context = new Context(indent, col, type, null, state.context);
-  }
-  function popContext(state) {
-    var t = state.context.type;
-    if (t == ")" || t == "]" || t == "}")
-      state.indented = state.context.indented;
-    return state.context = state.context.prev;
-  }
-
-  function typeBefore(stream, state) {
-    if (state.prevToken == "variable" || state.prevToken == "variable-3") return true;
-    if (/\S(?:[^- ]>|[*\]])\s*$|\*$/.test(stream.string.slice(0, stream.start))) return true;
-  }
-
-  function isTopScope(context) {
-    for (;;) {
-      if (!context || context.type == "top") return true;
-      if (context.type == "}" && context.prev.type != "namespace") return false;
-      context = context.prev;
-    }
+  function maybeEOL(stream, state) {
+    if (parserConfig.typeFirstDefinitions && stream.eol() && isTopScope(state.context))
+      state.typeAtEndOfLine = typeBefore(stream, state, stream.pos)
   }
 
   // Interface
 
   return {
     startState: function(basecolumn) {
       return {
         tokenize: null,
-        context: new Context((basecolumn || 0) - indentUnit, 0, "top", false),
+        context: new Context((basecolumn || 0) - indentUnit, 0, "top", null, false),
         indented: 0,
         startOfLine: true,
         prevToken: null
       };
     },
 
     token: function(stream, state) {
       var ctx = state.context;
       if (stream.sol()) {
         if (ctx.align == null) ctx.align = false;
         state.indented = stream.indentation();
         state.startOfLine = true;
       }
-      if (stream.eatSpace()) return null;
+      if (stream.eatSpace()) { maybeEOL(stream, state); return null; }
       curPunc = isDefKeyword = null;
       var style = (state.tokenize || tokenBase)(stream, state);
       if (style == "comment" || style == "meta") return style;
       if (ctx.align == null) ctx.align = true;
 
-      if (endStatement.test(curPunc)) while (isStatement(state.context.type)) popContext(state);
+      if (curPunc == ";" || curPunc == ":" || (curPunc == "," && stream.match(/^\s*(?:\/\/.*)?$/, false)))
+        while (state.context.type == "statement") popContext(state);
       else if (curPunc == "{") pushContext(state, stream.column(), "}");
       else if (curPunc == "[") pushContext(state, stream.column(), "]");
       else if (curPunc == "(") pushContext(state, stream.column(), ")");
       else if (curPunc == "}") {
-        while (isStatement(ctx.type)) ctx = popContext(state);
+        while (ctx.type == "statement") ctx = popContext(state);
         if (ctx.type == "}") ctx = popContext(state);
-        while (isStatement(ctx.type)) ctx = popContext(state);
+        while (ctx.type == "statement") ctx = popContext(state);
       }
       else if (curPunc == ctx.type) popContext(state);
       else if (indentStatements &&
                (((ctx.type == "}" || ctx.type == "top") && curPunc != ";") ||
-                (isStatement(ctx.type) && curPunc == "newstatement"))) {
-        var type = "statement";
-        if (curPunc == "newstatement" && indentSwitch && stream.current() == "switch")
-          type = "switchstatement";
-        else if (style == "keyword" && stream.current() == "namespace")
-          type = "namespace";
-        pushContext(state, stream.column(), type);
+                (ctx.type == "statement" && curPunc == "newstatement"))) {
+        pushContext(state, stream.column(), "statement", stream.current());
       }
 
       if (style == "variable" &&
           ((state.prevToken == "def" ||
-            (parserConfig.typeFirstDefinitions && typeBefore(stream, state) &&
+            (parserConfig.typeFirstDefinitions && typeBefore(stream, state, stream.start) &&
              isTopScope(state.context) && stream.match(/^\s*\(/, false)))))
         style = "def";
 
       if (hooks.token) {
         var result = hooks.token(stream, state, style);
         if (result !== undefined) style = result;
       }
 
       if (style == "def" && parserConfig.styleDefs === false) style = "variable";
 
       state.startOfLine = false;
       state.prevToken = isDefKeyword ? "def" : style || curPunc;
+      maybeEOL(stream, state);
       return style;
     },
 
     indent: function(state, textAfter) {
-      if (state.tokenize != tokenBase && state.tokenize != null) return CodeMirror.Pass;
+      if (state.tokenize != tokenBase && state.tokenize != null || state.typeAtEndOfLine) return CodeMirror.Pass;
       var ctx = state.context, firstChar = textAfter && textAfter.charAt(0);
-      if (isStatement(ctx.type) && firstChar == "}") ctx = ctx.prev;
+      var closing = firstChar == ctx.type;
+      if (ctx.type == "statement" && firstChar == "}") ctx = ctx.prev;
+      if (parserConfig.dontIndentStatements)
+        while (ctx.type == "statement" && parserConfig.dontIndentStatements.test(ctx.info))
+          ctx = ctx.prev
       if (hooks.indent) {
-        var hook = hooks.indent(state, ctx, textAfter);
+        var hook = hooks.indent(state, ctx, textAfter, indentUnit);
         if (typeof hook == "number") return hook
       }
-      var closing = firstChar == ctx.type;
-      var switchBlock = ctx.prev && ctx.prev.type == "switchstatement";
+      var switchBlock = ctx.prev && ctx.prev.info == "switch";
       if (parserConfig.allmanIndentation && /[{(]/.test(firstChar)) {
         while (ctx.type != "top" && ctx.type != "}") ctx = ctx.prev
         return ctx.indented
       }
-      if (isStatement(ctx.type))
+      if (ctx.type == "statement")
         return ctx.indented + (firstChar == "{" ? 0 : statementIndentUnit);
       if (ctx.align && (!dontAlignCalls || ctx.type != ")"))
         return ctx.column + (closing ? 0 : 1);
       if (ctx.type == ")" && !closing)
         return ctx.indented + statementIndentUnit;
 
       return ctx.indented + (closing ? 0 : indentUnit) +
         (!closing && switchBlock && !/^(?:case|default)\b/.test(textAfter) ? indentUnit : 0);
     },
 
     electricInput: indentSwitch ? /^\s*(?:case .*?:|default:|\{\}?|\})$/ : /^\s*[{}]$/,
     blockCommentStart: "/*",
     blockCommentEnd: "*/",
+    blockCommentContinue: " * ",
     lineComment: "//",
     fold: "brace"
   };
 });
 
   function words(str) {
     var obj = {}, words = str.split(" ");
     for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
     return obj;
   }
   function contains(words, word) {
     if (typeof words === "function") {
       return words(word);
     } else {
       return words.propertyIsEnumerable(word);
     }
   }
   var cKeywords = "auto if break case register continue return default do sizeof " +
-    "static else struct switch extern typedef union for goto while enum const volatile";
-  var cTypes = "int long char short double float unsigned signed void size_t ptrdiff_t";
+    "static else struct switch extern typedef union for goto while enum const " +
+    "volatile inline restrict asm fortran";
+
+  // Keywords from https://en.cppreference.com/w/cpp/keyword includes C++20.
+  var cppKeywords = "alignas alignof and and_eq audit axiom bitand bitor catch " +
+  "class compl concept constexpr const_cast decltype delete dynamic_cast " +
+  "explicit export final friend import module mutable namespace new noexcept " +
+  "not not_eq operator or or_eq override private protected public " +
+  "reinterpret_cast requires static_assert static_cast template this " +
+  "thread_local throw try typeid typename using virtual xor xor_eq";
+
+  var objCKeywords = "bycopy byref in inout oneway out self super atomic nonatomic retain copy " +
+  "readwrite readonly strong weak assign typeof nullable nonnull null_resettable _cmd " +
+  "@interface @implementation @end @protocol @encode @property @synthesize @dynamic @class " +
+  "@public @package @private @protected @required @optional @try @catch @finally @import " +
+  "@selector @encode @defs @synchronized @autoreleasepool @compatibility_alias @available";
+
+  var objCBuiltins = "FOUNDATION_EXPORT FOUNDATION_EXTERN NS_INLINE NS_FORMAT_FUNCTION " +
+  " NS_RETURNS_RETAINEDNS_ERROR_ENUM NS_RETURNS_NOT_RETAINED NS_RETURNS_INNER_POINTER " +
+  "NS_DESIGNATED_INITIALIZER NS_ENUM NS_OPTIONS NS_REQUIRES_NIL_TERMINATION " +
+  "NS_ASSUME_NONNULL_BEGIN NS_ASSUME_NONNULL_END NS_SWIFT_NAME NS_REFINED_FOR_SWIFT"
+
+  // Do not use this. Use the cTypes function below. This is global just to avoid
+  // excessive calls when cTypes is being called multiple times during a parse.
+  var basicCTypes = words("int long char short double float unsigned signed " +
+    "void bool");
+
+  // Do not use this. Use the objCTypes function below. This is global just to avoid
+  // excessive calls when objCTypes is being called multiple times during a parse.
+  var basicObjCTypes = words("SEL instancetype id Class Protocol BOOL");
+
+  // Returns true if identifier is a "C" type.
+  // C type is defined as those that are reserved by the compiler (basicTypes),
+  // and those that end in _t (Reserved by POSIX for types)
+  // http://www.gnu.org/software/libc/manual/html_node/Reserved-Names.html
+  function cTypes(identifier) {
+    return contains(basicCTypes, identifier) || /.+_t$/.test(identifier);
+  }
+
+  // Returns true if identifier is a "Objective C" type.
+  function objCTypes(identifier) {
+    return cTypes(identifier) || contains(basicObjCTypes, identifier);
+  }
+
+  var cBlockKeywords = "case do else for if switch while struct enum union";
+  var cDefKeywords = "struct enum union";
 
   function cppHook(stream, state) {
     if (!state.startOfLine) return false
     for (var ch, next = null; ch = stream.peek();) {
       if (ch == "\\" && stream.match(/^.$/)) {
         next = cppHook
         break
       } else if (ch == "/" && stream.match(/^\/[\/\*]/, false)) {
         break
       }
       stream.next()
     }
     state.tokenize = next
     return "meta"
   }
 
   function pointerHook(_stream, state) {
-    if (state.prevToken == "variable-3") return "variable-3";
+    if (state.prevToken == "type") return "type";
     return false;
   }
 
+  // For C and C++ (and ObjC): identifiers starting with __
+  // or _ followed by a capital letter are reserved for the compiler.
+  function cIsReservedIdentifier(token) {
+    if (!token || token.length < 2) return false;
+    if (token[0] != '_') return false;
+    return (token[1] == '_') || (token[1] !== token[1].toLowerCase());
+  }
+
   function cpp14Literal(stream) {
     stream.eatWhile(/[\w\.']/);
     return "number";
   }
 
   function cpp11StringHook(stream, state) {
     stream.backUp(1);
     // Raw strings.
     if (stream.match(/(R|u8R|uR|UR|LR)/)) {
       var match = stream.match(/"([^\s\\()]{0,16})\(/);
       if (!match) {
         return false;
       }
       state.cpp11RawStringDelim = match[1];
       state.tokenize = tokenRawString;
       return tokenRawString(stream, state);
     }
     // Unicode strings/chars.
     if (stream.match(/(u8|u|U|L)/)) {
       if (stream.match(/["']/, /* eat */ false)) {
         return "string";
       }
       return false;
     }
     // Ignore this hook.
     stream.next();
     return false;
   }
 
   function cppLooksLikeConstructor(word) {
-    var lastTwo = /(\w+)::(\w+)$/.exec(word);
+    var lastTwo = /(\w+)::~?(\w+)$/.exec(word);
     return lastTwo && lastTwo[1] == lastTwo[2];
   }
 
   // C#-style strings where "" escapes a quote.
   function tokenAtString(stream, state) {
     var next;
     while ((next = stream.next()) != null) {
       if (next == '"' && !stream.eat('"')) {
         state.tokenize = null;
         break;
       }
     }
     return "string";
   }
 
   // C++11 raw string literal is <prefix>"<delim>( anything )<delim>", where
   // <delim> can be a string up to 16 characters long.
   function tokenRawString(stream, state) {
     // Escape characters that have special regex meanings.
     var delim = state.cpp11RawStringDelim.replace(/[^\w\s]/g, '\\$&');
     var match = stream.match(new RegExp(".*?\\)" + delim + '"'));
     if (match)
       state.tokenize = null;
     else
       stream.skipToEnd();
     return "string";
   }
 
   function def(mimes, mode) {
     if (typeof mimes == "string") mimes = [mimes];
     var words = [];
     function add(obj) {
       if (obj) for (var prop in obj) if (obj.hasOwnProperty(prop))
         words.push(prop);
     }
     add(mode.keywords);
     add(mode.types);
     add(mode.builtin);
     add(mode.atoms);
     if (words.length) {
       mode.helperType = mimes[0];
       CodeMirror.registerHelper("hintWords", mimes[0], words);
     }
 
     for (var i = 0; i < mimes.length; ++i)
       CodeMirror.defineMIME(mimes[i], mode);
   }
 
   def(["text/x-csrc", "text/x-c", "text/x-chdr"], {
     name: "clike",
     keywords: words(cKeywords),
-    types: words(cTypes + " bool _Complex _Bool float_t double_t intptr_t intmax_t " +
-                 "int8_t int16_t int32_t int64_t uintptr_t uintmax_t uint8_t uint16_t " +
-                 "uint32_t uint64_t"),
-    blockKeywords: words("case do else for if switch while struct"),
-    defKeywords: words("struct"),
+    types: cTypes,
+    blockKeywords: words(cBlockKeywords),
+    defKeywords: words(cDefKeywords),
     typeFirstDefinitions: true,
-    atoms: words("null true false"),
-    hooks: {"#": cppHook, "*": pointerHook},
+    atoms: words("NULL true false"),
+    isReservedIdentifier: cIsReservedIdentifier,
+    hooks: {
+      "#": cppHook,
+      "*": pointerHook,
+    },
     modeProps: {fold: ["brace", "include"]}
   });
 
   def(["text/x-c++src", "text/x-c++hdr"], {
     name: "clike",
-    keywords: words(cKeywords + " asm dynamic_cast namespace reinterpret_cast try explicit new " +
-                    "static_cast typeid catch operator template typename class friend private " +
-                    "this using const_cast inline public throw virtual delete mutable protected " +
-                    "alignas alignof constexpr decltype nullptr noexcept thread_local final " +
-                    "static_assert override"),
-    types: words(cTypes + " bool wchar_t"),
-    blockKeywords: words("catch class do else finally for if struct switch try while"),
-    defKeywords: words("class namespace struct enum union"),
+    keywords: words(cKeywords + " " + cppKeywords),
+    types: cTypes,
+    blockKeywords: words(cBlockKeywords + " class try catch"),
+    defKeywords: words(cDefKeywords + " class namespace"),
     typeFirstDefinitions: true,
-    atoms: words("true false null"),
+    atoms: words("true false NULL nullptr"),
+    dontIndentStatements: /^template$/,
+    isIdentifierChar: /[\w\$_~\xa1-\uffff]/,
+    isReservedIdentifier: cIsReservedIdentifier,
     hooks: {
       "#": cppHook,
       "*": pointerHook,
       "u": cpp11StringHook,
       "U": cpp11StringHook,
       "L": cpp11StringHook,
       "R": cpp11StringHook,
       "0": cpp14Literal,
       "1": cpp14Literal,
       "2": cpp14Literal,
       "3": cpp14Literal,
       "4": cpp14Literal,
       "5": cpp14Literal,
       "6": cpp14Literal,
       "7": cpp14Literal,
       "8": cpp14Literal,
       "9": cpp14Literal,
       token: function(stream, state, style) {
         if (style == "variable" && stream.peek() == "(" &&
             (state.prevToken == ";" || state.prevToken == null ||
              state.prevToken == "}") &&
             cppLooksLikeConstructor(stream.current()))
           return "def";
       }
     },
     namespaceSeparator: "::",
     modeProps: {fold: ["brace", "include"]}
   });
 
   def("text/x-java", {
     name: "clike",
     keywords: words("abstract assert break case catch class const continue default " +
-                    "do else enum extends final finally float for goto if implements import " +
+                    "do else enum extends final finally for goto if implements import " +
                     "instanceof interface native new package private protected public " +
                     "return static strictfp super switch synchronized this throw throws transient " +
-                    "try volatile while"),
+                    "try volatile while @interface"),
     types: words("byte short int long float double boolean char void Boolean Byte Character Double Float " +
                  "Integer Long Number Object Short String StringBuffer StringBuilder Void"),
     blockKeywords: words("catch class do else finally for if switch try while"),
-    defKeywords: words("class interface package enum"),
+    defKeywords: words("class interface enum @interface"),
     typeFirstDefinitions: true,
     atoms: words("true false null"),
-    endStatement: /^[;:]$/,
+    number: /^(?:0x[a-f\d_]+|0b[01_]+|(?:[\d_]+\.?\d*|\.\d+)(?:e[-+]?[\d_]+)?)(u|ll?|l|f)?/i,
     hooks: {
       "@": function(stream) {
+        // Don't match the @interface keyword.
+        if (stream.match('interface', false)) return false;
+
         stream.eatWhile(/[\w\$_]/);
         return "meta";
       }
     },
     modeProps: {fold: ["brace", "import"]}
   });
 
   def("text/x-csharp", {
     name: "clike",
     keywords: words("abstract as async await base break case catch checked class const continue" +
                     " default delegate do else enum event explicit extern finally fixed for" +
                     " foreach goto if implicit in interface internal is lock namespace new" +
                     " operator out override params private protected public readonly ref return sealed" +
                     " sizeof stackalloc static struct switch this throw try typeof unchecked" +
                     " unsafe using virtual void volatile while add alias ascending descending dynamic from get" +
                     " global group into join let orderby partial remove select set value var yield"),
     types: words("Action Boolean Byte Char DateTime DateTimeOffset Decimal Double Func" +
                  " Guid Int16 Int32 Int64 Object SByte Single String Task TimeSpan UInt16 UInt32" +
                  " UInt64 bool byte char decimal double short int long object"  +
                  " sbyte float string ushort uint ulong"),
     blockKeywords: words("catch class do else finally for foreach if struct switch try while"),
     defKeywords: words("class interface namespace struct var"),
     typeFirstDefinitions: true,
     atoms: words("true false null"),
     hooks: {
       "@": function(stream, state) {
         if (stream.eat('"')) {
           state.tokenize = tokenAtString;
           return tokenAtString(stream, state);
         }
         stream.eatWhile(/[\w\$_]/);
         return "meta";
       }
     }
   });
 
   function tokenTripleString(stream, state) {
     var escaped = false;
     while (!stream.eol()) {
       if (!escaped && stream.match('"""')) {
         state.tokenize = null;
         break;
       }
       escaped = stream.next() == "\\" && !escaped;
     }
     return "string";
   }
 
+  function tokenNestedComment(depth) {
+    return function (stream, state) {
+      var ch
+      while (ch = stream.next()) {
+        if (ch == "*" && stream.eat("/")) {
+          if (depth == 1) {
+            state.tokenize = null
+            break
+          } else {
+            state.tokenize = tokenNestedComment(depth - 1)
+            return state.tokenize(stream, state)
+          }
+        } else if (ch == "/" && stream.eat("*")) {
+          state.tokenize = tokenNestedComment(depth + 1)
+          return state.tokenize(stream, state)
+        }
+      }
+      return "comment"
+    }
+  }
+
   def("text/x-scala", {
     name: "clike",
     keywords: words(
-
       /* scala */
       "abstract case catch class def do else extends final finally for forSome if " +
       "implicit import lazy match new null object override package private protected return " +
-      "sealed super this throw trait try type val var while with yield _ : = => <- <: " +
-      "<% >: # @ " +
+      "sealed super this throw trait try type val var while with yield _ " +
 
       /* package scala */
       "assert assume require print println printf readLine readBoolean readByte readShort " +
-      "readChar readInt readLong readFloat readDouble " +
-
-      ":: #:: "
+      "readChar readInt readLong readFloat readDouble"
     ),
     types: words(
       "AnyVal App Application Array BufferedIterator BigDecimal BigInt Char Console Either " +
-      "Enumeration Equiv Error Exception Fractional Function IndexedSeq Integral Iterable " +
+      "Enumeration Equiv Error Exception Fractional Function IndexedSeq Int Integral Iterable " +
       "Iterator List Map Numeric Nil NotNull Option Ordered Ordering PartialFunction PartialOrdering " +
       "Product Proxy Range Responder Seq Serializable Set Specializable Stream StringBuilder " +
       "StringContext Symbol Throwable Traversable TraversableOnce Tuple Unit Vector " +
 
       /* package java.lang */
       "Boolean Byte Character CharSequence Class ClassLoader Cloneable Comparable " +
       "Compiler Double Exception Float Integer Long Math Number Object Package Pair Process " +
       "Runtime Runnable SecurityManager Short StackTraceElement StrictMath String " +
       "StringBuffer System Thread ThreadGroup ThreadLocal Throwable Triple Void"
     ),
     multiLineStrings: true,
-    blockKeywords: words("catch class do else finally for forSome if match switch try while"),
-    defKeywords: words("class def object package trait type val var"),
+    blockKeywords: words("catch class enum do else finally for forSome if match switch try while"),
+    defKeywords: words("class enum def object package trait type val var"),
     atoms: words("true false null"),
     indentStatements: false,
     indentSwitch: false,
+    isOperatorChar: /[+\-*&%=<>!?|\/#:@]/,
     hooks: {
       "@": function(stream) {
         stream.eatWhile(/[\w\$_]/);
         return "meta";
       },
       '"': function(stream, state) {
         if (!stream.match('""')) return false;
         state.tokenize = tokenTripleString;
         return state.tokenize(stream, state);
       },
       "'": function(stream) {
         stream.eatWhile(/[\w\$_\xa1-\uffff]/);
         return "atom";
+      },
+      "=": function(stream, state) {
+        var cx = state.context
+        if (cx.type == "}" && cx.align && stream.eat(">")) {
+          state.context = new Context(cx.indented, cx.column, cx.type, cx.info, null, cx.prev)
+          return "operator"
+        } else {
+          return false
+        }
+      },
+
+      "/": function(stream, state) {
+        if (!stream.eat("*")) return false
+        state.tokenize = tokenNestedComment(1)
+        return state.tokenize(stream, state)
       }
     },
-    modeProps: {closeBrackets: {triples: '"'}}
+    modeProps: {closeBrackets: {pairs: '()[]{}""', triples: '"'}}
   });
 
   function tokenKotlinString(tripleString){
     return function (stream, state) {
       var escaped = false, next, end = false;
       while (!stream.eol()) {
         if (!tripleString && !escaped && stream.match('"') ) {end = true; break;}
         if (tripleString && stream.match('"""')) {end = true; break;}
         next = stream.next();
         if(!escaped && next == "$" && stream.match('{'))
           stream.skipTo("}");
         escaped = !escaped && next == "\\" && !tripleString;
       }
       if (end || !tripleString)
         state.tokenize = null;
       return "string";
     }
   }
 
   def("text/x-kotlin", {
     name: "clike",
     keywords: words(
       /*keywords*/
-      "package as typealias class interface this super val " +
-      "var fun for is in This throw return " +
+      "package as typealias class interface this super val operator " +
+      "var fun for is in This throw return annotation " +
       "break continue object if else while do try when !in !is as? " +
 
       /*soft keywords*/
       "file import where by get set abstract enum open inner override private public internal " +
       "protected catch finally out final vararg reified dynamic companion constructor init " +
       "sealed field property receiver param sparam lateinit data inline noinline tailrec " +
-      "external annotation crossinline const operator infix"
+      "external annotation crossinline const operator infix suspend actual expect setparam"
     ),
     types: words(
       /* package java.lang */
       "Boolean Byte Character CharSequence Class ClassLoader Cloneable Comparable " +
       "Compiler Double Exception Float Integer Long Math Number Object Package Pair Process " +
       "Runtime Runnable SecurityManager Short StackTraceElement StrictMath String " +
-      "StringBuffer System Thread ThreadGroup ThreadLocal Throwable Triple Void"
+      "StringBuffer System Thread ThreadGroup ThreadLocal Throwable Triple Void Annotation Any BooleanArray " +
+      "ByteArray Char CharArray DeprecationLevel DoubleArray Enum FloatArray Function Int IntArray Lazy " +
+      "LazyThreadSafetyMode LongArray Nothing ShortArray Unit"
     ),
     intendSwitch: false,
     indentStatements: false,
     multiLineStrings: true,
+    number: /^(?:0x[a-f\d_]+|0b[01_]+|(?:[\d_]+(\.\d+)?|\.\d+)(?:e[-+]?[\d_]+)?)(u|ll?|l|f)?/i,
     blockKeywords: words("catch class do else finally for if where try while enum"),
-    defKeywords: words("class val var object package interface fun"),
+    defKeywords: words("class val var object interface fun"),
     atoms: words("true false null this"),
     hooks: {
+      "@": function(stream) {
+        stream.eatWhile(/[\w\$_]/);
+        return "meta";
+      },
+      '*': function(_stream, state) {
+        return state.prevToken == '.' ? 'variable' : 'operator';
+      },
       '"': function(stream, state) {
         state.tokenize = tokenKotlinString(stream.match('""'));
         return state.tokenize(stream, state);
+      },
+      "/": function(stream, state) {
+        if (!stream.eat("*")) return false;
+        state.tokenize = tokenNestedComment(1);
+        return state.tokenize(stream, state)
+      },
+      indent: function(state, ctx, textAfter, indentUnit) {
+        var firstChar = textAfter && textAfter.charAt(0);
+        if ((state.prevToken == "}" || state.prevToken == ")") && textAfter == "")
+          return state.indented;
+        if ((state.prevToken == "operator" && textAfter != "}" && state.context.type != "}") ||
+          state.prevToken == "variable" && firstChar == "." ||
+          (state.prevToken == "}" || state.prevToken == ")") && firstChar == ".")
+          return indentUnit * 2 + ctx.indented;
+        if (ctx.align && ctx.type == "}")
+          return ctx.indented + (state.context.type == (textAfter || "").charAt(0) ? 0 : indentUnit);
       }
     },
     modeProps: {closeBrackets: {triples: '"'}}
   });
 
   def(["x-shader/x-vertex", "x-shader/x-fragment"], {
     name: "clike",
     keywords: words("sampler1D sampler2D sampler3D samplerCube " +
                     "sampler1DShadow sampler2DShadow " +
                     "const attribute uniform varying " +
                     "break continue discard return " +
                     "for while do if else struct " +
                     "in out inout"),
     types: words("float int bool void " +
                  "vec2 vec3 vec4 ivec2 ivec3 ivec4 bvec2 bvec3 bvec4 " +
                  "mat2 mat3 mat4"),
     blockKeywords: words("for while do if else struct"),
     builtin: words("radians degrees sin cos tan asin acos atan " +
                     "pow exp log exp2 sqrt inversesqrt " +
                     "abs sign floor ceil fract mod min max clamp mix step smoothstep " +
                     "length distance dot cross normalize ftransform faceforward " +
                     "reflect refract matrixCompMult " +
                     "lessThan lessThanEqual greaterThan greaterThanEqual " +
                     "equal notEqual any all not " +
                     "texture1D texture1DProj texture1DLod texture1DProjLod " +
                     "texture2D texture2DProj texture2DLod texture2DProjLod " +
                     "texture3D texture3DProj texture3DLod texture3DProjLod " +
                     "textureCube textureCubeLod " +
                     "shadow1D shadow2D shadow1DProj shadow2DProj " +
                     "shadow1DLod shadow2DLod shadow1DProjLod shadow2DProjLod " +
                     "dFdx dFdy fwidth " +
                     "noise1 noise2 noise3 noise4"),
     atoms: words("true false " +
                 "gl_FragColor gl_SecondaryColor gl_Normal gl_Vertex " +
                 "gl_MultiTexCoord0 gl_MultiTexCoord1 gl_MultiTexCoord2 gl_MultiTexCoord3 " +
                 "gl_MultiTexCoord4 gl_MultiTexCoord5 gl_MultiTexCoord6 gl_MultiTexCoord7 " +
                 "gl_FogCoord gl_PointCoord " +
                 "gl_Position gl_PointSize gl_ClipVertex " +
                 "gl_FrontColor gl_BackColor gl_FrontSecondaryColor gl_BackSecondaryColor " +
                 "gl_TexCoord gl_FogFragCoord " +
                 "gl_FragCoord gl_FrontFacing " +
                 "gl_FragData gl_FragDepth " +
                 "gl_ModelViewMatrix gl_ProjectionMatrix gl_ModelViewProjectionMatrix " +
                 "gl_TextureMatrix gl_NormalMatrix gl_ModelViewMatrixInverse " +
                 "gl_ProjectionMatrixInverse gl_ModelViewProjectionMatrixInverse " +
                 "gl_TexureMatrixTranspose gl_ModelViewMatrixInverseTranspose " +
                 "gl_ProjectionMatrixInverseTranspose " +
                 "gl_ModelViewProjectionMatrixInverseTranspose " +
                 "gl_TextureMatrixInverseTranspose " +
                 "gl_NormalScale gl_DepthRange gl_ClipPlane " +
                 "gl_Point gl_FrontMaterial gl_BackMaterial gl_LightSource gl_LightModel " +
                 "gl_FrontLightModelProduct gl_BackLightModelProduct " +
                 "gl_TextureColor gl_EyePlaneS gl_EyePlaneT gl_EyePlaneR gl_EyePlaneQ " +
                 "gl_FogParameters " +
                 "gl_MaxLights gl_MaxClipPlanes gl_MaxTextureUnits gl_MaxTextureCoords " +
                 "gl_MaxVertexAttribs gl_MaxVertexUniformComponents gl_MaxVaryingFloats " +
                 "gl_MaxVertexTextureImageUnits gl_MaxTextureImageUnits " +
                 "gl_MaxFragmentUniformComponents gl_MaxCombineTextureImageUnits " +
                 "gl_MaxDrawBuffers"),
     indentSwitch: false,
     hooks: {"#": cppHook},
     modeProps: {fold: ["brace", "include"]}
   });
 
   def("text/x-nesc", {
     name: "clike",
-    keywords: words(cKeywords + "as atomic async call command component components configuration event generic " +
+    keywords: words(cKeywords + " as atomic async call command component components configuration event generic " +
                     "implementation includes interface module new norace nx_struct nx_union post provides " +
                     "signal task uses abstract extends"),
-    types: words(cTypes),
-    blockKeywords: words("case do else for if switch while struct"),
+    types: cTypes,
+    blockKeywords: words(cBlockKeywords),
     atoms: words("null true false"),
     hooks: {"#": cppHook},
     modeProps: {fold: ["brace", "include"]}
   });
 
   def("text/x-objectivec", {
     name: "clike",
-    keywords: words(cKeywords + "inline restrict _Bool _Complex _Imaginery BOOL Class bycopy byref id IMP in " +
-                    "inout nil oneway out Protocol SEL self super atomic nonatomic retain copy readwrite readonly"),
-    types: words(cTypes),
-    atoms: words("YES NO NULL NILL ON OFF true false"),
+    keywords: words(cKeywords + " " + objCKeywords),
+    types: objCTypes,
+    builtin: words(objCBuiltins),
+    blockKeywords: words(cBlockKeywords + " @synthesize @try @catch @finally @autoreleasepool @synchronized"),
+    defKeywords: words(cDefKeywords + " @interface @implementation @protocol @class"),
+    dontIndentStatements: /^@.*$/,
+    typeFirstDefinitions: true,
+    atoms: words("YES NO NULL Nil nil true false nullptr"),
+    isReservedIdentifier: cIsReservedIdentifier,
     hooks: {
-      "@": function(stream) {
-        stream.eatWhile(/[\w\$]/);
-        return "keyword";
-      },
+      "#": cppHook,
+      "*": pointerHook,
+    },
+    modeProps: {fold: ["brace", "include"]}
+  });
+
+  def("text/x-objectivec++", {
+    name: "clike",
+    keywords: words(cKeywords + " " + objCKeywords + " " + cppKeywords),
+    types: objCTypes,
+    builtin: words(objCBuiltins),
+    blockKeywords: words(cBlockKeywords + " @synthesize @try @catch @finally @autoreleasepool @synchronized class try catch"),
+    defKeywords: words(cDefKeywords + " @interface @implementation @protocol @class class namespace"),
+    dontIndentStatements: /^@.*$|^template$/,
+    typeFirstDefinitions: true,
+    atoms: words("YES NO NULL Nil nil true false nullptr"),
+    isReservedIdentifier: cIsReservedIdentifier,
+    hooks: {
       "#": cppHook,
-      indent: function(_state, ctx, textAfter) {
-        if (ctx.type == "statement" && /^@\w/.test(textAfter)) return ctx.indented
+      "*": pointerHook,
+      "u": cpp11StringHook,
+      "U": cpp11StringHook,
+      "L": cpp11StringHook,
+      "R": cpp11StringHook,
+      "0": cpp14Literal,
+      "1": cpp14Literal,
+      "2": cpp14Literal,
+      "3": cpp14Literal,
+      "4": cpp14Literal,
+      "5": cpp14Literal,
+      "6": cpp14Literal,
+      "7": cpp14Literal,
+      "8": cpp14Literal,
+      "9": cpp14Literal,
+      token: function(stream, state, style) {
+        if (style == "variable" && stream.peek() == "(" &&
+            (state.prevToken == ";" || state.prevToken == null ||
+             state.prevToken == "}") &&
+            cppLooksLikeConstructor(stream.current()))
+          return "def";
       }
     },
-    modeProps: {fold: "brace"}
+    namespaceSeparator: "::",
+    modeProps: {fold: ["brace", "include"]}
   });
 
   def("text/x-squirrel", {
     name: "clike",
     keywords: words("base break clone continue const default delete enum extends function in class" +
                     " foreach local resume return this throw typeof yield constructor instanceof static"),
-    types: words(cTypes),
+    types: cTypes,
     blockKeywords: words("case catch class else for foreach if switch try while"),
     defKeywords: words("function local class"),
     typeFirstDefinitions: true,
     atoms: words("true false null"),
     hooks: {"#": cppHook},
     modeProps: {fold: ["brace", "include"]}
   });
 
   // Ceylon Strings need to deal with interpolation
   var stringTokenizer = null;
   function tokenCeylonString(type) {
     return function(stream, state) {
       var escaped = false, next, end = false;
       while (!stream.eol()) {
         if (!escaped && stream.match('"') &&
               (type == "single" || stream.match('""'))) {
           end = true;
           break;
         }
         if (!escaped && stream.match('``')) {
           stringTokenizer = tokenCeylonString(type);
           end = true;
           break;
         }
         next = stream.next();
         escaped = type == "single" && !escaped && next == "\\";
       }
       if (end)
           state.tokenize = null;
       return "string";
     }
   }
 
   def("text/x-ceylon", {
     name: "clike",
     keywords: words("abstracts alias assembly assert assign break case catch class continue dynamic else" +
                     " exists extends finally for function given if import in interface is let module new" +
                     " nonempty object of out outer package return satisfies super switch then this throw" +
                     " try value void while"),
     types: function(word) {
         // In Ceylon all identifiers that start with an uppercase are types
         var first = word.charAt(0);
         return (first === first.toUpperCase() && first !== first.toLowerCase());
     },
     blockKeywords: words("case catch class dynamic else finally for function if interface module new object switch try while"),
     defKeywords: words("class dynamic function interface module object package value"),
     builtin: words("abstract actual aliased annotation by default deprecated doc final formal late license" +
                    " native optional sealed see serializable shared suppressWarnings tagged throws variable"),
     isPunctuationChar: /[\[\]{}\(\),;\:\.`]/,
     isOperatorChar: /[+\-*&%=<>!?|^~:\/]/,
     numberStart: /[\d#$]/,
     number: /^(?:#[\da-fA-F_]+|\$[01_]+|[\d_]+[kMGTPmunpf]?|[\d_]+\.[\d_]+(?:[eE][-+]?\d+|[kMGTPmunpf]|)|)/i,
     multiLineStrings: true,
     typeFirstDefinitions: true,
     atoms: words("true false null larger smaller equal empty finished"),
     indentSwitch: false,
     styleDefs: false,
     hooks: {
       "@": function(stream) {
         stream.eatWhile(/[\w\$_]/);
         return "meta";
       },
       '"': function(stream, state) {
           state.tokenize = tokenCeylonString(stream.match('""') ? "triple" : "single");
           return state.tokenize(stream, state);
         },
       '`': function(stream, state) {
           if (!stringTokenizer || !stream.match('`')) return false;
           state.tokenize = stringTokenizer;
           stringTokenizer = null;
           return state.tokenize(stream, state);
         },
       "'": function(stream) {
         stream.eatWhile(/[\w\$_\xa1-\uffff]/);
         return "atom";
       },
       token: function(_stream, state, style) {
-          if ((style == "variable" || style == "variable-3") &&
+          if ((style == "variable" || style == "type") &&
               state.prevToken == ".") {
             return "variable-2";
           }
         }
     },
     modeProps: {
         fold: ["brace", "import"],
         closeBrackets: {triples: '"'}
     }
   });
 
 });

rhodecode/public/js/mode/clojure/clojure.js

@@ -1,249 +1,292 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
-
-/**
- * Author: Hans Engel
- * Branched from CodeMirror's Scheme mode (by Koh Zi Han, based on implementation by Koh Zi Chun)
- */
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 (function(mod) {
-  if (typeof exports == "object" && typeof module == "object") // CommonJS
+  if (typeof exports === "object" && typeof module === "object") // CommonJS
     mod(require("../../lib/codemirror"));
-  else if (typeof define == "function" && define.amd) // AMD
+  else if (typeof define === "function" && define.amd) // AMD
     define(["../../lib/codemirror"], mod);
   else // Plain browser env
     mod(CodeMirror);
 })(function(CodeMirror) {
 "use strict";
 
 CodeMirror.defineMode("clojure", function (options) {
-    var BUILTIN = "builtin", COMMENT = "comment", STRING = "string", CHARACTER = "string-2",
-        ATOM = "atom", NUMBER = "number", BRACKET = "bracket", KEYWORD = "keyword", VAR = "variable";
-    var INDENT_WORD_SKIP = options.indentUnit || 2;
-    var NORMAL_INDENT_UNIT = options.indentUnit || 2;
-
-    function makeKeywords(str) {
-        var obj = {}, words = str.split(" ");
-        for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
-        return obj;
-    }
-
-    var atoms = makeKeywords("true false nil");
-
-    var keywords = makeKeywords(
-      "defn defn- def def- defonce defmulti defmethod defmacro defstruct deftype defprotocol defrecord defproject deftest slice defalias defhinted defmacro- defn-memo defnk defnk defonce- defunbound defunbound- defvar defvar- let letfn do case cond condp for loop recur when when-not when-let when-first if if-let if-not . .. -> ->> doto and or dosync doseq dotimes dorun doall load import unimport ns in-ns refer try catch finally throw with-open with-local-vars binding gen-class gen-and-load-class gen-and-save-class handler-case handle");
-
-    var builtins = makeKeywords(
-        "* *' *1 *2 *3 *agent* *allow-unresolved-vars* *assert* *clojure-version* *command-line-args* *compile-files* *compile-path* *compiler-options* *data-readers* *e *err* *file* *flush-on-newline* *fn-loader* *in* *math-context* *ns* *out* *print-dup* *print-length* *print-level* *print-meta* *print-readably* *read-eval* *source-path* *unchecked-math* *use-context-classloader* *verbose-defrecords* *warn-on-reflection* + +' - -' -> ->> ->ArrayChunk ->Vec ->VecNode ->VecSeq -cache-protocol-fn -reset-methods .. / < <= = == > >= EMPTY-NODE accessor aclone add-classpath add-watch agent agent-error agent-errors aget alength alias all-ns alter alter-meta! alter-var-root amap ancestors and apply areduce array-map aset aset-boolean aset-byte aset-char aset-double aset-float aset-int aset-long aset-short assert assoc assoc! assoc-in associative? atom await await-for await1 bases bean bigdec bigint biginteger binding bit-and bit-and-not bit-clear bit-flip bit-not bit-or bit-set bit-shift-left bit-shift-right bit-test bit-xor boolean boolean-array booleans bound-fn bound-fn* bound? butlast byte byte-array bytes case cast char char-array char-escape-string char-name-string char? chars chunk chunk-append chunk-buffer chunk-cons chunk-first chunk-next chunk-rest chunked-seq? class class? clear-agent-errors clojure-version coll? comment commute comp comparator compare compare-and-set! compile complement concat cond condp conj conj! cons constantly construct-proxy contains? count counted? create-ns create-struct cycle dec dec' decimal? declare default-data-readers definline definterface defmacro defmethod defmulti defn defn- defonce defprotocol defrecord defstruct deftype delay delay? deliver denominator deref derive descendants destructure disj disj! dissoc dissoc! distinct distinct? doall dorun doseq dosync dotimes doto double double-array doubles drop drop-last drop-while empty empty? ensure enumeration-seq error-handler error-mode eval even? every-pred every? ex-data ex-info extend extend-protocol extend-type extenders extends? false? ffirst file-seq filter filterv find find-keyword find-ns find-protocol-impl find-protocol-method find-var first flatten float float-array float? floats flush fn fn? fnext fnil for force format frequencies future future-call future-cancel future-cancelled? future-done? future? gen-class gen-interface gensym get get-in get-method get-proxy-class get-thread-bindings get-validator group-by hash hash-combine hash-map hash-set identical? identity if-let if-not ifn? import in-ns inc inc' init-proxy instance? int int-array integer? interleave intern interpose into into-array ints io! isa? iterate iterator-seq juxt keep keep-indexed key keys keyword keyword? last lazy-cat lazy-seq let letfn line-seq list list* list? load load-file load-reader load-string loaded-libs locking long long-array longs loop macroexpand macroexpand-1 make-array make-hierarchy map map-indexed map? mapcat mapv max max-key memfn memoize merge merge-with meta method-sig methods min min-key mod munge name namespace namespace-munge neg? newline next nfirst nil? nnext not not-any? not-empty not-every? not= ns ns-aliases ns-imports ns-interns ns-map ns-name ns-publics ns-refers ns-resolve ns-unalias ns-unmap nth nthnext nthrest num number? numerator object-array odd? or parents partial partition partition-all partition-by pcalls peek persistent! pmap pop pop! pop-thread-bindings pos? pr pr-str prefer-method prefers primitives-classnames print print-ctor print-dup print-method print-simple print-str printf println println-str prn prn-str promise proxy proxy-call-with-super proxy-mappings proxy-name proxy-super push-thread-bindings pvalues quot rand rand-int rand-nth range ratio? rational? rationalize re-find re-groups re-matcher re-matches re-pattern re-seq read read-line read-string realized? reduce reduce-kv reductions ref ref-history-count ref-max-history ref-min-history ref-set refer refer-clojure reify release-pending-sends rem remove remove-all-methods remove-method remove-ns remove-watch repeat repeatedly replace replicate require reset! reset-meta! resolve rest restart-agent resultset-seq reverse reversible? rseq rsubseq satisfies? second select-keys send send-off seq seq? seque sequence sequential? set set-error-handler! set-error-mode! set-validator! set? short short-array shorts shuffle shutdown-agents slurp some some-fn sort sort-by sorted-map sorted-map-by sorted-set sorted-set-by sorted? special-symbol? spit split-at split-with str string? struct struct-map subs subseq subvec supers swap! symbol symbol? sync take take-last take-nth take-while test the-ns thread-bound? time to-array to-array-2d trampoline transient tree-seq true? type unchecked-add unchecked-add-int unchecked-byte unchecked-char unchecked-dec unchecked-dec-int unchecked-divide-int unchecked-double unchecked-float unchecked-inc unchecked-inc-int unchecked-int unchecked-long unchecked-multiply unchecked-multiply-int unchecked-negate unchecked-negate-int unchecked-remainder-int unchecked-short unchecked-subtract unchecked-subtract-int underive unquote unquote-splicing update-in update-proxy use val vals var-get var-set var? vary-meta vec vector vector-of vector? when when-first when-let when-not while with-bindings with-bindings* with-in-str with-loading-context with-local-vars with-meta with-open with-out-str with-precision with-redefs with-redefs-fn xml-seq zero? zipmap *default-data-reader-fn* as-> cond-> cond->> reduced reduced? send-via set-agent-send-executor! set-agent-send-off-executor! some-> some->>");
-
-    var indentKeys = makeKeywords(
-        // Built-ins
-        "ns fn def defn defmethod bound-fn if if-not case condp when while when-not when-first do future comment doto locking proxy with-open with-precision reify deftype defrecord defprotocol extend extend-protocol extend-type try catch " +
-
-        // Binding forms
-        "let letfn binding loop for doseq dotimes when-let if-let " +
-
-        // Data structures
-        "defstruct struct-map assoc " +
-
-        // clojure.test
-        "testing deftest " +
-
-        // contrib
-        "handler-case handle dotrace deftrace");
-
-    var tests = {
-        digit: /\d/,
-        digit_or_colon: /[\d:]/,
-        hex: /[0-9a-f]/i,
-        sign: /[+-]/,
-        exponent: /e/i,
-        keyword_char: /[^\s\(\[\;\)\]]/,
-        symbol: /[\w*+!\-\._?:<>\/\xa1-\uffff]/,
-        block_indent: /^(?:def|with)[^\/]+$|\/(?:def|with)/
-    };
-
-    function stateStack(indent, type, prev) { // represents a state stack object
-        this.indent = indent;
-        this.type = type;
-        this.prev = prev;
-    }
+  var atoms = ["false", "nil", "true"];
+  var specialForms = [".", "catch", "def", "do", "if", "monitor-enter",
+      "monitor-exit", "new", "quote", "recur", "set!", "throw", "try", "var"];
+  var coreSymbols = ["*", "*'", "*1", "*2", "*3", "*agent*",
+      "*allow-unresolved-vars*", "*assert*", "*clojure-version*",
+      "*command-line-args*", "*compile-files*", "*compile-path*",
+      "*compiler-options*", "*data-readers*", "*default-data-reader-fn*", "*e",
+      "*err*", "*file*", "*flush-on-newline*", "*fn-loader*", "*in*",
+      "*math-context*", "*ns*", "*out*", "*print-dup*", "*print-length*",
+      "*print-level*", "*print-meta*", "*print-namespace-maps*",
+      "*print-readably*", "*read-eval*", "*reader-resolver*", "*source-path*",
+      "*suppress-read*", "*unchecked-math*", "*use-context-classloader*",
+      "*verbose-defrecords*", "*warn-on-reflection*", "+", "+'", "-", "-'",
+      "->", "->>", "->ArrayChunk", "->Eduction", "->Vec", "->VecNode",
+      "->VecSeq", "-cache-protocol-fn", "-reset-methods", "..", "/", "<", "<=",
+      "=", "==", ">", ">=", "EMPTY-NODE", "Inst", "StackTraceElement->vec",
+      "Throwable->map", "accessor", "aclone", "add-classpath", "add-watch",
+      "agent", "agent-error", "agent-errors", "aget", "alength", "alias",
+      "all-ns", "alter", "alter-meta!", "alter-var-root", "amap", "ancestors",
+      "and", "any?", "apply", "areduce", "array-map", "as->", "aset",
+      "aset-boolean", "aset-byte", "aset-char", "aset-double", "aset-float",
+      "aset-int", "aset-long", "aset-short", "assert", "assoc", "assoc!",
+      "assoc-in", "associative?", "atom", "await", "await-for", "await1",
+      "bases", "bean", "bigdec", "bigint", "biginteger", "binding", "bit-and",
+      "bit-and-not", "bit-clear", "bit-flip", "bit-not", "bit-or", "bit-set",
+      "bit-shift-left", "bit-shift-right", "bit-test", "bit-xor", "boolean",
+      "boolean-array", "boolean?", "booleans", "bound-fn", "bound-fn*",
+      "bound?", "bounded-count", "butlast", "byte", "byte-array", "bytes",
+      "bytes?", "case", "cast", "cat", "char", "char-array",
+      "char-escape-string", "char-name-string", "char?", "chars", "chunk",
+      "chunk-append", "chunk-buffer", "chunk-cons", "chunk-first", "chunk-next",
+      "chunk-rest", "chunked-seq?", "class", "class?", "clear-agent-errors",
+      "clojure-version", "coll?", "comment", "commute", "comp", "comparator",
+      "compare", "compare-and-set!", "compile", "complement", "completing",
+      "concat", "cond", "cond->", "cond->>", "condp", "conj", "conj!", "cons",
+      "constantly", "construct-proxy", "contains?", "count", "counted?",
+      "create-ns", "create-struct", "cycle", "dec", "dec'", "decimal?",
+      "declare", "dedupe", "default-data-readers", "definline", "definterface",
+      "defmacro", "defmethod", "defmulti", "defn", "defn-", "defonce",
+      "defprotocol", "defrecord", "defstruct", "deftype", "delay", "delay?",
+      "deliver", "denominator", "deref", "derive", "descendants", "destructure",
+      "disj", "disj!", "dissoc", "dissoc!", "distinct", "distinct?", "doall",
+      "dorun", "doseq", "dosync", "dotimes", "doto", "double", "double-array",
+      "double?", "doubles", "drop", "drop-last", "drop-while", "eduction",
+      "empty", "empty?", "ensure", "ensure-reduced", "enumeration-seq",
+      "error-handler", "error-mode", "eval", "even?", "every-pred", "every?",
+      "ex-data", "ex-info", "extend", "extend-protocol", "extend-type",
+      "extenders", "extends?", "false?", "ffirst", "file-seq", "filter",
+      "filterv", "find", "find-keyword", "find-ns", "find-protocol-impl",
+      "find-protocol-method", "find-var", "first", "flatten", "float",
+      "float-array", "float?", "floats", "flush", "fn", "fn?", "fnext", "fnil",
+      "for", "force", "format", "frequencies", "future", "future-call",
+      "future-cancel", "future-cancelled?", "future-done?", "future?",
+      "gen-class", "gen-interface", "gensym", "get", "get-in", "get-method",
+      "get-proxy-class", "get-thread-bindings", "get-validator", "group-by",
+      "halt-when", "hash", "hash-combine", "hash-map", "hash-ordered-coll",
+      "hash-set", "hash-unordered-coll", "ident?", "identical?", "identity",
+      "if-let", "if-not", "if-some", "ifn?", "import", "in-ns", "inc", "inc'",
+      "indexed?", "init-proxy", "inst-ms", "inst-ms*", "inst?", "instance?",
+      "int", "int-array", "int?", "integer?", "interleave", "intern",
+      "interpose", "into", "into-array", "ints", "io!", "isa?", "iterate",
+      "iterator-seq", "juxt", "keep", "keep-indexed", "key", "keys", "keyword",
+      "keyword?", "last", "lazy-cat", "lazy-seq", "let", "letfn", "line-seq",
+      "list", "list*", "list?", "load", "load-file", "load-reader",
+      "load-string", "loaded-libs", "locking", "long", "long-array", "longs",
+      "loop", "macroexpand", "macroexpand-1", "make-array", "make-hierarchy",
+      "map", "map-entry?", "map-indexed", "map?", "mapcat", "mapv", "max",
+      "max-key", "memfn", "memoize", "merge", "merge-with", "meta",
+      "method-sig", "methods", "min", "min-key", "mix-collection-hash", "mod",
+      "munge", "name", "namespace", "namespace-munge", "nat-int?", "neg-int?",
+      "neg?", "newline", "next", "nfirst", "nil?", "nnext", "not", "not-any?",
+      "not-empty", "not-every?", "not=", "ns", "ns-aliases", "ns-imports",
+      "ns-interns", "ns-map", "ns-name", "ns-publics", "ns-refers",
+      "ns-resolve", "ns-unalias", "ns-unmap", "nth", "nthnext", "nthrest",
+      "num", "number?", "numerator", "object-array", "odd?", "or", "parents",
+      "partial", "partition", "partition-all", "partition-by", "pcalls", "peek",
+      "persistent!", "pmap", "pop", "pop!", "pop-thread-bindings", "pos-int?",
+      "pos?", "pr", "pr-str", "prefer-method", "prefers",
+      "primitives-classnames", "print", "print-ctor", "print-dup",
+      "print-method", "print-simple", "print-str", "printf", "println",
+      "println-str", "prn", "prn-str", "promise", "proxy",
+      "proxy-call-with-super", "proxy-mappings", "proxy-name", "proxy-super",
+      "push-thread-bindings", "pvalues", "qualified-ident?",
+      "qualified-keyword?", "qualified-symbol?", "quot", "rand", "rand-int",
+      "rand-nth", "random-sample", "range", "ratio?", "rational?",
+      "rationalize", "re-find", "re-groups", "re-matcher", "re-matches",
+      "re-pattern", "re-seq", "read", "read-line", "read-string",
+      "reader-conditional", "reader-conditional?", "realized?", "record?",
+      "reduce", "reduce-kv", "reduced", "reduced?", "reductions", "ref",
+      "ref-history-count", "ref-max-history", "ref-min-history", "ref-set",
+      "refer", "refer-clojure", "reify", "release-pending-sends", "rem",
+      "remove", "remove-all-methods", "remove-method", "remove-ns",
+      "remove-watch", "repeat", "repeatedly", "replace", "replicate", "require",
+      "reset!", "reset-meta!", "reset-vals!", "resolve", "rest",
+      "restart-agent", "resultset-seq", "reverse", "reversible?", "rseq",
+      "rsubseq", "run!", "satisfies?", "second", "select-keys", "send",
+      "send-off", "send-via", "seq", "seq?", "seqable?", "seque", "sequence",
+      "sequential?", "set", "set-agent-send-executor!",
+      "set-agent-send-off-executor!", "set-error-handler!", "set-error-mode!",
+      "set-validator!", "set?", "short", "short-array", "shorts", "shuffle",
+      "shutdown-agents", "simple-ident?", "simple-keyword?", "simple-symbol?",
+      "slurp", "some", "some->", "some->>", "some-fn", "some?", "sort",
+      "sort-by", "sorted-map", "sorted-map-by", "sorted-set", "sorted-set-by",
+      "sorted?", "special-symbol?", "spit", "split-at", "split-with", "str",
+      "string?", "struct", "struct-map", "subs", "subseq", "subvec", "supers",
+      "swap!", "swap-vals!", "symbol", "symbol?", "sync", "tagged-literal",
+      "tagged-literal?", "take", "take-last", "take-nth", "take-while", "test",
+      "the-ns", "thread-bound?", "time", "to-array", "to-array-2d",
+      "trampoline", "transduce", "transient", "tree-seq", "true?", "type",
+      "unchecked-add", "unchecked-add-int", "unchecked-byte", "unchecked-char",
+      "unchecked-dec", "unchecked-dec-int", "unchecked-divide-int",
+      "unchecked-double", "unchecked-float", "unchecked-inc",
+      "unchecked-inc-int", "unchecked-int", "unchecked-long",
+      "unchecked-multiply", "unchecked-multiply-int", "unchecked-negate",
+      "unchecked-negate-int", "unchecked-remainder-int", "unchecked-short",
+      "unchecked-subtract", "unchecked-subtract-int", "underive", "unquote",
+      "unquote-splicing", "unreduced", "unsigned-bit-shift-right", "update",
+      "update-in", "update-proxy", "uri?", "use", "uuid?", "val", "vals",
+      "var-get", "var-set", "var?", "vary-meta", "vec", "vector", "vector-of",
+      "vector?", "volatile!", "volatile?", "vreset!", "vswap!", "when",
+      "when-first", "when-let", "when-not", "when-some", "while",
+      "with-bindings", "with-bindings*", "with-in-str", "with-loading-context",
+      "with-local-vars", "with-meta", "with-open", "with-out-str",
+      "with-precision", "with-redefs", "with-redefs-fn", "xml-seq", "zero?",
+      "zipmap"];
+  var haveBodyParameter = [
+      "->", "->>", "as->", "binding", "bound-fn", "case", "catch", "comment",
+      "cond", "cond->", "cond->>", "condp", "def", "definterface", "defmethod",
+      "defn", "defmacro", "defprotocol", "defrecord", "defstruct", "deftype",
+      "do", "doseq", "dotimes", "doto", "extend", "extend-protocol",
+      "extend-type", "fn", "for", "future", "if", "if-let", "if-not", "if-some",
+      "let", "letfn", "locking", "loop", "ns", "proxy", "reify", "struct-map",
+      "some->", "some->>", "try", "when", "when-first", "when-let", "when-not",
+      "when-some", "while", "with-bindings", "with-bindings*", "with-in-str",
+      "with-loading-context", "with-local-vars", "with-meta", "with-open",
+      "with-out-str", "with-precision", "with-redefs", "with-redefs-fn"];
 
-    function pushStack(state, indent, type) {
-        state.indentStack = new stateStack(indent, type, state.indentStack);
-    }
-
-    function popStack(state) {
-        state.indentStack = state.indentStack.prev;
-    }
+  CodeMirror.registerHelper("hintWords", "clojure",
+    [].concat(atoms, specialForms, coreSymbols));
 
-    function isNumber(ch, stream){
-        // hex
-        if ( ch === '0' && stream.eat(/x/i) ) {
-            stream.eatWhile(tests.hex);
-            return true;
-        }
+  var atom = createLookupMap(atoms);
+  var specialForm = createLookupMap(specialForms);
+  var coreSymbol = createLookupMap(coreSymbols);
+  var hasBodyParameter = createLookupMap(haveBodyParameter);
+  var delimiter = /^(?:[\\\[\]\s"(),;@^`{}~]|$)/;
+  var numberLiteral = /^(?:[+\-]?\d+(?:(?:N|(?:[eE][+\-]?\d+))|(?:\.?\d*(?:M|(?:[eE][+\-]?\d+))?)|\/\d+|[xX][0-9a-fA-F]+|r[0-9a-zA-Z]+)?(?=[\\\[\]\s"#'(),;@^`{}~]|$))/;
+  var characterLiteral = /^(?:\\(?:backspace|formfeed|newline|return|space|tab|o[0-7]{3}|u[0-9A-Fa-f]{4}|x[0-9A-Fa-f]{4}|.)?(?=[\\\[\]\s"(),;@^`{}~]|$))/;
 
-        // leading sign
-        if ( ( ch == '+' || ch == '-' ) && ( tests.digit.test(stream.peek()) ) ) {
-          stream.eat(tests.sign);
-          ch = stream.next();
-        }
-
-        if ( tests.digit.test(ch) ) {
-            stream.eat(ch);
-            stream.eatWhile(tests.digit);
+  // simple-namespace := /^[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*/
+  // simple-symbol    := /^(?:\/|[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)/
+  // qualified-symbol := (<simple-namespace>(<.><simple-namespace>)*</>)?<simple-symbol>
+  var qualifiedSymbol = /^(?:(?:[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*(?:\.[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)*\/)?(?:\/|[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)*(?=[\\\[\]\s"(),;@^`{}~]|$))/;
 
-            if ( '.' == stream.peek() ) {
-                stream.eat('.');
-                stream.eatWhile(tests.digit);
-            } else if ('/' == stream.peek() ) {
-                stream.eat('/');
-                stream.eatWhile(tests.digit);
-            }
-
-            if ( stream.eat(tests.exponent) ) {
-                stream.eat(tests.sign);
-                stream.eatWhile(tests.digit);
-            }
-
-            return true;
-        }
+  function base(stream, state) {
+    if (stream.eatSpace() || stream.eat(",")) return ["space", null];
+    if (stream.match(numberLiteral)) return [null, "number"];
+    if (stream.match(characterLiteral)) return [null, "string-2"];
+    if (stream.eat(/^"/)) return (state.tokenize = inString)(stream, state);
+    if (stream.eat(/^[(\[{]/)) return ["open", "bracket"];
+    if (stream.eat(/^[)\]}]/)) return ["close", "bracket"];
+    if (stream.eat(/^;/)) {stream.skipToEnd(); return ["space", "comment"];}
+    if (stream.eat(/^[#'@^`~]/)) return [null, "meta"];
 
-        return false;
-    }
+    var matches = stream.match(qualifiedSymbol);
+    var symbol = matches && matches[0];
 
-    // Eat character that starts after backslash \
-    function eatCharacter(stream) {
-        var first = stream.next();
-        // Read special literals: backspace, newline, space, return.
-        // Just read all lowercase letters.
-        if (first && first.match(/[a-z]/) && stream.match(/[a-z]+/, true)) {
-            return;
-        }
-        // Read unicode character: \u1000 \uA0a1
-        if (first === "u") {
-            stream.match(/[0-9a-z]{4}/i, true);
-        }
+    if (!symbol) {
+      // advance stream by at least one character so we don't get stuck.
+      stream.next();
+      stream.eatWhile(function (c) {return !is(c, delimiter);});
+      return [null, "error"];
     }
 
-    return {
-        startState: function () {
-            return {
-                indentStack: null,
-                indentation: 0,
-                mode: false
-            };
-        },
+    if (symbol === "comment" && state.lastToken === "(")
+      return (state.tokenize = inComment)(stream, state);
+    if (is(symbol, atom) || symbol.charAt(0) === ":") return ["symbol", "atom"];
+    if (is(symbol, specialForm) || is(symbol, coreSymbol)) return ["symbol", "keyword"];
+    if (state.lastToken === "(") return ["symbol", "builtin"]; // other operator
+
+    return ["symbol", "variable"];
+  }
 
-        token: function (stream, state) {
-            if (state.indentStack == null && stream.sol()) {
-                // update indentation, but only if indentStack is empty
-                state.indentation = stream.indentation();
-            }
+  function inString(stream, state) {
+    var escaped = false, next;
+
+    while (next = stream.next()) {
+      if (next === "\"" && !escaped) {state.tokenize = base; break;}
+      escaped = !escaped && next === "\\";
+    }
+
+    return [null, "string"];
+  }
 
-            // skip spaces
-            if (state.mode != "string" && stream.eatSpace()) {
-                return null;
-            }
-            var returnType = null;
+  function inComment(stream, state) {
+    var parenthesisCount = 1;
+    var next;
 
-            switch(state.mode){
-                case "string": // multi-line string parsing mode
-                    var next, escaped = false;
-                    while ((next = stream.next()) != null) {
-                        if (next == "\"" && !escaped) {
+    while (next = stream.next()) {
+      if (next === ")") parenthesisCount--;
+      if (next === "(") parenthesisCount++;
+      if (parenthesisCount === 0) {
+        stream.backUp(1);
+        state.tokenize = base;
+        break;
+      }
+    }
 
-                            state.mode = false;
-                            break;
-                        }
-                        escaped = !escaped && next == "\\";
-                    }
-                    returnType = STRING; // continue on in string mode
-                    break;
-                default: // default parsing mode
-                    var ch = stream.next();
+    return ["space", "comment"];
+  }
+
+  function createLookupMap(words) {
+    var obj = {};
+
+    for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+
+    return obj;
+  }
 
-                    if (ch == "\"") {
-                        state.mode = "string";
-                        returnType = STRING;
-                    } else if (ch == "\\") {
-                        eatCharacter(stream);
-                        returnType = CHARACTER;
-                    } else if (ch == "'" && !( tests.digit_or_colon.test(stream.peek()) )) {
-                        returnType = ATOM;
-                    } else if (ch == ";") { // comment
-                        stream.skipToEnd(); // rest of the line is a comment
-                        returnType = COMMENT;
-                    } else if (isNumber(ch,stream)){
-                        returnType = NUMBER;
-                    } else if (ch == "(" || ch == "[" || ch == "{" ) {
-                        var keyWord = '', indentTemp = stream.column(), letter;
-                        /**
-                        Either
-                        (indent-word ..
-                        (non-indent-word ..
-                        (;something else, bracket, etc.
-                        */
+  function is(value, test) {
+    if (test instanceof RegExp) return test.test(value);
+    if (test instanceof Object) return test.propertyIsEnumerable(value);
+  }
 
-                        if (ch == "(") while ((letter = stream.eat(tests.keyword_char)) != null) {
-                            keyWord += letter;
-                        }
+  return {
+    startState: function () {
+      return {
+        ctx: {prev: null, start: 0, indentTo: 0},
+        lastToken: null,
+        tokenize: base
+      };
+    },
+
+    token: function (stream, state) {
+      if (stream.sol() && (typeof state.ctx.indentTo !== "number"))
+        state.ctx.indentTo = state.ctx.start + 1;
+
+      var typeStylePair = state.tokenize(stream, state);
+      var type = typeStylePair[0];
+      var style = typeStylePair[1];
+      var current = stream.current();
 
-                        if (keyWord.length > 0 && (indentKeys.propertyIsEnumerable(keyWord) ||
-                                                   tests.block_indent.test(keyWord))) { // indent-word
-                            pushStack(state, indentTemp + INDENT_WORD_SKIP, ch);
-                        } else { // non-indent word
-                            // we continue eating the spaces
-                            stream.eatSpace();
-                            if (stream.eol() || stream.peek() == ";") {
-                                // nothing significant after
-                                // we restart indentation the user defined spaces after
-                                pushStack(state, indentTemp + NORMAL_INDENT_UNIT, ch);
-                            } else {
-                                pushStack(state, indentTemp + stream.current().length, ch); // else we match
-                            }
-                        }
-                        stream.backUp(stream.current().length - 1); // undo all the eating
+      if (type !== "space") {
+        if (state.lastToken === "(" && state.ctx.indentTo === null) {
+          if (type === "symbol" && is(current, hasBodyParameter))
+            state.ctx.indentTo = state.ctx.start + options.indentUnit;
+          else state.ctx.indentTo = "next";
+        } else if (state.ctx.indentTo === "next") {
+          state.ctx.indentTo = stream.column();
+        }
+
+        state.lastToken = current;
+      }
 
-                        returnType = BRACKET;
-                    } else if (ch == ")" || ch == "]" || ch == "}") {
-                        returnType = BRACKET;
-                        if (state.indentStack != null && state.indentStack.type == (ch == ")" ? "(" : (ch == "]" ? "[" :"{"))) {
-                            popStack(state);
-                        }
-                    } else if ( ch == ":" ) {
-                        stream.eatWhile(tests.symbol);
-                        return ATOM;
-                    } else {
-                        stream.eatWhile(tests.symbol);
+      if (type === "open")
+        state.ctx = {prev: state.ctx, start: stream.column(), indentTo: null};
+      else if (type === "close") state.ctx = state.ctx.prev || state.ctx;
+
+      return style;
+    },
 
-                        if (keywords && keywords.propertyIsEnumerable(stream.current())) {
-                            returnType = KEYWORD;
-                        } else if (builtins && builtins.propertyIsEnumerable(stream.current())) {
-                            returnType = BUILTIN;
-                        } else if (atoms && atoms.propertyIsEnumerable(stream.current())) {
-                            returnType = ATOM;
-                        } else {
-                          returnType = VAR;
-                        }
-                    }
-            }
+    indent: function (state) {
+      var i = state.ctx.indentTo;
 
-            return returnType;
-        },
+      return (typeof i === "number") ?
+        i :
+        state.ctx.start + 1;
+    },
 
-        indent: function (state) {
-            if (state.indentStack == null) return state.indentation;
-            return state.indentStack.indent;
-        },
-
-        closeBrackets: {pairs: "()[]{}\"\""},
-        lineComment: ";;"
-    };
+    closeBrackets: {pairs: "()[]{}\"\""},
+    lineComment: ";;"
+  };
 });
 
 CodeMirror.defineMIME("text/x-clojure", "clojure");
 CodeMirror.defineMIME("text/x-clojurescript", "clojure");
+CodeMirror.defineMIME("application/edn", "clojure");
 
 });

rhodecode/public/js/mode/cmake/cmake.js

@@ -1,97 +1,97 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 (function(mod) {
   if (typeof exports == "object" && typeof module == "object")
     mod(require("../../lib/codemirror"));
   else if (typeof define == "function" && define.amd)
     define(["../../lib/codemirror"], mod);
   else
     mod(CodeMirror);
 })(function(CodeMirror) {
 "use strict";
 
 CodeMirror.defineMode("cmake", function () {
   var variable_regex = /({)?[a-zA-Z0-9_]+(})?/;
 
   function tokenString(stream, state) {
     var current, prev, found_var = false;
     while (!stream.eol() && (current = stream.next()) != state.pending) {
       if (current === '$' && prev != '\\' && state.pending == '"') {
         found_var = true;
         break;
       }
       prev = current;
     }
     if (found_var) {
       stream.backUp(1);
     }
     if (current == state.pending) {
       state.continueString = false;
     } else {
       state.continueString = true;
     }
     return "string";
   }
 
   function tokenize(stream, state) {
     var ch = stream.next();
 
     // Have we found a variable?
     if (ch === '$') {
       if (stream.match(variable_regex)) {
         return 'variable-2';
       }
       return 'variable';
     }
     // Should we still be looking for the end of a string?
     if (state.continueString) {
       // If so, go through the loop again
       stream.backUp(1);
       return tokenString(stream, state);
     }
     // Do we just have a function on our hands?
     // In 'cmake_minimum_required (VERSION 2.8.8)', 'cmake_minimum_required' is matched
     if (stream.match(/(\s+)?\w+\(/) || stream.match(/(\s+)?\w+\ \(/)) {
       stream.backUp(1);
       return 'def';
     }
     if (ch == "#") {
       stream.skipToEnd();
       return "comment";
     }
     // Have we found a string?
     if (ch == "'" || ch == '"') {
       // Store the type (single or double)
       state.pending = ch;
       // Perform the looping function to find the end
       return tokenString(stream, state);
     }
     if (ch == '(' || ch == ')') {
       return 'bracket';
     }
     if (ch.match(/[0-9]/)) {
       return 'number';
     }
     stream.eatWhile(/[\w-]/);
     return null;
   }
   return {
     startState: function () {
       var state = {};
       state.inDefinition = false;
       state.inInclude = false;
       state.continueString = false;
       state.pending = false;
       return state;
     },
     token: function (stream, state) {
       if (stream.eatSpace()) return null;
       return tokenize(stream, state);
     }
   };
 });
 
 CodeMirror.defineMIME("text/x-cmake", "cmake");
 
 });

rhodecode/public/js/mode/cobol/cobol.js

@@ -1,255 +1,255 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 /**
  * Author: Gautam Mehta
  * Branched from CodeMirror's Scheme mode
  */
 (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("cobol", function () {
   var BUILTIN = "builtin", COMMENT = "comment", STRING = "string",
       ATOM = "atom", NUMBER = "number", KEYWORD = "keyword", MODTAG = "header",
       COBOLLINENUM = "def", PERIOD = "link";
   function makeKeywords(str) {
     var obj = {}, words = str.split(" ");
     for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
     return obj;
   }
   var atoms = makeKeywords("TRUE FALSE ZEROES ZEROS ZERO SPACES SPACE LOW-VALUE LOW-VALUES ");
   var keywords = makeKeywords(
       "ACCEPT ACCESS ACQUIRE ADD ADDRESS " +
       "ADVANCING AFTER ALIAS ALL ALPHABET " +
       "ALPHABETIC ALPHABETIC-LOWER ALPHABETIC-UPPER ALPHANUMERIC ALPHANUMERIC-EDITED " +
       "ALSO ALTER ALTERNATE AND ANY " +
       "ARE AREA AREAS ARITHMETIC ASCENDING " +
       "ASSIGN AT ATTRIBUTE AUTHOR AUTO " +
       "AUTO-SKIP AUTOMATIC B-AND B-EXOR B-LESS " +
       "B-NOT B-OR BACKGROUND-COLOR BACKGROUND-COLOUR BEEP " +
       "BEFORE BELL BINARY BIT BITS " +
       "BLANK BLINK BLOCK BOOLEAN BOTTOM " +
       "BY CALL CANCEL CD CF " +
       "CH CHARACTER CHARACTERS CLASS CLOCK-UNITS " +
       "CLOSE COBOL CODE CODE-SET COL " +
       "COLLATING COLUMN COMMA COMMIT COMMITMENT " +
       "COMMON COMMUNICATION COMP COMP-0 COMP-1 " +
       "COMP-2 COMP-3 COMP-4 COMP-5 COMP-6 " +
       "COMP-7 COMP-8 COMP-9 COMPUTATIONAL COMPUTATIONAL-0 " +
       "COMPUTATIONAL-1 COMPUTATIONAL-2 COMPUTATIONAL-3 COMPUTATIONAL-4 COMPUTATIONAL-5 " +
       "COMPUTATIONAL-6 COMPUTATIONAL-7 COMPUTATIONAL-8 COMPUTATIONAL-9 COMPUTE " +
       "CONFIGURATION CONNECT CONSOLE CONTAINED CONTAINS " +
       "CONTENT CONTINUE CONTROL CONTROL-AREA CONTROLS " +
       "CONVERTING COPY CORR CORRESPONDING COUNT " +
       "CRT CRT-UNDER CURRENCY CURRENT CURSOR " +
       "DATA DATE DATE-COMPILED DATE-WRITTEN DAY " +
       "DAY-OF-WEEK DB DB-ACCESS-CONTROL-KEY DB-DATA-NAME DB-EXCEPTION " +
       "DB-FORMAT-NAME DB-RECORD-NAME DB-SET-NAME DB-STATUS DBCS " +
       "DBCS-EDITED DE DEBUG-CONTENTS DEBUG-ITEM DEBUG-LINE " +
       "DEBUG-NAME DEBUG-SUB-1 DEBUG-SUB-2 DEBUG-SUB-3 DEBUGGING " +
       "DECIMAL-POINT DECLARATIVES DEFAULT DELETE DELIMITED " +
       "DELIMITER DEPENDING DESCENDING DESCRIBED DESTINATION " +
       "DETAIL DISABLE DISCONNECT DISPLAY DISPLAY-1 " +
       "DISPLAY-2 DISPLAY-3 DISPLAY-4 DISPLAY-5 DISPLAY-6 " +
       "DISPLAY-7 DISPLAY-8 DISPLAY-9 DIVIDE DIVISION " +
       "DOWN DROP DUPLICATE DUPLICATES DYNAMIC " +
       "EBCDIC EGI EJECT ELSE EMI " +
       "EMPTY EMPTY-CHECK ENABLE END END. END-ACCEPT END-ACCEPT. " +
       "END-ADD END-CALL END-COMPUTE END-DELETE END-DISPLAY " +
       "END-DIVIDE END-EVALUATE END-IF END-INVOKE END-MULTIPLY " +
       "END-OF-PAGE END-PERFORM END-READ END-RECEIVE END-RETURN " +
       "END-REWRITE END-SEARCH END-START END-STRING END-SUBTRACT " +
       "END-UNSTRING END-WRITE END-XML ENTER ENTRY " +
       "ENVIRONMENT EOP EQUAL EQUALS ERASE " +
       "ERROR ESI EVALUATE EVERY EXCEEDS " +
       "EXCEPTION EXCLUSIVE EXIT EXTEND EXTERNAL " +
       "EXTERNALLY-DESCRIBED-KEY FD FETCH FILE FILE-CONTROL " +
       "FILE-STREAM FILES FILLER FINAL FIND " +
       "FINISH FIRST FOOTING FOR FOREGROUND-COLOR " +
       "FOREGROUND-COLOUR FORMAT FREE FROM FULL " +
       "FUNCTION GENERATE GET GIVING GLOBAL " +
       "GO GOBACK GREATER GROUP HEADING " +
       "HIGH-VALUE HIGH-VALUES HIGHLIGHT I-O I-O-CONTROL " +
       "ID IDENTIFICATION IF IN INDEX " +
       "INDEX-1 INDEX-2 INDEX-3 INDEX-4 INDEX-5 " +
       "INDEX-6 INDEX-7 INDEX-8 INDEX-9 INDEXED " +
       "INDIC INDICATE INDICATOR INDICATORS INITIAL " +
       "INITIALIZE INITIATE INPUT INPUT-OUTPUT INSPECT " +
       "INSTALLATION INTO INVALID INVOKE IS " +
       "JUST JUSTIFIED KANJI KEEP KEY " +
       "LABEL LAST LD LEADING LEFT " +
       "LEFT-JUSTIFY LENGTH LENGTH-CHECK LESS LIBRARY " +
       "LIKE LIMIT LIMITS LINAGE LINAGE-COUNTER " +
       "LINE LINE-COUNTER LINES LINKAGE LOCAL-STORAGE " +
       "LOCALE LOCALLY LOCK " +
       "MEMBER MEMORY MERGE MESSAGE METACLASS " +
       "MODE MODIFIED MODIFY MODULES MOVE " +
       "MULTIPLE MULTIPLY NATIONAL NATIVE NEGATIVE " +
       "NEXT NO NO-ECHO NONE NOT " +
       "NULL NULL-KEY-MAP NULL-MAP NULLS NUMBER " +
       "NUMERIC NUMERIC-EDITED OBJECT OBJECT-COMPUTER OCCURS " +
       "OF OFF OMITTED ON ONLY " +
       "OPEN OPTIONAL OR ORDER ORGANIZATION " +
       "OTHER OUTPUT OVERFLOW OWNER PACKED-DECIMAL " +
       "PADDING PAGE PAGE-COUNTER PARSE PERFORM " +
       "PF PH PIC PICTURE PLUS " +
       "POINTER POSITION POSITIVE PREFIX PRESENT " +
       "PRINTING PRIOR PROCEDURE PROCEDURE-POINTER PROCEDURES " +
       "PROCEED PROCESS PROCESSING PROGRAM PROGRAM-ID " +
       "PROMPT PROTECTED PURGE QUEUE QUOTE " +
       "QUOTES RANDOM RD READ READY " +
       "REALM RECEIVE RECONNECT RECORD RECORD-NAME " +
       "RECORDS RECURSIVE REDEFINES REEL REFERENCE " +
       "REFERENCE-MONITOR REFERENCES RELATION RELATIVE RELEASE " +
       "REMAINDER REMOVAL RENAMES REPEATED REPLACE " +
       "REPLACING REPORT REPORTING REPORTS REPOSITORY " +
       "REQUIRED RERUN RESERVE RESET RETAINING " +
       "RETRIEVAL RETURN RETURN-CODE RETURNING REVERSE-VIDEO " +
       "REVERSED REWIND REWRITE RF RH " +
       "RIGHT RIGHT-JUSTIFY ROLLBACK ROLLING ROUNDED " +
       "RUN SAME SCREEN SD SEARCH " +
       "SECTION SECURE SECURITY SEGMENT SEGMENT-LIMIT " +
       "SELECT SEND SENTENCE SEPARATE SEQUENCE " +
       "SEQUENTIAL SET SHARED SIGN SIZE " +
       "SKIP1 SKIP2 SKIP3 SORT SORT-MERGE " +
       "SORT-RETURN SOURCE SOURCE-COMPUTER SPACE-FILL " +
       "SPECIAL-NAMES STANDARD STANDARD-1 STANDARD-2 " +
       "START STARTING STATUS STOP STORE " +
       "STRING SUB-QUEUE-1 SUB-QUEUE-2 SUB-QUEUE-3 SUB-SCHEMA " +
       "SUBFILE SUBSTITUTE SUBTRACT SUM SUPPRESS " +
       "SYMBOLIC SYNC SYNCHRONIZED SYSIN SYSOUT " +
       "TABLE TALLYING TAPE TENANT TERMINAL " +
       "TERMINATE TEST TEXT THAN THEN " +
       "THROUGH THRU TIME TIMES TITLE " +
       "TO TOP TRAILING TRAILING-SIGN TRANSACTION " +
       "TYPE TYPEDEF UNDERLINE UNEQUAL UNIT " +
       "UNSTRING UNTIL UP UPDATE UPON " +
       "USAGE USAGE-MODE USE USING VALID " +
       "VALIDATE VALUE VALUES VARYING VLR " +
       "WAIT WHEN WHEN-COMPILED WITH WITHIN " +
       "WORDS WORKING-STORAGE WRITE XML XML-CODE " +
       "XML-EVENT XML-NTEXT XML-TEXT ZERO ZERO-FILL " );
 
   var builtins = makeKeywords("- * ** / + < <= = > >= ");
   var tests = {
     digit: /\d/,
     digit_or_colon: /[\d:]/,
     hex: /[0-9a-f]/i,
     sign: /[+-]/,
     exponent: /e/i,
     keyword_char: /[^\s\(\[\;\)\]]/,
     symbol: /[\w*+\-]/
   };
   function isNumber(ch, stream){
     // hex
     if ( ch === '0' && stream.eat(/x/i) ) {
       stream.eatWhile(tests.hex);
       return true;
     }
     // leading sign
     if ( ( ch == '+' || ch == '-' ) && ( tests.digit.test(stream.peek()) ) ) {
       stream.eat(tests.sign);
       ch = stream.next();
     }
     if ( tests.digit.test(ch) ) {
       stream.eat(ch);
       stream.eatWhile(tests.digit);
       if ( '.' == stream.peek()) {
         stream.eat('.');
         stream.eatWhile(tests.digit);
       }
       if ( stream.eat(tests.exponent) ) {
         stream.eat(tests.sign);
         stream.eatWhile(tests.digit);
       }
       return true;
     }
     return false;
   }
   return {
     startState: function () {
       return {
         indentStack: null,
         indentation: 0,
         mode: false
       };
     },
     token: function (stream, state) {
       if (state.indentStack == null && stream.sol()) {
         // update indentation, but only if indentStack is empty
         state.indentation = 6 ; //stream.indentation();
       }
       // skip spaces
       if (stream.eatSpace()) {
         return null;
       }
       var returnType = null;
       switch(state.mode){
       case "string": // multi-line string parsing mode
         var next = false;
         while ((next = stream.next()) != null) {
           if (next == "\"" || next == "\'") {
             state.mode = false;
             break;
           }
         }
         returnType = STRING; // continue on in string mode
         break;
       default: // default parsing mode
         var ch = stream.next();
         var col = stream.column();
         if (col >= 0 && col <= 5) {
           returnType = COBOLLINENUM;
         } else if (col >= 72 && col <= 79) {
           stream.skipToEnd();
           returnType = MODTAG;
         } else if (ch == "*" && col == 6) { // comment
           stream.skipToEnd(); // rest of the line is a comment
           returnType = COMMENT;
         } else if (ch == "\"" || ch == "\'") {
           state.mode = "string";
           returnType = STRING;
         } else if (ch == "'" && !( tests.digit_or_colon.test(stream.peek()) )) {
           returnType = ATOM;
         } else if (ch == ".") {
           returnType = PERIOD;
         } else if (isNumber(ch,stream)){
           returnType = NUMBER;
         } else {
           if (stream.current().match(tests.symbol)) {
             while (col < 71) {
               if (stream.eat(tests.symbol) === undefined) {
                 break;
               } else {
                 col++;
               }
             }
           }
           if (keywords && keywords.propertyIsEnumerable(stream.current().toUpperCase())) {
             returnType = KEYWORD;
           } else if (builtins && builtins.propertyIsEnumerable(stream.current().toUpperCase())) {
             returnType = BUILTIN;
           } else if (atoms && atoms.propertyIsEnumerable(stream.current().toUpperCase())) {
             returnType = ATOM;
           } else returnType = null;
         }
       }
       return returnType;
     },
     indent: function (state) {
       if (state.indentStack == null) return state.indentation;
       return state.indentStack.indent;
     }
   };
 });
 
 CodeMirror.defineMIME("text/x-cobol", "cobol");
 
 });

rhodecode/public/js/mode/coffeescript/coffeescript.js

@@ -1,355 +1,359 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 /**
  * Link to the project's GitHub page:
  * https://github.com/pickhardt/coffeescript-codemirror-mode
  */
 (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("coffeescript", function(conf, parserConf) {
   var ERRORCLASS = "error";
 
   function wordRegexp(words) {
     return new RegExp("^((" + words.join(")|(") + "))\\b");
   }
 
   var operators = /^(?:->|=>|\+[+=]?|-[\-=]?|\*[\*=]?|\/[\/=]?|[=!]=|<[><]?=?|>>?=?|%=?|&=?|\|=?|\^=?|\~|!|\?|(or|and|\|\||&&|\?)=)/;
   var delimiters = /^(?:[()\[\]{},:`=;]|\.\.?\.?)/;
   var identifiers = /^[_A-Za-z$][_A-Za-z$0-9]*/;
   var atProp = /^@[_A-Za-z$][_A-Za-z$0-9]*/;
 
   var wordOperators = wordRegexp(["and", "or", "not",
                                   "is", "isnt", "in",
                                   "instanceof", "typeof"]);
   var indentKeywords = ["for", "while", "loop", "if", "unless", "else",
                         "switch", "try", "catch", "finally", "class"];
   var commonKeywords = ["break", "by", "continue", "debugger", "delete",
                         "do", "in", "of", "new", "return", "then",
                         "this", "@", "throw", "when", "until", "extends"];
 
   var keywords = wordRegexp(indentKeywords.concat(commonKeywords));
 
   indentKeywords = wordRegexp(indentKeywords);
 
 
   var stringPrefixes = /^('{3}|\"{3}|['\"])/;
   var regexPrefixes = /^(\/{3}|\/)/;
   var commonConstants = ["Infinity", "NaN", "undefined", "null", "true", "false", "on", "off", "yes", "no"];
   var constants = wordRegexp(commonConstants);
 
   // Tokenizers
   function tokenBase(stream, state) {
     // Handle scope changes
     if (stream.sol()) {
       if (state.scope.align === null) state.scope.align = false;
       var scopeOffset = state.scope.offset;
       if (stream.eatSpace()) {
         var lineOffset = stream.indentation();
         if (lineOffset > scopeOffset && state.scope.type == "coffee") {
           return "indent";
         } else if (lineOffset < scopeOffset) {
           return "dedent";
         }
         return null;
       } else {
         if (scopeOffset > 0) {
           dedent(stream, state);
         }
       }
     }
     if (stream.eatSpace()) {
       return null;
     }
 
     var ch = stream.peek();
 
     // Handle docco title comment (single line)
     if (stream.match("####")) {
       stream.skipToEnd();
       return "comment";
     }
 
     // Handle multi line comments
     if (stream.match("###")) {
       state.tokenize = longComment;
       return state.tokenize(stream, state);
     }
 
     // Single line comment
     if (ch === "#") {
       stream.skipToEnd();
       return "comment";
     }
 
     // Handle number literals
     if (stream.match(/^-?[0-9\.]/, false)) {
       var floatLiteral = false;
       // Floats
       if (stream.match(/^-?\d*\.\d+(e[\+\-]?\d+)?/i)) {
         floatLiteral = true;
       }
       if (stream.match(/^-?\d+\.\d*/)) {
         floatLiteral = true;
       }
       if (stream.match(/^-?\.\d+/)) {
         floatLiteral = true;
       }
 
       if (floatLiteral) {
         // prevent from getting extra . on 1..
         if (stream.peek() == "."){
           stream.backUp(1);
         }
         return "number";
       }
       // Integers
       var intLiteral = false;
       // Hex
       if (stream.match(/^-?0x[0-9a-f]+/i)) {
         intLiteral = true;
       }
       // Decimal
       if (stream.match(/^-?[1-9]\d*(e[\+\-]?\d+)?/)) {
         intLiteral = true;
       }
       // Zero by itself with no other piece of number.
       if (stream.match(/^-?0(?![\dx])/i)) {
         intLiteral = true;
       }
       if (intLiteral) {
         return "number";
       }
     }
 
     // Handle strings
     if (stream.match(stringPrefixes)) {
       state.tokenize = tokenFactory(stream.current(), false, "string");
       return state.tokenize(stream, state);
     }
     // Handle regex literals
     if (stream.match(regexPrefixes)) {
       if (stream.current() != "/" || stream.match(/^.*\//, false)) { // prevent highlight of division
         state.tokenize = tokenFactory(stream.current(), true, "string-2");
         return state.tokenize(stream, state);
       } else {
         stream.backUp(1);
       }
     }
 
 
 
     // Handle operators and delimiters
     if (stream.match(operators) || stream.match(wordOperators)) {
       return "operator";
     }
     if (stream.match(delimiters)) {
       return "punctuation";
     }
 
     if (stream.match(constants)) {
       return "atom";
     }
 
     if (stream.match(atProp) || state.prop && stream.match(identifiers)) {
       return "property";
     }
 
     if (stream.match(keywords)) {
       return "keyword";
     }
 
     if (stream.match(identifiers)) {
       return "variable";
     }
 
     // Handle non-detected items
     stream.next();
     return ERRORCLASS;
   }
 
   function tokenFactory(delimiter, singleline, outclass) {
     return function(stream, state) {
       while (!stream.eol()) {
         stream.eatWhile(/[^'"\/\\]/);
         if (stream.eat("\\")) {
           stream.next();
           if (singleline && stream.eol()) {
             return outclass;
           }
         } else if (stream.match(delimiter)) {
           state.tokenize = tokenBase;
           return outclass;
         } else {
           stream.eat(/['"\/]/);
         }
       }
       if (singleline) {
         if (parserConf.singleLineStringErrors) {
           outclass = ERRORCLASS;
         } else {
           state.tokenize = tokenBase;
         }
       }
       return outclass;
     };
   }
 
   function longComment(stream, state) {
     while (!stream.eol()) {
       stream.eatWhile(/[^#]/);
       if (stream.match("###")) {
         state.tokenize = tokenBase;
         break;
       }
       stream.eatWhile("#");
     }
     return "comment";
   }
 
   function indent(stream, state, type) {
     type = type || "coffee";
     var offset = 0, align = false, alignOffset = null;
     for (var scope = state.scope; scope; scope = scope.prev) {
       if (scope.type === "coffee" || scope.type == "}") {
         offset = scope.offset + conf.indentUnit;
         break;
       }
     }
     if (type !== "coffee") {
       align = null;
       alignOffset = stream.column() + stream.current().length;
     } else if (state.scope.align) {
       state.scope.align = false;
     }
     state.scope = {
       offset: offset,
       type: type,
       prev: state.scope,
       align: align,
       alignOffset: alignOffset
     };
   }
 
   function dedent(stream, state) {
     if (!state.scope.prev) return;
     if (state.scope.type === "coffee") {
       var _indent = stream.indentation();
       var matched = false;
       for (var scope = state.scope; scope; scope = scope.prev) {
         if (_indent === scope.offset) {
           matched = true;
           break;
         }
       }
       if (!matched) {
         return true;
       }
       while (state.scope.prev && state.scope.offset !== _indent) {
         state.scope = state.scope.prev;
       }
       return false;
     } else {
       state.scope = state.scope.prev;
       return false;
     }
   }
 
   function tokenLexer(stream, state) {
     var style = state.tokenize(stream, state);
     var current = stream.current();
 
     // Handle scope changes.
     if (current === "return") {
       state.dedent = true;
     }
     if (((current === "->" || current === "=>") && stream.eol())
         || style === "indent") {
       indent(stream, state);
     }
     var delimiter_index = "[({".indexOf(current);
     if (delimiter_index !== -1) {
       indent(stream, state, "])}".slice(delimiter_index, delimiter_index+1));
     }
     if (indentKeywords.exec(current)){
       indent(stream, state);
     }
     if (current == "then"){
       dedent(stream, state);
     }
 
 
     if (style === "dedent") {
       if (dedent(stream, state)) {
         return ERRORCLASS;
       }
     }
     delimiter_index = "])}".indexOf(current);
     if (delimiter_index !== -1) {
       while (state.scope.type == "coffee" && state.scope.prev)
         state.scope = state.scope.prev;
       if (state.scope.type == current)
         state.scope = state.scope.prev;
     }
     if (state.dedent && stream.eol()) {
       if (state.scope.type == "coffee" && state.scope.prev)
         state.scope = state.scope.prev;
       state.dedent = false;
     }
 
     return style;
   }
 
   var external = {
     startState: function(basecolumn) {
       return {
         tokenize: tokenBase,
         scope: {offset:basecolumn || 0, type:"coffee", prev: null, align: false},
         prop: false,
         dedent: 0
       };
     },
 
     token: function(stream, state) {
       var fillAlign = state.scope.align === null && state.scope;
       if (fillAlign && stream.sol()) fillAlign.align = false;
 
       var style = tokenLexer(stream, state);
       if (style && style != "comment") {
         if (fillAlign) fillAlign.align = true;
         state.prop = style == "punctuation" && stream.current() == "."
       }
 
       return style;
     },
 
     indent: function(state, text) {
       if (state.tokenize != tokenBase) return 0;
       var scope = state.scope;
       var closer = text && "])}".indexOf(text.charAt(0)) > -1;
       if (closer) while (scope.type == "coffee" && scope.prev) scope = scope.prev;
       var closes = closer && scope.type === text.charAt(0);
       if (scope.align)
         return scope.alignOffset - (closes ? 1 : 0);
       else
         return (closes ? scope.prev : scope).offset;
     },
 
     lineComment: "#",
     fold: "indent"
   };
   return external;
 });
 
+// IANA registered media type
+// https://www.iana.org/assignments/media-types/
+CodeMirror.defineMIME("application/vnd.coffeescript", "coffeescript");
+
 CodeMirror.defineMIME("text/x-coffeescript", "coffeescript");
 CodeMirror.defineMIME("text/coffeescript", "coffeescript");
 
 });

rhodecode/public/js/mode/commonlisp/commonlisp.js

@@ -1,123 +1,124 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("commonlisp", function (config) {
   var specialForm = /^(block|let*|return-from|catch|load-time-value|setq|eval-when|locally|symbol-macrolet|flet|macrolet|tagbody|function|multiple-value-call|the|go|multiple-value-prog1|throw|if|progn|unwind-protect|labels|progv|let|quote)$/;
   var assumeBody = /^with|^def|^do|^prog|case$|^cond$|bind$|when$|unless$/;
   var numLiteral = /^(?:[+\-]?(?:\d+|\d*\.\d+)(?:[efd][+\-]?\d+)?|[+\-]?\d+(?:\/[+\-]?\d+)?|#b[+\-]?[01]+|#o[+\-]?[0-7]+|#x[+\-]?[\da-f]+)/;
   var symbol = /[^\s'`,@()\[\]";]/;
   var type;
 
   function readSym(stream) {
     var ch;
     while (ch = stream.next()) {
       if (ch == "\\") stream.next();
       else if (!symbol.test(ch)) { stream.backUp(1); break; }
     }
     return stream.current();
   }
 
   function base(stream, state) {
     if (stream.eatSpace()) {type = "ws"; return null;}
     if (stream.match(numLiteral)) return "number";
     var ch = stream.next();
     if (ch == "\\") ch = stream.next();
 
     if (ch == '"') return (state.tokenize = inString)(stream, state);
     else if (ch == "(") { type = "open"; return "bracket"; }
     else if (ch == ")" || ch == "]") { type = "close"; return "bracket"; }
     else if (ch == ";") { stream.skipToEnd(); type = "ws"; return "comment"; }
     else if (/['`,@]/.test(ch)) return null;
     else if (ch == "|") {
       if (stream.skipTo("|")) { stream.next(); return "symbol"; }
       else { stream.skipToEnd(); return "error"; }
     } else if (ch == "#") {
       var ch = stream.next();
-      if (ch == "[") { type = "open"; return "bracket"; }
+      if (ch == "(") { type = "open"; return "bracket"; }
       else if (/[+\-=\.']/.test(ch)) return null;
       else if (/\d/.test(ch) && stream.match(/^\d*#/)) return null;
       else if (ch == "|") return (state.tokenize = inComment)(stream, state);
       else if (ch == ":") { readSym(stream); return "meta"; }
+      else if (ch == "\\") { stream.next(); readSym(stream); return "string-2" }
       else return "error";
     } else {
       var name = readSym(stream);
       if (name == ".") return null;
       type = "symbol";
       if (name == "nil" || name == "t" || name.charAt(0) == ":") return "atom";
       if (state.lastType == "open" && (specialForm.test(name) || assumeBody.test(name))) return "keyword";
       if (name.charAt(0) == "&") return "variable-2";
       return "variable";
     }
   }
 
   function inString(stream, state) {
     var escaped = false, next;
     while (next = stream.next()) {
       if (next == '"' && !escaped) { state.tokenize = base; break; }
       escaped = !escaped && next == "\\";
     }
     return "string";
   }
 
   function inComment(stream, state) {
     var next, last;
     while (next = stream.next()) {
       if (next == "#" && last == "|") { state.tokenize = base; break; }
       last = next;
     }
     type = "ws";
     return "comment";
   }
 
   return {
     startState: function () {
       return {ctx: {prev: null, start: 0, indentTo: 0}, lastType: null, tokenize: base};
     },
 
     token: function (stream, state) {
       if (stream.sol() && typeof state.ctx.indentTo != "number")
         state.ctx.indentTo = state.ctx.start + 1;
 
       type = null;
       var style = state.tokenize(stream, state);
       if (type != "ws") {
         if (state.ctx.indentTo == null) {
           if (type == "symbol" && assumeBody.test(stream.current()))
             state.ctx.indentTo = state.ctx.start + config.indentUnit;
           else
             state.ctx.indentTo = "next";
         } else if (state.ctx.indentTo == "next") {
           state.ctx.indentTo = stream.column();
         }
         state.lastType = type;
       }
       if (type == "open") state.ctx = {prev: state.ctx, start: stream.column(), indentTo: null};
       else if (type == "close") state.ctx = state.ctx.prev || state.ctx;
       return style;
     },
 
     indent: function (state, _textAfter) {
       var i = state.ctx.indentTo;
       return typeof i == "number" ? i : state.ctx.start + 1;
     },
 
     closeBrackets: {pairs: "()[]{}\"\""},
     lineComment: ";;",
     blockCommentStart: "#|",
     blockCommentEnd: "|#"
   };
 });
 
 CodeMirror.defineMIME("text/x-common-lisp", "commonlisp");
 
 });

rhodecode/public/js/mode/crystal/crystal.js

@@ -1,391 +1,433 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("crystal", function(config) {
     function wordRegExp(words, end) {
       return new RegExp((end ? "" : "^") + "(?:" + words.join("|") + ")" + (end ? "$" : "\\b"));
     }
 
     function chain(tokenize, stream, state) {
       state.tokenize.push(tokenize);
       return tokenize(stream, state);
     }
 
     var operators = /^(?:[-+/%|&^]|\*\*?|[<>]{2})/;
     var conditionalOperators = /^(?:[=!]~|===|<=>|[<>=!]=?|[|&]{2}|~)/;
     var indexingOperators = /^(?:\[\][?=]?)/;
     var anotherOperators = /^(?:\.(?:\.{2})?|->|[?:])/;
     var idents = /^[a-z_\u009F-\uFFFF][a-zA-Z0-9_\u009F-\uFFFF]*/;
     var types = /^[A-Z_\u009F-\uFFFF][a-zA-Z0-9_\u009F-\uFFFF]*/;
     var keywords = wordRegExp([
       "abstract", "alias", "as", "asm", "begin", "break", "case", "class", "def", "do",
-      "else", "elsif", "end", "ensure", "enum", "extend", "for", "fun", "if", "ifdef",
+      "else", "elsif", "end", "ensure", "enum", "extend", "for", "fun", "if",
       "include", "instance_sizeof", "lib", "macro", "module", "next", "of", "out", "pointerof",
-      "private", "protected", "rescue", "return", "require", "sizeof", "struct",
-      "super", "then", "type", "typeof", "union", "unless", "until", "when", "while", "with",
-      "yield", "__DIR__", "__FILE__", "__LINE__"
+      "private", "protected", "rescue", "return", "require", "select", "sizeof", "struct",
+      "super", "then", "type", "typeof", "uninitialized", "union", "unless", "until", "when", "while", "with",
+      "yield", "__DIR__", "__END_LINE__", "__FILE__", "__LINE__"
     ]);
     var atomWords = wordRegExp(["true", "false", "nil", "self"]);
     var indentKeywordsArray = [
       "def", "fun", "macro",
       "class", "module", "struct", "lib", "enum", "union",
-      "if", "unless", "case", "while", "until", "begin", "then",
-      "do",
-      "for", "ifdef"
+      "do", "for"
     ];
     var indentKeywords = wordRegExp(indentKeywordsArray);
-    var dedentKeywordsArray = [
-      "end",
-      "else", "elsif",
-      "rescue", "ensure"
-    ];
+    var indentExpressionKeywordsArray = ["if", "unless", "case", "while", "until", "begin", "then"];
+    var indentExpressionKeywords = wordRegExp(indentExpressionKeywordsArray);
+    var dedentKeywordsArray = ["end", "else", "elsif", "rescue", "ensure"];
     var dedentKeywords = wordRegExp(dedentKeywordsArray);
     var dedentPunctualsArray = ["\\)", "\\}", "\\]"];
     var dedentPunctuals = new RegExp("^(?:" + dedentPunctualsArray.join("|") + ")$");
     var nextTokenizer = {
       "def": tokenFollowIdent, "fun": tokenFollowIdent, "macro": tokenMacroDef,
       "class": tokenFollowType, "module": tokenFollowType, "struct": tokenFollowType,
       "lib": tokenFollowType, "enum": tokenFollowType, "union": tokenFollowType
     };
     var matching = {"[": "]", "{": "}", "(": ")", "<": ">"};
 
     function tokenBase(stream, state) {
       if (stream.eatSpace()) {
         return null;
       }
 
       // Macros
       if (state.lastToken != "\\" && stream.match("{%", false)) {
         return chain(tokenMacro("%", "%"), stream, state);
       }
 
       if (state.lastToken != "\\" && stream.match("{{", false)) {
         return chain(tokenMacro("{", "}"), stream, state);
       }
 
       // Comments
       if (stream.peek() == "#") {
         stream.skipToEnd();
         return "comment";
       }
 
       // Variables and keywords
       var matched;
       if (stream.match(idents)) {
         stream.eat(/[?!]/);
 
         matched = stream.current();
         if (stream.eat(":")) {
           return "atom";
         } else if (state.lastToken == ".") {
           return "property";
         } else if (keywords.test(matched)) {
-          if (state.lastToken != "abstract" && indentKeywords.test(matched)) {
-            if (!(matched == "fun" && state.blocks.indexOf("lib") >= 0)) {
+          if (indentKeywords.test(matched)) {
+            if (!(matched == "fun" && state.blocks.indexOf("lib") >= 0) && !(matched == "def" && state.lastToken == "abstract")) {
               state.blocks.push(matched);
               state.currentIndent += 1;
             }
-          } else if (dedentKeywords.test(matched)) {
+          } else if ((state.lastStyle == "operator" || !state.lastStyle) && indentExpressionKeywords.test(matched)) {
+            state.blocks.push(matched);
+            state.currentIndent += 1;
+          } else if (matched == "end") {
             state.blocks.pop();
             state.currentIndent -= 1;
           }
 
           if (nextTokenizer.hasOwnProperty(matched)) {
             state.tokenize.push(nextTokenizer[matched]);
           }
 
           return "keyword";
         } else if (atomWords.test(matched)) {
           return "atom";
         }
 
         return "variable";
       }
 
       // Class variables and instance variables
       // or attributes
       if (stream.eat("@")) {
         if (stream.peek() == "[") {
           return chain(tokenNest("[", "]", "meta"), stream, state);
         }
 
         stream.eat("@");
         stream.match(idents) || stream.match(types);
         return "variable-2";
       }
 
-      // Global variables
-      if (stream.eat("$")) {
-        stream.eat(/[0-9]+|\?/) || stream.match(idents) || stream.match(types);
-        return "variable-3";
-      }
-
       // Constants and types
       if (stream.match(types)) {
         return "tag";
       }
 
       // Symbols or ':' operator
       if (stream.eat(":")) {
         if (stream.eat("\"")) {
           return chain(tokenQuote("\"", "atom", false), stream, state);
         } else if (stream.match(idents) || stream.match(types) ||
                    stream.match(operators) || stream.match(conditionalOperators) || stream.match(indexingOperators)) {
           return "atom";
         }
         stream.eat(":");
         return "operator";
       }
 
       // Strings
       if (stream.eat("\"")) {
         return chain(tokenQuote("\"", "string", true), stream, state);
       }
 
       // Strings or regexps or macro variables or '%' operator
       if (stream.peek() == "%") {
         var style = "string";
         var embed = true;
         var delim;
 
         if (stream.match("%r")) {
           // Regexps
           style = "string-2";
           delim = stream.next();
         } else if (stream.match("%w")) {
           embed = false;
           delim = stream.next();
+        } else if (stream.match("%q")) {
+          embed = false;
+          delim = stream.next();
         } else {
           if(delim = stream.match(/^%([^\w\s=])/)) {
             delim = delim[1];
           } else if (stream.match(/^%[a-zA-Z0-9_\u009F-\uFFFF]*/)) {
             // Macro variables
             return "meta";
           } else {
             // '%' operator
             return "operator";
           }
         }
 
         if (matching.hasOwnProperty(delim)) {
           delim = matching[delim];
         }
         return chain(tokenQuote(delim, style, embed), stream, state);
       }
 
+      // Here Docs
+      if (matched = stream.match(/^<<-('?)([A-Z]\w*)\1/)) {
+        return chain(tokenHereDoc(matched[2], !matched[1]), stream, state)
+      }
+
       // Characters
       if (stream.eat("'")) {
         stream.match(/^(?:[^']|\\(?:[befnrtv0'"]|[0-7]{3}|u(?:[0-9a-fA-F]{4}|\{[0-9a-fA-F]{1,6}\})))/);
         stream.eat("'");
         return "atom";
       }
 
       // Numbers
       if (stream.eat("0")) {
         if (stream.eat("x")) {
           stream.match(/^[0-9a-fA-F]+/);
         } else if (stream.eat("o")) {
           stream.match(/^[0-7]+/);
         } else if (stream.eat("b")) {
           stream.match(/^[01]+/);
         }
         return "number";
       }
 
-      if (stream.eat(/\d/)) {
+      if (stream.eat(/^\d/)) {
         stream.match(/^\d*(?:\.\d+)?(?:[eE][+-]?\d+)?/);
         return "number";
       }
 
       // Operators
       if (stream.match(operators)) {
-        stream.eat("="); // Operators can follow assigin symbol.
+        stream.eat("="); // Operators can follow assign symbol.
         return "operator";
       }
 
       if (stream.match(conditionalOperators) || stream.match(anotherOperators)) {
         return "operator";
       }
 
       // Parens and braces
       if (matched = stream.match(/[({[]/, false)) {
         matched = matched[0];
         return chain(tokenNest(matched, matching[matched], null), stream, state);
       }
 
       // Escapes
       if (stream.eat("\\")) {
         stream.next();
         return "meta";
       }
 
       stream.next();
       return null;
     }
 
     function tokenNest(begin, end, style, started) {
       return function (stream, state) {
         if (!started && stream.match(begin)) {
           state.tokenize[state.tokenize.length - 1] = tokenNest(begin, end, style, true);
           state.currentIndent += 1;
           return style;
         }
 
         var nextStyle = tokenBase(stream, state);
         if (stream.current() === end) {
           state.tokenize.pop();
           state.currentIndent -= 1;
           nextStyle = style;
         }
 
         return nextStyle;
       };
     }
 
     function tokenMacro(begin, end, started) {
       return function (stream, state) {
         if (!started && stream.match("{" + begin)) {
           state.currentIndent += 1;
           state.tokenize[state.tokenize.length - 1] = tokenMacro(begin, end, true);
           return "meta";
         }
 
         if (stream.match(end + "}")) {
           state.currentIndent -= 1;
           state.tokenize.pop();
           return "meta";
         }
 
         return tokenBase(stream, state);
       };
     }
 
     function tokenMacroDef(stream, state) {
       if (stream.eatSpace()) {
         return null;
       }
 
       var matched;
       if (matched = stream.match(idents)) {
         if (matched == "def") {
           return "keyword";
         }
         stream.eat(/[?!]/);
       }
 
       state.tokenize.pop();
       return "def";
     }
 
     function tokenFollowIdent(stream, state) {
       if (stream.eatSpace()) {
         return null;
       }
 
       if (stream.match(idents)) {
         stream.eat(/[!?]/);
       } else {
         stream.match(operators) || stream.match(conditionalOperators) || stream.match(indexingOperators);
       }
       state.tokenize.pop();
       return "def";
     }
 
     function tokenFollowType(stream, state) {
       if (stream.eatSpace()) {
         return null;
       }
 
       stream.match(types);
       state.tokenize.pop();
       return "def";
     }
 
     function tokenQuote(end, style, embed) {
       return function (stream, state) {
         var escaped = false;
 
         while (stream.peek()) {
           if (!escaped) {
             if (stream.match("{%", false)) {
               state.tokenize.push(tokenMacro("%", "%"));
               return style;
             }
 
             if (stream.match("{{", false)) {
               state.tokenize.push(tokenMacro("{", "}"));
               return style;
             }
 
             if (embed && stream.match("#{", false)) {
               state.tokenize.push(tokenNest("#{", "}", "meta"));
               return style;
             }
 
             var ch = stream.next();
 
             if (ch == end) {
               state.tokenize.pop();
               return style;
             }
 
-            escaped = ch == "\\";
+            escaped = embed && ch == "\\";
           } else {
             stream.next();
             escaped = false;
           }
         }
 
         return style;
       };
     }
 
+    function tokenHereDoc(phrase, embed) {
+      return function (stream, state) {
+        if (stream.sol()) {
+          stream.eatSpace()
+          if (stream.match(phrase)) {
+            state.tokenize.pop();
+            return "string";
+          }
+        }
+
+        var escaped = false;
+        while (stream.peek()) {
+          if (!escaped) {
+            if (stream.match("{%", false)) {
+              state.tokenize.push(tokenMacro("%", "%"));
+              return "string";
+            }
+
+            if (stream.match("{{", false)) {
+              state.tokenize.push(tokenMacro("{", "}"));
+              return "string";
+            }
+
+            if (embed && stream.match("#{", false)) {
+              state.tokenize.push(tokenNest("#{", "}", "meta"));
+              return "string";
+            }
+
+            escaped = embed && stream.next() == "\\";
+          } else {
+            stream.next();
+            escaped = false;
+          }
+        }
+
+        return "string";
+      }
+    }
+
     return {
       startState: function () {
         return {
           tokenize: [tokenBase],
           currentIndent: 0,
           lastToken: null,
+          lastStyle: null,
           blocks: []
         };
       },
 
       token: function (stream, state) {
         var style = state.tokenize[state.tokenize.length - 1](stream, state);
         var token = stream.current();
 
         if (style && style != "comment") {
           state.lastToken = token;
+          state.lastStyle = style;
         }
 
         return style;
       },
 
       indent: function (state, textAfter) {
         textAfter = textAfter.replace(/^\s*(?:\{%)?\s*|\s*(?:%\})?\s*$/g, "");
 
         if (dedentKeywords.test(textAfter) || dedentPunctuals.test(textAfter)) {
           return config.indentUnit * (state.currentIndent - 1);
         }
 
         return config.indentUnit * state.currentIndent;
       },
 
       fold: "indent",
       electricInput: wordRegExp(dedentPunctualsArray.concat(dedentKeywordsArray), true),
       lineComment: '#'
     };
   });
 
   CodeMirror.defineMIME("text/x-crystal", "crystal");
 });

rhodecode/public/js/mode/css/css.js

@@ -1,825 +1,831 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("css", function(config, parserConfig) {
   var inline = parserConfig.inline
   if (!parserConfig.propertyKeywords) parserConfig = CodeMirror.resolveMode("text/css");
 
   var indentUnit = config.indentUnit,
       tokenHooks = parserConfig.tokenHooks,
       documentTypes = parserConfig.documentTypes || {},
       mediaTypes = parserConfig.mediaTypes || {},
       mediaFeatures = parserConfig.mediaFeatures || {},
       mediaValueKeywords = parserConfig.mediaValueKeywords || {},
       propertyKeywords = parserConfig.propertyKeywords || {},
       nonStandardPropertyKeywords = parserConfig.nonStandardPropertyKeywords || {},
       fontProperties = parserConfig.fontProperties || {},
       counterDescriptors = parserConfig.counterDescriptors || {},
       colorKeywords = parserConfig.colorKeywords || {},
       valueKeywords = parserConfig.valueKeywords || {},
       allowNested = parserConfig.allowNested,
+      lineComment = parserConfig.lineComment,
       supportsAtComponent = parserConfig.supportsAtComponent === true;
 
   var type, override;
   function ret(style, tp) { type = tp; return style; }
 
   // Tokenizers
 
   function tokenBase(stream, state) {
     var ch = stream.next();
     if (tokenHooks[ch]) {
       var result = tokenHooks[ch](stream, state);
       if (result !== false) return result;
     }
     if (ch == "@") {
       stream.eatWhile(/[\w\\\-]/);
       return ret("def", stream.current());
     } else if (ch == "=" || (ch == "~" || ch == "|") && stream.eat("=")) {
       return ret(null, "compare");
     } else if (ch == "\"" || ch == "'") {
       state.tokenize = tokenString(ch);
       return state.tokenize(stream, state);
     } else if (ch == "#") {
       stream.eatWhile(/[\w\\\-]/);
       return ret("atom", "hash");
     } else if (ch == "!") {
       stream.match(/^\s*\w*/);
       return ret("keyword", "important");
     } else if (/\d/.test(ch) || ch == "." && stream.eat(/\d/)) {
       stream.eatWhile(/[\w.%]/);
       return ret("number", "unit");
     } else if (ch === "-") {
       if (/[\d.]/.test(stream.peek())) {
         stream.eatWhile(/[\w.%]/);
         return ret("number", "unit");
-      } else if (stream.match(/^-[\w\\\-]+/)) {
+      } else if (stream.match(/^-[\w\\\-]*/)) {
         stream.eatWhile(/[\w\\\-]/);
         if (stream.match(/^\s*:/, false))
           return ret("variable-2", "variable-definition");
         return ret("variable-2", "variable");
       } else if (stream.match(/^\w+-/)) {
         return ret("meta", "meta");
       }
     } else if (/[,+>*\/]/.test(ch)) {
       return ret(null, "select-op");
     } else if (ch == "." && stream.match(/^-?[_a-z][_a-z0-9-]*/i)) {
       return ret("qualifier", "qualifier");
     } else if (/[:;{}\[\]\(\)]/.test(ch)) {
       return ret(null, ch);
-    } else if ((ch == "u" && stream.match(/rl(-prefix)?\(/)) ||
-               (ch == "d" && stream.match("omain(")) ||
-               (ch == "r" && stream.match("egexp("))) {
-      stream.backUp(1);
-      state.tokenize = tokenParenthesized;
-      return ret("property", "word");
+    } else if (stream.match(/[\w-.]+(?=\()/)) {
+      if (/^(url(-prefix)?|domain|regexp)$/.test(stream.current().toLowerCase())) {
+        state.tokenize = tokenParenthesized;
+      }
+      return ret("variable callee", "variable");
     } else if (/[\w\\\-]/.test(ch)) {
       stream.eatWhile(/[\w\\\-]/);
       return ret("property", "word");
     } else {
       return ret(null, null);
     }
   }
 
   function tokenString(quote) {
     return function(stream, state) {
       var escaped = false, ch;
       while ((ch = stream.next()) != null) {
         if (ch == quote && !escaped) {
           if (quote == ")") stream.backUp(1);
           break;
         }
         escaped = !escaped && ch == "\\";
       }
       if (ch == quote || !escaped && quote != ")") state.tokenize = null;
       return ret("string", "string");
     };
   }
 
   function tokenParenthesized(stream, state) {
     stream.next(); // Must be '('
     if (!stream.match(/\s*[\"\')]/, false))
       state.tokenize = tokenString(")");
     else
       state.tokenize = null;
     return ret(null, "(");
   }
 
   // Context management
 
   function Context(type, indent, prev) {
     this.type = type;
     this.indent = indent;
     this.prev = prev;
   }
 
   function pushContext(state, stream, type, indent) {
     state.context = new Context(type, stream.indentation() + (indent === false ? 0 : indentUnit), state.context);
     return type;
   }
 
   function popContext(state) {
     if (state.context.prev)
       state.context = state.context.prev;
     return state.context.type;
   }
 
   function pass(type, stream, state) {
     return states[state.context.type](type, stream, state);
   }
   function popAndPass(type, stream, state, n) {
     for (var i = n || 1; i > 0; i--)
       state.context = state.context.prev;
     return pass(type, stream, state);
   }
 
   // Parser
 
   function wordAsValue(stream) {
     var word = stream.current().toLowerCase();
     if (valueKeywords.hasOwnProperty(word))
       override = "atom";
     else if (colorKeywords.hasOwnProperty(word))
       override = "keyword";
     else
       override = "variable";
   }
 
   var states = {};
 
   states.top = function(type, stream, state) {
     if (type == "{") {
       return pushContext(state, stream, "block");
     } else if (type == "}" && state.context.prev) {
       return popContext(state);
-    } else if (supportsAtComponent && /@component/.test(type)) {
+    } else if (supportsAtComponent && /@component/i.test(type)) {
       return pushContext(state, stream, "atComponentBlock");
-    } else if (/^@(-moz-)?document$/.test(type)) {
+    } else if (/^@(-moz-)?document$/i.test(type)) {
       return pushContext(state, stream, "documentTypes");
-    } else if (/^@(media|supports|(-moz-)?document|import)$/.test(type)) {
+    } else if (/^@(media|supports|(-moz-)?document|import)$/i.test(type)) {
       return pushContext(state, stream, "atBlock");
-    } else if (/^@(font-face|counter-style)/.test(type)) {
+    } else if (/^@(font-face|counter-style)/i.test(type)) {
       state.stateArg = type;
       return "restricted_atBlock_before";
-    } else if (/^@(-(moz|ms|o|webkit)-)?keyframes$/.test(type)) {
+    } else if (/^@(-(moz|ms|o|webkit)-)?keyframes$/i.test(type)) {
       return "keyframes";
     } else if (type && type.charAt(0) == "@") {
       return pushContext(state, stream, "at");
     } else if (type == "hash") {
       override = "builtin";
     } else if (type == "word") {
       override = "tag";
     } else if (type == "variable-definition") {
       return "maybeprop";
     } else if (type == "interpolation") {
       return pushContext(state, stream, "interpolation");
     } else if (type == ":") {
       return "pseudo";
     } else if (allowNested && type == "(") {
       return pushContext(state, stream, "parens");
     }
     return state.context.type;
   };
 
   states.block = function(type, stream, state) {
     if (type == "word") {
       var word = stream.current().toLowerCase();
       if (propertyKeywords.hasOwnProperty(word)) {
         override = "property";
         return "maybeprop";
       } else if (nonStandardPropertyKeywords.hasOwnProperty(word)) {
         override = "string-2";
         return "maybeprop";
       } else if (allowNested) {
         override = stream.match(/^\s*:(?:\s|$)/, false) ? "property" : "tag";
         return "block";
       } else {
         override += " error";
         return "maybeprop";
       }
     } else if (type == "meta") {
       return "block";
     } else if (!allowNested && (type == "hash" || type == "qualifier")) {
       override = "error";
       return "block";
     } else {
       return states.top(type, stream, state);
     }
   };
 
   states.maybeprop = function(type, stream, state) {
     if (type == ":") return pushContext(state, stream, "prop");
     return pass(type, stream, state);
   };
 
   states.prop = function(type, stream, state) {
     if (type == ";") return popContext(state);
     if (type == "{" && allowNested) return pushContext(state, stream, "propBlock");
     if (type == "}" || type == "{") return popAndPass(type, stream, state);
     if (type == "(") return pushContext(state, stream, "parens");
 
     if (type == "hash" && !/^#([0-9a-fA-f]{3,4}|[0-9a-fA-f]{6}|[0-9a-fA-f]{8})$/.test(stream.current())) {
       override += " error";
     } else if (type == "word") {
       wordAsValue(stream);
     } else if (type == "interpolation") {
       return pushContext(state, stream, "interpolation");
     }
     return "prop";
   };
 
   states.propBlock = function(type, _stream, state) {
     if (type == "}") return popContext(state);
     if (type == "word") { override = "property"; return "maybeprop"; }
     return state.context.type;
   };
 
   states.parens = function(type, stream, state) {
     if (type == "{" || type == "}") return popAndPass(type, stream, state);
     if (type == ")") return popContext(state);
     if (type == "(") return pushContext(state, stream, "parens");
     if (type == "interpolation") return pushContext(state, stream, "interpolation");
     if (type == "word") wordAsValue(stream);
     return "parens";
   };
 
   states.pseudo = function(type, stream, state) {
+    if (type == "meta") return "pseudo";
+
     if (type == "word") {
       override = "variable-3";
       return state.context.type;
     }
     return pass(type, stream, state);
   };
 
   states.documentTypes = function(type, stream, state) {
     if (type == "word" && documentTypes.hasOwnProperty(stream.current())) {
       override = "tag";
       return state.context.type;
     } else {
       return states.atBlock(type, stream, state);
     }
   };
 
   states.atBlock = function(type, stream, state) {
     if (type == "(") return pushContext(state, stream, "atBlock_parens");
     if (type == "}" || type == ";") return popAndPass(type, stream, state);
     if (type == "{") return popContext(state) && pushContext(state, stream, allowNested ? "block" : "top");
 
     if (type == "interpolation") return pushContext(state, stream, "interpolation");
 
     if (type == "word") {
       var word = stream.current().toLowerCase();
       if (word == "only" || word == "not" || word == "and" || word == "or")
         override = "keyword";
       else if (mediaTypes.hasOwnProperty(word))
         override = "attribute";
       else if (mediaFeatures.hasOwnProperty(word))
         override = "property";
       else if (mediaValueKeywords.hasOwnProperty(word))
         override = "keyword";
       else if (propertyKeywords.hasOwnProperty(word))
         override = "property";
       else if (nonStandardPropertyKeywords.hasOwnProperty(word))
         override = "string-2";
       else if (valueKeywords.hasOwnProperty(word))
         override = "atom";
       else if (colorKeywords.hasOwnProperty(word))
         override = "keyword";
       else
         override = "error";
     }
     return state.context.type;
   };
 
   states.atComponentBlock = function(type, stream, state) {
     if (type == "}")
       return popAndPass(type, stream, state);
     if (type == "{")
       return popContext(state) && pushContext(state, stream, allowNested ? "block" : "top", false);
     if (type == "word")
       override = "error";
     return state.context.type;
   };
 
   states.atBlock_parens = function(type, stream, state) {
     if (type == ")") return popContext(state);
     if (type == "{" || type == "}") return popAndPass(type, stream, state, 2);
     return states.atBlock(type, stream, state);
   };
 
   states.restricted_atBlock_before = function(type, stream, state) {
     if (type == "{")
       return pushContext(state, stream, "restricted_atBlock");
     if (type == "word" && state.stateArg == "@counter-style") {
       override = "variable";
       return "restricted_atBlock_before";
     }
     return pass(type, stream, state);
   };
 
   states.restricted_atBlock = function(type, stream, state) {
     if (type == "}") {
       state.stateArg = null;
       return popContext(state);
     }
     if (type == "word") {
       if ((state.stateArg == "@font-face" && !fontProperties.hasOwnProperty(stream.current().toLowerCase())) ||
           (state.stateArg == "@counter-style" && !counterDescriptors.hasOwnProperty(stream.current().toLowerCase())))
         override = "error";
       else
         override = "property";
       return "maybeprop";
     }
     return "restricted_atBlock";
   };
 
   states.keyframes = function(type, stream, state) {
     if (type == "word") { override = "variable"; return "keyframes"; }
     if (type == "{") return pushContext(state, stream, "top");
     return pass(type, stream, state);
   };
 
   states.at = function(type, stream, state) {
     if (type == ";") return popContext(state);
     if (type == "{" || type == "}") return popAndPass(type, stream, state);
     if (type == "word") override = "tag";
     else if (type == "hash") override = "builtin";
     return "at";
   };
 
   states.interpolation = function(type, stream, state) {
     if (type == "}") return popContext(state);
     if (type == "{" || type == ";") return popAndPass(type, stream, state);
     if (type == "word") override = "variable";
     else if (type != "variable" && type != "(" && type != ")") override = "error";
     return "interpolation";
   };
 
   return {
     startState: function(base) {
       return {tokenize: null,
               state: inline ? "block" : "top",
               stateArg: null,
               context: new Context(inline ? "block" : "top", base || 0, null)};
     },
 
     token: function(stream, state) {
       if (!state.tokenize && stream.eatSpace()) return null;
       var style = (state.tokenize || tokenBase)(stream, state);
       if (style && typeof style == "object") {
         type = style[1];
         style = style[0];
       }
       override = style;
-      state.state = states[state.state](type, stream, state);
+      if (type != "comment")
+        state.state = states[state.state](type, stream, state);
       return override;
     },
 
     indent: function(state, textAfter) {
       var cx = state.context, ch = textAfter && textAfter.charAt(0);
       var indent = cx.indent;
       if (cx.type == "prop" && (ch == "}" || ch == ")")) cx = cx.prev;
       if (cx.prev) {
         if (ch == "}" && (cx.type == "block" || cx.type == "top" ||
                           cx.type == "interpolation" || cx.type == "restricted_atBlock")) {
           // Resume indentation from parent context.
           cx = cx.prev;
           indent = cx.indent;
         } else if (ch == ")" && (cx.type == "parens" || cx.type == "atBlock_parens") ||
             ch == "{" && (cx.type == "at" || cx.type == "atBlock")) {
           // Dedent relative to current context.
           indent = Math.max(0, cx.indent - indentUnit);
-          cx = cx.prev;
         }
       }
       return indent;
     },
 
     electricChars: "}",
     blockCommentStart: "/*",
     blockCommentEnd: "*/",
+    blockCommentContinue: " * ",
+    lineComment: lineComment,
     fold: "brace"
   };
 });
 
   function keySet(array) {
     var keys = {};
     for (var i = 0; i < array.length; ++i) {
-      keys[array[i]] = true;
+      keys[array[i].toLowerCase()] = true;
     }
     return keys;
   }
 
   var documentTypes_ = [
     "domain", "regexp", "url", "url-prefix"
   ], documentTypes = keySet(documentTypes_);
 
   var mediaTypes_ = [
     "all", "aural", "braille", "handheld", "print", "projection", "screen",
     "tty", "tv", "embossed"
   ], mediaTypes = keySet(mediaTypes_);
 
   var mediaFeatures_ = [
     "width", "min-width", "max-width", "height", "min-height", "max-height",
     "device-width", "min-device-width", "max-device-width", "device-height",
     "min-device-height", "max-device-height", "aspect-ratio",
     "min-aspect-ratio", "max-aspect-ratio", "device-aspect-ratio",
     "min-device-aspect-ratio", "max-device-aspect-ratio", "color", "min-color",
     "max-color", "color-index", "min-color-index", "max-color-index",
     "monochrome", "min-monochrome", "max-monochrome", "resolution",
     "min-resolution", "max-resolution", "scan", "grid", "orientation",
     "device-pixel-ratio", "min-device-pixel-ratio", "max-device-pixel-ratio",
     "pointer", "any-pointer", "hover", "any-hover"
   ], mediaFeatures = keySet(mediaFeatures_);
 
   var mediaValueKeywords_ = [
     "landscape", "portrait", "none", "coarse", "fine", "on-demand", "hover",
     "interlace", "progressive"
   ], mediaValueKeywords = keySet(mediaValueKeywords_);
 
   var propertyKeywords_ = [
     "align-content", "align-items", "align-self", "alignment-adjust",
     "alignment-baseline", "anchor-point", "animation", "animation-delay",
     "animation-direction", "animation-duration", "animation-fill-mode",
     "animation-iteration-count", "animation-name", "animation-play-state",
     "animation-timing-function", "appearance", "azimuth", "backface-visibility",
     "background", "background-attachment", "background-blend-mode", "background-clip",
     "background-color", "background-image", "background-origin", "background-position",
     "background-repeat", "background-size", "baseline-shift", "binding",
     "bleed", "bookmark-label", "bookmark-level", "bookmark-state",
     "bookmark-target", "border", "border-bottom", "border-bottom-color",
     "border-bottom-left-radius", "border-bottom-right-radius",
     "border-bottom-style", "border-bottom-width", "border-collapse",
     "border-color", "border-image", "border-image-outset",
     "border-image-repeat", "border-image-slice", "border-image-source",
     "border-image-width", "border-left", "border-left-color",
     "border-left-style", "border-left-width", "border-radius", "border-right",
     "border-right-color", "border-right-style", "border-right-width",
     "border-spacing", "border-style", "border-top", "border-top-color",
     "border-top-left-radius", "border-top-right-radius", "border-top-style",
     "border-top-width", "border-width", "bottom", "box-decoration-break",
     "box-shadow", "box-sizing", "break-after", "break-before", "break-inside",
-    "caption-side", "clear", "clip", "color", "color-profile", "column-count",
+    "caption-side", "caret-color", "clear", "clip", "color", "color-profile", "column-count",
     "column-fill", "column-gap", "column-rule", "column-rule-color",
     "column-rule-style", "column-rule-width", "column-span", "column-width",
     "columns", "content", "counter-increment", "counter-reset", "crop", "cue",
     "cue-after", "cue-before", "cursor", "direction", "display",
     "dominant-baseline", "drop-initial-after-adjust",
     "drop-initial-after-align", "drop-initial-before-adjust",
     "drop-initial-before-align", "drop-initial-size", "drop-initial-value",
     "elevation", "empty-cells", "fit", "fit-position", "flex", "flex-basis",
     "flex-direction", "flex-flow", "flex-grow", "flex-shrink", "flex-wrap",
     "float", "float-offset", "flow-from", "flow-into", "font", "font-feature-settings",
     "font-family", "font-kerning", "font-language-override", "font-size", "font-size-adjust",
     "font-stretch", "font-style", "font-synthesis", "font-variant",
     "font-variant-alternates", "font-variant-caps", "font-variant-east-asian",
     "font-variant-ligatures", "font-variant-numeric", "font-variant-position",
     "font-weight", "grid", "grid-area", "grid-auto-columns", "grid-auto-flow",
-    "grid-auto-position", "grid-auto-rows", "grid-column", "grid-column-end",
-    "grid-column-start", "grid-row", "grid-row-end", "grid-row-start",
-    "grid-template", "grid-template-areas", "grid-template-columns",
+    "grid-auto-rows", "grid-column", "grid-column-end", "grid-column-gap",
+    "grid-column-start", "grid-gap", "grid-row", "grid-row-end", "grid-row-gap",
+    "grid-row-start", "grid-template", "grid-template-areas", "grid-template-columns",
     "grid-template-rows", "hanging-punctuation", "height", "hyphens",
     "icon", "image-orientation", "image-rendering", "image-resolution",
-    "inline-box-align", "justify-content", "left", "letter-spacing",
+    "inline-box-align", "justify-content", "justify-items", "justify-self", "left", "letter-spacing",
     "line-break", "line-height", "line-stacking", "line-stacking-ruby",
     "line-stacking-shift", "line-stacking-strategy", "list-style",
     "list-style-image", "list-style-position", "list-style-type", "margin",
     "margin-bottom", "margin-left", "margin-right", "margin-top",
-    "marker-offset", "marks", "marquee-direction", "marquee-loop",
+    "marks", "marquee-direction", "marquee-loop",
     "marquee-play-count", "marquee-speed", "marquee-style", "max-height",
-    "max-width", "min-height", "min-width", "move-to", "nav-down", "nav-index",
+    "max-width", "min-height", "min-width", "mix-blend-mode", "move-to", "nav-down", "nav-index",
     "nav-left", "nav-right", "nav-up", "object-fit", "object-position",
     "opacity", "order", "orphans", "outline",
     "outline-color", "outline-offset", "outline-style", "outline-width",
     "overflow", "overflow-style", "overflow-wrap", "overflow-x", "overflow-y",
     "padding", "padding-bottom", "padding-left", "padding-right", "padding-top",
     "page", "page-break-after", "page-break-before", "page-break-inside",
     "page-policy", "pause", "pause-after", "pause-before", "perspective",
-    "perspective-origin", "pitch", "pitch-range", "play-during", "position",
+    "perspective-origin", "pitch", "pitch-range", "place-content", "place-items", "place-self", "play-during", "position",
     "presentation-level", "punctuation-trim", "quotes", "region-break-after",
     "region-break-before", "region-break-inside", "region-fragment",
     "rendering-intent", "resize", "rest", "rest-after", "rest-before", "richness",
     "right", "rotation", "rotation-point", "ruby-align", "ruby-overhang",
     "ruby-position", "ruby-span", "shape-image-threshold", "shape-inside", "shape-margin",
     "shape-outside", "size", "speak", "speak-as", "speak-header",
     "speak-numeral", "speak-punctuation", "speech-rate", "stress", "string-set",
     "tab-size", "table-layout", "target", "target-name", "target-new",
     "target-position", "text-align", "text-align-last", "text-decoration",
     "text-decoration-color", "text-decoration-line", "text-decoration-skip",
     "text-decoration-style", "text-emphasis", "text-emphasis-color",
     "text-emphasis-position", "text-emphasis-style", "text-height",
     "text-indent", "text-justify", "text-outline", "text-overflow", "text-shadow",
     "text-size-adjust", "text-space-collapse", "text-transform", "text-underline-position",
     "text-wrap", "top", "transform", "transform-origin", "transform-style",
     "transition", "transition-delay", "transition-duration",
     "transition-property", "transition-timing-function", "unicode-bidi",
-    "vertical-align", "visibility", "voice-balance", "voice-duration",
+    "user-select", "vertical-align", "visibility", "voice-balance", "voice-duration",
     "voice-family", "voice-pitch", "voice-range", "voice-rate", "voice-stress",
-    "voice-volume", "volume", "white-space", "widows", "width", "word-break",
+    "voice-volume", "volume", "white-space", "widows", "width", "will-change", "word-break",
     "word-spacing", "word-wrap", "z-index",
     // SVG-specific
     "clip-path", "clip-rule", "mask", "enable-background", "filter", "flood-color",
     "flood-opacity", "lighting-color", "stop-color", "stop-opacity", "pointer-events",
     "color-interpolation", "color-interpolation-filters",
     "color-rendering", "fill", "fill-opacity", "fill-rule", "image-rendering",
     "marker", "marker-end", "marker-mid", "marker-start", "shape-rendering", "stroke",
     "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin",
     "stroke-miterlimit", "stroke-opacity", "stroke-width", "text-rendering",
     "baseline-shift", "dominant-baseline", "glyph-orientation-horizontal",
     "glyph-orientation-vertical", "text-anchor", "writing-mode"
   ], propertyKeywords = keySet(propertyKeywords_);
 
   var nonStandardPropertyKeywords_ = [
     "scrollbar-arrow-color", "scrollbar-base-color", "scrollbar-dark-shadow-color",
     "scrollbar-face-color", "scrollbar-highlight-color", "scrollbar-shadow-color",
     "scrollbar-3d-light-color", "scrollbar-track-color", "shape-inside",
     "searchfield-cancel-button", "searchfield-decoration", "searchfield-results-button",
     "searchfield-results-decoration", "zoom"
   ], nonStandardPropertyKeywords = keySet(nonStandardPropertyKeywords_);
 
   var fontProperties_ = [
     "font-family", "src", "unicode-range", "font-variant", "font-feature-settings",
     "font-stretch", "font-weight", "font-style"
   ], fontProperties = keySet(fontProperties_);
 
   var counterDescriptors_ = [
     "additive-symbols", "fallback", "negative", "pad", "prefix", "range",
     "speak-as", "suffix", "symbols", "system"
   ], counterDescriptors = keySet(counterDescriptors_);
 
   var colorKeywords_ = [
     "aliceblue", "antiquewhite", "aqua", "aquamarine", "azure", "beige",
     "bisque", "black", "blanchedalmond", "blue", "blueviolet", "brown",
     "burlywood", "cadetblue", "chartreuse", "chocolate", "coral", "cornflowerblue",
     "cornsilk", "crimson", "cyan", "darkblue", "darkcyan", "darkgoldenrod",
     "darkgray", "darkgreen", "darkkhaki", "darkmagenta", "darkolivegreen",
     "darkorange", "darkorchid", "darkred", "darksalmon", "darkseagreen",
     "darkslateblue", "darkslategray", "darkturquoise", "darkviolet",
     "deeppink", "deepskyblue", "dimgray", "dodgerblue", "firebrick",
     "floralwhite", "forestgreen", "fuchsia", "gainsboro", "ghostwhite",
     "gold", "goldenrod", "gray", "grey", "green", "greenyellow", "honeydew",
     "hotpink", "indianred", "indigo", "ivory", "khaki", "lavender",
     "lavenderblush", "lawngreen", "lemonchiffon", "lightblue", "lightcoral",
     "lightcyan", "lightgoldenrodyellow", "lightgray", "lightgreen", "lightpink",
     "lightsalmon", "lightseagreen", "lightskyblue", "lightslategray",
     "lightsteelblue", "lightyellow", "lime", "limegreen", "linen", "magenta",
     "maroon", "mediumaquamarine", "mediumblue", "mediumorchid", "mediumpurple",
     "mediumseagreen", "mediumslateblue", "mediumspringgreen", "mediumturquoise",
     "mediumvioletred", "midnightblue", "mintcream", "mistyrose", "moccasin",
     "navajowhite", "navy", "oldlace", "olive", "olivedrab", "orange", "orangered",
     "orchid", "palegoldenrod", "palegreen", "paleturquoise", "palevioletred",
     "papayawhip", "peachpuff", "peru", "pink", "plum", "powderblue",
     "purple", "rebeccapurple", "red", "rosybrown", "royalblue", "saddlebrown",
     "salmon", "sandybrown", "seagreen", "seashell", "sienna", "silver", "skyblue",
     "slateblue", "slategray", "snow", "springgreen", "steelblue", "tan",
     "teal", "thistle", "tomato", "turquoise", "violet", "wheat", "white",
     "whitesmoke", "yellow", "yellowgreen"
   ], colorKeywords = keySet(colorKeywords_);
 
   var valueKeywords_ = [
     "above", "absolute", "activeborder", "additive", "activecaption", "afar",
     "after-white-space", "ahead", "alias", "all", "all-scroll", "alphabetic", "alternate",
     "always", "amharic", "amharic-abegede", "antialiased", "appworkspace",
-    "arabic-indic", "armenian", "asterisks", "attr", "auto", "avoid", "avoid-column", "avoid-page",
+    "arabic-indic", "armenian", "asterisks", "attr", "auto", "auto-flow", "avoid", "avoid-column", "avoid-page",
     "avoid-region", "background", "backwards", "baseline", "below", "bidi-override", "binary",
     "bengali", "blink", "block", "block-axis", "bold", "bolder", "border", "border-box",
     "both", "bottom", "break", "break-all", "break-word", "bullets", "button", "button-bevel",
     "buttonface", "buttonhighlight", "buttonshadow", "buttontext", "calc", "cambodian",
     "capitalize", "caps-lock-indicator", "caption", "captiontext", "caret",
     "cell", "center", "checkbox", "circle", "cjk-decimal", "cjk-earthly-branch",
     "cjk-heavenly-stem", "cjk-ideographic", "clear", "clip", "close-quote",
     "col-resize", "collapse", "color", "color-burn", "color-dodge", "column", "column-reverse",
-    "compact", "condensed", "contain", "content",
+    "compact", "condensed", "contain", "content", "contents",
     "content-box", "context-menu", "continuous", "copy", "counter", "counters", "cover", "crop",
     "cross", "crosshair", "currentcolor", "cursive", "cyclic", "darken", "dashed", "decimal",
-    "decimal-leading-zero", "default", "default-button", "destination-atop",
+    "decimal-leading-zero", "default", "default-button", "dense", "destination-atop",
     "destination-in", "destination-out", "destination-over", "devanagari", "difference",
     "disc", "discard", "disclosure-closed", "disclosure-open", "document",
     "dot-dash", "dot-dot-dash",
     "dotted", "double", "down", "e-resize", "ease", "ease-in", "ease-in-out", "ease-out",
     "element", "ellipse", "ellipsis", "embed", "end", "ethiopic", "ethiopic-abegede",
     "ethiopic-abegede-am-et", "ethiopic-abegede-gez", "ethiopic-abegede-ti-er",
     "ethiopic-abegede-ti-et", "ethiopic-halehame-aa-er",
     "ethiopic-halehame-aa-et", "ethiopic-halehame-am-et",
     "ethiopic-halehame-gez", "ethiopic-halehame-om-et",
     "ethiopic-halehame-sid-et", "ethiopic-halehame-so-et",
     "ethiopic-halehame-ti-er", "ethiopic-halehame-ti-et", "ethiopic-halehame-tig",
     "ethiopic-numeric", "ew-resize", "exclusion", "expanded", "extends", "extra-condensed",
     "extra-expanded", "fantasy", "fast", "fill", "fixed", "flat", "flex", "flex-end", "flex-start", "footnotes",
-    "forwards", "from", "geometricPrecision", "georgian", "graytext", "groove",
+    "forwards", "from", "geometricPrecision", "georgian", "graytext", "grid", "groove",
     "gujarati", "gurmukhi", "hand", "hangul", "hangul-consonant", "hard-light", "hebrew",
     "help", "hidden", "hide", "higher", "highlight", "highlighttext",
     "hiragana", "hiragana-iroha", "horizontal", "hsl", "hsla", "hue", "icon", "ignore",
     "inactiveborder", "inactivecaption", "inactivecaptiontext", "infinite",
     "infobackground", "infotext", "inherit", "initial", "inline", "inline-axis",
-    "inline-block", "inline-flex", "inline-table", "inset", "inside", "intrinsic", "invert",
+    "inline-block", "inline-flex", "inline-grid", "inline-table", "inset", "inside", "intrinsic", "invert",
     "italic", "japanese-formal", "japanese-informal", "justify", "kannada",
     "katakana", "katakana-iroha", "keep-all", "khmer",
     "korean-hangul-formal", "korean-hanja-formal", "korean-hanja-informal",
     "landscape", "lao", "large", "larger", "left", "level", "lighter", "lighten",
     "line-through", "linear", "linear-gradient", "lines", "list-item", "listbox", "listitem",
     "local", "logical", "loud", "lower", "lower-alpha", "lower-armenian",
     "lower-greek", "lower-hexadecimal", "lower-latin", "lower-norwegian",
     "lower-roman", "lowercase", "ltr", "luminosity", "malayalam", "match", "matrix", "matrix3d",
     "media-controls-background", "media-current-time-display",
     "media-fullscreen-button", "media-mute-button", "media-play-button",
     "media-return-to-realtime-button", "media-rewind-button",
     "media-seek-back-button", "media-seek-forward-button", "media-slider",
     "media-sliderthumb", "media-time-remaining-display", "media-volume-slider",
     "media-volume-slider-container", "media-volume-sliderthumb", "medium",
     "menu", "menulist", "menulist-button", "menulist-text",
     "menulist-textfield", "menutext", "message-box", "middle", "min-intrinsic",
     "mix", "mongolian", "monospace", "move", "multiple", "multiply", "myanmar", "n-resize",
     "narrower", "ne-resize", "nesw-resize", "no-close-quote", "no-drop",
     "no-open-quote", "no-repeat", "none", "normal", "not-allowed", "nowrap",
-    "ns-resize", "numbers", "numeric", "nw-resize", "nwse-resize", "oblique", "octal", "open-quote",
+    "ns-resize", "numbers", "numeric", "nw-resize", "nwse-resize", "oblique", "octal", "opacity", "open-quote",
     "optimizeLegibility", "optimizeSpeed", "oriya", "oromo", "outset",
     "outside", "outside-shape", "overlay", "overline", "padding", "padding-box",
     "painted", "page", "paused", "persian", "perspective", "plus-darker", "plus-lighter",
     "pointer", "polygon", "portrait", "pre", "pre-line", "pre-wrap", "preserve-3d",
     "progress", "push-button", "radial-gradient", "radio", "read-only",
     "read-write", "read-write-plaintext-only", "rectangle", "region",
     "relative", "repeat", "repeating-linear-gradient",
     "repeating-radial-gradient", "repeat-x", "repeat-y", "reset", "reverse",
     "rgb", "rgba", "ridge", "right", "rotate", "rotate3d", "rotateX", "rotateY",
     "rotateZ", "round", "row", "row-resize", "row-reverse", "rtl", "run-in", "running",
     "s-resize", "sans-serif", "saturation", "scale", "scale3d", "scaleX", "scaleY", "scaleZ", "screen",
-    "scroll", "scrollbar", "se-resize", "searchfield",
+    "scroll", "scrollbar", "scroll-position", "se-resize", "searchfield",
     "searchfield-cancel-button", "searchfield-decoration",
-    "searchfield-results-button", "searchfield-results-decoration",
+    "searchfield-results-button", "searchfield-results-decoration", "self-start", "self-end",
     "semi-condensed", "semi-expanded", "separate", "serif", "show", "sidama",
     "simp-chinese-formal", "simp-chinese-informal", "single",
     "skew", "skewX", "skewY", "skip-white-space", "slide", "slider-horizontal",
     "slider-vertical", "sliderthumb-horizontal", "sliderthumb-vertical", "slow",
     "small", "small-caps", "small-caption", "smaller", "soft-light", "solid", "somali",
-    "source-atop", "source-in", "source-out", "source-over", "space", "space-around", "space-between", "spell-out", "square",
+    "source-atop", "source-in", "source-out", "source-over", "space", "space-around", "space-between", "space-evenly", "spell-out", "square",
     "square-button", "start", "static", "status-bar", "stretch", "stroke", "sub",
-    "subpixel-antialiased", "super", "sw-resize", "symbolic", "symbols", "table",
+    "subpixel-antialiased", "super", "sw-resize", "symbolic", "symbols", "system-ui", "table",
     "table-caption", "table-cell", "table-column", "table-column-group",
     "table-footer-group", "table-header-group", "table-row", "table-row-group",
     "tamil",
     "telugu", "text", "text-bottom", "text-top", "textarea", "textfield", "thai",
     "thick", "thin", "threeddarkshadow", "threedface", "threedhighlight",
     "threedlightshadow", "threedshadow", "tibetan", "tigre", "tigrinya-er",
     "tigrinya-er-abegede", "tigrinya-et", "tigrinya-et-abegede", "to", "top",
-    "trad-chinese-formal", "trad-chinese-informal",
+    "trad-chinese-formal", "trad-chinese-informal", "transform",
     "translate", "translate3d", "translateX", "translateY", "translateZ",
-    "transparent", "ultra-condensed", "ultra-expanded", "underline", "up",
+    "transparent", "ultra-condensed", "ultra-expanded", "underline", "unset", "up",
     "upper-alpha", "upper-armenian", "upper-greek", "upper-hexadecimal",
     "upper-latin", "upper-norwegian", "upper-roman", "uppercase", "urdu", "url",
     "var", "vertical", "vertical-text", "visible", "visibleFill", "visiblePainted",
     "visibleStroke", "visual", "w-resize", "wait", "wave", "wider",
     "window", "windowframe", "windowtext", "words", "wrap", "wrap-reverse", "x-large", "x-small", "xor",
     "xx-large", "xx-small"
   ], valueKeywords = keySet(valueKeywords_);
 
   var allWords = documentTypes_.concat(mediaTypes_).concat(mediaFeatures_).concat(mediaValueKeywords_)
     .concat(propertyKeywords_).concat(nonStandardPropertyKeywords_).concat(colorKeywords_)
     .concat(valueKeywords_);
   CodeMirror.registerHelper("hintWords", "css", allWords);
 
   function tokenCComment(stream, state) {
     var maybeEnd = false, ch;
     while ((ch = stream.next()) != null) {
       if (maybeEnd && ch == "/") {
         state.tokenize = null;
         break;
       }
       maybeEnd = (ch == "*");
     }
     return ["comment", "comment"];
   }
 
   CodeMirror.defineMIME("text/css", {
     documentTypes: documentTypes,
     mediaTypes: mediaTypes,
     mediaFeatures: mediaFeatures,
     mediaValueKeywords: mediaValueKeywords,
     propertyKeywords: propertyKeywords,
     nonStandardPropertyKeywords: nonStandardPropertyKeywords,
     fontProperties: fontProperties,
     counterDescriptors: counterDescriptors,
     colorKeywords: colorKeywords,
     valueKeywords: valueKeywords,
     tokenHooks: {
       "/": function(stream, state) {
         if (!stream.eat("*")) return false;
         state.tokenize = tokenCComment;
         return tokenCComment(stream, state);
       }
     },
     name: "css"
   });
 
   CodeMirror.defineMIME("text/x-scss", {
     mediaTypes: mediaTypes,
     mediaFeatures: mediaFeatures,
     mediaValueKeywords: mediaValueKeywords,
     propertyKeywords: propertyKeywords,
     nonStandardPropertyKeywords: nonStandardPropertyKeywords,
     colorKeywords: colorKeywords,
     valueKeywords: valueKeywords,
     fontProperties: fontProperties,
     allowNested: true,
+    lineComment: "//",
     tokenHooks: {
       "/": function(stream, state) {
         if (stream.eat("/")) {
           stream.skipToEnd();
           return ["comment", "comment"];
         } else if (stream.eat("*")) {
           state.tokenize = tokenCComment;
           return tokenCComment(stream, state);
         } else {
           return ["operator", "operator"];
         }
       },
       ":": function(stream) {
-        if (stream.match(/\s*\{/))
-          return [null, "{"];
+        if (stream.match(/\s*\{/, false))
+          return [null, null]
         return false;
       },
       "$": function(stream) {
         stream.match(/^[\w-]+/);
         if (stream.match(/^\s*:/, false))
           return ["variable-2", "variable-definition"];
         return ["variable-2", "variable"];
       },
       "#": function(stream) {
         if (!stream.eat("{")) return false;
         return [null, "interpolation"];
       }
     },
     name: "css",
     helperType: "scss"
   });
 
   CodeMirror.defineMIME("text/x-less", {
     mediaTypes: mediaTypes,
     mediaFeatures: mediaFeatures,
     mediaValueKeywords: mediaValueKeywords,
     propertyKeywords: propertyKeywords,
     nonStandardPropertyKeywords: nonStandardPropertyKeywords,
     colorKeywords: colorKeywords,
     valueKeywords: valueKeywords,
     fontProperties: fontProperties,
     allowNested: true,
+    lineComment: "//",
     tokenHooks: {
       "/": function(stream, state) {
         if (stream.eat("/")) {
           stream.skipToEnd();
           return ["comment", "comment"];
         } else if (stream.eat("*")) {
           state.tokenize = tokenCComment;
           return tokenCComment(stream, state);
         } else {
           return ["operator", "operator"];
         }
       },
       "@": function(stream) {
         if (stream.eat("{")) return [null, "interpolation"];
-        if (stream.match(/^(charset|document|font-face|import|(-(moz|ms|o|webkit)-)?keyframes|media|namespace|page|supports)\b/, false)) return false;
+        if (stream.match(/^(charset|document|font-face|import|(-(moz|ms|o|webkit)-)?keyframes|media|namespace|page|supports)\b/i, false)) return false;
         stream.eatWhile(/[\w\\\-]/);
         if (stream.match(/^\s*:/, false))
           return ["variable-2", "variable-definition"];
         return ["variable-2", "variable"];
       },
       "&": function() {
         return ["atom", "atom"];
       }
     },
     name: "css",
     helperType: "less"
   });
 
   CodeMirror.defineMIME("text/x-gss", {
     documentTypes: documentTypes,
     mediaTypes: mediaTypes,
     mediaFeatures: mediaFeatures,
     propertyKeywords: propertyKeywords,
     nonStandardPropertyKeywords: nonStandardPropertyKeywords,
     fontProperties: fontProperties,
     counterDescriptors: counterDescriptors,
     colorKeywords: colorKeywords,
     valueKeywords: valueKeywords,
     supportsAtComponent: true,
     tokenHooks: {
       "/": function(stream, state) {
         if (!stream.eat("*")) return false;
         state.tokenize = tokenCComment;
         return tokenCComment(stream, state);
       }
     },
     name: "css",
     helperType: "gss"
   });
 
 });

rhodecode/public/js/mode/cypher/cypher.js

@@ -1,146 +1,150 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 // By the Neo4j Team and contributors.
 // https://github.com/neo4j-contrib/CodeMirror
 
 (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";
   var wordRegexp = function(words) {
     return new RegExp("^(?:" + words.join("|") + ")$", "i");
   };
 
   CodeMirror.defineMode("cypher", function(config) {
     var tokenBase = function(stream/*, state*/) {
       var ch = stream.next();
-      if (ch === "\"" || ch === "'") {
-        stream.match(/.+?["']/);
+      if (ch ==='"') {
+        stream.match(/.*?"/);
+        return "string";
+      }
+      if (ch === "'") {
+        stream.match(/.*?'/);
         return "string";
       }
       if (/[{}\(\),\.;\[\]]/.test(ch)) {
         curPunc = ch;
         return "node";
       } else if (ch === "/" && stream.eat("/")) {
         stream.skipToEnd();
         return "comment";
       } else if (operatorChars.test(ch)) {
         stream.eatWhile(operatorChars);
         return null;
       } else {
         stream.eatWhile(/[_\w\d]/);
         if (stream.eat(":")) {
           stream.eatWhile(/[\w\d_\-]/);
           return "atom";
         }
         var word = stream.current();
         if (funcs.test(word)) return "builtin";
         if (preds.test(word)) return "def";
         if (keywords.test(word)) return "keyword";
         return "variable";
       }
     };
     var pushContext = function(state, type, col) {
       return state.context = {
         prev: state.context,
         indent: state.indent,
         col: col,
         type: type
       };
     };
     var popContext = function(state) {
       state.indent = state.context.indent;
       return state.context = state.context.prev;
     };
     var indentUnit = config.indentUnit;
     var curPunc;
     var funcs = wordRegexp(["abs", "acos", "allShortestPaths", "asin", "atan", "atan2", "avg", "ceil", "coalesce", "collect", "cos", "cot", "count", "degrees", "e", "endnode", "exp", "extract", "filter", "floor", "haversin", "head", "id", "keys", "labels", "last", "left", "length", "log", "log10", "lower", "ltrim", "max", "min", "node", "nodes", "percentileCont", "percentileDisc", "pi", "radians", "rand", "range", "reduce", "rel", "relationship", "relationships", "replace", "reverse", "right", "round", "rtrim", "shortestPath", "sign", "sin", "size", "split", "sqrt", "startnode", "stdev", "stdevp", "str", "substring", "sum", "tail", "tan", "timestamp", "toFloat", "toInt", "toString", "trim", "type", "upper"]);
     var preds = wordRegexp(["all", "and", "any", "contains", "exists", "has", "in", "none", "not", "or", "single", "xor"]);
-    var keywords = wordRegexp(["as", "asc", "ascending", "assert", "by", "case", "commit", "constraint", "create", "csv", "cypher", "delete", "desc", "descending", "detach", "distinct", "drop", "else", "end", "ends", "explain", "false", "fieldterminator", "foreach", "from", "headers", "in", "index", "is", "join", "limit", "load", "match", "merge", "null", "on", "optional", "order", "periodic", "profile", "remove", "return", "scan", "set", "skip", "start", "starts", "then", "true", "union", "unique", "unwind", "using", "when", "where", "with"]);
+    var keywords = wordRegexp(["as", "asc", "ascending", "assert", "by", "case", "commit", "constraint", "create", "csv", "cypher", "delete", "desc", "descending", "detach", "distinct", "drop", "else", "end", "ends", "explain", "false", "fieldterminator", "foreach", "from", "headers", "in", "index", "is", "join", "limit", "load", "match", "merge", "null", "on", "optional", "order", "periodic", "profile", "remove", "return", "scan", "set", "skip", "start", "starts", "then", "true", "union", "unique", "unwind", "using", "when", "where", "with", "call", "yield"]);
     var operatorChars = /[*+\-<>=&|~%^]/;
 
     return {
       startState: function(/*base*/) {
         return {
           tokenize: tokenBase,
           context: null,
           indent: 0,
           col: 0
         };
       },
       token: function(stream, state) {
         if (stream.sol()) {
           if (state.context && (state.context.align == null)) {
             state.context.align = false;
           }
           state.indent = stream.indentation();
         }
         if (stream.eatSpace()) {
           return null;
         }
         var style = state.tokenize(stream, state);
         if (style !== "comment" && state.context && (state.context.align == null) && state.context.type !== "pattern") {
           state.context.align = true;
         }
         if (curPunc === "(") {
           pushContext(state, ")", stream.column());
         } else if (curPunc === "[") {
           pushContext(state, "]", stream.column());
         } else if (curPunc === "{") {
           pushContext(state, "}", stream.column());
         } else if (/[\]\}\)]/.test(curPunc)) {
           while (state.context && state.context.type === "pattern") {
             popContext(state);
           }
           if (state.context && curPunc === state.context.type) {
             popContext(state);
           }
         } else if (curPunc === "." && state.context && state.context.type === "pattern") {
           popContext(state);
         } else if (/atom|string|variable/.test(style) && state.context) {
           if (/[\}\]]/.test(state.context.type)) {
             pushContext(state, "pattern", stream.column());
           } else if (state.context.type === "pattern" && !state.context.align) {
             state.context.align = true;
             state.context.col = stream.column();
           }
         }
         return style;
       },
       indent: function(state, textAfter) {
         var firstChar = textAfter && textAfter.charAt(0);
         var context = state.context;
         if (/[\]\}]/.test(firstChar)) {
           while (context && context.type === "pattern") {
             context = context.prev;
           }
         }
         var closing = context && firstChar === context.type;
         if (!context) return 0;
         if (context.type === "keywords") return CodeMirror.commands.newlineAndIndent;
         if (context.align) return context.col + (closing ? 0 : 1);
         return context.indent + (closing ? 0 : indentUnit);
       }
     };
   });
 
   CodeMirror.modeExtensions["cypher"] = {
     autoFormatLineBreaks: function(text) {
       var i, lines, reProcessedPortion;
       var lines = text.split("\n");
       var reProcessedPortion = /\s+\b(return|where|order by|match|with|skip|limit|create|delete|set)\b\s/g;
       for (var i = 0; i < lines.length; i++)
         lines[i] = lines[i].replace(reProcessedPortion, " \n$1 ").trim();
       return lines.join("\n");
     }
   };
 
   CodeMirror.defineMIME("application/x-cypher-query", "cypher");
 
 });

rhodecode/public/js/mode/d/d.js

@@ -1,218 +1,223 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("d", function(config, parserConfig) {
   var indentUnit = config.indentUnit,
       statementIndentUnit = parserConfig.statementIndentUnit || indentUnit,
       keywords = parserConfig.keywords || {},
       builtin = parserConfig.builtin || {},
       blockKeywords = parserConfig.blockKeywords || {},
       atoms = parserConfig.atoms || {},
       hooks = parserConfig.hooks || {},
       multiLineStrings = parserConfig.multiLineStrings;
   var isOperatorChar = /[+\-*&%=<>!?|\/]/;
 
   var curPunc;
 
   function tokenBase(stream, state) {
     var ch = stream.next();
     if (hooks[ch]) {
       var result = hooks[ch](stream, state);
       if (result !== false) return result;
     }
     if (ch == '"' || ch == "'" || ch == "`") {
       state.tokenize = tokenString(ch);
       return state.tokenize(stream, state);
     }
     if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
       curPunc = ch;
       return null;
     }
     if (/\d/.test(ch)) {
       stream.eatWhile(/[\w\.]/);
       return "number";
     }
     if (ch == "/") {
       if (stream.eat("+")) {
-        state.tokenize = tokenComment;
+        state.tokenize = tokenNestedComment;
         return tokenNestedComment(stream, state);
       }
       if (stream.eat("*")) {
         state.tokenize = tokenComment;
         return tokenComment(stream, state);
       }
       if (stream.eat("/")) {
         stream.skipToEnd();
         return "comment";
       }
     }
     if (isOperatorChar.test(ch)) {
       stream.eatWhile(isOperatorChar);
       return "operator";
     }
     stream.eatWhile(/[\w\$_\xa1-\uffff]/);
     var cur = stream.current();
     if (keywords.propertyIsEnumerable(cur)) {
       if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
       return "keyword";
     }
     if (builtin.propertyIsEnumerable(cur)) {
       if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
       return "builtin";
     }
     if (atoms.propertyIsEnumerable(cur)) return "atom";
     return "variable";
   }
 
   function tokenString(quote) {
     return function(stream, state) {
       var escaped = false, next, end = false;
       while ((next = stream.next()) != null) {
         if (next == quote && !escaped) {end = true; break;}
         escaped = !escaped && next == "\\";
       }
       if (end || !(escaped || multiLineStrings))
         state.tokenize = null;
       return "string";
     };
   }
 
   function tokenComment(stream, state) {
     var maybeEnd = false, ch;
     while (ch = stream.next()) {
       if (ch == "/" && maybeEnd) {
         state.tokenize = null;
         break;
       }
       maybeEnd = (ch == "*");
     }
     return "comment";
   }
 
   function tokenNestedComment(stream, state) {
     var maybeEnd = false, ch;
     while (ch = stream.next()) {
       if (ch == "/" && maybeEnd) {
         state.tokenize = null;
         break;
       }
       maybeEnd = (ch == "+");
     }
     return "comment";
   }
 
   function Context(indented, column, type, align, prev) {
     this.indented = indented;
     this.column = column;
     this.type = type;
     this.align = align;
     this.prev = prev;
   }
   function pushContext(state, col, type) {
     var indent = state.indented;
     if (state.context && state.context.type == "statement")
       indent = state.context.indented;
     return state.context = new Context(indent, col, type, null, state.context);
   }
   function popContext(state) {
     var t = state.context.type;
     if (t == ")" || t == "]" || t == "}")
       state.indented = state.context.indented;
     return state.context = state.context.prev;
   }
 
   // Interface
 
   return {
     startState: function(basecolumn) {
       return {
         tokenize: null,
         context: new Context((basecolumn || 0) - indentUnit, 0, "top", false),
         indented: 0,
         startOfLine: true
       };
     },
 
     token: function(stream, state) {
       var ctx = state.context;
       if (stream.sol()) {
         if (ctx.align == null) ctx.align = false;
         state.indented = stream.indentation();
         state.startOfLine = true;
       }
       if (stream.eatSpace()) return null;
       curPunc = null;
       var style = (state.tokenize || tokenBase)(stream, state);
       if (style == "comment" || style == "meta") return style;
       if (ctx.align == null) ctx.align = true;
 
       if ((curPunc == ";" || curPunc == ":" || curPunc == ",") && ctx.type == "statement") popContext(state);
       else if (curPunc == "{") pushContext(state, stream.column(), "}");
       else if (curPunc == "[") pushContext(state, stream.column(), "]");
       else if (curPunc == "(") pushContext(state, stream.column(), ")");
       else if (curPunc == "}") {
         while (ctx.type == "statement") ctx = popContext(state);
         if (ctx.type == "}") ctx = popContext(state);
         while (ctx.type == "statement") ctx = popContext(state);
       }
       else if (curPunc == ctx.type) popContext(state);
       else if (((ctx.type == "}" || ctx.type == "top") && curPunc != ';') || (ctx.type == "statement" && curPunc == "newstatement"))
         pushContext(state, stream.column(), "statement");
       state.startOfLine = false;
       return style;
     },
 
     indent: function(state, textAfter) {
       if (state.tokenize != tokenBase && state.tokenize != null) return CodeMirror.Pass;
       var ctx = state.context, firstChar = textAfter && textAfter.charAt(0);
       if (ctx.type == "statement" && firstChar == "}") ctx = ctx.prev;
       var closing = firstChar == ctx.type;
       if (ctx.type == "statement") return ctx.indented + (firstChar == "{" ? 0 : statementIndentUnit);
       else if (ctx.align) return ctx.column + (closing ? 0 : 1);
       else return ctx.indented + (closing ? 0 : indentUnit);
     },
 
-    electricChars: "{}"
+    electricChars: "{}",
+    blockCommentStart: "/*",
+    blockCommentEnd: "*/",
+    blockCommentContinue: " * ",
+    lineComment: "//",
+    fold: "brace"
   };
 });
 
   function words(str) {
     var obj = {}, words = str.split(" ");
     for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
     return obj;
   }
 
   var blockKeywords = "body catch class do else enum for foreach foreach_reverse if in interface mixin " +
                       "out scope struct switch try union unittest version while with";
 
   CodeMirror.defineMIME("text/x-d", {
     name: "d",
     keywords: words("abstract alias align asm assert auto break case cast cdouble cent cfloat const continue " +
                     "debug default delegate delete deprecated export extern final finally function goto immutable " +
                     "import inout invariant is lazy macro module new nothrow override package pragma private " +
                     "protected public pure ref return shared short static super synchronized template this " +
                     "throw typedef typeid typeof volatile __FILE__ __LINE__ __gshared __traits __vector __parameters " +
                     blockKeywords),
     blockKeywords: words(blockKeywords),
     builtin: words("bool byte char creal dchar double float idouble ifloat int ireal long real short ubyte " +
                    "ucent uint ulong ushort wchar wstring void size_t sizediff_t"),
     atoms: words("exit failure success true false null"),
     hooks: {
       "@": function(stream, _state) {
         stream.eatWhile(/[\w\$_]/);
         return "meta";
       }
     }
   });
 
 });

rhodecode/public/js/mode/dart/dart.js

@@ -1,130 +1,166 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 (function(mod) {
   if (typeof exports == "object" && typeof module == "object") // CommonJS
     mod(require("../../lib/codemirror"), require("../clike/clike"));
   else if (typeof define == "function" && define.amd) // AMD
     define(["../../lib/codemirror", "../clike/clike"], mod);
   else // Plain browser env
     mod(CodeMirror);
 })(function(CodeMirror) {
   "use strict";
 
   var keywords = ("this super static final const abstract class extends external factory " +
-    "implements get native operator set typedef with enum throw rethrow " +
-    "assert break case continue default in return new deferred async await " +
+    "implements mixin get native set typedef with enum throw rethrow " +
+    "assert break case continue default in return new deferred async await covariant " +
     "try catch finally do else for if switch while import library export " +
-    "part of show hide is as").split(" ");
+    "part of show hide is as extension on").split(" ");
   var blockKeywords = "try catch finally do else for if switch while".split(" ");
   var atoms = "true false null".split(" ");
   var builtins = "void bool num int double dynamic var String".split(" ");
 
   function set(words) {
     var obj = {};
     for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
     return obj;
   }
 
   function pushInterpolationStack(state) {
     (state.interpolationStack || (state.interpolationStack = [])).push(state.tokenize);
   }
 
   function popInterpolationStack(state) {
     return (state.interpolationStack || (state.interpolationStack = [])).pop();
   }
 
   function sizeInterpolationStack(state) {
     return state.interpolationStack ? state.interpolationStack.length : 0;
   }
 
   CodeMirror.defineMIME("application/dart", {
     name: "clike",
     keywords: set(keywords),
     blockKeywords: set(blockKeywords),
     builtin: set(builtins),
     atoms: set(atoms),
     hooks: {
       "@": function(stream) {
         stream.eatWhile(/[\w\$_\.]/);
         return "meta";
       },
 
       // custom string handling to deal with triple-quoted strings and string interpolation
       "'": function(stream, state) {
         return tokenString("'", stream, state, false);
       },
       "\"": function(stream, state) {
         return tokenString("\"", stream, state, false);
       },
       "r": function(stream, state) {
         var peek = stream.peek();
         if (peek == "'" || peek == "\"") {
           return tokenString(stream.next(), stream, state, true);
         }
         return false;
       },
 
       "}": function(_stream, state) {
         // "}" is end of interpolation, if interpolation stack is non-empty
         if (sizeInterpolationStack(state) > 0) {
           state.tokenize = popInterpolationStack(state);
           return null;
         }
         return false;
+      },
+
+      "/": function(stream, state) {
+        if (!stream.eat("*")) return false
+        state.tokenize = tokenNestedComment(1)
+        return state.tokenize(stream, state)
+      },
+      token: function(stream, _, style) {
+        if (style == "variable") {
+          // Assume uppercase symbols are classes using variable-2
+          var isUpper = RegExp('^[_$]*[A-Z][a-zA-Z0-9_$]*$','g');
+          if (isUpper.test(stream.current())) {
+            return 'variable-2';
+          }
+        }
       }
     }
   });
 
   function tokenString(quote, stream, state, raw) {
     var tripleQuoted = false;
     if (stream.eat(quote)) {
       if (stream.eat(quote)) tripleQuoted = true;
       else return "string"; //empty string
     }
     function tokenStringHelper(stream, state) {
       var escaped = false;
       while (!stream.eol()) {
         if (!raw && !escaped && stream.peek() == "$") {
           pushInterpolationStack(state);
           state.tokenize = tokenInterpolation;
           return "string";
         }
         var next = stream.next();
         if (next == quote && !escaped && (!tripleQuoted || stream.match(quote + quote))) {
           state.tokenize = null;
           break;
         }
         escaped = !raw && !escaped && next == "\\";
       }
       return "string";
     }
     state.tokenize = tokenStringHelper;
     return tokenStringHelper(stream, state);
   }
 
   function tokenInterpolation(stream, state) {
     stream.eat("$");
     if (stream.eat("{")) {
       // let clike handle the content of ${...},
       // we take over again when "}" appears (see hooks).
       state.tokenize = null;
     } else {
       state.tokenize = tokenInterpolationIdentifier;
     }
     return null;
   }
 
   function tokenInterpolationIdentifier(stream, state) {
     stream.eatWhile(/[\w_]/);
     state.tokenize = popInterpolationStack(state);
     return "variable";
   }
 
+  function tokenNestedComment(depth) {
+    return function (stream, state) {
+      var ch
+      while (ch = stream.next()) {
+        if (ch == "*" && stream.eat("/")) {
+          if (depth == 1) {
+            state.tokenize = null
+            break
+          } else {
+            state.tokenize = tokenNestedComment(depth - 1)
+            return state.tokenize(stream, state)
+          }
+        } else if (ch == "/" && stream.eat("*")) {
+          state.tokenize = tokenNestedComment(depth + 1)
+          return state.tokenize(stream, state)
+        }
+      }
+      return "comment"
+    }
+  }
+
   CodeMirror.registerHelper("hintWords", "application/dart", keywords.concat(atoms).concat(builtins));
 
   // This is needed to make loading through meta.js work.
   CodeMirror.defineMode("dart", function(conf) {
     return CodeMirror.getMode(conf, "application/dart");
   }, "clike");
 });

rhodecode/public/js/mode/diff/diff.js

@@ -1,47 +1,47 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("diff", function() {
 
   var TOKEN_NAMES = {
     '+': 'positive',
     '-': 'negative',
     '@': 'meta'
   };
 
   return {
     token: function(stream) {
       var tw_pos = stream.string.search(/[\t ]+?$/);
 
       if (!stream.sol() || tw_pos === 0) {
         stream.skipToEnd();
         return ("error " + (
           TOKEN_NAMES[stream.string.charAt(0)] || '')).replace(/ $/, '');
       }
 
       var token_name = TOKEN_NAMES[stream.peek()] || stream.skipToEnd();
 
       if (tw_pos === -1) {
         stream.skipToEnd();
       } else {
         stream.pos = tw_pos;
       }
 
       return token_name;
     }
   };
 });
 
 CodeMirror.defineMIME("text/x-diff", "diff");
 
 });

rhodecode/public/js/mode/django/django.js

@@ -1,356 +1,356 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 (function(mod) {
   if (typeof exports == "object" && typeof module == "object") // CommonJS
     mod(require("../../lib/codemirror"), require("../htmlmixed/htmlmixed"),
         require("../../addon/mode/overlay"));
   else if (typeof define == "function" && define.amd) // AMD
     define(["../../lib/codemirror", "../htmlmixed/htmlmixed",
             "../../addon/mode/overlay"], mod);
   else // Plain browser env
     mod(CodeMirror);
 })(function(CodeMirror) {
   "use strict";
 
   CodeMirror.defineMode("django:inner", function() {
     var keywords = ["block", "endblock", "for", "endfor", "true", "false", "filter", "endfilter",
                     "loop", "none", "self", "super", "if", "elif", "endif", "as", "else", "import",
                     "with", "endwith", "without", "context", "ifequal", "endifequal", "ifnotequal",
                     "endifnotequal", "extends", "include", "load", "comment", "endcomment",
                     "empty", "url", "static", "trans", "blocktrans", "endblocktrans", "now",
                     "regroup", "lorem", "ifchanged", "endifchanged", "firstof", "debug", "cycle",
                     "csrf_token", "autoescape", "endautoescape", "spaceless", "endspaceless",
                     "ssi", "templatetag", "verbatim", "endverbatim", "widthratio"],
         filters = ["add", "addslashes", "capfirst", "center", "cut", "date",
                    "default", "default_if_none", "dictsort",
                    "dictsortreversed", "divisibleby", "escape", "escapejs",
                    "filesizeformat", "first", "floatformat", "force_escape",
                    "get_digit", "iriencode", "join", "last", "length",
                    "length_is", "linebreaks", "linebreaksbr", "linenumbers",
                    "ljust", "lower", "make_list", "phone2numeric", "pluralize",
                    "pprint", "random", "removetags", "rjust", "safe",
                    "safeseq", "slice", "slugify", "stringformat", "striptags",
                    "time", "timesince", "timeuntil", "title", "truncatechars",
                    "truncatechars_html", "truncatewords", "truncatewords_html",
                    "unordered_list", "upper", "urlencode", "urlize",
                    "urlizetrunc", "wordcount", "wordwrap", "yesno"],
         operators = ["==", "!=", "<", ">", "<=", ">="],
         wordOperators = ["in", "not", "or", "and"];
 
     keywords = new RegExp("^\\b(" + keywords.join("|") + ")\\b");
     filters = new RegExp("^\\b(" + filters.join("|") + ")\\b");
     operators = new RegExp("^\\b(" + operators.join("|") + ")\\b");
     wordOperators = new RegExp("^\\b(" + wordOperators.join("|") + ")\\b");
 
     // We have to return "null" instead of null, in order to avoid string
     // styling as the default, when using Django templates inside HTML
     // element attributes
     function tokenBase (stream, state) {
       // Attempt to identify a variable, template or comment tag respectively
       if (stream.match("{{")) {
         state.tokenize = inVariable;
         return "tag";
       } else if (stream.match("{%")) {
         state.tokenize = inTag;
         return "tag";
       } else if (stream.match("{#")) {
         state.tokenize = inComment;
         return "comment";
       }
 
       // Ignore completely any stream series that do not match the
       // Django template opening tags.
       while (stream.next() != null && !stream.match(/\{[{%#]/, false)) {}
       return null;
     }
 
     // A string can be included in either single or double quotes (this is
-    // the delimeter). Mark everything as a string until the start delimeter
+    // the delimiter). Mark everything as a string until the start delimiter
     // occurs again.
-    function inString (delimeter, previousTokenizer) {
+    function inString (delimiter, previousTokenizer) {
       return function (stream, state) {
-        if (!state.escapeNext && stream.eat(delimeter)) {
+        if (!state.escapeNext && stream.eat(delimiter)) {
           state.tokenize = previousTokenizer;
         } else {
           if (state.escapeNext) {
             state.escapeNext = false;
           }
 
           var ch = stream.next();
 
           // Take into account the backslash for escaping characters, such as
-          // the string delimeter.
+          // the string delimiter.
           if (ch == "\\") {
             state.escapeNext = true;
           }
         }
 
         return "string";
       };
     }
 
     // Apply Django template variable syntax highlighting
     function inVariable (stream, state) {
       // Attempt to match a dot that precedes a property
       if (state.waitDot) {
         state.waitDot = false;
 
         if (stream.peek() != ".") {
           return "null";
         }
 
-        // Dot folowed by a non-word character should be considered an error.
+        // Dot followed by a non-word character should be considered an error.
         if (stream.match(/\.\W+/)) {
           return "error";
         } else if (stream.eat(".")) {
           state.waitProperty = true;
           return "null";
         } else {
           throw Error ("Unexpected error while waiting for property.");
         }
       }
 
       // Attempt to match a pipe that precedes a filter
       if (state.waitPipe) {
         state.waitPipe = false;
 
         if (stream.peek() != "|") {
           return "null";
         }
 
-        // Pipe folowed by a non-word character should be considered an error.
+        // Pipe followed by a non-word character should be considered an error.
         if (stream.match(/\.\W+/)) {
           return "error";
         } else if (stream.eat("|")) {
           state.waitFilter = true;
           return "null";
         } else {
           throw Error ("Unexpected error while waiting for filter.");
         }
       }
 
       // Highlight properties
       if (state.waitProperty) {
         state.waitProperty = false;
         if (stream.match(/\b(\w+)\b/)) {
           state.waitDot = true;  // A property can be followed by another property
           state.waitPipe = true;  // A property can be followed by a filter
           return "property";
         }
       }
 
       // Highlight filters
       if (state.waitFilter) {
           state.waitFilter = false;
         if (stream.match(filters)) {
           return "variable-2";
         }
       }
 
       // Ignore all white spaces
       if (stream.eatSpace()) {
         state.waitProperty = false;
         return "null";
       }
 
       // Identify numbers
       if (stream.match(/\b\d+(\.\d+)?\b/)) {
         return "number";
       }
 
       // Identify strings
       if (stream.match("'")) {
         state.tokenize = inString("'", state.tokenize);
         return "string";
       } else if (stream.match('"')) {
         state.tokenize = inString('"', state.tokenize);
         return "string";
       }
 
       // Attempt to find the variable
       if (stream.match(/\b(\w+)\b/) && !state.foundVariable) {
         state.waitDot = true;
         state.waitPipe = true;  // A property can be followed by a filter
         return "variable";
       }
 
       // If found closing tag reset
       if (stream.match("}}")) {
         state.waitProperty = null;
         state.waitFilter = null;
         state.waitDot = null;
         state.waitPipe = null;
         state.tokenize = tokenBase;
         return "tag";
       }
 
       // If nothing was found, advance to the next character
       stream.next();
       return "null";
     }
 
     function inTag (stream, state) {
       // Attempt to match a dot that precedes a property
       if (state.waitDot) {
         state.waitDot = false;
 
         if (stream.peek() != ".") {
           return "null";
         }
 
-        // Dot folowed by a non-word character should be considered an error.
+        // Dot followed by a non-word character should be considered an error.
         if (stream.match(/\.\W+/)) {
           return "error";
         } else if (stream.eat(".")) {
           state.waitProperty = true;
           return "null";
         } else {
           throw Error ("Unexpected error while waiting for property.");
         }
       }
 
       // Attempt to match a pipe that precedes a filter
       if (state.waitPipe) {
         state.waitPipe = false;
 
         if (stream.peek() != "|") {
           return "null";
         }
 
-        // Pipe folowed by a non-word character should be considered an error.
+        // Pipe followed by a non-word character should be considered an error.
         if (stream.match(/\.\W+/)) {
           return "error";
         } else if (stream.eat("|")) {
           state.waitFilter = true;
           return "null";
         } else {
           throw Error ("Unexpected error while waiting for filter.");
         }
       }
 
       // Highlight properties
       if (state.waitProperty) {
         state.waitProperty = false;
         if (stream.match(/\b(\w+)\b/)) {
           state.waitDot = true;  // A property can be followed by another property
           state.waitPipe = true;  // A property can be followed by a filter
           return "property";
         }
       }
 
       // Highlight filters
       if (state.waitFilter) {
           state.waitFilter = false;
         if (stream.match(filters)) {
           return "variable-2";
         }
       }
 
       // Ignore all white spaces
       if (stream.eatSpace()) {
         state.waitProperty = false;
         return "null";
       }
 
       // Identify numbers
       if (stream.match(/\b\d+(\.\d+)?\b/)) {
         return "number";
       }
 
       // Identify strings
       if (stream.match("'")) {
         state.tokenize = inString("'", state.tokenize);
         return "string";
       } else if (stream.match('"')) {
         state.tokenize = inString('"', state.tokenize);
         return "string";
       }
 
       // Attempt to match an operator
       if (stream.match(operators)) {
         return "operator";
       }
 
       // Attempt to match a word operator
       if (stream.match(wordOperators)) {
         return "keyword";
       }
 
       // Attempt to match a keyword
       var keywordMatch = stream.match(keywords);
       if (keywordMatch) {
         if (keywordMatch[0] == "comment") {
           state.blockCommentTag = true;
         }
         return "keyword";
       }
 
       // Attempt to match a variable
       if (stream.match(/\b(\w+)\b/)) {
         state.waitDot = true;
         state.waitPipe = true;  // A property can be followed by a filter
         return "variable";
       }
 
       // If found closing tag reset
       if (stream.match("%}")) {
         state.waitProperty = null;
         state.waitFilter = null;
         state.waitDot = null;
         state.waitPipe = null;
         // If the tag that closes is a block comment tag, we want to mark the
         // following code as comment, until the tag closes.
         if (state.blockCommentTag) {
           state.blockCommentTag = false;  // Release the "lock"
           state.tokenize = inBlockComment;
         } else {
           state.tokenize = tokenBase;
         }
         return "tag";
       }
 
       // If nothing was found, advance to the next character
       stream.next();
       return "null";
     }
 
     // Mark everything as comment inside the tag and the tag itself.
     function inComment (stream, state) {
       if (stream.match(/^.*?#\}/)) state.tokenize = tokenBase
       else stream.skipToEnd()
       return "comment";
     }
 
     // Mark everything as a comment until the `blockcomment` tag closes.
     function inBlockComment (stream, state) {
       if (stream.match(/\{%\s*endcomment\s*%\}/, false)) {
         state.tokenize = inTag;
         stream.match("{%");
         return "tag";
       } else {
         stream.next();
         return "comment";
       }
     }
 
     return {
       startState: function () {
         return {tokenize: tokenBase};
       },
       token: function (stream, state) {
         return state.tokenize(stream, state);
       },
       blockCommentStart: "{% comment %}",
       blockCommentEnd: "{% endcomment %}"
     };
   });
 
   CodeMirror.defineMode("django", function(config) {
     var htmlBase = CodeMirror.getMode(config, "text/html");
     var djangoInner = CodeMirror.getMode(config, "django:inner");
     return CodeMirror.overlayMode(htmlBase, djangoInner);
   });
 
   CodeMirror.defineMIME("text/x-django", "django");
 });

rhodecode/public/js/mode/dockerfile/dockerfile.js

@@ -1,79 +1,211 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 (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";
 
+  var from = "from";
+  var fromRegex = new RegExp("^(\\s*)\\b(" + from + ")\\b", "i");
+
+  var shells = ["run", "cmd", "entrypoint", "shell"];
+  var shellsAsArrayRegex = new RegExp("^(\\s*)(" + shells.join('|') + ")(\\s+\\[)", "i");
+
+  var expose = "expose";
+  var exposeRegex = new RegExp("^(\\s*)(" + expose + ")(\\s+)", "i");
+
+  var others = [
+    "arg", "from", "maintainer", "label", "env",
+    "add", "copy", "volume", "user",
+    "workdir", "onbuild", "stopsignal", "healthcheck", "shell"
+  ];
+
   // Collect all Dockerfile directives
-  var instructions = ["from", "maintainer", "run", "cmd", "expose", "env",
-                      "add", "copy", "entrypoint", "volume", "user",
-                      "workdir", "onbuild"],
+  var instructions = [from, expose].concat(shells).concat(others),
       instructionRegex = "(" + instructions.join('|') + ")",
-      instructionOnlyLine = new RegExp(instructionRegex + "\\s*$", "i"),
-      instructionWithArguments = new RegExp(instructionRegex + "(\\s+)", "i");
+      instructionOnlyLine = new RegExp("^(\\s*)" + instructionRegex + "(\\s*)(#.*)?$", "i"),
+      instructionWithArguments = new RegExp("^(\\s*)" + instructionRegex + "(\\s+)", "i");
 
   CodeMirror.defineSimpleMode("dockerfile", {
     start: [
       // Block comment: This is a line starting with a comment
       {
-        regex: /#.*$/,
+        regex: /^\s*#.*$/,
+        sol: true,
         token: "comment"
       },
+      {
+        regex: fromRegex,
+        token: [null, "keyword"],
+        sol: true,
+        next: "from"
+      },
       // Highlight an instruction without any arguments (for convenience)
       {
         regex: instructionOnlyLine,
-        token: "variable-2"
+        token: [null, "keyword", null, "error"],
+        sol: true
+      },
+      {
+        regex: shellsAsArrayRegex,
+        token: [null, "keyword", null],
+        sol: true,
+        next: "array"
+      },
+      {
+        regex: exposeRegex,
+        token: [null, "keyword", null],
+        sol: true,
+        next: "expose"
       },
       // Highlight an instruction followed by arguments
       {
         regex: instructionWithArguments,
-        token: ["variable-2", null],
+        token: [null, "keyword", null],
+        sol: true,
         next: "arguments"
       },
       {
         regex: /./,
         token: null
       }
     ],
-    arguments: [
+    from: [
       {
-        // Line comment without instruction arguments is an error
-        regex: /#.*$/,
-        token: "error",
-        next: "start"
-      },
-      {
-        regex: /[^#]+\\$/,
-        token: null
-      },
-      {
-        // Match everything except for the inline comment
-        regex: /[^#]+/,
+        regex: /\s*$/,
         token: null,
         next: "start"
       },
       {
-        regex: /$/,
-        token: null,
+        // Line comment without instruction arguments is an error
+        regex: /(\s*)(#.*)$/,
+        token: [null, "error"],
+        next: "start"
+      },
+      {
+        regex: /(\s*\S+\s+)(as)/i,
+        token: [null, "keyword"],
         next: "start"
       },
       // Fail safe return to start
       {
         token: null,
         next: "start"
       }
     ],
-      meta: {
-          lineComment: "#"
+    single: [
+      {
+        regex: /(?:[^\\']|\\.)/,
+        token: "string"
+      },
+      {
+        regex: /'/,
+        token: "string",
+        pop: true
+      }
+    ],
+    double: [
+      {
+        regex: /(?:[^\\"]|\\.)/,
+        token: "string"
+      },
+      {
+        regex: /"/,
+        token: "string",
+        pop: true
+      }
+    ],
+    array: [
+      {
+        regex: /\]/,
+        token: null,
+        next: "start"
+      },
+      {
+        regex: /"(?:[^\\"]|\\.)*"?/,
+        token: "string"
       }
+    ],
+    expose: [
+      {
+        regex: /\d+$/,
+        token: "number",
+        next: "start"
+      },
+      {
+        regex: /[^\d]+$/,
+        token: null,
+        next: "start"
+      },
+      {
+        regex: /\d+/,
+        token: "number"
+      },
+      {
+        regex: /[^\d]+/,
+        token: null
+      },
+      // Fail safe return to start
+      {
+        token: null,
+        next: "start"
+      }
+    ],
+    arguments: [
+      {
+        regex: /^\s*#.*$/,
+        sol: true,
+        token: "comment"
+      },
+      {
+        regex: /"(?:[^\\"]|\\.)*"?$/,
+        token: "string",
+        next: "start"
+      },
+      {
+        regex: /"/,
+        token: "string",
+        push: "double"
+      },
+      {
+        regex: /'(?:[^\\']|\\.)*'?$/,
+        token: "string",
+        next: "start"
+      },
+      {
+        regex: /'/,
+        token: "string",
+        push: "single"
+      },
+      {
+        regex: /[^#"']+[\\`]$/,
+        token: null
+      },
+      {
+        regex: /[^#"']+$/,
+        token: null,
+        next: "start"
+      },
+      {
+        regex: /[^#"']+/,
+        token: null
+      },
+      // Fail safe return to start
+      {
+        token: null,
+        next: "start"
+      }
+    ],
+    meta: {
+      lineComment: "#"
+    }
   });
 
   CodeMirror.defineMIME("text/x-dockerfile", "dockerfile");
 });

rhodecode/public/js/mode/dtd/dtd.js

@@ -1,142 +1,142 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 /*
   DTD mode
   Ported to CodeMirror by Peter Kroon <[e-mail]>
   Report bugs/issues here: https://github.com/codemirror/CodeMirror/issues
   GitHub: @peterkroon
 */
 
 (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("dtd", function(config) {
   var indentUnit = config.indentUnit, type;
   function ret(style, tp) {type = tp; return style;}
 
   function tokenBase(stream, state) {
     var ch = stream.next();
 
     if (ch == "<" && stream.eat("!") ) {
       if (stream.eatWhile(/[\-]/)) {
         state.tokenize = tokenSGMLComment;
         return tokenSGMLComment(stream, state);
       } else if (stream.eatWhile(/[\w]/)) return ret("keyword", "doindent");
     } else if (ch == "<" && stream.eat("?")) { //xml declaration
       state.tokenize = inBlock("meta", "?>");
       return ret("meta", ch);
     } else if (ch == "#" && stream.eatWhile(/[\w]/)) return ret("atom", "tag");
     else if (ch == "|") return ret("keyword", "seperator");
     else if (ch.match(/[\(\)\[\]\-\.,\+\?>]/)) return ret(null, ch);//if(ch === ">") return ret(null, "endtag"); else
     else if (ch.match(/[\[\]]/)) return ret("rule", ch);
     else if (ch == "\"" || ch == "'") {
       state.tokenize = tokenString(ch);
       return state.tokenize(stream, state);
     } else if (stream.eatWhile(/[a-zA-Z\?\+\d]/)) {
       var sc = stream.current();
       if( sc.substr(sc.length-1,sc.length).match(/\?|\+/) !== null )stream.backUp(1);
       return ret("tag", "tag");
     } else if (ch == "%" || ch == "*" ) return ret("number", "number");
     else {
       stream.eatWhile(/[\w\\\-_%.{,]/);
       return ret(null, null);
     }
   }
 
   function tokenSGMLComment(stream, state) {
     var dashes = 0, ch;
     while ((ch = stream.next()) != null) {
       if (dashes >= 2 && ch == ">") {
         state.tokenize = tokenBase;
         break;
       }
       dashes = (ch == "-") ? dashes + 1 : 0;
     }
     return ret("comment", "comment");
   }
 
   function tokenString(quote) {
     return function(stream, state) {
       var escaped = false, ch;
       while ((ch = stream.next()) != null) {
         if (ch == quote && !escaped) {
           state.tokenize = tokenBase;
           break;
         }
         escaped = !escaped && ch == "\\";
       }
       return ret("string", "tag");
     };
   }
 
   function inBlock(style, terminator) {
     return function(stream, state) {
       while (!stream.eol()) {
         if (stream.match(terminator)) {
           state.tokenize = tokenBase;
           break;
         }
         stream.next();
       }
       return style;
     };
   }
 
   return {
     startState: function(base) {
       return {tokenize: tokenBase,
               baseIndent: base || 0,
               stack: []};
     },
 
     token: function(stream, state) {
       if (stream.eatSpace()) return null;
       var style = state.tokenize(stream, state);
 
       var context = state.stack[state.stack.length-1];
       if (stream.current() == "[" || type === "doindent" || type == "[") state.stack.push("rule");
       else if (type === "endtag") state.stack[state.stack.length-1] = "endtag";
       else if (stream.current() == "]" || type == "]" || (type == ">" && context == "rule")) state.stack.pop();
       else if (type == "[") state.stack.push("[");
       return style;
     },
 
     indent: function(state, textAfter) {
       var n = state.stack.length;
 
       if( textAfter.match(/\]\s+|\]/) )n=n-1;
       else if(textAfter.substr(textAfter.length-1, textAfter.length) === ">"){
-        if(textAfter.substr(0,1) === "<")n;
-        else if( type == "doindent" && textAfter.length > 1 )n;
+        if(textAfter.substr(0,1) === "<") {}
+        else if( type == "doindent" && textAfter.length > 1 ) {}
         else if( type == "doindent")n--;
-        else if( type == ">" && textAfter.length > 1)n;
-        else if( type == "tag" && textAfter !== ">")n;
+        else if( type == ">" && textAfter.length > 1) {}
+        else if( type == "tag" && textAfter !== ">") {}
         else if( type == "tag" && state.stack[state.stack.length-1] == "rule")n--;
         else if( type == "tag")n++;
         else if( textAfter === ">" && state.stack[state.stack.length-1] == "rule" && type === ">")n--;
-        else if( textAfter === ">" && state.stack[state.stack.length-1] == "rule")n;
+        else if( textAfter === ">" && state.stack[state.stack.length-1] == "rule") {}
         else if( textAfter.substr(0,1) !== "<" && textAfter.substr(0,1) === ">" )n=n-1;
-        else if( textAfter === ">")n;
+        else if( textAfter === ">") {}
         else n=n-1;
         //over rule them all
         if(type == null || type == "]")n--;
       }
 
       return state.baseIndent + n * indentUnit;
     },
 
     electricChars: "]>"
   };
 });
 
 CodeMirror.defineMIME("application/xml-dtd", "dtd");
 
 });

rhodecode/public/js/mode/dylan/dylan.js

@@ -1,291 +1,352 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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";
 
+function forEach(arr, f) {
+  for (var i = 0; i < arr.length; i++) f(arr[i], i)
+}
+function some(arr, f) {
+  for (var i = 0; i < arr.length; i++) if (f(arr[i], i)) return true
+  return false
+}
+
 CodeMirror.defineMode("dylan", function(_config) {
   // Words
   var words = {
     // Words that introduce unnamed definitions like "define interface"
     unnamedDefinition: ["interface"],
 
     // Words that introduce simple named definitions like "define library"
     namedDefinition: ["module", "library", "macro",
                       "C-struct", "C-union",
                       "C-function", "C-callable-wrapper"
                      ],
 
     // Words that introduce type definitions like "define class".
     // These are also parameterized like "define method" and are
     // appended to otherParameterizedDefinitionWords
     typeParameterizedDefinition: ["class", "C-subtype", "C-mapped-subtype"],
 
     // Words that introduce trickier definitions like "define method".
     // These require special definitions to be added to startExpressions
     otherParameterizedDefinition: ["method", "function",
                                    "C-variable", "C-address"
                                   ],
 
     // Words that introduce module constant definitions.
     // These must also be simple definitions and are
     // appended to otherSimpleDefinitionWords
     constantSimpleDefinition: ["constant"],
 
     // Words that introduce module variable definitions.
     // These must also be simple definitions and are
     // appended to otherSimpleDefinitionWords
     variableSimpleDefinition: ["variable"],
 
     // Other words that introduce simple definitions
     // (without implicit bodies).
     otherSimpleDefinition: ["generic", "domain",
                             "C-pointer-type",
                             "table"
                            ],
 
     // Words that begin statements with implicit bodies.
     statement: ["if", "block", "begin", "method", "case",
                 "for", "select", "when", "unless", "until",
                 "while", "iterate", "profiling", "dynamic-bind"
                ],
 
     // Patterns that act as separators in compound statements.
     // This may include any general pattern that must be indented
     // specially.
     separator: ["finally", "exception", "cleanup", "else",
                 "elseif", "afterwards"
                ],
 
     // Keywords that do not require special indentation handling,
     // but which should be highlighted
     other: ["above", "below", "by", "from", "handler", "in",
             "instance", "let", "local", "otherwise", "slot",
             "subclass", "then", "to", "keyed-by", "virtual"
            ],
 
     // Condition signaling function calls
     signalingCalls: ["signal", "error", "cerror",
                      "break", "check-type", "abort"
                     ]
   };
 
   words["otherDefinition"] =
     words["unnamedDefinition"]
     .concat(words["namedDefinition"])
     .concat(words["otherParameterizedDefinition"]);
 
   words["definition"] =
     words["typeParameterizedDefinition"]
     .concat(words["otherDefinition"]);
 
   words["parameterizedDefinition"] =
     words["typeParameterizedDefinition"]
     .concat(words["otherParameterizedDefinition"]);
 
   words["simpleDefinition"] =
     words["constantSimpleDefinition"]
     .concat(words["variableSimpleDefinition"])
     .concat(words["otherSimpleDefinition"]);
 
   words["keyword"] =
     words["statement"]
     .concat(words["separator"])
     .concat(words["other"]);
 
   // Patterns
   var symbolPattern = "[-_a-zA-Z?!*@<>$%]+";
   var symbol = new RegExp("^" + symbolPattern);
   var patterns = {
     // Symbols with special syntax
     symbolKeyword: symbolPattern + ":",
     symbolClass: "<" + symbolPattern + ">",
     symbolGlobal: "\\*" + symbolPattern + "\\*",
     symbolConstant: "\\$" + symbolPattern
   };
   var patternStyles = {
     symbolKeyword: "atom",
     symbolClass: "tag",
     symbolGlobal: "variable-2",
     symbolConstant: "variable-3"
   };
 
   // Compile all patterns to regular expressions
   for (var patternName in patterns)
     if (patterns.hasOwnProperty(patternName))
       patterns[patternName] = new RegExp("^" + patterns[patternName]);
 
   // Names beginning "with-" and "without-" are commonly
   // used as statement macro
   patterns["keyword"] = [/^with(?:out)?-[-_a-zA-Z?!*@<>$%]+/];
 
   var styles = {};
   styles["keyword"] = "keyword";
   styles["definition"] = "def";
   styles["simpleDefinition"] = "def";
   styles["signalingCalls"] = "builtin";
 
   // protected words lookup table
   var wordLookup = {};
   var styleLookup = {};
 
-  [
+  forEach([
     "keyword",
     "definition",
     "simpleDefinition",
     "signalingCalls"
-  ].forEach(function(type) {
-    words[type].forEach(function(word) {
+  ], function(type) {
+    forEach(words[type], function(word) {
       wordLookup[word] = type;
       styleLookup[word] = styles[type];
     });
   });
 
 
   function chain(stream, state, f) {
     state.tokenize = f;
     return f(stream, state);
   }
 
   function tokenBase(stream, state) {
     // String
     var ch = stream.peek();
     if (ch == "'" || ch == '"') {
       stream.next();
       return chain(stream, state, tokenString(ch, "string"));
     }
     // Comment
     else if (ch == "/") {
       stream.next();
       if (stream.eat("*")) {
         return chain(stream, state, tokenComment);
       } else if (stream.eat("/")) {
         stream.skipToEnd();
         return "comment";
-      } else {
-        stream.skipTo(" ");
-        return "operator";
       }
+      stream.backUp(1);
     }
     // Decimal
-    else if (/\d/.test(ch)) {
-      stream.match(/^\d*(?:\.\d*)?(?:e[+\-]?\d+)?/);
-      return "number";
+    else if (/[+\-\d\.]/.test(ch)) {
+      if (stream.match(/^[+-]?[0-9]*\.[0-9]*([esdx][+-]?[0-9]+)?/i) ||
+          stream.match(/^[+-]?[0-9]+([esdx][+-]?[0-9]+)/i) ||
+          stream.match(/^[+-]?\d+/)) {
+        return "number";
+      }
     }
     // Hash
     else if (ch == "#") {
       stream.next();
       // Symbol with string syntax
       ch = stream.peek();
       if (ch == '"') {
         stream.next();
-        return chain(stream, state, tokenString('"', "string-2"));
+        return chain(stream, state, tokenString('"', "string"));
       }
       // Binary number
       else if (ch == "b") {
         stream.next();
         stream.eatWhile(/[01]/);
         return "number";
       }
       // Hex number
       else if (ch == "x") {
         stream.next();
         stream.eatWhile(/[\da-f]/i);
         return "number";
       }
       // Octal number
       else if (ch == "o") {
         stream.next();
         stream.eatWhile(/[0-7]/);
         return "number";
       }
+      // Token concatenation in macros
+      else if (ch == '#') {
+        stream.next();
+        return "punctuation";
+      }
+      // Sequence literals
+      else if ((ch == '[') || (ch == '(')) {
+        stream.next();
+        return "bracket";
       // Hash symbol
-      else {
+      } else if (stream.match(/f|t|all-keys|include|key|next|rest/i)) {
+        return "atom";
+      } else {
         stream.eatWhile(/[-a-zA-Z]/);
-        return "keyword";
+        return "error";
+      }
+    } else if (ch == "~") {
+      stream.next();
+      ch = stream.peek();
+      if (ch == "=") {
+        stream.next();
+        ch = stream.peek();
+        if (ch == "=") {
+          stream.next();
+          return "operator";
+        }
+        return "operator";
       }
+      return "operator";
+    } else if (ch == ":") {
+      stream.next();
+      ch = stream.peek();
+      if (ch == "=") {
+        stream.next();
+        return "operator";
+      } else if (ch == ":") {
+        stream.next();
+        return "punctuation";
+      }
+    } else if ("[](){}".indexOf(ch) != -1) {
+      stream.next();
+      return "bracket";
+    } else if (".,".indexOf(ch) != -1) {
+      stream.next();
+      return "punctuation";
     } else if (stream.match("end")) {
       return "keyword";
     }
     for (var name in patterns) {
       if (patterns.hasOwnProperty(name)) {
         var pattern = patterns[name];
-        if ((pattern instanceof Array && pattern.some(function(p) {
+        if ((pattern instanceof Array && some(pattern, function(p) {
           return stream.match(p);
         })) || stream.match(pattern))
           return patternStyles[name];
       }
     }
+    if (/[+\-*\/^=<>&|]/.test(ch)) {
+      stream.next();
+      return "operator";
+    }
     if (stream.match("define")) {
       return "def";
     } else {
       stream.eatWhile(/[\w\-]/);
       // Keyword
-      if (wordLookup[stream.current()]) {
+      if (wordLookup.hasOwnProperty(stream.current())) {
         return styleLookup[stream.current()];
       } else if (stream.current().match(symbol)) {
         return "variable";
       } else {
         stream.next();
         return "variable-2";
       }
     }
   }
 
   function tokenComment(stream, state) {
-    var maybeEnd = false,
-    ch;
+    var maybeEnd = false, maybeNested = false, nestedCount = 0, ch;
     while ((ch = stream.next())) {
       if (ch == "/" && maybeEnd) {
-        state.tokenize = tokenBase;
-        break;
+        if (nestedCount > 0) {
+          nestedCount--;
+        } else {
+          state.tokenize = tokenBase;
+          break;
+        }
+      } else if (ch == "*" && maybeNested) {
+        nestedCount++;
       }
       maybeEnd = (ch == "*");
+      maybeNested = (ch == "/");
     }
     return "comment";
   }
 
   function tokenString(quote, style) {
     return function(stream, state) {
-      var next, end = false;
+      var escaped = false, next, end = false;
       while ((next = stream.next()) != null) {
-        if (next == quote) {
+        if (next == quote && !escaped) {
           end = true;
           break;
         }
+        escaped = !escaped && next == "\\";
       }
-      if (end)
+      if (end || !escaped) {
         state.tokenize = tokenBase;
+      }
       return style;
     };
   }
 
   // Interface
   return {
     startState: function() {
       return {
         tokenize: tokenBase,
         currentIndent: 0
       };
     },
     token: function(stream, state) {
       if (stream.eatSpace())
         return null;
       var style = state.tokenize(stream, state);
       return style;
     },
     blockCommentStart: "/*",
     blockCommentEnd: "*/"
   };
 });
 
 CodeMirror.defineMIME("text/x-dylan", "dylan");
 
 });

rhodecode/public/js/mode/ebnf/ebnf.js

@@ -1,195 +1,195 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("ebnf", function (config) {
     var commentType = {slash: 0, parenthesis: 1};
     var stateType = {comment: 0, _string: 1, characterClass: 2};
     var bracesMode = null;
 
     if (config.bracesMode)
       bracesMode = CodeMirror.getMode(config, config.bracesMode);
 
     return {
       startState: function () {
         return {
           stringType: null,
           commentType: null,
           braced: 0,
           lhs: true,
           localState: null,
           stack: [],
           inDefinition: false
         };
       },
       token: function (stream, state) {
         if (!stream) return;
 
         //check for state changes
         if (state.stack.length === 0) {
           //strings
           if ((stream.peek() == '"') || (stream.peek() == "'")) {
             state.stringType = stream.peek();
             stream.next(); // Skip quote
             state.stack.unshift(stateType._string);
           } else if (stream.match(/^\/\*/)) { //comments starting with /*
             state.stack.unshift(stateType.comment);
             state.commentType = commentType.slash;
           } else if (stream.match(/^\(\*/)) { //comments starting with (*
             state.stack.unshift(stateType.comment);
             state.commentType = commentType.parenthesis;
           }
         }
 
         //return state
         //stack has
         switch (state.stack[0]) {
         case stateType._string:
           while (state.stack[0] === stateType._string && !stream.eol()) {
             if (stream.peek() === state.stringType) {
               stream.next(); // Skip quote
               state.stack.shift(); // Clear flag
             } else if (stream.peek() === "\\") {
               stream.next();
               stream.next();
             } else {
               stream.match(/^.[^\\\"\']*/);
             }
           }
           return state.lhs ? "property string" : "string"; // Token style
 
         case stateType.comment:
           while (state.stack[0] === stateType.comment && !stream.eol()) {
             if (state.commentType === commentType.slash && stream.match(/\*\//)) {
               state.stack.shift(); // Clear flag
               state.commentType = null;
             } else if (state.commentType === commentType.parenthesis && stream.match(/\*\)/)) {
               state.stack.shift(); // Clear flag
               state.commentType = null;
             } else {
               stream.match(/^.[^\*]*/);
             }
           }
           return "comment";
 
         case stateType.characterClass:
           while (state.stack[0] === stateType.characterClass && !stream.eol()) {
             if (!(stream.match(/^[^\]\\]+/) || stream.match(/^\\./))) {
               state.stack.shift();
             }
           }
           return "operator";
         }
 
         var peek = stream.peek();
 
         if (bracesMode !== null && (state.braced || peek === "{")) {
           if (state.localState === null)
-            state.localState = bracesMode.startState();
+            state.localState = CodeMirror.startState(bracesMode);
 
           var token = bracesMode.token(stream, state.localState),
           text = stream.current();
 
           if (!token) {
             for (var i = 0; i < text.length; i++) {
               if (text[i] === "{") {
                 if (state.braced === 0) {
                   token = "matchingbracket";
                 }
                 state.braced++;
               } else if (text[i] === "}") {
                 state.braced--;
                 if (state.braced === 0) {
                   token = "matchingbracket";
                 }
               }
             }
           }
           return token;
         }
 
         //no stack
         switch (peek) {
         case "[":
           stream.next();
           state.stack.unshift(stateType.characterClass);
           return "bracket";
         case ":":
         case "|":
         case ";":
           stream.next();
           return "operator";
         case "%":
           if (stream.match("%%")) {
             return "header";
           } else if (stream.match(/[%][A-Za-z]+/)) {
             return "keyword";
           } else if (stream.match(/[%][}]/)) {
             return "matchingbracket";
           }
           break;
         case "/":
           if (stream.match(/[\/][A-Za-z]+/)) {
           return "keyword";
         }
         case "\\":
           if (stream.match(/[\][a-z]+/)) {
             return "string-2";
           }
         case ".":
           if (stream.match(".")) {
             return "atom";
           }
         case "*":
         case "-":
         case "+":
         case "^":
           if (stream.match(peek)) {
             return "atom";
           }
         case "$":
           if (stream.match("$$")) {
             return "builtin";
           } else if (stream.match(/[$][0-9]+/)) {
             return "variable-3";
           }
         case "<":
           if (stream.match(/<<[a-zA-Z_]+>>/)) {
             return "builtin";
           }
         }
 
         if (stream.match(/^\/\//)) {
           stream.skipToEnd();
           return "comment";
         } else if (stream.match(/return/)) {
           return "operator";
         } else if (stream.match(/^[a-zA-Z_][a-zA-Z0-9_]*/)) {
           if (stream.match(/(?=[\(.])/)) {
             return "variable";
           } else if (stream.match(/(?=[\s\n]*[:=])/)) {
             return "def";
           }
           return "variable-2";
         } else if (["[", "]", "(", ")"].indexOf(stream.peek()) != -1) {
           stream.next();
           return "bracket";
         } else if (!stream.eatSpace()) {
           stream.next();
         }
         return null;
       }
     };
   });
 
   CodeMirror.defineMIME("text/x-ebnf", "ebnf");
 });

rhodecode/public/js/mode/ecl/ecl.js

@@ -1,206 +1,206 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("ecl", function(config) {
 
   function words(str) {
     var obj = {}, words = str.split(" ");
     for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
     return obj;
   }
 
   function metaHook(stream, state) {
     if (!state.startOfLine) return false;
     stream.skipToEnd();
     return "meta";
   }
 
   var indentUnit = config.indentUnit;
   var keyword = words("abs acos allnodes ascii asin asstring atan atan2 ave case choose choosen choosesets clustersize combine correlation cos cosh count covariance cron dataset dedup define denormalize distribute distributed distribution ebcdic enth error evaluate event eventextra eventname exists exp failcode failmessage fetch fromunicode getisvalid global graph group hash hash32 hash64 hashcrc hashmd5 having if index intformat isvalid iterate join keyunicode length library limit ln local log loop map matched matchlength matchposition matchtext matchunicode max merge mergejoin min nolocal nonempty normalize parse pipe power preload process project pull random range rank ranked realformat recordof regexfind regexreplace regroup rejected rollup round roundup row rowdiff sample set sin sinh sizeof soapcall sort sorted sqrt stepped stored sum table tan tanh thisnode topn tounicode transfer trim truncate typeof ungroup unicodeorder variance which workunit xmldecode xmlencode xmltext xmlunicode");
   var variable = words("apply assert build buildindex evaluate fail keydiff keypatch loadxml nothor notify output parallel sequential soapcall wait");
   var variable_2 = words("__compressed__ all and any as atmost before beginc++ best between case const counter csv descend encrypt end endc++ endmacro except exclusive expire export extend false few first flat from full function group header heading hole ifblock import in interface joined keep keyed last left limit load local locale lookup macro many maxcount maxlength min skew module named nocase noroot noscan nosort not of only opt or outer overwrite packed partition penalty physicallength pipe quote record relationship repeat return right scan self separator service shared skew skip sql store terminator thor threshold token transform trim true type unicodeorder unsorted validate virtual whole wild within xml xpath");
   var variable_3 = words("ascii big_endian boolean data decimal ebcdic integer pattern qstring real record rule set of string token udecimal unicode unsigned varstring varunicode");
   var builtin = words("checkpoint deprecated failcode failmessage failure global independent onwarning persist priority recovery stored success wait when");
   var blockKeywords = words("catch class do else finally for if switch try while");
   var atoms = words("true false null");
   var hooks = {"#": metaHook};
   var isOperatorChar = /[+\-*&%=<>!?|\/]/;
 
   var curPunc;
 
   function tokenBase(stream, state) {
     var ch = stream.next();
     if (hooks[ch]) {
       var result = hooks[ch](stream, state);
       if (result !== false) return result;
     }
     if (ch == '"' || ch == "'") {
       state.tokenize = tokenString(ch);
       return state.tokenize(stream, state);
     }
     if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
       curPunc = ch;
       return null;
     }
     if (/\d/.test(ch)) {
       stream.eatWhile(/[\w\.]/);
       return "number";
     }
     if (ch == "/") {
       if (stream.eat("*")) {
         state.tokenize = tokenComment;
         return tokenComment(stream, state);
       }
       if (stream.eat("/")) {
         stream.skipToEnd();
         return "comment";
       }
     }
     if (isOperatorChar.test(ch)) {
       stream.eatWhile(isOperatorChar);
       return "operator";
     }
     stream.eatWhile(/[\w\$_]/);
     var cur = stream.current().toLowerCase();
     if (keyword.propertyIsEnumerable(cur)) {
       if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
       return "keyword";
     } else if (variable.propertyIsEnumerable(cur)) {
       if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
       return "variable";
     } else if (variable_2.propertyIsEnumerable(cur)) {
       if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
       return "variable-2";
     } else if (variable_3.propertyIsEnumerable(cur)) {
       if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
       return "variable-3";
     } else if (builtin.propertyIsEnumerable(cur)) {
       if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
       return "builtin";
     } else { //Data types are of from KEYWORD##
                 var i = cur.length - 1;
                 while(i >= 0 && (!isNaN(cur[i]) || cur[i] == '_'))
                         --i;
 
                 if (i > 0) {
                         var cur2 = cur.substr(0, i + 1);
                 if (variable_3.propertyIsEnumerable(cur2)) {
                         if (blockKeywords.propertyIsEnumerable(cur2)) curPunc = "newstatement";
                         return "variable-3";
                 }
             }
     }
     if (atoms.propertyIsEnumerable(cur)) return "atom";
     return null;
   }
 
   function tokenString(quote) {
     return function(stream, state) {
       var escaped = false, next, end = false;
       while ((next = stream.next()) != null) {
         if (next == quote && !escaped) {end = true; break;}
         escaped = !escaped && next == "\\";
       }
       if (end || !escaped)
         state.tokenize = tokenBase;
       return "string";
     };
   }
 
   function tokenComment(stream, state) {
     var maybeEnd = false, ch;
     while (ch = stream.next()) {
       if (ch == "/" && maybeEnd) {
         state.tokenize = tokenBase;
         break;
       }
       maybeEnd = (ch == "*");
     }
     return "comment";
   }
 
   function Context(indented, column, type, align, prev) {
     this.indented = indented;
     this.column = column;
     this.type = type;
     this.align = align;
     this.prev = prev;
   }
   function pushContext(state, col, type) {
     return state.context = new Context(state.indented, col, type, null, state.context);
   }
   function popContext(state) {
     var t = state.context.type;
     if (t == ")" || t == "]" || t == "}")
       state.indented = state.context.indented;
     return state.context = state.context.prev;
   }
 
   // Interface
 
   return {
     startState: function(basecolumn) {
       return {
         tokenize: null,
         context: new Context((basecolumn || 0) - indentUnit, 0, "top", false),
         indented: 0,
         startOfLine: true
       };
     },
 
     token: function(stream, state) {
       var ctx = state.context;
       if (stream.sol()) {
         if (ctx.align == null) ctx.align = false;
         state.indented = stream.indentation();
         state.startOfLine = true;
       }
       if (stream.eatSpace()) return null;
       curPunc = null;
       var style = (state.tokenize || tokenBase)(stream, state);
       if (style == "comment" || style == "meta") return style;
       if (ctx.align == null) ctx.align = true;
 
       if ((curPunc == ";" || curPunc == ":") && ctx.type == "statement") popContext(state);
       else if (curPunc == "{") pushContext(state, stream.column(), "}");
       else if (curPunc == "[") pushContext(state, stream.column(), "]");
       else if (curPunc == "(") pushContext(state, stream.column(), ")");
       else if (curPunc == "}") {
         while (ctx.type == "statement") ctx = popContext(state);
         if (ctx.type == "}") ctx = popContext(state);
         while (ctx.type == "statement") ctx = popContext(state);
       }
       else if (curPunc == ctx.type) popContext(state);
       else if (ctx.type == "}" || ctx.type == "top" || (ctx.type == "statement" && curPunc == "newstatement"))
         pushContext(state, stream.column(), "statement");
       state.startOfLine = false;
       return style;
     },
 
     indent: function(state, textAfter) {
       if (state.tokenize != tokenBase && state.tokenize != null) return 0;
       var ctx = state.context, firstChar = textAfter && textAfter.charAt(0);
       if (ctx.type == "statement" && firstChar == "}") ctx = ctx.prev;
       var closing = firstChar == ctx.type;
       if (ctx.type == "statement") return ctx.indented + (firstChar == "{" ? 0 : indentUnit);
       else if (ctx.align) return ctx.column + (closing ? 0 : 1);
       else return ctx.indented + (closing ? 0 : indentUnit);
     },
 
     electricChars: "{}"
   };
 });
 
 CodeMirror.defineMIME("text/x-ecl", "ecl");
 
 });

rhodecode/public/js/mode/eiffel/eiffel.js

@@ -1,160 +1,160 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("eiffel", function() {
   function wordObj(words) {
     var o = {};
     for (var i = 0, e = words.length; i < e; ++i) o[words[i]] = true;
     return o;
   }
   var keywords = wordObj([
     'note',
     'across',
     'when',
     'variant',
     'until',
     'unique',
     'undefine',
     'then',
     'strip',
     'select',
     'retry',
     'rescue',
     'require',
     'rename',
     'reference',
     'redefine',
     'prefix',
     'once',
     'old',
     'obsolete',
     'loop',
     'local',
     'like',
     'is',
     'inspect',
     'infix',
     'include',
     'if',
     'frozen',
     'from',
     'external',
     'export',
     'ensure',
     'end',
     'elseif',
     'else',
     'do',
     'creation',
     'create',
     'check',
     'alias',
     'agent',
     'separate',
     'invariant',
     'inherit',
     'indexing',
     'feature',
     'expanded',
     'deferred',
     'class',
     'Void',
     'True',
     'Result',
     'Precursor',
     'False',
     'Current',
     'create',
     'attached',
     'detachable',
     'as',
     'and',
     'implies',
     'not',
     'or'
   ]);
   var operators = wordObj([":=", "and then","and", "or","<<",">>"]);
 
   function chain(newtok, stream, state) {
     state.tokenize.push(newtok);
     return newtok(stream, state);
   }
 
   function tokenBase(stream, state) {
     if (stream.eatSpace()) return null;
     var ch = stream.next();
     if (ch == '"'||ch == "'") {
       return chain(readQuoted(ch, "string"), stream, state);
     } else if (ch == "-"&&stream.eat("-")) {
       stream.skipToEnd();
       return "comment";
     } else if (ch == ":"&&stream.eat("=")) {
       return "operator";
     } else if (/[0-9]/.test(ch)) {
       stream.eatWhile(/[xXbBCc0-9\.]/);
       stream.eat(/[\?\!]/);
       return "ident";
     } else if (/[a-zA-Z_0-9]/.test(ch)) {
       stream.eatWhile(/[a-zA-Z_0-9]/);
       stream.eat(/[\?\!]/);
       return "ident";
     } else if (/[=+\-\/*^%<>~]/.test(ch)) {
       stream.eatWhile(/[=+\-\/*^%<>~]/);
       return "operator";
     } else {
       return null;
     }
   }
 
   function readQuoted(quote, style,  unescaped) {
     return function(stream, state) {
       var escaped = false, ch;
       while ((ch = stream.next()) != null) {
         if (ch == quote && (unescaped || !escaped)) {
           state.tokenize.pop();
           break;
         }
         escaped = !escaped && ch == "%";
       }
       return style;
     };
   }
 
   return {
     startState: function() {
       return {tokenize: [tokenBase]};
     },
 
     token: function(stream, state) {
       var style = state.tokenize[state.tokenize.length-1](stream, state);
       if (style == "ident") {
         var word = stream.current();
         style = keywords.propertyIsEnumerable(stream.current()) ? "keyword"
           : operators.propertyIsEnumerable(stream.current()) ? "operator"
           : /^[A-Z][A-Z_0-9]*$/g.test(word) ? "tag"
           : /^0[bB][0-1]+$/g.test(word) ? "number"
           : /^0[cC][0-7]+$/g.test(word) ? "number"
           : /^0[xX][a-fA-F0-9]+$/g.test(word) ? "number"
           : /^([0-9]+\.[0-9]*)|([0-9]*\.[0-9]+)$/g.test(word) ? "number"
           : /^[0-9]+$/g.test(word) ? "number"
           : "variable";
       }
       return style;
     },
     lineComment: "--"
   };
 });
 
 CodeMirror.defineMIME("text/x-eiffel", "eiffel");
 
 });

rhodecode/public/js/mode/elm/elm.js

@@ -1,205 +1,205 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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";
+          return isDef ? "type" : "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");
 });

rhodecode/public/js/mode/erlang/erlang.js

@@ -1,618 +1,619 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 /*jshint unused:true, eqnull:true, curly:true, bitwise:true */
 /*jshint undef:true, latedef:true, trailing:true */
 /*global CodeMirror:true */
 
 // erlang mode.
 // tokenizer -> token types -> CodeMirror styles
 // tokenizer maintains a parse stack
 // indenter uses the parse stack
 
 // TODO indenter:
 //   bit syntax
 //   old guard/bif/conversion clashes (e.g. "float/1")
 //   type/spec/opaque
 
 (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.defineMIME("text/x-erlang", "erlang");
 
 CodeMirror.defineMode("erlang", function(cmCfg) {
   "use strict";
 
 /////////////////////////////////////////////////////////////////////////////
 // constants
 
   var typeWords = [
     "-type", "-spec", "-export_type", "-opaque"];
 
   var keywordWords = [
     "after","begin","catch","case","cond","end","fun","if",
     "let","of","query","receive","try","when"];
 
   var separatorRE    = /[\->,;]/;
   var separatorWords = [
     "->",";",","];
 
   var operatorAtomWords = [
     "and","andalso","band","bnot","bor","bsl","bsr","bxor",
     "div","not","or","orelse","rem","xor"];
 
   var operatorSymbolRE    = /[\+\-\*\/<>=\|:!]/;
   var operatorSymbolWords = [
     "=","+","-","*","/",">",">=","<","=<","=:=","==","=/=","/=","||","<-","!"];
 
   var openParenRE    = /[<\(\[\{]/;
   var openParenWords = [
     "<<","(","[","{"];
 
   var closeParenRE    = /[>\)\]\}]/;
   var closeParenWords = [
     "}","]",")",">>"];
 
   var guardWords = [
     "is_atom","is_binary","is_bitstring","is_boolean","is_float",
     "is_function","is_integer","is_list","is_number","is_pid",
     "is_port","is_record","is_reference","is_tuple",
     "atom","binary","bitstring","boolean","function","integer","list",
     "number","pid","port","record","reference","tuple"];
 
   var bifWords = [
     "abs","adler32","adler32_combine","alive","apply","atom_to_binary",
     "atom_to_list","binary_to_atom","binary_to_existing_atom",
     "binary_to_list","binary_to_term","bit_size","bitstring_to_list",
     "byte_size","check_process_code","contact_binary","crc32",
     "crc32_combine","date","decode_packet","delete_module",
     "disconnect_node","element","erase","exit","float","float_to_list",
     "garbage_collect","get","get_keys","group_leader","halt","hd",
     "integer_to_list","internal_bif","iolist_size","iolist_to_binary",
     "is_alive","is_atom","is_binary","is_bitstring","is_boolean",
     "is_float","is_function","is_integer","is_list","is_number","is_pid",
     "is_port","is_process_alive","is_record","is_reference","is_tuple",
     "length","link","list_to_atom","list_to_binary","list_to_bitstring",
     "list_to_existing_atom","list_to_float","list_to_integer",
     "list_to_pid","list_to_tuple","load_module","make_ref","module_loaded",
     "monitor_node","node","node_link","node_unlink","nodes","notalive",
     "now","open_port","pid_to_list","port_close","port_command",
     "port_connect","port_control","pre_loaded","process_flag",
     "process_info","processes","purge_module","put","register",
     "registered","round","self","setelement","size","spawn","spawn_link",
     "spawn_monitor","spawn_opt","split_binary","statistics",
     "term_to_binary","time","throw","tl","trunc","tuple_size",
     "tuple_to_list","unlink","unregister","whereis"];
 
 // upper case: [A-Z] [Ø-Þ] [À-Ö]
 // lower case: [a-z] [ß-ö] [ø-ÿ]
   var anumRE       = /[\w@Ø-ÞÀ-Öß-öø-ÿ]/;
   var escapesRE    =
     /[0-7]{1,3}|[bdefnrstv\\"']|\^[a-zA-Z]|x[0-9a-zA-Z]{2}|x{[0-9a-zA-Z]+}/;
 
 /////////////////////////////////////////////////////////////////////////////
 // tokenizer
 
   function tokenizer(stream,state) {
     // in multi-line string
     if (state.in_string) {
       state.in_string = (!doubleQuote(stream));
       return rval(state,stream,"string");
     }
 
     // in multi-line atom
     if (state.in_atom) {
       state.in_atom = (!singleQuote(stream));
       return rval(state,stream,"atom");
     }
 
     // whitespace
     if (stream.eatSpace()) {
       return rval(state,stream,"whitespace");
     }
 
     // attributes and type specs
     if (!peekToken(state) &&
         stream.match(/-\s*[a-zß-öø-ÿ][\wØ-ÞÀ-Öß-öø-ÿ]*/)) {
       if (is_member(stream.current(),typeWords)) {
         return rval(state,stream,"type");
       }else{
         return rval(state,stream,"attribute");
       }
     }
 
     var ch = stream.next();
 
     // comment
     if (ch == '%') {
       stream.skipToEnd();
       return rval(state,stream,"comment");
     }
 
     // colon
     if (ch == ":") {
       return rval(state,stream,"colon");
     }
 
     // macro
     if (ch == '?') {
       stream.eatSpace();
       stream.eatWhile(anumRE);
       return rval(state,stream,"macro");
     }
 
     // record
     if (ch == "#") {
       stream.eatSpace();
       stream.eatWhile(anumRE);
       return rval(state,stream,"record");
     }
 
     // dollar escape
     if (ch == "$") {
       if (stream.next() == "\\" && !stream.match(escapesRE)) {
         return rval(state,stream,"error");
       }
       return rval(state,stream,"number");
     }
 
     // dot
     if (ch == ".") {
       return rval(state,stream,"dot");
     }
 
     // quoted atom
     if (ch == '\'') {
       if (!(state.in_atom = (!singleQuote(stream)))) {
         if (stream.match(/\s*\/\s*[0-9]/,false)) {
           stream.match(/\s*\/\s*[0-9]/,true);
           return rval(state,stream,"fun");      // 'f'/0 style fun
         }
         if (stream.match(/\s*\(/,false) || stream.match(/\s*:/,false)) {
           return rval(state,stream,"function");
         }
       }
       return rval(state,stream,"atom");
     }
 
     // string
     if (ch == '"') {
       state.in_string = (!doubleQuote(stream));
       return rval(state,stream,"string");
     }
 
     // variable
     if (/[A-Z_Ø-ÞÀ-Ö]/.test(ch)) {
       stream.eatWhile(anumRE);
       return rval(state,stream,"variable");
     }
 
     // atom/keyword/BIF/function
     if (/[a-z_ß-öø-ÿ]/.test(ch)) {
       stream.eatWhile(anumRE);
 
       if (stream.match(/\s*\/\s*[0-9]/,false)) {
         stream.match(/\s*\/\s*[0-9]/,true);
         return rval(state,stream,"fun");      // f/0 style fun
       }
 
       var w = stream.current();
 
       if (is_member(w,keywordWords)) {
         return rval(state,stream,"keyword");
       }else if (is_member(w,operatorAtomWords)) {
         return rval(state,stream,"operator");
       }else if (stream.match(/\s*\(/,false)) {
         // 'put' and 'erlang:put' are bifs, 'foo:put' is not
         if (is_member(w,bifWords) &&
             ((peekToken(state).token != ":") ||
              (peekToken(state,2).token == "erlang"))) {
           return rval(state,stream,"builtin");
         }else if (is_member(w,guardWords)) {
           return rval(state,stream,"guard");
         }else{
           return rval(state,stream,"function");
         }
       }else if (lookahead(stream) == ":") {
         if (w == "erlang") {
           return rval(state,stream,"builtin");
         } else {
           return rval(state,stream,"function");
         }
       }else if (is_member(w,["true","false"])) {
         return rval(state,stream,"boolean");
       }else{
         return rval(state,stream,"atom");
       }
     }
 
     // number
     var digitRE      = /[0-9]/;
     var radixRE      = /[0-9a-zA-Z]/;         // 36#zZ style int
     if (digitRE.test(ch)) {
       stream.eatWhile(digitRE);
       if (stream.eat('#')) {                // 36#aZ  style integer
         if (!stream.eatWhile(radixRE)) {
           stream.backUp(1);                 //"36#" - syntax error
         }
       } else if (stream.eat('.')) {       // float
         if (!stream.eatWhile(digitRE)) {
           stream.backUp(1);        // "3." - probably end of function
         } else {
           if (stream.eat(/[eE]/)) {        // float with exponent
             if (stream.eat(/[-+]/)) {
               if (!stream.eatWhile(digitRE)) {
                 stream.backUp(2);            // "2e-" - syntax error
               }
             } else {
               if (!stream.eatWhile(digitRE)) {
                 stream.backUp(1);            // "2e" - syntax error
               }
             }
           }
         }
       }
       return rval(state,stream,"number");   // normal integer
     }
 
     // open parens
     if (nongreedy(stream,openParenRE,openParenWords)) {
       return rval(state,stream,"open_paren");
     }
 
     // close parens
     if (nongreedy(stream,closeParenRE,closeParenWords)) {
       return rval(state,stream,"close_paren");
     }
 
     // separators
     if (greedy(stream,separatorRE,separatorWords)) {
       return rval(state,stream,"separator");
     }
 
     // operators
     if (greedy(stream,operatorSymbolRE,operatorSymbolWords)) {
       return rval(state,stream,"operator");
     }
 
     return rval(state,stream,null);
   }
 
 /////////////////////////////////////////////////////////////////////////////
 // utilities
   function nongreedy(stream,re,words) {
     if (stream.current().length == 1 && re.test(stream.current())) {
       stream.backUp(1);
       while (re.test(stream.peek())) {
         stream.next();
         if (is_member(stream.current(),words)) {
           return true;
         }
       }
       stream.backUp(stream.current().length-1);
     }
     return false;
   }
 
   function greedy(stream,re,words) {
     if (stream.current().length == 1 && re.test(stream.current())) {
       while (re.test(stream.peek())) {
         stream.next();
       }
       while (0 < stream.current().length) {
         if (is_member(stream.current(),words)) {
           return true;
         }else{
           stream.backUp(1);
         }
       }
       stream.next();
     }
     return false;
   }
 
   function doubleQuote(stream) {
     return quote(stream, '"', '\\');
   }
 
   function singleQuote(stream) {
     return quote(stream,'\'','\\');
   }
 
   function quote(stream,quoteChar,escapeChar) {
     while (!stream.eol()) {
       var ch = stream.next();
       if (ch == quoteChar) {
         return true;
       }else if (ch == escapeChar) {
         stream.next();
       }
     }
     return false;
   }
 
   function lookahead(stream) {
     var m = stream.match(/([\n\s]+|%[^\n]*\n)*(.)/,false);
     return m ? m.pop() : "";
   }
 
   function is_member(element,list) {
     return (-1 < list.indexOf(element));
   }
 
   function rval(state,stream,type) {
 
     // parse stack
     pushToken(state,realToken(type,stream));
 
     // map erlang token type to CodeMirror style class
     //     erlang             -> CodeMirror tag
     switch (type) {
       case "atom":        return "atom";
       case "attribute":   return "attribute";
       case "boolean":     return "atom";
       case "builtin":     return "builtin";
       case "close_paren": return null;
       case "colon":       return null;
       case "comment":     return "comment";
       case "dot":         return null;
       case "error":       return "error";
       case "fun":         return "meta";
       case "function":    return "tag";
       case "guard":       return "property";
       case "keyword":     return "keyword";
       case "macro":       return "variable-2";
       case "number":      return "number";
       case "open_paren":  return null;
       case "operator":    return "operator";
       case "record":      return "bracket";
       case "separator":   return null;
       case "string":      return "string";
       case "type":        return "def";
       case "variable":    return "variable";
       default:            return null;
     }
   }
 
   function aToken(tok,col,ind,typ) {
     return {token:  tok,
             column: col,
             indent: ind,
             type:   typ};
   }
 
   function realToken(type,stream) {
     return aToken(stream.current(),
                  stream.column(),
                  stream.indentation(),
                  type);
   }
 
   function fakeToken(type) {
     return aToken(type,0,0,type);
   }
 
   function peekToken(state,depth) {
     var len = state.tokenStack.length;
     var dep = (depth ? depth : 1);
 
     if (len < dep) {
       return false;
     }else{
       return state.tokenStack[len-dep];
     }
   }
 
   function pushToken(state,token) {
 
     if (!(token.type == "comment" || token.type == "whitespace")) {
       state.tokenStack = maybe_drop_pre(state.tokenStack,token);
       state.tokenStack = maybe_drop_post(state.tokenStack);
     }
   }
 
   function maybe_drop_pre(s,token) {
     var last = s.length-1;
 
     if (0 < last && s[last].type === "record" && token.type === "dot") {
       s.pop();
     }else if (0 < last && s[last].type === "group") {
       s.pop();
       s.push(token);
     }else{
       s.push(token);
     }
     return s;
   }
 
   function maybe_drop_post(s) {
+    if (!s.length) return s
     var last = s.length-1;
 
     if (s[last].type === "dot") {
       return [];
     }
-    if (s[last].type === "fun" && s[last-1].token === "fun") {
+    if (last > 1 && s[last].type === "fun" && s[last-1].token === "fun") {
       return s.slice(0,last-1);
     }
-    switch (s[s.length-1].token) {
+    switch (s[last].token) {
       case "}":    return d(s,{g:["{"]});
       case "]":    return d(s,{i:["["]});
       case ")":    return d(s,{i:["("]});
       case ">>":   return d(s,{i:["<<"]});
       case "end":  return d(s,{i:["begin","case","fun","if","receive","try"]});
       case ",":    return d(s,{e:["begin","try","when","->",
                                   ",","(","[","{","<<"]});
       case "->":   return d(s,{r:["when"],
                                m:["try","if","case","receive"]});
       case ";":    return d(s,{E:["case","fun","if","receive","try","when"]});
       case "catch":return d(s,{e:["try"]});
       case "of":   return d(s,{e:["case"]});
       case "after":return d(s,{e:["receive","try"]});
       default:     return s;
     }
   }
 
   function d(stack,tt) {
     // stack is a stack of Token objects.
     // tt is an object; {type:tokens}
     // type is a char, tokens is a list of token strings.
     // The function returns (possibly truncated) stack.
     // It will descend the stack, looking for a Token such that Token.token
     //  is a member of tokens. If it does not find that, it will normally (but
     //  see "E" below) return stack. If it does find a match, it will remove
     //  all the Tokens between the top and the matched Token.
     // If type is "m", that is all it does.
     // If type is "i", it will also remove the matched Token and the top Token.
     // If type is "g", like "i", but add a fake "group" token at the top.
     // If type is "r", it will remove the matched Token, but not the top Token.
     // If type is "e", it will keep the matched Token but not the top Token.
     // If type is "E", it behaves as for type "e", except if there is no match,
     //  in which case it will return an empty stack.
 
     for (var type in tt) {
       var len = stack.length-1;
       var tokens = tt[type];
       for (var i = len-1; -1 < i ; i--) {
         if (is_member(stack[i].token,tokens)) {
           var ss = stack.slice(0,i);
           switch (type) {
               case "m": return ss.concat(stack[i]).concat(stack[len]);
               case "r": return ss.concat(stack[len]);
               case "i": return ss;
               case "g": return ss.concat(fakeToken("group"));
               case "E": return ss.concat(stack[i]);
               case "e": return ss.concat(stack[i]);
           }
         }
       }
     }
     return (type == "E" ? [] : stack);
   }
 
 /////////////////////////////////////////////////////////////////////////////
 // indenter
 
   function indenter(state,textAfter) {
     var t;
     var unit = cmCfg.indentUnit;
     var wordAfter = wordafter(textAfter);
     var currT = peekToken(state,1);
     var prevT = peekToken(state,2);
 
     if (state.in_string || state.in_atom) {
       return CodeMirror.Pass;
     }else if (!prevT) {
       return 0;
     }else if (currT.token == "when") {
       return currT.column+unit;
     }else if (wordAfter === "when" && prevT.type === "function") {
       return prevT.indent+unit;
     }else if (wordAfter === "(" && currT.token === "fun") {
       return  currT.column+3;
     }else if (wordAfter === "catch" && (t = getToken(state,["try"]))) {
       return t.column;
     }else if (is_member(wordAfter,["end","after","of"])) {
       t = getToken(state,["begin","case","fun","if","receive","try"]);
       return t ? t.column : CodeMirror.Pass;
     }else if (is_member(wordAfter,closeParenWords)) {
       t = getToken(state,openParenWords);
       return t ? t.column : CodeMirror.Pass;
     }else if (is_member(currT.token,[",","|","||"]) ||
               is_member(wordAfter,[",","|","||"])) {
       t = postcommaToken(state);
       return t ? t.column+t.token.length : unit;
     }else if (currT.token == "->") {
       if (is_member(prevT.token, ["receive","case","if","try"])) {
         return prevT.column+unit+unit;
       }else{
         return prevT.column+unit;
       }
     }else if (is_member(currT.token,openParenWords)) {
       return currT.column+currT.token.length;
     }else{
       t = defaultToken(state);
       return truthy(t) ? t.column+unit : 0;
     }
   }
 
   function wordafter(str) {
     var m = str.match(/,|[a-z]+|\}|\]|\)|>>|\|+|\(/);
 
     return truthy(m) && (m.index === 0) ? m[0] : "";
   }
 
   function postcommaToken(state) {
     var objs = state.tokenStack.slice(0,-1);
     var i = getTokenIndex(objs,"type",["open_paren"]);
 
     return truthy(objs[i]) ? objs[i] : false;
   }
 
   function defaultToken(state) {
     var objs = state.tokenStack;
     var stop = getTokenIndex(objs,"type",["open_paren","separator","keyword"]);
     var oper = getTokenIndex(objs,"type",["operator"]);
 
     if (truthy(stop) && truthy(oper) && stop < oper) {
       return objs[stop+1];
     } else if (truthy(stop)) {
       return objs[stop];
     } else {
       return false;
     }
   }
 
   function getToken(state,tokens) {
     var objs = state.tokenStack;
     var i = getTokenIndex(objs,"token",tokens);
 
     return truthy(objs[i]) ? objs[i] : false;
   }
 
   function getTokenIndex(objs,propname,propvals) {
 
     for (var i = objs.length-1; -1 < i ; i--) {
       if (is_member(objs[i][propname],propvals)) {
         return i;
       }
     }
     return false;
   }
 
   function truthy(x) {
     return (x !== false) && (x != null);
   }
 
 /////////////////////////////////////////////////////////////////////////////
 // this object defines the mode
 
   return {
     startState:
       function() {
         return {tokenStack: [],
                 in_string:  false,
                 in_atom:    false};
       },
 
     token:
       function(stream, state) {
         return tokenizer(stream, state);
       },
 
     indent:
       function(state, textAfter) {
         return indenter(state,textAfter);
       },
 
     lineComment: "%"
   };
 });
 
 });

rhodecode/public/js/mode/factor/factor.js

@@ -1,83 +1,85 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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"},
+      {regex: /(STRING:)(\s)/, token: ["keyword", null], next: "string2"},
+      {regex: /\S*?"/, 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: /(?:0x[\d,a-f]+)|(?:0o[0-7]+)|(?:0b[0,1]+)|(?:\-?\d+.?\d*)(?=\s)/, token: "number"},
       //{regex: /[+-]?/} //fractional
       // definition: defining word, defined word, etc
-      {regex: /(\:)(\s+)(\S+)(\s+)(\()/, token: ["keyword", null, "def", null, "keyword"], next: "stack"},
+      {regex: /((?:GENERIC)|\:?\:)(\s+)(\S+)(\s+)(\()/, token: ["keyword", null, "def", null, "bracket"], next: "stack"},
+      // method definition: defining word, type, defined word, etc
+      {regex: /(M\:)(\s+)(\S+)(\s+)(\S+)/, token: ["keyword", null, "def", null, "tag"]},
       // 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"},
+      {regex: /(USE\:|IN\:)(\s+)(\S+)(?=\s|$)/, token: ["keyword", null, "tag"]},
+      // definition: a defining word, defined word
+      {regex: /(\S+\:)(\s+)(\S+)(?=\s|$)/, token: ["keyword", null, "def"]},
       // "keywords", incl. ; t f . [ ] { } defining words
-      {regex: /;|t|f|if|\.|\[|\]|\{|\}|MAIN:/, token: "keyword"},
+      {regex: /(?:;|\\|t|f|if|loop|while|until|do|PRIVATE>|<PRIVATE|\.|\S*\[|\]|\S*\{|\})(?=\s|$)/, token: "keyword"},
+      // <constructors> and the like
+      {regex: /\S+[\)>\.\*\?]+(?=\s|$)/, token: "builtin"},
+      {regex: /[\)><]+\S+(?=\s|$)/, token: "builtin"},
+      // operators
+      {regex: /(?:[\+\-\=\/\*<>])(?=\s|$)/, token: "keyword"},
       // any id (?)
       {regex: /\S+/, token: "variable"},
-
-      {
-        regex: /./,
-        token: null
-      }
+      {regex: /\s+|./, token: null}
     ],
     vocabulary: [
       {regex: /;/, token: "keyword", next: "start"},
-      {regex: /\S+/, token: "variable-2"},
-      {
-        regex: /./,
-        token: null
-      }
+      {regex: /\S+/, token: "tag"},
+      {regex: /\s+|./, token: null}
     ],
     string: [
       {regex: /(?:[^\\]|\\.)*?"/, token: "string", next: "start"},
       {regex: /.*/, token: "string"}
     ],
+    string2: [
+      {regex: /^;/, token: "keyword", 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
-      }
+      {regex: /\)/, token: "bracket", next: "start"},
+      {regex: /--/, token: "bracket"},
+      {regex: /\S+/, token: "meta"},
+      {regex: /\s+|./, 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");
 });

rhodecode/public/js/mode/forth/forth.js

@@ -1,180 +1,180 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 // Author: Aliaksei Chapyzhenka
 
 (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";
 
   function toWordList(words) {
     var ret = [];
     words.split(' ').forEach(function(e){
       ret.push({name: e});
     });
     return ret;
   }
 
   var coreWordList = toWordList(
 'INVERT AND OR XOR\
  2* 2/ LSHIFT RSHIFT\
  0= = 0< < > U< MIN MAX\
  2DROP 2DUP 2OVER 2SWAP ?DUP DEPTH DROP DUP OVER ROT SWAP\
  >R R> R@\
  + - 1+ 1- ABS NEGATE\
  S>D * M* UM*\
  FM/MOD SM/REM UM/MOD */ */MOD / /MOD MOD\
  HERE , @ ! CELL+ CELLS C, C@ C! CHARS 2@ 2!\
  ALIGN ALIGNED +! ALLOT\
  CHAR [CHAR] [ ] BL\
  FIND EXECUTE IMMEDIATE COUNT LITERAL STATE\
  ; DOES> >BODY\
  EVALUATE\
  SOURCE >IN\
  <# # #S #> HOLD SIGN BASE >NUMBER HEX DECIMAL\
  FILL MOVE\
  . CR EMIT SPACE SPACES TYPE U. .R U.R\
  ACCEPT\
  TRUE FALSE\
  <> U> 0<> 0>\
  NIP TUCK ROLL PICK\
  2>R 2R@ 2R>\
  WITHIN UNUSED MARKER\
  I J\
  TO\
  COMPILE, [COMPILE]\
  SAVE-INPUT RESTORE-INPUT\
  PAD ERASE\
  2LITERAL DNEGATE\
  D- D+ D0< D0= D2* D2/ D< D= DMAX DMIN D>S DABS\
  M+ M*/ D. D.R 2ROT DU<\
  CATCH THROW\
  FREE RESIZE ALLOCATE\
  CS-PICK CS-ROLL\
  GET-CURRENT SET-CURRENT FORTH-WORDLIST GET-ORDER SET-ORDER\
  PREVIOUS SEARCH-WORDLIST WORDLIST FIND ALSO ONLY FORTH DEFINITIONS ORDER\
  -TRAILING /STRING SEARCH COMPARE CMOVE CMOVE> BLANK SLITERAL');
 
   var immediateWordList = toWordList('IF ELSE THEN BEGIN WHILE REPEAT UNTIL RECURSE [IF] [ELSE] [THEN] ?DO DO LOOP +LOOP UNLOOP LEAVE EXIT AGAIN CASE OF ENDOF ENDCASE');
 
   CodeMirror.defineMode('forth', function() {
     function searchWordList (wordList, word) {
       var i;
       for (i = wordList.length - 1; i >= 0; i--) {
         if (wordList[i].name === word.toUpperCase()) {
           return wordList[i];
         }
       }
       return undefined;
     }
   return {
     startState: function() {
       return {
         state: '',
         base: 10,
         coreWordList: coreWordList,
         immediateWordList: immediateWordList,
         wordList: []
       };
     },
     token: function (stream, stt) {
       var mat;
       if (stream.eatSpace()) {
         return null;
       }
       if (stt.state === '') { // interpretation
         if (stream.match(/^(\]|:NONAME)(\s|$)/i)) {
           stt.state = ' compilation';
           return 'builtin compilation';
         }
         mat = stream.match(/^(\:)\s+(\S+)(\s|$)+/);
         if (mat) {
           stt.wordList.push({name: mat[2].toUpperCase()});
           stt.state = ' compilation';
           return 'def' + stt.state;
         }
         mat = stream.match(/^(VARIABLE|2VARIABLE|CONSTANT|2CONSTANT|CREATE|POSTPONE|VALUE|WORD)\s+(\S+)(\s|$)+/i);
         if (mat) {
           stt.wordList.push({name: mat[2].toUpperCase()});
           return 'def' + stt.state;
         }
         mat = stream.match(/^(\'|\[\'\])\s+(\S+)(\s|$)+/);
         if (mat) {
           return 'builtin' + stt.state;
         }
         } else { // compilation
         // ; [
         if (stream.match(/^(\;|\[)(\s)/)) {
           stt.state = '';
           stream.backUp(1);
           return 'builtin compilation';
         }
         if (stream.match(/^(\;|\[)($)/)) {
           stt.state = '';
           return 'builtin compilation';
         }
         if (stream.match(/^(POSTPONE)\s+\S+(\s|$)+/)) {
           return 'builtin';
         }
       }
 
       // dynamic wordlist
       mat = stream.match(/^(\S+)(\s+|$)/);
       if (mat) {
         if (searchWordList(stt.wordList, mat[1]) !== undefined) {
           return 'variable' + stt.state;
         }
 
         // comments
         if (mat[1] === '\\') {
           stream.skipToEnd();
             return 'comment' + stt.state;
           }
 
           // core words
           if (searchWordList(stt.coreWordList, mat[1]) !== undefined) {
             return 'builtin' + stt.state;
           }
           if (searchWordList(stt.immediateWordList, mat[1]) !== undefined) {
             return 'keyword' + stt.state;
           }
 
           if (mat[1] === '(') {
             stream.eatWhile(function (s) { return s !== ')'; });
             stream.eat(')');
             return 'comment' + stt.state;
           }
 
           // // strings
           if (mat[1] === '.(') {
             stream.eatWhile(function (s) { return s !== ')'; });
             stream.eat(')');
             return 'string' + stt.state;
           }
           if (mat[1] === 'S"' || mat[1] === '."' || mat[1] === 'C"') {
             stream.eatWhile(function (s) { return s !== '"'; });
             stream.eat('"');
             return 'string' + stt.state;
           }
 
           // numbers
           if (mat[1] - 0xfffffffff) {
             return 'number' + stt.state;
           }
           // if (mat[1].match(/^[-+]?[0-9]+\.[0-9]*/)) {
           //     return 'number' + stt.state;
           // }
 
           return 'atom' + stt.state;
         }
       }
     };
   });
   CodeMirror.defineMIME("text/x-forth", "forth");
 });

rhodecode/public/js/mode/fortran/fortran.js

@@ -1,188 +1,188 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("fortran", function() {
   function words(array) {
     var keys = {};
     for (var i = 0; i < array.length; ++i) {
       keys[array[i]] = true;
     }
     return keys;
   }
 
   var keywords = words([
                   "abstract", "accept", "allocatable", "allocate",
                   "array", "assign", "asynchronous", "backspace",
                   "bind", "block", "byte", "call", "case",
                   "class", "close", "common", "contains",
                   "continue", "cycle", "data", "deallocate",
                   "decode", "deferred", "dimension", "do",
                   "elemental", "else", "encode", "end",
                   "endif", "entry", "enumerator", "equivalence",
                   "exit", "external", "extrinsic", "final",
                   "forall", "format", "function", "generic",
                   "go", "goto", "if", "implicit", "import", "include",
                   "inquire", "intent", "interface", "intrinsic",
                   "module", "namelist", "non_intrinsic",
                   "non_overridable", "none", "nopass",
                   "nullify", "open", "optional", "options",
                   "parameter", "pass", "pause", "pointer",
                   "print", "private", "program", "protected",
                   "public", "pure", "read", "recursive", "result",
                   "return", "rewind", "save", "select", "sequence",
                   "stop", "subroutine", "target", "then", "to", "type",
                   "use", "value", "volatile", "where", "while",
                   "write"]);
   var builtins = words(["abort", "abs", "access", "achar", "acos",
                           "adjustl", "adjustr", "aimag", "aint", "alarm",
                           "all", "allocated", "alog", "amax", "amin",
                           "amod", "and", "anint", "any", "asin",
                           "associated", "atan", "besj", "besjn", "besy",
                           "besyn", "bit_size", "btest", "cabs", "ccos",
                           "ceiling", "cexp", "char", "chdir", "chmod",
                           "clog", "cmplx", "command_argument_count",
                           "complex", "conjg", "cos", "cosh", "count",
                           "cpu_time", "cshift", "csin", "csqrt", "ctime",
                           "c_funloc", "c_loc", "c_associated", "c_null_ptr",
                           "c_null_funptr", "c_f_pointer", "c_null_char",
                           "c_alert", "c_backspace", "c_form_feed",
                           "c_new_line", "c_carriage_return",
                           "c_horizontal_tab", "c_vertical_tab", "dabs",
                           "dacos", "dasin", "datan", "date_and_time",
                           "dbesj", "dbesj", "dbesjn", "dbesy", "dbesy",
                           "dbesyn", "dble", "dcos", "dcosh", "ddim", "derf",
                           "derfc", "dexp", "digits", "dim", "dint", "dlog",
                           "dlog", "dmax", "dmin", "dmod", "dnint",
                           "dot_product", "dprod", "dsign", "dsinh",
                           "dsin", "dsqrt", "dtanh", "dtan", "dtime",
                           "eoshift", "epsilon", "erf", "erfc", "etime",
                           "exit", "exp", "exponent", "extends_type_of",
                           "fdate", "fget", "fgetc", "float", "floor",
                           "flush", "fnum", "fputc", "fput", "fraction",
                           "fseek", "fstat", "ftell", "gerror", "getarg",
                           "get_command", "get_command_argument",
                           "get_environment_variable", "getcwd",
                           "getenv", "getgid", "getlog", "getpid",
                           "getuid", "gmtime", "hostnm", "huge", "iabs",
                           "iachar", "iand", "iargc", "ibclr", "ibits",
                           "ibset", "ichar", "idate", "idim", "idint",
                           "idnint", "ieor", "ierrno", "ifix", "imag",
                           "imagpart", "index", "int", "ior", "irand",
                           "isatty", "ishft", "ishftc", "isign",
                           "iso_c_binding", "is_iostat_end", "is_iostat_eor",
                           "itime", "kill", "kind", "lbound", "len", "len_trim",
                           "lge", "lgt", "link", "lle", "llt", "lnblnk", "loc",
                           "log", "logical", "long", "lshift", "lstat", "ltime",
                           "matmul", "max", "maxexponent", "maxloc", "maxval",
                           "mclock", "merge", "move_alloc", "min", "minexponent",
                           "minloc", "minval", "mod", "modulo", "mvbits",
                           "nearest", "new_line", "nint", "not", "or", "pack",
                           "perror", "precision", "present", "product", "radix",
                           "rand", "random_number", "random_seed", "range",
                           "real", "realpart", "rename", "repeat", "reshape",
                           "rrspacing", "rshift", "same_type_as", "scale",
                           "scan", "second", "selected_int_kind",
                           "selected_real_kind", "set_exponent", "shape",
                           "short", "sign", "signal", "sinh", "sin", "sleep",
                           "sngl", "spacing", "spread", "sqrt", "srand", "stat",
                           "sum", "symlnk", "system", "system_clock", "tan",
                           "tanh", "time", "tiny", "transfer", "transpose",
                           "trim", "ttynam", "ubound", "umask", "unlink",
                           "unpack", "verify", "xor", "zabs", "zcos", "zexp",
                           "zlog", "zsin", "zsqrt"]);
 
     var dataTypes =  words(["c_bool", "c_char", "c_double", "c_double_complex",
                      "c_float", "c_float_complex", "c_funptr", "c_int",
                      "c_int16_t", "c_int32_t", "c_int64_t", "c_int8_t",
                      "c_int_fast16_t", "c_int_fast32_t", "c_int_fast64_t",
                      "c_int_fast8_t", "c_int_least16_t", "c_int_least32_t",
                      "c_int_least64_t", "c_int_least8_t", "c_intmax_t",
                      "c_intptr_t", "c_long", "c_long_double",
                      "c_long_double_complex", "c_long_long", "c_ptr",
                      "c_short", "c_signed_char", "c_size_t", "character",
                      "complex", "double", "integer", "logical", "real"]);
   var isOperatorChar = /[+\-*&=<>\/\:]/;
   var litOperator = new RegExp("(\.and\.|\.or\.|\.eq\.|\.lt\.|\.le\.|\.gt\.|\.ge\.|\.ne\.|\.not\.|\.eqv\.|\.neqv\.)", "i");
 
   function tokenBase(stream, state) {
 
     if (stream.match(litOperator)){
         return 'operator';
     }
 
     var ch = stream.next();
     if (ch == "!") {
       stream.skipToEnd();
       return "comment";
     }
     if (ch == '"' || ch == "'") {
       state.tokenize = tokenString(ch);
       return state.tokenize(stream, state);
     }
     if (/[\[\]\(\),]/.test(ch)) {
       return null;
     }
     if (/\d/.test(ch)) {
       stream.eatWhile(/[\w\.]/);
       return "number";
     }
     if (isOperatorChar.test(ch)) {
       stream.eatWhile(isOperatorChar);
       return "operator";
     }
     stream.eatWhile(/[\w\$_]/);
     var word = stream.current().toLowerCase();
 
     if (keywords.hasOwnProperty(word)){
             return 'keyword';
     }
     if (builtins.hasOwnProperty(word) || dataTypes.hasOwnProperty(word)) {
             return 'builtin';
     }
     return "variable";
   }
 
   function tokenString(quote) {
     return function(stream, state) {
       var escaped = false, next, end = false;
       while ((next = stream.next()) != null) {
         if (next == quote && !escaped) {
             end = true;
             break;
         }
         escaped = !escaped && next == "\\";
       }
       if (end || !escaped) state.tokenize = null;
       return "string";
     };
   }
 
   // Interface
 
   return {
     startState: function() {
       return {tokenize: null};
     },
 
     token: function(stream, state) {
       if (stream.eatSpace()) return null;
       var style = (state.tokenize || tokenBase)(stream, state);
       if (style == "comment" || style == "meta") return style;
       return style;
     }
   };
 });
 
 CodeMirror.defineMIME("text/x-fortran", "fortran");
 
 });

rhodecode/public/js/mode/gas/gas.js

@@ -1,345 +1,345 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("gas", function(_config, parserConfig) {
   'use strict';
 
   // If an architecture is specified, its initialization function may
   // populate this array with custom parsing functions which will be
   // tried in the event that the standard functions do not find a match.
   var custom = [];
 
   // The symbol used to start a line comment changes based on the target
   // architecture.
   // If no architecture is pased in "parserConfig" then only multiline
   // comments will have syntax support.
   var lineCommentStartSymbol = "";
 
   // These directives are architecture independent.
   // Machine specific directives should go in their respective
   // architecture initialization function.
   // Reference:
   // http://sourceware.org/binutils/docs/as/Pseudo-Ops.html#Pseudo-Ops
   var directives = {
     ".abort" : "builtin",
     ".align" : "builtin",
     ".altmacro" : "builtin",
     ".ascii" : "builtin",
     ".asciz" : "builtin",
     ".balign" : "builtin",
     ".balignw" : "builtin",
     ".balignl" : "builtin",
     ".bundle_align_mode" : "builtin",
     ".bundle_lock" : "builtin",
     ".bundle_unlock" : "builtin",
     ".byte" : "builtin",
     ".cfi_startproc" : "builtin",
     ".comm" : "builtin",
     ".data" : "builtin",
     ".def" : "builtin",
     ".desc" : "builtin",
     ".dim" : "builtin",
     ".double" : "builtin",
     ".eject" : "builtin",
     ".else" : "builtin",
     ".elseif" : "builtin",
     ".end" : "builtin",
     ".endef" : "builtin",
     ".endfunc" : "builtin",
     ".endif" : "builtin",
     ".equ" : "builtin",
     ".equiv" : "builtin",
     ".eqv" : "builtin",
     ".err" : "builtin",
     ".error" : "builtin",
     ".exitm" : "builtin",
     ".extern" : "builtin",
     ".fail" : "builtin",
     ".file" : "builtin",
     ".fill" : "builtin",
     ".float" : "builtin",
     ".func" : "builtin",
     ".global" : "builtin",
     ".gnu_attribute" : "builtin",
     ".hidden" : "builtin",
     ".hword" : "builtin",
     ".ident" : "builtin",
     ".if" : "builtin",
     ".incbin" : "builtin",
     ".include" : "builtin",
     ".int" : "builtin",
     ".internal" : "builtin",
     ".irp" : "builtin",
     ".irpc" : "builtin",
     ".lcomm" : "builtin",
     ".lflags" : "builtin",
     ".line" : "builtin",
     ".linkonce" : "builtin",
     ".list" : "builtin",
     ".ln" : "builtin",
     ".loc" : "builtin",
     ".loc_mark_labels" : "builtin",
     ".local" : "builtin",
     ".long" : "builtin",
     ".macro" : "builtin",
     ".mri" : "builtin",
     ".noaltmacro" : "builtin",
     ".nolist" : "builtin",
     ".octa" : "builtin",
     ".offset" : "builtin",
     ".org" : "builtin",
     ".p2align" : "builtin",
     ".popsection" : "builtin",
     ".previous" : "builtin",
     ".print" : "builtin",
     ".protected" : "builtin",
     ".psize" : "builtin",
     ".purgem" : "builtin",
     ".pushsection" : "builtin",
     ".quad" : "builtin",
     ".reloc" : "builtin",
     ".rept" : "builtin",
     ".sbttl" : "builtin",
     ".scl" : "builtin",
     ".section" : "builtin",
     ".set" : "builtin",
     ".short" : "builtin",
     ".single" : "builtin",
     ".size" : "builtin",
     ".skip" : "builtin",
     ".sleb128" : "builtin",
     ".space" : "builtin",
     ".stab" : "builtin",
     ".string" : "builtin",
     ".struct" : "builtin",
     ".subsection" : "builtin",
     ".symver" : "builtin",
     ".tag" : "builtin",
     ".text" : "builtin",
     ".title" : "builtin",
     ".type" : "builtin",
     ".uleb128" : "builtin",
     ".val" : "builtin",
     ".version" : "builtin",
     ".vtable_entry" : "builtin",
     ".vtable_inherit" : "builtin",
     ".warning" : "builtin",
     ".weak" : "builtin",
     ".weakref" : "builtin",
     ".word" : "builtin"
   };
 
   var registers = {};
 
   function x86(_parserConfig) {
     lineCommentStartSymbol = "#";
 
     registers.ax  = "variable";
     registers.eax = "variable-2";
     registers.rax = "variable-3";
 
     registers.bx  = "variable";
     registers.ebx = "variable-2";
     registers.rbx = "variable-3";
 
     registers.cx  = "variable";
     registers.ecx = "variable-2";
     registers.rcx = "variable-3";
 
     registers.dx  = "variable";
     registers.edx = "variable-2";
     registers.rdx = "variable-3";
 
     registers.si  = "variable";
     registers.esi = "variable-2";
     registers.rsi = "variable-3";
 
     registers.di  = "variable";
     registers.edi = "variable-2";
     registers.rdi = "variable-3";
 
     registers.sp  = "variable";
     registers.esp = "variable-2";
     registers.rsp = "variable-3";
 
     registers.bp  = "variable";
     registers.ebp = "variable-2";
     registers.rbp = "variable-3";
 
     registers.ip  = "variable";
     registers.eip = "variable-2";
     registers.rip = "variable-3";
 
     registers.cs  = "keyword";
     registers.ds  = "keyword";
     registers.ss  = "keyword";
     registers.es  = "keyword";
     registers.fs  = "keyword";
     registers.gs  = "keyword";
   }
 
   function armv6(_parserConfig) {
     // Reference:
     // http://infocenter.arm.com/help/topic/com.arm.doc.qrc0001l/QRC0001_UAL.pdf
     // http://infocenter.arm.com/help/topic/com.arm.doc.ddi0301h/DDI0301H_arm1176jzfs_r0p7_trm.pdf
     lineCommentStartSymbol = "@";
     directives.syntax = "builtin";
 
     registers.r0  = "variable";
     registers.r1  = "variable";
     registers.r2  = "variable";
     registers.r3  = "variable";
     registers.r4  = "variable";
     registers.r5  = "variable";
     registers.r6  = "variable";
     registers.r7  = "variable";
     registers.r8  = "variable";
     registers.r9  = "variable";
     registers.r10 = "variable";
     registers.r11 = "variable";
     registers.r12 = "variable";
 
     registers.sp  = "variable-2";
     registers.lr  = "variable-2";
     registers.pc  = "variable-2";
     registers.r13 = registers.sp;
     registers.r14 = registers.lr;
     registers.r15 = registers.pc;
 
     custom.push(function(ch, stream) {
       if (ch === '#') {
         stream.eatWhile(/\w/);
         return "number";
       }
     });
   }
 
   var arch = (parserConfig.architecture || "x86").toLowerCase();
   if (arch === "x86") {
     x86(parserConfig);
   } else if (arch === "arm" || arch === "armv6") {
     armv6(parserConfig);
   }
 
   function nextUntilUnescaped(stream, end) {
     var escaped = false, next;
     while ((next = stream.next()) != null) {
       if (next === end && !escaped) {
         return false;
       }
       escaped = !escaped && next === "\\";
     }
     return escaped;
   }
 
   function clikeComment(stream, state) {
     var maybeEnd = false, ch;
     while ((ch = stream.next()) != null) {
       if (ch === "/" && maybeEnd) {
         state.tokenize = null;
         break;
       }
       maybeEnd = (ch === "*");
     }
     return "comment";
   }
 
   return {
     startState: function() {
       return {
         tokenize: null
       };
     },
 
     token: function(stream, state) {
       if (state.tokenize) {
         return state.tokenize(stream, state);
       }
 
       if (stream.eatSpace()) {
         return null;
       }
 
       var style, cur, ch = stream.next();
 
       if (ch === "/") {
         if (stream.eat("*")) {
           state.tokenize = clikeComment;
           return clikeComment(stream, state);
         }
       }
 
       if (ch === lineCommentStartSymbol) {
         stream.skipToEnd();
         return "comment";
       }
 
       if (ch === '"') {
         nextUntilUnescaped(stream, '"');
         return "string";
       }
 
       if (ch === '.') {
         stream.eatWhile(/\w/);
         cur = stream.current().toLowerCase();
         style = directives[cur];
         return style || null;
       }
 
       if (ch === '=') {
         stream.eatWhile(/\w/);
         return "tag";
       }
 
       if (ch === '{') {
         return "braket";
       }
 
       if (ch === '}') {
         return "braket";
       }
 
       if (/\d/.test(ch)) {
         if (ch === "0" && stream.eat("x")) {
           stream.eatWhile(/[0-9a-fA-F]/);
           return "number";
         }
         stream.eatWhile(/\d/);
         return "number";
       }
 
       if (/\w/.test(ch)) {
         stream.eatWhile(/\w/);
         if (stream.eat(":")) {
           return 'tag';
         }
         cur = stream.current().toLowerCase();
         style = registers[cur];
         return style || null;
       }
 
       for (var i = 0; i < custom.length; i++) {
         style = custom[i](ch, stream, state);
         if (style) {
           return style;
         }
       }
     },
 
     lineComment: lineCommentStartSymbol,
     blockCommentStart: "/*",
     blockCommentEnd: "*/"
   };
 });
 
 });

rhodecode/public/js/mode/gfm/gfm.js

@@ -1,130 +1,129 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 (function(mod) {
   if (typeof exports == "object" && typeof module == "object") // CommonJS
     mod(require("../../lib/codemirror"), require("../markdown/markdown"), require("../../addon/mode/overlay"));
   else if (typeof define == "function" && define.amd) // AMD
     define(["../../lib/codemirror", "../markdown/markdown", "../../addon/mode/overlay"], mod);
   else // Plain browser env
     mod(CodeMirror);
 })(function(CodeMirror) {
 "use strict";
 
 var urlRE = /^((?:(?:aaas?|about|acap|adiumxtra|af[ps]|aim|apt|attachment|aw|beshare|bitcoin|bolo|callto|cap|chrome(?:-extension)?|cid|coap|com-eventbrite-attendee|content|crid|cvs|data|dav|dict|dlna-(?:playcontainer|playsingle)|dns|doi|dtn|dvb|ed2k|facetime|feed|file|finger|fish|ftp|geo|gg|git|gizmoproject|go|gopher|gtalk|h323|hcp|https?|iax|icap|icon|im|imap|info|ipn|ipp|irc[6s]?|iris(?:\.beep|\.lwz|\.xpc|\.xpcs)?|itms|jar|javascript|jms|keyparc|lastfm|ldaps?|magnet|mailto|maps|market|message|mid|mms|ms-help|msnim|msrps?|mtqp|mumble|mupdate|mvn|news|nfs|nih?|nntp|notes|oid|opaquelocktoken|palm|paparazzi|platform|pop|pres|proxy|psyc|query|res(?:ource)?|rmi|rsync|rtmp|rtsp|secondlife|service|session|sftp|sgn|shttp|sieve|sips?|skype|sm[bs]|snmp|soap\.beeps?|soldat|spotify|ssh|steam|svn|tag|teamspeak|tel(?:net)?|tftp|things|thismessage|tip|tn3270|tv|udp|unreal|urn|ut2004|vemmi|ventrilo|view-source|webcal|wss?|wtai|wyciwyg|xcon(?:-userid)?|xfire|xmlrpc\.beeps?|xmpp|xri|ymsgr|z39\.50[rs]?):(?:\/{1,3}|[a-z0-9%])|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}\/)(?:[^\s()<>]|\([^\s()<>]*\))+(?:\([^\s()<>]*\)|[^\s`*!()\[\]{};:'".,<>?«»“”‘’]))/i
 
 CodeMirror.defineMode("gfm", function(config, modeConfig) {
   var codeDepth = 0;
   function blankLine(state) {
     state.code = false;
     return null;
   }
   var gfmOverlay = {
     startState: function() {
       return {
         code: false,
         codeBlock: false,
         ateSpace: false
       };
     },
     copyState: function(s) {
       return {
         code: s.code,
         codeBlock: s.codeBlock,
         ateSpace: s.ateSpace
       };
     },
     token: function(stream, state) {
       state.combineTokens = null;
 
       // Hack to prevent formatting override inside code blocks (block and inline)
       if (state.codeBlock) {
         if (stream.match(/^```+/)) {
           state.codeBlock = false;
           return null;
         }
         stream.skipToEnd();
         return null;
       }
       if (stream.sol()) {
         state.code = false;
       }
       if (stream.sol() && stream.match(/^```+/)) {
         stream.skipToEnd();
         state.codeBlock = true;
         return null;
       }
       // If this block is changed, it may need to be updated in Markdown mode
       if (stream.peek() === '`') {
         stream.next();
         var before = stream.pos;
         stream.eatWhile('`');
         var difference = 1 + stream.pos - before;
         if (!state.code) {
           codeDepth = difference;
           state.code = true;
         } else {
           if (difference === codeDepth) { // Must be exact
             state.code = false;
           }
         }
         return null;
       } else if (state.code) {
         stream.next();
         return null;
       }
       // Check if space. If so, links can be formatted later on
       if (stream.eatSpace()) {
         state.ateSpace = true;
         return null;
       }
       if (stream.sol() || state.ateSpace) {
         state.ateSpace = false;
         if (modeConfig.gitHubSpice !== false) {
-          if(stream.match(/^(?:[a-zA-Z0-9\-_]+\/)?(?:[a-zA-Z0-9\-_]+@)?(?:[a-f0-9]{7,40}\b)/)) {
+          if(stream.match(/^(?:[a-zA-Z0-9\-_]+\/)?(?:[a-zA-Z0-9\-_]+@)?(?=.{0,6}\d)(?:[a-f0-9]{7,40}\b)/)) {
             // User/Project@SHA
             // User@SHA
             // SHA
             state.combineTokens = true;
             return "link";
           } else if (stream.match(/^(?:[a-zA-Z0-9\-_]+\/)?(?:[a-zA-Z0-9\-_]+)?#[0-9]+\b/)) {
             // User/Project#Num
             // User#Num
             // #Num
             state.combineTokens = true;
             return "link";
           }
         }
       }
       if (stream.match(urlRE) &&
           stream.string.slice(stream.start - 2, stream.start) != "](" &&
           (stream.start == 0 || /\W/.test(stream.string.charAt(stream.start - 1)))) {
         // URLs
         // Taken from http://daringfireball.net/2010/07/improved_regex_for_matching_urls
         // And then (issue #1160) simplified to make it not crash the Chrome Regexp engine
         // And then limited url schemes to the CommonMark list, so foo:bar isn't matched as a URL
         state.combineTokens = true;
         return "link";
       }
       stream.next();
       return null;
     },
     blankLine: blankLine
   };
 
   var markdownConfig = {
-    underscoresBreakWords: false,
     taskLists: true,
-    fencedCodeBlocks: '```',
-    strikethrough: true
+    strikethrough: true,
+    emoji: true
   };
   for (var attr in modeConfig) {
     markdownConfig[attr] = modeConfig[attr];
   }
   markdownConfig.name = "markdown";
   return CodeMirror.overlayMode(CodeMirror.getMode(config, markdownConfig), gfmOverlay);
 
 }, "markdown");
 
   CodeMirror.defineMIME("text/x-gfm", "gfm");
 });

rhodecode/public/js/mode/gherkin/gherkin.js

@@ -1,178 +1,178 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 /*
 Gherkin mode - http://www.cukes.info/
 Report bugs/issues here: https://github.com/codemirror/CodeMirror/issues
 */
 
 // Following Objs from Brackets implementation: https://github.com/tregusti/brackets-gherkin/blob/master/main.js
 //var Quotes = {
 //  SINGLE: 1,
 //  DOUBLE: 2
 //};
 
 //var regex = {
 //  keywords: /(Feature| {2}(Scenario|In order to|As|I)| {4}(Given|When|Then|And))/
 //};
 
 (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("gherkin", function () {
   return {
     startState: function () {
       return {
         lineNumber: 0,
         tableHeaderLine: false,
         allowFeature: true,
         allowBackground: false,
         allowScenario: false,
         allowSteps: false,
         allowPlaceholders: false,
         allowMultilineArgument: false,
         inMultilineString: false,
         inMultilineTable: false,
         inKeywordLine: false
       };
     },
     token: function (stream, state) {
       if (stream.sol()) {
         state.lineNumber++;
         state.inKeywordLine = false;
         if (state.inMultilineTable) {
             state.tableHeaderLine = false;
             if (!stream.match(/\s*\|/, false)) {
               state.allowMultilineArgument = false;
               state.inMultilineTable = false;
             }
         }
       }
 
       stream.eatSpace();
 
       if (state.allowMultilineArgument) {
 
         // STRING
         if (state.inMultilineString) {
           if (stream.match('"""')) {
             state.inMultilineString = false;
             state.allowMultilineArgument = false;
           } else {
             stream.match(/.*/);
           }
           return "string";
         }
 
         // TABLE
         if (state.inMultilineTable) {
           if (stream.match(/\|\s*/)) {
             return "bracket";
           } else {
             stream.match(/[^\|]*/);
             return state.tableHeaderLine ? "header" : "string";
           }
         }
 
         // DETECT START
         if (stream.match('"""')) {
           // String
           state.inMultilineString = true;
           return "string";
         } else if (stream.match("|")) {
           // Table
           state.inMultilineTable = true;
           state.tableHeaderLine = true;
           return "bracket";
         }
 
       }
 
       // LINE COMMENT
       if (stream.match(/#.*/)) {
         return "comment";
 
       // TAG
       } else if (!state.inKeywordLine && stream.match(/@\S+/)) {
         return "tag";
 
       // FEATURE
       } else if (!state.inKeywordLine && state.allowFeature && stream.match(/(機能|功能|フィーチャ|기능|โครงหลัก|ความสามารถ|ความต้องการทางธุรกิจ|ಹೆಚ್ಚಳ|గుణము|ਮੁਹਾਂਦਰਾ|ਨਕਸ਼ ਨੁਹਾਰ|ਖਾਸੀਅਤ|रूप लेख|وِیژگی|خاصية|תכונה|Функціонал|Функция|Функционалност|Функционал|Үзенчәлеклелек|Свойство|Особина|Мөмкинлек|Могућност|Λειτουργία|Δυνατότητα|Właściwość|Vlastnosť|Trajto|Tính năng|Savybė|Pretty much|Požiadavka|Požadavek|Potrzeba biznesowa|Özellik|Osobina|Ominaisuus|Omadus|OH HAI|Mogućnost|Mogucnost|Jellemző|Hwæt|Hwaet|Funzionalità|Funktionalitéit|Funktionalität|Funkcja|Funkcionalnost|Funkcionalitāte|Funkcia|Fungsi|Functionaliteit|Funcționalitate|Funcţionalitate|Functionalitate|Funcionalitat|Funcionalidade|Fonctionnalité|Fitur|Fīča|Feature|Eiginleiki|Egenskap|Egenskab|Característica|Caracteristica|Business Need|Aspekt|Arwedd|Ahoy matey!|Ability):/)) {
         state.allowScenario = true;
         state.allowBackground = true;
         state.allowPlaceholders = false;
         state.allowSteps = false;
         state.allowMultilineArgument = false;
         state.inKeywordLine = true;
         return "keyword";
 
       // BACKGROUND
       } else if (!state.inKeywordLine && state.allowBackground && stream.match(/(背景|배경|แนวคิด|ಹಿನ್ನೆಲೆ|నేపథ్యం|ਪਿਛੋਕੜ|पृष्ठभूमि|زمینه|الخلفية|רקע|Тарих|Предыстория|Предистория|Позадина|Передумова|Основа|Контекст|Кереш|Υπόβαθρο|Założenia|Yo\-ho\-ho|Tausta|Taust|Situācija|Rerefons|Pozadina|Pozadie|Pozadí|Osnova|Latar Belakang|Kontext|Konteksts|Kontekstas|Kontekst|Háttér|Hannergrond|Grundlage|Geçmiş|Fundo|Fono|First off|Dis is what went down|Dasar|Contexto|Contexte|Context|Contesto|Cenário de Fundo|Cenario de Fundo|Cefndir|Bối cảnh|Bakgrunnur|Bakgrunn|Bakgrund|Baggrund|Background|B4|Antecedents|Antecedentes|Ær|Aer|Achtergrond):/)) {
         state.allowPlaceholders = false;
         state.allowSteps = true;
         state.allowBackground = false;
         state.allowMultilineArgument = false;
         state.inKeywordLine = true;
         return "keyword";
 
       // SCENARIO OUTLINE
       } else if (!state.inKeywordLine && state.allowScenario && stream.match(/(場景大綱|场景大纲|劇本大綱|剧本大纲|テンプレ|シナリオテンプレート|シナリオテンプレ|シナリオアウトライン|시나리오 개요|สรุปเหตุการณ์|โครงสร้างของเหตุการณ์|ವಿವರಣೆ|కథనం|ਪਟਕਥਾ ਰੂਪ ਰੇਖਾ|ਪਟਕਥਾ ਢਾਂਚਾ|परिदृश्य रूपरेखा|سيناريو مخطط|الگوی سناریو|תבנית תרחיש|Сценарийның төзелеше|Сценарий структураси|Структура сценарію|Структура сценария|Структура сценарија|Скица|Рамка на сценарий|Концепт|Περιγραφή Σεναρίου|Wharrimean is|Template Situai|Template Senario|Template Keadaan|Tapausaihio|Szenariogrundriss|Szablon scenariusza|Swa hwær swa|Swa hwaer swa|Struktura scenarija|Structură scenariu|Structura scenariu|Skica|Skenario konsep|Shiver me timbers|Senaryo taslağı|Schema dello scenario|Scenariomall|Scenariomal|Scenario Template|Scenario Outline|Scenario Amlinellol|Scenārijs pēc parauga|Scenarijaus šablonas|Reckon it's like|Raamstsenaarium|Plang vum Szenario|Plan du Scénario|Plan du scénario|Osnova scénáře|Osnova Scenára|Náčrt Scenáru|Náčrt Scénáře|Náčrt Scenára|MISHUN SRSLY|Menggariskan Senario|Lýsing Dæma|Lýsing Atburðarásar|Konturo de la scenaro|Koncept|Khung tình huống|Khung kịch bản|Forgatókönyv vázlat|Esquema do Cenário|Esquema do Cenario|Esquema del escenario|Esquema de l'escenari|Esbozo do escenario|Delineação do Cenário|Delineacao do Cenario|All y'all|Abstrakt Scenario|Abstract Scenario):/)) {
         state.allowPlaceholders = true;
         state.allowSteps = true;
         state.allowMultilineArgument = false;
         state.inKeywordLine = true;
         return "keyword";
 
       // EXAMPLES
       } else if (state.allowScenario && stream.match(/(例子|例|サンプル|예|ชุดของเหตุการณ์|ชุดของตัวอย่าง|ಉದಾಹರಣೆಗಳು|ఉదాహరణలు|ਉਦਾਹਰਨਾਂ|उदाहरण|نمونه ها|امثلة|דוגמאות|Үрнәкләр|Сценарији|Примеры|Примери|Приклади|Мисоллар|Мисаллар|Σενάρια|Παραδείγματα|You'll wanna|Voorbeelden|Variantai|Tapaukset|Se þe|Se the|Se ðe|Scenarios|Scenariji|Scenarijai|Przykłady|Primjeri|Primeri|Příklady|Príklady|Piemēri|Példák|Pavyzdžiai|Paraugs|Örnekler|Juhtumid|Exemplos|Exemples|Exemple|Exempel|EXAMPLZ|Examples|Esempi|Enghreifftiau|Ekzemploj|Eksempler|Ejemplos|Dữ liệu|Dead men tell no tales|Dæmi|Contoh|Cenários|Cenarios|Beispiller|Beispiele|Atburðarásir):/)) {
         state.allowPlaceholders = false;
         state.allowSteps = true;
         state.allowBackground = false;
         state.allowMultilineArgument = true;
         return "keyword";
 
       // SCENARIO
       } else if (!state.inKeywordLine && state.allowScenario && stream.match(/(場景|场景|劇本|剧本|シナリオ|시나리오|เหตุการณ์|ಕಥಾಸಾರಾಂಶ|సన్నివేశం|ਪਟਕਥਾ|परिदृश्य|سيناريو|سناریو|תרחיש|Сценарій|Сценарио|Сценарий|Пример|Σενάριο|Tình huống|The thing of it is|Tapaus|Szenario|Swa|Stsenaarium|Skenario|Situai|Senaryo|Senario|Scenaro|Scenariusz|Scenariu|Scénario|Scenario|Scenarijus|Scenārijs|Scenarij|Scenarie|Scénář|Scenár|Primer|MISHUN|Kịch bản|Keadaan|Heave to|Forgatókönyv|Escenario|Escenari|Cenário|Cenario|Awww, look mate|Atburðarás):/)) {
         state.allowPlaceholders = false;
         state.allowSteps = true;
         state.allowBackground = false;
         state.allowMultilineArgument = false;
         state.inKeywordLine = true;
         return "keyword";
 
       // STEPS
       } else if (!state.inKeywordLine && state.allowSteps && stream.match(/(那麼|那么|而且|當|当|并且|同時|同时|前提|假设|假設|假定|假如|但是|但し|並且|もし|ならば|ただし|しかし|かつ|하지만|조건|먼저|만일|만약|단|그리고|그러면|และ |เมื่อ |แต่ |ดังนั้น |กำหนดให้ |ಸ್ಥಿತಿಯನ್ನು |ಮತ್ತು |ನೀಡಿದ |ನಂತರ |ಆದರೆ |మరియు |చెప్పబడినది |కాని |ఈ పరిస్థితిలో |అప్పుడు |ਪਰ |ਤਦ |ਜੇਕਰ |ਜਿਵੇਂ ਕਿ |ਜਦੋਂ |ਅਤੇ |यदि |परन्तु |पर |तब |तदा |तथा |जब |चूंकि |किन्तु |कदा |और |अगर |و |هنگامی |متى |لكن |عندما |ثم |بفرض |با فرض |اما |اذاً |آنگاه |כאשר |וגם |בהינתן |אזי |אז |אבל |Якщо |Һәм |Унда |Тоді |Тогда |То |Также |Та |Пусть |Припустимо, що |Припустимо |Онда |Но |Нехай |Нәтиҗәдә |Лекин |Ләкин |Коли |Когда |Когато |Када |Кад |К тому же |І |И |Задато |Задати |Задате |Если |Допустим |Дано |Дадено |Вә |Ва |Бирок |Әмма |Әйтик |Әгәр |Аммо |Али |Але |Агар |А також |А |Τότε |Όταν |Και |Δεδομένου |Αλλά |Þurh |Þegar |Þa þe |Þá |Þa |Zatati |Zakładając |Zadato |Zadate |Zadano |Zadani |Zadan |Za předpokladu |Za predpokladu |Youse know when youse got |Youse know like when |Yna |Yeah nah |Y'know |Y |Wun |Wtedy |When y'all |When |Wenn |WEN |wann |Ve |Và |Und |Un |ugeholl |Too right |Thurh |Thì |Then y'all |Then |Tha the |Tha |Tetapi |Tapi |Tak |Tada |Tad |Stel |Soit |Siis |Și |Şi |Si |Sed |Se |Så |Quando |Quand |Quan |Pryd |Potom |Pokud |Pokiaľ |Però |Pero |Pak |Oraz |Onda |Ond |Oletetaan |Og |Och |O zaman |Niin |Nhưng |När |Når |Mutta |Men |Mas |Maka |Majd |Mając |Mais |Maar |mä |Ma |Lorsque |Lorsqu'|Logo |Let go and haul |Kun |Kuid |Kui |Kiedy |Khi |Ketika |Kemudian |Keď |Když |Kaj |Kai |Kada |Kad |Jeżeli |Jeśli |Ja |It's just unbelievable |Ir |I CAN HAZ |I |Ha |Givun |Givet |Given y'all |Given |Gitt |Gegeven |Gegeben seien |Gegeben sei |Gdy |Gangway! |Fakat |Étant donnés |Etant donnés |Étant données |Etant données |Étant donnée |Etant donnée |Étant donné |Etant donné |Et |És |Entonces |Entón |Então |Entao |En |Eğer ki |Ef |Eeldades |E |Ðurh |Duota |Dun |Donitaĵo |Donat |Donada |Do |Diyelim ki |Diberi |Dengan |Den youse gotta |DEN |De |Dato |Dați fiind |Daţi fiind |Dati fiind |Dati |Date fiind |Date |Data |Dat fiind |Dar |Dann |dann |Dan |Dados |Dado |Dadas |Dada |Ða ðe |Ða |Cuando |Cho |Cando |Când |Cand |Cal |But y'all |But at the end of the day I reckon |BUT |But |Buh |Blimey! |Biết |Bet |Bagi |Aye |awer |Avast! |Atunci |Atesa |Atès |Apabila |Anrhegedig a |Angenommen |And y'all |And |AN |An |an |Amikor |Amennyiben |Ama |Als |Alors |Allora |Ali |Aleshores |Ale |Akkor |Ak |Adott |Ac |Aber |A zároveň |A tiež |A taktiež |A také |A |a |7 |\* )/)) {
         state.inStep = true;
         state.allowPlaceholders = true;
         state.allowMultilineArgument = true;
         state.inKeywordLine = true;
         return "keyword";
 
       // INLINE STRING
       } else if (stream.match(/"[^"]*"?/)) {
         return "string";
 
       // PLACEHOLDER
       } else if (state.allowPlaceholders && stream.match(/<[^>]*>?/)) {
         return "variable";
 
       // Fall through
       } else {
         stream.next();
         stream.eatWhile(/[^@"<#]/);
         return null;
       }
     }
   };
 });
 
 CodeMirror.defineMIME("text/x-feature", "gherkin");
 
 });

rhodecode/public/js/mode/go/go.js

@@ -1,185 +1,187 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("go", function(config) {
   var indentUnit = config.indentUnit;
 
   var keywords = {
     "break":true, "case":true, "chan":true, "const":true, "continue":true,
     "default":true, "defer":true, "else":true, "fallthrough":true, "for":true,
     "func":true, "go":true, "goto":true, "if":true, "import":true,
     "interface":true, "map":true, "package":true, "range":true, "return":true,
     "select":true, "struct":true, "switch":true, "type":true, "var":true,
     "bool":true, "byte":true, "complex64":true, "complex128":true,
     "float32":true, "float64":true, "int8":true, "int16":true, "int32":true,
     "int64":true, "string":true, "uint8":true, "uint16":true, "uint32":true,
-    "uint64":true, "int":true, "uint":true, "uintptr":true
+    "uint64":true, "int":true, "uint":true, "uintptr":true, "error": true,
+    "rune":true
   };
 
   var atoms = {
     "true":true, "false":true, "iota":true, "nil":true, "append":true,
-    "cap":true, "close":true, "complex":true, "copy":true, "imag":true,
+    "cap":true, "close":true, "complex":true, "copy":true, "delete":true, "imag":true,
     "len":true, "make":true, "new":true, "panic":true, "print":true,
     "println":true, "real":true, "recover":true
   };
 
   var isOperatorChar = /[+\-*&^%:=<>!|\/]/;
 
   var curPunc;
 
   function tokenBase(stream, state) {
     var ch = stream.next();
     if (ch == '"' || ch == "'" || ch == "`") {
       state.tokenize = tokenString(ch);
       return state.tokenize(stream, state);
     }
     if (/[\d\.]/.test(ch)) {
       if (ch == ".") {
         stream.match(/^[0-9]+([eE][\-+]?[0-9]+)?/);
       } else if (ch == "0") {
         stream.match(/^[xX][0-9a-fA-F]+/) || stream.match(/^0[0-7]+/);
       } else {
         stream.match(/^[0-9]*\.?[0-9]*([eE][\-+]?[0-9]+)?/);
       }
       return "number";
     }
     if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
       curPunc = ch;
       return null;
     }
     if (ch == "/") {
       if (stream.eat("*")) {
         state.tokenize = tokenComment;
         return tokenComment(stream, state);
       }
       if (stream.eat("/")) {
         stream.skipToEnd();
         return "comment";
       }
     }
     if (isOperatorChar.test(ch)) {
       stream.eatWhile(isOperatorChar);
       return "operator";
     }
     stream.eatWhile(/[\w\$_\xa1-\uffff]/);
     var cur = stream.current();
     if (keywords.propertyIsEnumerable(cur)) {
       if (cur == "case" || cur == "default") curPunc = "case";
       return "keyword";
     }
     if (atoms.propertyIsEnumerable(cur)) return "atom";
     return "variable";
   }
 
   function tokenString(quote) {
     return function(stream, state) {
       var escaped = false, next, end = false;
       while ((next = stream.next()) != null) {
         if (next == quote && !escaped) {end = true; break;}
         escaped = !escaped && quote != "`" && next == "\\";
       }
       if (end || !(escaped || quote == "`"))
         state.tokenize = tokenBase;
       return "string";
     };
   }
 
   function tokenComment(stream, state) {
     var maybeEnd = false, ch;
     while (ch = stream.next()) {
       if (ch == "/" && maybeEnd) {
         state.tokenize = tokenBase;
         break;
       }
       maybeEnd = (ch == "*");
     }
     return "comment";
   }
 
   function Context(indented, column, type, align, prev) {
     this.indented = indented;
     this.column = column;
     this.type = type;
     this.align = align;
     this.prev = prev;
   }
   function pushContext(state, col, type) {
     return state.context = new Context(state.indented, col, type, null, state.context);
   }
   function popContext(state) {
     if (!state.context.prev) return;
     var t = state.context.type;
     if (t == ")" || t == "]" || t == "}")
       state.indented = state.context.indented;
     return state.context = state.context.prev;
   }
 
   // Interface
 
   return {
     startState: function(basecolumn) {
       return {
         tokenize: null,
         context: new Context((basecolumn || 0) - indentUnit, 0, "top", false),
         indented: 0,
         startOfLine: true
       };
     },
 
     token: function(stream, state) {
       var ctx = state.context;
       if (stream.sol()) {
         if (ctx.align == null) ctx.align = false;
         state.indented = stream.indentation();
         state.startOfLine = true;
         if (ctx.type == "case") ctx.type = "}";
       }
       if (stream.eatSpace()) return null;
       curPunc = null;
       var style = (state.tokenize || tokenBase)(stream, state);
       if (style == "comment") return style;
       if (ctx.align == null) ctx.align = true;
 
       if (curPunc == "{") pushContext(state, stream.column(), "}");
       else if (curPunc == "[") pushContext(state, stream.column(), "]");
       else if (curPunc == "(") pushContext(state, stream.column(), ")");
       else if (curPunc == "case") ctx.type = "case";
-      else if (curPunc == "}" && ctx.type == "}") ctx = popContext(state);
+      else if (curPunc == "}" && ctx.type == "}") popContext(state);
       else if (curPunc == ctx.type) popContext(state);
       state.startOfLine = false;
       return style;
     },
 
     indent: function(state, textAfter) {
-      if (state.tokenize != tokenBase && state.tokenize != null) return 0;
+      if (state.tokenize != tokenBase && state.tokenize != null) return CodeMirror.Pass;
       var ctx = state.context, firstChar = textAfter && textAfter.charAt(0);
       if (ctx.type == "case" && /^(?:case|default)\b/.test(textAfter)) {
         state.context.type = "}";
         return ctx.indented;
       }
       var closing = firstChar == ctx.type;
       if (ctx.align) return ctx.column + (closing ? 0 : 1);
       else return ctx.indented + (closing ? 0 : indentUnit);
     },
 
     electricChars: "{}):",
+    closeBrackets: "()[]{}''\"\"``",
     fold: "brace",
     blockCommentStart: "/*",
     blockCommentEnd: "*/",
     lineComment: "//"
   };
 });
 
 CodeMirror.defineMIME("text/x-go", "go");
 
 });

rhodecode/public/js/mode/groovy/groovy.js

@@ -1,230 +1,233 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("groovy", function(config) {
   function words(str) {
     var obj = {}, words = str.split(" ");
     for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
     return obj;
   }
   var keywords = words(
     "abstract as assert boolean break byte case catch char class const continue def default " +
     "do double else enum extends final finally float for goto if implements import in " +
     "instanceof int interface long native new package private protected public return " +
-    "short static strictfp super switch synchronized threadsafe throw throws transient " +
+    "short static strictfp super switch synchronized threadsafe throw throws trait transient " +
     "try void volatile while");
-  var blockKeywords = words("catch class do else finally for if switch try while enum interface def");
+  var blockKeywords = words("catch class def do else enum finally for if interface switch trait try while");
   var standaloneKeywords = words("return break continue");
   var atoms = words("null true false this");
 
   var curPunc;
   function tokenBase(stream, state) {
     var ch = stream.next();
     if (ch == '"' || ch == "'") {
       return startString(ch, stream, state);
     }
     if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
       curPunc = ch;
       return null;
     }
     if (/\d/.test(ch)) {
       stream.eatWhile(/[\w\.]/);
       if (stream.eat(/eE/)) { stream.eat(/\+\-/); stream.eatWhile(/\d/); }
       return "number";
     }
     if (ch == "/") {
       if (stream.eat("*")) {
         state.tokenize.push(tokenComment);
         return tokenComment(stream, state);
       }
       if (stream.eat("/")) {
         stream.skipToEnd();
         return "comment";
       }
       if (expectExpression(state.lastToken, false)) {
         return startString(ch, stream, state);
       }
     }
     if (ch == "-" && stream.eat(">")) {
       curPunc = "->";
       return null;
     }
     if (/[+\-*&%=<>!?|\/~]/.test(ch)) {
       stream.eatWhile(/[+\-*&%=<>|~]/);
       return "operator";
     }
     stream.eatWhile(/[\w\$_]/);
     if (ch == "@") { stream.eatWhile(/[\w\$_\.]/); return "meta"; }
     if (state.lastToken == ".") return "property";
     if (stream.eat(":")) { curPunc = "proplabel"; return "property"; }
     var cur = stream.current();
     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";
   }
   tokenBase.isBase = true;
 
   function startString(quote, stream, state) {
     var tripleQuoted = false;
     if (quote != "/" && stream.eat(quote)) {
       if (stream.eat(quote)) tripleQuoted = true;
       else return "string";
     }
     function t(stream, state) {
       var escaped = false, next, end = !tripleQuoted;
       while ((next = stream.next()) != null) {
         if (next == quote && !escaped) {
           if (!tripleQuoted) { break; }
           if (stream.match(quote + quote)) { end = true; break; }
         }
         if (quote == '"' && next == "$" && !escaped && stream.eat("{")) {
           state.tokenize.push(tokenBaseUntilBrace());
           return "string";
         }
         escaped = !escaped && next == "\\";
       }
       if (end) state.tokenize.pop();
       return "string";
     }
     state.tokenize.push(t);
     return t(stream, state);
   }
 
   function tokenBaseUntilBrace() {
     var depth = 1;
     function t(stream, state) {
       if (stream.peek() == "}") {
         depth--;
         if (depth == 0) {
           state.tokenize.pop();
           return state.tokenize[state.tokenize.length-1](stream, state);
         }
       } else if (stream.peek() == "{") {
         depth++;
       }
       return tokenBase(stream, state);
     }
     t.isBase = true;
     return t;
   }
 
   function tokenComment(stream, state) {
     var maybeEnd = false, ch;
     while (ch = stream.next()) {
       if (ch == "/" && maybeEnd) {
         state.tokenize.pop();
         break;
       }
       maybeEnd = (ch == "*");
     }
     return "comment";
   }
 
   function expectExpression(last, newline) {
     return !last || last == "operator" || last == "->" || /[\.\[\{\(,;:]/.test(last) ||
       last == "newstatement" || last == "keyword" || last == "proplabel" ||
       (last == "standalone" && !newline);
   }
 
   function Context(indented, column, type, align, prev) {
     this.indented = indented;
     this.column = column;
     this.type = type;
     this.align = align;
     this.prev = prev;
   }
   function pushContext(state, col, type) {
     return state.context = new Context(state.indented, col, type, null, state.context);
   }
   function popContext(state) {
     var t = state.context.type;
     if (t == ")" || t == "]" || t == "}")
       state.indented = state.context.indented;
     return state.context = state.context.prev;
   }
 
   // Interface
 
   return {
     startState: function(basecolumn) {
       return {
         tokenize: [tokenBase],
         context: new Context((basecolumn || 0) - config.indentUnit, 0, "top", false),
         indented: 0,
         startOfLine: true,
         lastToken: null
       };
     },
 
     token: function(stream, state) {
       var ctx = state.context;
       if (stream.sol()) {
         if (ctx.align == null) ctx.align = false;
         state.indented = stream.indentation();
         state.startOfLine = true;
         // Automatic semicolon insertion
         if (ctx.type == "statement" && !expectExpression(state.lastToken, true)) {
           popContext(state); ctx = state.context;
         }
       }
       if (stream.eatSpace()) return null;
       curPunc = null;
       var style = state.tokenize[state.tokenize.length-1](stream, state);
       if (style == "comment") return style;
       if (ctx.align == null) ctx.align = true;
 
       if ((curPunc == ";" || curPunc == ":") && ctx.type == "statement") popContext(state);
       // Handle indentation for {x -> \n ... }
       else if (curPunc == "->" && ctx.type == "statement" && ctx.prev.type == "}") {
         popContext(state);
         state.context.align = false;
       }
       else if (curPunc == "{") pushContext(state, stream.column(), "}");
       else if (curPunc == "[") pushContext(state, stream.column(), "]");
       else if (curPunc == "(") pushContext(state, stream.column(), ")");
       else if (curPunc == "}") {
         while (ctx.type == "statement") ctx = popContext(state);
         if (ctx.type == "}") ctx = popContext(state);
         while (ctx.type == "statement") ctx = popContext(state);
       }
       else if (curPunc == ctx.type) popContext(state);
       else if (ctx.type == "}" || ctx.type == "top" || (ctx.type == "statement" && curPunc == "newstatement"))
         pushContext(state, stream.column(), "statement");
       state.startOfLine = false;
       state.lastToken = curPunc || style;
       return style;
     },
 
     indent: function(state, textAfter) {
-      if (!state.tokenize[state.tokenize.length-1].isBase) return 0;
+      if (!state.tokenize[state.tokenize.length-1].isBase) return CodeMirror.Pass;
       var firstChar = textAfter && textAfter.charAt(0), ctx = state.context;
       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);
       else return ctx.indented + (closing ? 0 : config.indentUnit);
     },
 
     electricChars: "{}",
     closeBrackets: {triples: "'\""},
-    fold: "brace"
+    fold: "brace",
+    blockCommentStart: "/*",
+    blockCommentEnd: "*/",
+    lineComment: "//"
   };
 });
 
 CodeMirror.defineMIME("text/x-groovy", "groovy");
 
 });

rhodecode/public/js/mode/haml/haml.js

@@ -1,161 +1,161 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 (function(mod) {
   if (typeof exports == "object" && typeof module == "object") // CommonJS
     mod(require("../../lib/codemirror"), require("../htmlmixed/htmlmixed"), require("../ruby/ruby"));
   else if (typeof define == "function" && define.amd) // AMD
     define(["../../lib/codemirror", "../htmlmixed/htmlmixed", "../ruby/ruby"], mod);
   else // Plain browser env
     mod(CodeMirror);
 })(function(CodeMirror) {
 "use strict";
 
-  // full haml mode. This handled embeded ruby and html fragments too
+  // full haml mode. This handled embedded ruby and html fragments too
   CodeMirror.defineMode("haml", function(config) {
     var htmlMode = CodeMirror.getMode(config, {name: "htmlmixed"});
     var rubyMode = CodeMirror.getMode(config, "ruby");
 
     function rubyInQuote(endQuote) {
       return function(stream, state) {
         var ch = stream.peek();
         if (ch == endQuote && state.rubyState.tokenize.length == 1) {
           // step out of ruby context as it seems to complete processing all the braces
           stream.next();
           state.tokenize = html;
           return "closeAttributeTag";
         } else {
           return ruby(stream, state);
         }
       };
     }
 
     function ruby(stream, state) {
       if (stream.match("-#")) {
         stream.skipToEnd();
         return "comment";
       }
       return rubyMode.token(stream, state.rubyState);
     }
 
     function html(stream, state) {
       var ch = stream.peek();
 
       // handle haml declarations. All declarations that cant be handled here
       // will be passed to html mode
       if (state.previousToken.style == "comment" ) {
         if (state.indented > state.previousToken.indented) {
           stream.skipToEnd();
           return "commentLine";
         }
       }
 
       if (state.startOfLine) {
         if (ch == "!" && stream.match("!!")) {
           stream.skipToEnd();
           return "tag";
         } else if (stream.match(/^%[\w:#\.]+=/)) {
           state.tokenize = ruby;
           return "hamlTag";
         } else if (stream.match(/^%[\w:]+/)) {
           return "hamlTag";
         } else if (ch == "/" ) {
           stream.skipToEnd();
           return "comment";
         }
       }
 
       if (state.startOfLine || state.previousToken.style == "hamlTag") {
         if ( ch == "#" || ch == ".") {
           stream.match(/[\w-#\.]*/);
           return "hamlAttribute";
         }
       }
 
       // donot handle --> as valid ruby, make it HTML close comment instead
       if (state.startOfLine && !stream.match("-->", false) && (ch == "=" || ch == "-" )) {
         state.tokenize = ruby;
         return state.tokenize(stream, state);
       }
 
       if (state.previousToken.style == "hamlTag" ||
           state.previousToken.style == "closeAttributeTag" ||
           state.previousToken.style == "hamlAttribute") {
         if (ch == "(") {
           state.tokenize = rubyInQuote(")");
           return state.tokenize(stream, state);
         } else if (ch == "{") {
           if (!stream.match(/^\{%.*/)) {
             state.tokenize = rubyInQuote("}");
             return state.tokenize(stream, state);
           }
         }
       }
 
       return htmlMode.token(stream, state.htmlState);
     }
 
     return {
       // default to html mode
       startState: function() {
-        var htmlState = htmlMode.startState();
-        var rubyState = rubyMode.startState();
+        var htmlState = CodeMirror.startState(htmlMode);
+        var rubyState = CodeMirror.startState(rubyMode);
         return {
           htmlState: htmlState,
           rubyState: rubyState,
           indented: 0,
           previousToken: { style: null, indented: 0},
           tokenize: html
         };
       },
 
       copyState: function(state) {
         return {
           htmlState : CodeMirror.copyState(htmlMode, state.htmlState),
           rubyState: CodeMirror.copyState(rubyMode, state.rubyState),
           indented: state.indented,
           previousToken: state.previousToken,
           tokenize: state.tokenize
         };
       },
 
       token: function(stream, state) {
         if (stream.sol()) {
           state.indented = stream.indentation();
           state.startOfLine = true;
         }
         if (stream.eatSpace()) return null;
         var style = state.tokenize(stream, state);
         state.startOfLine = false;
         // dont record comment line as we only want to measure comment line with
         // the opening comment block
         if (style && style != "commentLine") {
           state.previousToken = { style: style, indented: state.indented };
         }
         // if current state is ruby and the previous token is not `,` reset the
         // tokenize to html
         if (stream.eol() && state.tokenize == ruby) {
           stream.backUp(1);
           var ch = stream.peek();
           stream.next();
           if (ch && ch != ",") {
             state.tokenize = html;
           }
         }
         // reprocess some of the specific style tag when finish setting previousToken
         if (style == "hamlTag") {
           style = "tag";
         } else if (style == "commentLine") {
           style = "comment";
         } else if (style == "hamlAttribute") {
           style = "attribute";
         } else if (style == "closeAttributeTag") {
           style = null;
         }
         return style;
       }
     };
   }, "htmlmixed", "ruby");
 
   CodeMirror.defineMIME("text/x-haml", "haml");
 });

rhodecode/public/js/mode/handlebars/handlebars.js

@@ -1,62 +1,70 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 (function(mod) {
   if (typeof exports == "object" && typeof module == "object") // CommonJS
     mod(require("../../lib/codemirror"), require("../../addon/mode/simple"), require("../../addon/mode/multiplex"));
   else if (typeof define == "function" && define.amd) // AMD
     define(["../../lib/codemirror", "../../addon/mode/simple", "../../addon/mode/multiplex"], mod);
   else // Plain browser env
     mod(CodeMirror);
 })(function(CodeMirror) {
   "use strict";
 
   CodeMirror.defineSimpleMode("handlebars-tags", {
     start: [
+      { regex: /\{\{\{/, push: "handlebars_raw", token: "tag" },
       { regex: /\{\{!--/, push: "dash_comment", token: "comment" },
       { regex: /\{\{!/,   push: "comment", token: "comment" },
       { regex: /\{\{/,    push: "handlebars", token: "tag" }
     ],
+    handlebars_raw: [
+      { regex: /\}\}\}/, pop: true, token: "tag" },
+    ],
     handlebars: [
       { regex: /\}\}/, pop: true, token: "tag" },
 
       // Double and single quotes
       { regex: /"(?:[^\\"]|\\.)*"?/, token: "string" },
       { regex: /'(?:[^\\']|\\.)*'?/, token: "string" },
 
       // Handlebars keywords
       { regex: />|[#\/]([A-Za-z_]\w*)/, token: "keyword" },
       { regex: /(?:else|this)\b/, token: "keyword" },
 
       // Numeral
       { regex: /\d+/i, token: "number" },
 
       // Atoms like = and .
       { regex: /=|~|@|true|false/, token: "atom" },
 
       // Paths
       { regex: /(?:\.\.\/)*(?:[A-Za-z_][\w\.]*)+/, token: "variable-2" }
     ],
     dash_comment: [
       { regex: /--\}\}/, pop: true, token: "comment" },
 
       // Commented code
       { regex: /./, token: "comment"}
     ],
     comment: [
       { regex: /\}\}/, pop: true, token: "comment" },
       { regex: /./, token: "comment" }
-    ]
+    ],
+    meta: {
+      blockCommentStart: "{{--",
+      blockCommentEnd: "--}}"
+    }
   });
 
   CodeMirror.defineMode("handlebars", function(config, parserConfig) {
     var handlebars = CodeMirror.getMode(config, "handlebars-tags");
     if (!parserConfig || !parserConfig.base) return handlebars;
     return CodeMirror.multiplexingMode(
       CodeMirror.getMode(config, parserConfig.base),
       {open: "{{", close: "}}", mode: handlebars, parseDelimiters: true}
     );
   });
 
   CodeMirror.defineMIME("text/x-handlebars-template", "handlebars");
 });

rhodecode/public/js/mode/haskell-literate/haskell-literate.js

@@ -1,43 +1,43 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 (function (mod) {
   if (typeof exports == "object" && typeof module == "object") // CommonJS
     mod(require("../../lib/codemirror"), require("../haskell/haskell"))
   else if (typeof define == "function" && define.amd) // AMD
     define(["../../lib/codemirror", "../haskell/haskell"], mod)
   else // Plain browser env
     mod(CodeMirror)
 })(function (CodeMirror) {
   "use strict"
 
   CodeMirror.defineMode("haskell-literate", function (config, parserConfig) {
     var baseMode = CodeMirror.getMode(config, (parserConfig && parserConfig.base) || "haskell")
 
     return {
       startState: function () {
         return {
           inCode: false,
           baseState: CodeMirror.startState(baseMode)
         }
       },
       token: function (stream, state) {
         if (stream.sol()) {
           if (state.inCode = stream.eat(">"))
             return "meta"
         }
         if (state.inCode) {
           return baseMode.token(stream, state.baseState)
         } else {
           stream.skipToEnd()
           return "comment"
         }
       },
       innerMode: function (state) {
         return state.inCode ? {state: state.baseState, mode: baseMode} : null
       }
     }
   }, "haskell")
 
   CodeMirror.defineMIME("text/x-literate-haskell", "haskell-literate")
-})
+});

rhodecode/public/js/mode/haskell/haskell.js

@@ -1,267 +1,268 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("haskell", function(_config, modeConfig) {
 
   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 = /\d/;
   var hexitRE = /[0-9A-Fa-f]/;
   var octitRE = /[0-7]/;
   var idRE = /[a-z_A-Z0-9'\xa1-\uffff]/;
   var symbolRE = /[-!#$%&*+.\/<=>?@\\^|~:]/;
   var specialRE = /[(),;[\]`{}]/;
   var whiteCharRE = /[ \t\v\f]/; // newlines are handled in tokenizer
 
   function normal(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";
+      return "string 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)) {
       source.eatWhile(idRE);
       return "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.match(/^\.\d+/)) {
         t = "number";
       }
       if (source.eat(/[eE]/)) {
         t = "number";
         source.eat(/[-+]/);
         source.eatWhile(digitRE); // should require at least 1
       }
       return t;
     }
 
     if (ch == "." && source.eat("."))
       return "keyword";
 
     if (symbolRE.test(ch)) {
       if (ch == '-' && source.eat(/-/)) {
         source.eatWhile(/-/);
         if (!source.eat(symbolRE)) {
           source.skipToEnd();
           return "comment";
         }
       }
       var t = "variable";
       if (ch == ':') {
         t = "variable-2";
       }
       source.eatWhile(symbolRE);
       return t;
     }
 
     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('&')) {
         }
         else {
           source.next(); // should handle other escapes here
         }
       }
     }
     setState(normal);
-    return "error";
+    return "string error";
   }
 
   function stringGap(source, setState) {
     if (source.eat('\\')) {
       return switchState(source, setState, stringLiteral);
     }
     source.next();
     setState(normal);
     return "error";
   }
 
 
   var wellKnownWords = (function() {
     var wkw = {};
     function setType(t) {
       return function () {
         for (var i = 0; i < arguments.length; i++)
           wkw[arguments[i]] = t;
       };
     }
 
     setType("keyword")(
       "case", "class", "data", "default", "deriving", "do", "else", "foreign",
       "if", "import", "in", "infix", "infixl", "infixr", "instance", "let",
       "module", "newtype", "of", "then", "type", "where", "_");
 
     setType("keyword")(
-      "\.\.", ":", "::", "=", "\\", "\"", "<-", "->", "@", "~", "=>");
+      "\.\.", ":", "::", "=", "\\", "<-", "->", "@", "~", "=>");
 
     setType("builtin")(
-      "!!", "$!", "$", "&&", "+", "++", "-", ".", "/", "/=", "<", "<=", "=<<",
-      "==", ">", ">=", ">>", ">>=", "^", "^^", "||", "*", "**");
+      "!!", "$!", "$", "&&", "+", "++", "-", ".", "/", "/=", "<", "<*", "<=",
+      "<$>", "<*>", "=<<", "==", ">", ">=", ">>", ">>=", "^", "^^", "||", "*",
+      "*>", "**");
 
     setType("builtin")(
-      "Bool", "Bounded", "Char", "Double", "EQ", "Either", "Enum", "Eq",
-      "False", "FilePath", "Float", "Floating", "Fractional", "Functor", "GT",
-      "IO", "IOError", "Int", "Integer", "Integral", "Just", "LT", "Left",
+      "Applicative", "Bool", "Bounded", "Char", "Double", "EQ", "Either", "Enum",
+      "Eq", "False", "FilePath", "Float", "Floating", "Fractional", "Functor",
+      "GT", "IO", "IOError", "Int", "Integer", "Integral", "Just", "LT", "Left",
       "Maybe", "Monad", "Nothing", "Num", "Ord", "Ordering", "Rational", "Read",
       "ReadS", "Real", "RealFloat", "RealFrac", "Right", "Show", "ShowS",
       "String", "True");
 
     setType("builtin")(
       "abs", "acos", "acosh", "all", "and", "any", "appendFile", "asTypeOf",
       "asin", "asinh", "atan", "atan2", "atanh", "break", "catch", "ceiling",
       "compare", "concat", "concatMap", "const", "cos", "cosh", "curry",
       "cycle", "decodeFloat", "div", "divMod", "drop", "dropWhile", "either",
       "elem", "encodeFloat", "enumFrom", "enumFromThen", "enumFromThenTo",
       "enumFromTo", "error", "even", "exp", "exponent", "fail", "filter",
       "flip", "floatDigits", "floatRadix", "floatRange", "floor", "fmap",
       "foldl", "foldl1", "foldr", "foldr1", "fromEnum", "fromInteger",
       "fromIntegral", "fromRational", "fst", "gcd", "getChar", "getContents",
       "getLine", "head", "id", "init", "interact", "ioError", "isDenormalized",
       "isIEEE", "isInfinite", "isNaN", "isNegativeZero", "iterate", "last",
       "lcm", "length", "lex", "lines", "log", "logBase", "lookup", "map",
       "mapM", "mapM_", "max", "maxBound", "maximum", "maybe", "min", "minBound",
       "minimum", "mod", "negate", "not", "notElem", "null", "odd", "or",
-      "otherwise", "pi", "pred", "print", "product", "properFraction",
+      "otherwise", "pi", "pred", "print", "product", "properFraction", "pure",
       "putChar", "putStr", "putStrLn", "quot", "quotRem", "read", "readFile",
       "readIO", "readList", "readLn", "readParen", "reads", "readsPrec",
       "realToFrac", "recip", "rem", "repeat", "replicate", "return", "reverse",
       "round", "scaleFloat", "scanl", "scanl1", "scanr", "scanr1", "seq",
       "sequence", "sequence_", "show", "showChar", "showList", "showParen",
       "showString", "shows", "showsPrec", "significand", "signum", "sin",
       "sinh", "snd", "span", "splitAt", "sqrt", "subtract", "succ", "sum",
       "tail", "take", "takeWhile", "tan", "tanh", "toEnum", "toInteger",
       "toRational", "truncate", "uncurry", "undefined", "unlines", "until",
       "unwords", "unzip", "unzip3", "userError", "words", "writeFile", "zip",
       "zip3", "zipWith", "zipWith3");
 
     var override = modeConfig.overrideKeywords;
     if (override) for (var word in override) if (override.hasOwnProperty(word))
       wkw[word] = override[word];
 
     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;
     },
 
     blockCommentStart: "{-",
     blockCommentEnd: "-}",
     lineComment: "--"
   };
 
 });
 
 CodeMirror.defineMIME("text/x-haskell", "haskell");
 
 });

rhodecode/public/js/mode/haxe/haxe.js

@@ -1,515 +1,515 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("haxe", function(config, parserConfig) {
   var indentUnit = config.indentUnit;
 
   // Tokenizer
 
   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"}, attribute = {type:"attribute", style: "attribute"};
   var type = kw("typedef");
   var keywords = {
     "if": A, "while": A, "else": B, "do": B, "try": B,
     "return": C, "break": C, "continue": C, "new": C, "throw": C,
     "var": kw("var"), "inline":attribute, "static": attribute, "using":kw("import"),
     "public": attribute, "private": attribute, "cast": kw("cast"), "import": kw("import"), "macro": kw("macro"),
     "function": kw("function"), "catch": kw("catch"), "untyped": kw("untyped"), "callback": kw("cb"),
     "for": kw("for"), "switch": kw("switch"), "case": kw("case"), "default": kw("default"),
     "in": operator, "never": kw("property_access"), "trace":kw("trace"),
     "class": type, "abstract":type, "enum":type, "interface":type, "typedef":type, "extends":type, "implements":type, "dynamic":type,
     "true": atom, "false": atom, "null": atom
   };
 
   var isOperatorChar = /[+\-*&%=<>!?|]/;
 
   function chain(stream, state, f) {
     state.tokenize = f;
     return f(stream, state);
   }
 
   function toUnescaped(stream, end) {
     var escaped = false, next;
     while ((next = stream.next()) != null) {
       if (next == end && !escaped)
         return true;
       escaped = !escaped && next == "\\";
     }
   }
 
   // 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 haxeTokenBase(stream, state) {
     var ch = stream.next();
     if (ch == '"' || ch == "'") {
       return chain(stream, state, haxeTokenString(ch));
     } else if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
       return ret(ch);
     } else if (ch == "0" && stream.eat(/x/i)) {
       stream.eatWhile(/[\da-f]/i);
       return ret("number", "number");
     } else if (/\d/.test(ch) || ch == "-" && stream.eat(/\d/)) {
       stream.match(/^\d*(?:\.\d*(?!\.))?(?:[eE][+\-]?\d+)?/);
       return ret("number", "number");
     } else if (state.reAllowed && (ch == "~" && stream.eat(/\//))) {
       toUnescaped(stream, "/");
       stream.eatWhile(/[gimsu]/);
       return ret("regexp", "string-2");
     } else if (ch == "/") {
       if (stream.eat("*")) {
         return chain(stream, state, haxeTokenComment);
       } else if (stream.eat("/")) {
         stream.skipToEnd();
         return ret("comment", "comment");
       } else {
         stream.eatWhile(isOperatorChar);
         return ret("operator", null, stream.current());
       }
     } else if (ch == "#") {
         stream.skipToEnd();
         return ret("conditional", "meta");
     } else if (ch == "@") {
       stream.eat(/:/);
       stream.eatWhile(/[\w_]/);
       return ret ("metadata", "meta");
     } else if (isOperatorChar.test(ch)) {
       stream.eatWhile(isOperatorChar);
       return ret("operator", null, stream.current());
     } else {
       var word;
       if(/[A-Z]/.test(ch)) {
         stream.eatWhile(/[\w_<>]/);
         word = stream.current();
         return ret("type", "variable-3", word);
       } else {
         stream.eatWhile(/[\w_]/);
         var word = stream.current(), known = keywords.propertyIsEnumerable(word) && keywords[word];
         return (known && state.kwAllowed) ? ret(known.type, known.style, word) :
                        ret("variable", "variable", word);
       }
     }
   }
 
   function haxeTokenString(quote) {
     return function(stream, state) {
       if (toUnescaped(stream, quote))
         state.tokenize = haxeTokenBase;
       return ret("string", "string");
     };
   }
 
   function haxeTokenComment(stream, state) {
     var maybeEnd = false, ch;
     while (ch = stream.next()) {
       if (ch == "/" && maybeEnd) {
         state.tokenize = haxeTokenBase;
         break;
       }
       maybeEnd = (ch == "*");
     }
     return ret("comment", "comment");
   }
 
   // Parser
 
   var atomicTypes = {"atom": true, "number": true, "variable": true, "string": true, "regexp": true};
 
   function HaxeLexical(indented, column, type, align, prev, info) {
     this.indented = indented;
     this.column = column;
     this.type = type;
     this.prev = prev;
     this.info = info;
     if (align != null) this.align = align;
   }
 
   function inScope(state, varname) {
     for (var v = state.localVars; v; v = v.next)
       if (v.name == varname) return true;
   }
 
   function parseHaxe(state, style, type, content, stream) {
     var cc = state.cc;
     // Communicate our context to the combinators.
     // (Less wasteful than consing up a hundred closures on every call.)
     cx.state = state; cx.stream = stream; cx.marked = null, cx.cc = cc;
 
     if (!state.lexical.hasOwnProperty("align"))
       state.lexical.align = true;
 
     while(true) {
       var combinator = cc.length ? cc.pop() : statement;
       if (combinator(type, content)) {
         while(cc.length && cc[cc.length - 1].lex)
           cc.pop()();
         if (cx.marked) return cx.marked;
         if (type == "variable" && inScope(state, content)) return "variable-2";
         if (type == "variable" && imported(state, content)) return "variable-3";
         return style;
       }
     }
   }
 
   function imported(state, typename) {
     if (/[a-z]/.test(typename.charAt(0)))
       return false;
     var len = state.importedtypes.length;
     for (var i = 0; i<len; i++)
       if(state.importedtypes[i]==typename) return true;
   }
 
   function registerimport(importname) {
     var state = cx.state;
     for (var t = state.importedtypes; t; t = t.next)
       if(t.name == importname) return;
     state.importedtypes = { name: importname, next: state.importedtypes };
   }
   // Combinator utils
 
   var cx = {state: null, column: null, marked: null, cc: null};
   function pass() {
     for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]);
   }
   function cont() {
     pass.apply(null, arguments);
     return true;
   }
   function inList(name, list) {
     for (var v = list; v; v = v.next)
       if (v.name == name) return true;
     return false;
   }
   function register(varname) {
     var state = cx.state;
     if (state.context) {
       cx.marked = "def";
       if (inList(varname, state.localVars)) return;
       state.localVars = {name: varname, next: state.localVars};
     } else if (state.globalVars) {
       if (inList(varname, state.globalVars)) return;
       state.globalVars = {name: varname, next: state.globalVars};
     }
   }
 
   // Combinators
 
   var defaultVars = {name: "this", next: null};
   function pushcontext() {
     if (!cx.state.context) cx.state.localVars = defaultVars;
     cx.state.context = {prev: cx.state.context, vars: cx.state.localVars};
   }
   function popcontext() {
     cx.state.localVars = cx.state.context.vars;
     cx.state.context = cx.state.context.prev;
   }
   popcontext.lex = true;
   function pushlex(type, info) {
     var result = function() {
       var state = cx.state;
       state.lexical = new HaxeLexical(state.indented, cx.stream.column(), type, null, state.lexical, info);
     };
     result.lex = true;
     return result;
   }
   function poplex() {
     var state = cx.state;
     if (state.lexical.prev) {
       if (state.lexical.type == ")")
         state.indented = state.lexical.indented;
       state.lexical = state.lexical.prev;
     }
   }
   poplex.lex = true;
 
   function expect(wanted) {
     function f(type) {
       if (type == wanted) return cont();
       else if (wanted == ";") return pass();
       else return cont(f);
     }
     return f;
   }
 
   function statement(type) {
     if (type == "@") return cont(metadef);
     if (type == "var") return cont(pushlex("vardef"), vardef1, expect(";"), poplex);
     if (type == "keyword a") return cont(pushlex("form"), expression, statement, poplex);
     if (type == "keyword b") return cont(pushlex("form"), statement, poplex);
     if (type == "{") return cont(pushlex("}"), pushcontext, block, poplex, popcontext);
     if (type == ";") return cont();
     if (type == "attribute") return cont(maybeattribute);
     if (type == "function") return cont(functiondef);
     if (type == "for") return cont(pushlex("form"), expect("("), pushlex(")"), forspec1, expect(")"),
                                    poplex, statement, poplex);
     if (type == "variable") return cont(pushlex("stat"), maybelabel);
     if (type == "switch") return cont(pushlex("form"), expression, pushlex("}", "switch"), expect("{"),
                                       block, poplex, poplex);
     if (type == "case") return cont(expression, expect(":"));
     if (type == "default") return cont(expect(":"));
     if (type == "catch") return cont(pushlex("form"), pushcontext, expect("("), funarg, expect(")"),
                                      statement, poplex, popcontext);
     if (type == "import") return cont(importdef, expect(";"));
     if (type == "typedef") return cont(typedef);
     return pass(pushlex("stat"), expression, expect(";"), poplex);
   }
   function expression(type) {
     if (atomicTypes.hasOwnProperty(type)) return cont(maybeoperator);
     if (type == "type" ) return cont(maybeoperator);
     if (type == "function") return cont(functiondef);
     if (type == "keyword c") return cont(maybeexpression);
     if (type == "(") return cont(pushlex(")"), maybeexpression, expect(")"), poplex, maybeoperator);
     if (type == "operator") return cont(expression);
     if (type == "[") return cont(pushlex("]"), commasep(maybeexpression, "]"), poplex, maybeoperator);
     if (type == "{") return cont(pushlex("}"), commasep(objprop, "}"), poplex, maybeoperator);
     return cont();
   }
   function maybeexpression(type) {
     if (type.match(/[;\}\)\],]/)) return pass();
     return pass(expression);
   }
 
   function maybeoperator(type, value) {
     if (type == "operator" && /\+\+|--/.test(value)) return cont(maybeoperator);
     if (type == "operator" || type == ":") return cont(expression);
     if (type == ";") return;
     if (type == "(") return cont(pushlex(")"), commasep(expression, ")"), poplex, maybeoperator);
     if (type == ".") return cont(property, maybeoperator);
     if (type == "[") return cont(pushlex("]"), expression, expect("]"), poplex, maybeoperator);
   }
 
   function maybeattribute(type) {
     if (type == "attribute") return cont(maybeattribute);
     if (type == "function") return cont(functiondef);
     if (type == "var") return cont(vardef1);
   }
 
   function metadef(type) {
     if(type == ":") return cont(metadef);
     if(type == "variable") return cont(metadef);
     if(type == "(") return cont(pushlex(")"), commasep(metaargs, ")"), poplex, statement);
   }
   function metaargs(type) {
     if(type == "variable") return cont();
   }
 
   function importdef (type, value) {
     if(type == "variable" && /[A-Z]/.test(value.charAt(0))) { registerimport(value); return cont(); }
     else if(type == "variable" || type == "property" || type == "." || value == "*") return cont(importdef);
   }
 
   function typedef (type, value)
   {
     if(type == "variable" && /[A-Z]/.test(value.charAt(0))) { registerimport(value); return cont(); }
     else if (type == "type" && /[A-Z]/.test(value.charAt(0))) { return cont(); }
   }
 
   function maybelabel(type) {
     if (type == ":") return cont(poplex, statement);
     return pass(maybeoperator, expect(";"), poplex);
   }
   function property(type) {
     if (type == "variable") {cx.marked = "property"; return cont();}
   }
   function objprop(type) {
     if (type == "variable") cx.marked = "property";
     if (atomicTypes.hasOwnProperty(type)) return cont(expect(":"), expression);
   }
   function commasep(what, end) {
     function proceed(type) {
       if (type == ",") return cont(what, proceed);
       if (type == end) return cont();
       return cont(expect(end));
     }
     return function(type) {
       if (type == end) return cont();
       else return pass(what, proceed);
     };
   }
   function block(type) {
     if (type == "}") return cont();
     return pass(statement, block);
   }
   function vardef1(type, value) {
     if (type == "variable"){register(value); return cont(typeuse, vardef2);}
     return cont();
   }
   function vardef2(type, value) {
     if (value == "=") return cont(expression, vardef2);
     if (type == ",") return cont(vardef1);
   }
   function forspec1(type, value) {
     if (type == "variable") {
       register(value);
       return cont(forin, expression)
     } else {
       return pass()
     }
   }
   function forin(_type, value) {
     if (value == "in") return cont();
   }
   function functiondef(type, value) {
     //function names starting with upper-case letters are recognised as types, so cludging them together here.
     if (type == "variable" || type == "type") {register(value); return cont(functiondef);}
     if (value == "new") return cont(functiondef);
     if (type == "(") return cont(pushlex(")"), pushcontext, commasep(funarg, ")"), poplex, typeuse, statement, popcontext);
   }
   function typeuse(type) {
     if(type == ":") return cont(typestring);
   }
   function typestring(type) {
     if(type == "type") return cont();
     if(type == "variable") return cont();
     if(type == "{") return cont(pushlex("}"), commasep(typeprop, "}"), poplex);
   }
   function typeprop(type) {
     if(type == "variable") return cont(typeuse);
   }
   function funarg(type, value) {
     if (type == "variable") {register(value); return cont(typeuse);}
   }
 
   // Interface
   return {
     startState: function(basecolumn) {
       var defaulttypes = ["Int", "Float", "String", "Void", "Std", "Bool", "Dynamic", "Array"];
       var state = {
         tokenize: haxeTokenBase,
         reAllowed: true,
         kwAllowed: true,
         cc: [],
         lexical: new HaxeLexical((basecolumn || 0) - indentUnit, 0, "block", false),
         localVars: parserConfig.localVars,
         importedtypes: defaulttypes,
         context: parserConfig.localVars && {vars: parserConfig.localVars},
         indented: 0
       };
       if (parserConfig.globalVars && typeof parserConfig.globalVars == "object")
         state.globalVars = parserConfig.globalVars;
       return state;
     },
 
     token: function(stream, state) {
       if (stream.sol()) {
         if (!state.lexical.hasOwnProperty("align"))
           state.lexical.align = false;
         state.indented = stream.indentation();
       }
       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 != '.';
       return parseHaxe(state, style, type, content, stream);
     },
 
     indent: function(state, textAfter) {
       if (state.tokenize != haxeTokenBase) return 0;
       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 + 4;
       else if (type == "form" && firstChar == "{") return lexical.indented;
       else if (type == "stat" || type == "form") return lexical.indented + indentUnit;
       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: "{}",
     blockCommentStart: "/*",
     blockCommentEnd: "*/",
     lineComment: "//"
   };
 });
 
 CodeMirror.defineMIME("text/x-haxe", "haxe");
 
 CodeMirror.defineMode("hxml", function () {
 
   return {
     startState: function () {
       return {
         define: false,
         inString: false
       };
     },
     token: function (stream, state) {
       var ch = stream.peek();
       var sol = stream.sol();
 
       ///* comments */
       if (ch == "#") {
         stream.skipToEnd();
         return "comment";
       }
       if (sol && ch == "-") {
         var style = "variable-2";
 
         stream.eat(/-/);
 
         if (stream.peek() == "-") {
           stream.eat(/-/);
           style = "keyword a";
         }
 
         if (stream.peek() == "D") {
           stream.eat(/[D]/);
           style = "keyword c";
           state.define = true;
         }
 
         stream.eatWhile(/[A-Z]/i);
         return style;
       }
 
       var ch = stream.peek();
 
       if (state.inString == false && ch == "'") {
         state.inString = true;
-        ch = stream.next();
+        stream.next();
       }
 
       if (state.inString == true) {
         if (stream.skipTo("'")) {
 
         } else {
           stream.skipToEnd();
         }
 
         if (stream.peek() == "'") {
           stream.next();
           state.inString = false;
         }
 
         return "string";
       }
 
       stream.next();
       return null;
     },
     lineComment: "#"
   };
 });
 
 CodeMirror.defineMIME("text/x-hxml", "hxml");
 
 });

rhodecode/public/js/mode/htmlembedded/htmlembedded.js

@@ -1,28 +1,37 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 (function(mod) {
   if (typeof exports == "object" && typeof module == "object") // CommonJS
     mod(require("../../lib/codemirror"), require("../htmlmixed/htmlmixed"),
         require("../../addon/mode/multiplex"));
   else if (typeof define == "function" && define.amd) // AMD
     define(["../../lib/codemirror", "../htmlmixed/htmlmixed",
             "../../addon/mode/multiplex"], mod);
   else // Plain browser env
     mod(CodeMirror);
 })(function(CodeMirror) {
   "use strict";
 
   CodeMirror.defineMode("htmlembedded", function(config, parserConfig) {
+    var closeComment = parserConfig.closeComment || "--%>"
     return CodeMirror.multiplexingMode(CodeMirror.getMode(config, "htmlmixed"), {
+      open: parserConfig.openComment || "<%--",
+      close: closeComment,
+      delimStyle: "comment",
+      mode: {token: function(stream) {
+        stream.skipTo(closeComment) || stream.skipToEnd()
+        return "comment"
+      }}
+    }, {
       open: parserConfig.open || parserConfig.scriptStartRegex || "<%",
       close: parserConfig.close || parserConfig.scriptEndRegex || "%>",
       mode: CodeMirror.getMode(config, parserConfig.scriptingModeSpec)
     });
   }, "htmlmixed");
 
   CodeMirror.defineMIME("application/x-ejs", {name: "htmlembedded", scriptingModeSpec:"javascript"});
   CodeMirror.defineMIME("application/x-aspx", {name: "htmlembedded", scriptingModeSpec:"text/x-csharp"});
   CodeMirror.defineMIME("application/x-jsp", {name: "htmlembedded", scriptingModeSpec:"text/x-java"});
   CodeMirror.defineMIME("application/x-erb", {name: "htmlembedded", scriptingModeSpec:"ruby"});
 });

rhodecode/public/js/mode/htmlmixed/htmlmixed.js

@@ -1,150 +1,152 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 (function(mod) {
   if (typeof exports == "object" && typeof module == "object") // CommonJS
     mod(require("../../lib/codemirror"), require("../xml/xml"), require("../javascript/javascript"), require("../css/css"));
   else if (typeof define == "function" && define.amd) // AMD
     define(["../../lib/codemirror", "../xml/xml", "../javascript/javascript", "../css/css"], mod);
   else // Plain browser env
     mod(CodeMirror);
 })(function(CodeMirror) {
   "use strict";
 
   var defaultTags = {
     script: [
       ["lang", /(javascript|babel)/i, "javascript"],
-      ["type", /^(?:text|application)\/(?:x-)?(?:java|ecma)script$|^$/i, "javascript"],
+      ["type", /^(?:text|application)\/(?:x-)?(?:java|ecma)script$|^module$|^$/i, "javascript"],
       ["type", /./, "text/plain"],
       [null, null, "javascript"]
     ],
     style:  [
       ["lang", /^css$/i, "css"],
       ["type", /^(text\/)?(x-)?(stylesheet|css)$/i, "css"],
       ["type", /./, "text/plain"],
       [null, null, "css"]
     ]
   };
 
   function maybeBackup(stream, pat, style) {
     var cur = stream.current(), close = cur.search(pat);
     if (close > -1) {
       stream.backUp(cur.length - close);
     } else if (cur.match(/<\/?$/)) {
       stream.backUp(cur.length);
       if (!stream.match(pat, false)) stream.match(cur);
     }
     return style;
   }
 
   var attrRegexpCache = {};
   function getAttrRegexp(attr) {
     var regexp = attrRegexpCache[attr];
     if (regexp) return regexp;
     return attrRegexpCache[attr] = new RegExp("\\s+" + attr + "\\s*=\\s*('|\")?([^'\"]+)('|\")?\\s*");
   }
 
-  function getAttrValue(stream, attr) {
-    var pos = stream.pos, match;
-    while (pos >= 0 && stream.string.charAt(pos) !== "<") pos--;
-    if (pos < 0) return pos;
-    if (match = stream.string.slice(pos, stream.pos).match(getAttrRegexp(attr)))
-      return match[2];
-    return "";
+  function getAttrValue(text, attr) {
+    var match = text.match(getAttrRegexp(attr))
+    return match ? /^\s*(.*?)\s*$/.exec(match[2])[1] : ""
   }
 
   function getTagRegexp(tagName, anchored) {
     return new RegExp((anchored ? "^" : "") + "<\/\s*" + tagName + "\s*>", "i");
   }
 
   function addTags(from, to) {
     for (var tag in from) {
       var dest = to[tag] || (to[tag] = []);
       var source = from[tag];
       for (var i = source.length - 1; i >= 0; i--)
         dest.unshift(source[i])
     }
   }
 
-  function findMatchingMode(tagInfo, stream) {
+  function findMatchingMode(tagInfo, tagText) {
     for (var i = 0; i < tagInfo.length; i++) {
       var spec = tagInfo[i];
-      if (!spec[0] || spec[1].test(getAttrValue(stream, spec[0]))) return spec[2];
+      if (!spec[0] || spec[1].test(getAttrValue(tagText, spec[0]))) return spec[2];
     }
   }
 
   CodeMirror.defineMode("htmlmixed", function (config, parserConfig) {
     var htmlMode = CodeMirror.getMode(config, {
       name: "xml",
       htmlMode: true,
       multilineTagIndentFactor: parserConfig.multilineTagIndentFactor,
       multilineTagIndentPastTag: parserConfig.multilineTagIndentPastTag
     });
 
     var tags = {};
     var configTags = parserConfig && parserConfig.tags, configScript = parserConfig && parserConfig.scriptTypes;
     addTags(defaultTags, tags);
     if (configTags) addTags(configTags, tags);
     if (configScript) for (var i = configScript.length - 1; i >= 0; i--)
       tags.script.unshift(["type", configScript[i].matches, configScript[i].mode])
 
     function html(stream, state) {
-      var tagName = state.htmlState.tagName && state.htmlState.tagName.toLowerCase();
-      var tagInfo = tagName && tags.hasOwnProperty(tagName) && tags[tagName];
-
-      var style = htmlMode.token(stream, state.htmlState), modeSpec;
-
-      if (tagInfo && /\btag\b/.test(style) && stream.current() === ">" &&
-          (modeSpec = findMatchingMode(tagInfo, stream))) {
-        var mode = CodeMirror.getMode(config, modeSpec);
-        var endTagA = getTagRegexp(tagName, true), endTag = getTagRegexp(tagName, false);
+      var style = htmlMode.token(stream, state.htmlState), tag = /\btag\b/.test(style), tagName
+      if (tag && !/[<>\s\/]/.test(stream.current()) &&
+          (tagName = state.htmlState.tagName && state.htmlState.tagName.toLowerCase()) &&
+          tags.hasOwnProperty(tagName)) {
+        state.inTag = tagName + " "
+      } else if (state.inTag && tag && />$/.test(stream.current())) {
+        var inTag = /^([\S]+) (.*)/.exec(state.inTag)
+        state.inTag = null
+        var modeSpec = stream.current() == ">" && findMatchingMode(tags[inTag[1]], inTag[2])
+        var mode = CodeMirror.getMode(config, modeSpec)
+        var endTagA = getTagRegexp(inTag[1], true), endTag = getTagRegexp(inTag[1], false);
         state.token = function (stream, state) {
           if (stream.match(endTagA, false)) {
             state.token = html;
             state.localState = state.localMode = null;
             return null;
           }
           return maybeBackup(stream, endTag, state.localMode.token(stream, state.localState));
         };
         state.localMode = mode;
-        state.localState = CodeMirror.startState(mode, htmlMode.indent(state.htmlState, ""));
+        state.localState = CodeMirror.startState(mode, htmlMode.indent(state.htmlState, "", ""));
+      } else if (state.inTag) {
+        state.inTag += stream.current()
+        if (stream.eol()) state.inTag += " "
       }
       return style;
     };
 
     return {
       startState: function () {
-        var state = htmlMode.startState();
-        return {token: html, localMode: null, localState: null, htmlState: state};
+        var state = CodeMirror.startState(htmlMode);
+        return {token: html, inTag: null, localMode: null, localState: null, htmlState: state};
       },
 
       copyState: function (state) {
         var local;
         if (state.localState) {
           local = CodeMirror.copyState(state.localMode, state.localState);
         }
-        return {token: state.token, localMode: state.localMode, localState: local,
+        return {token: state.token, inTag: state.inTag,
+                localMode: state.localMode, localState: local,
                 htmlState: CodeMirror.copyState(htmlMode, state.htmlState)};
       },
 
       token: function (stream, state) {
         return state.token(stream, state);
       },
 
-      indent: function (state, textAfter) {
+      indent: function (state, textAfter, line) {
         if (!state.localMode || /^\s*<\//.test(textAfter))
-          return htmlMode.indent(state.htmlState, textAfter);
+          return htmlMode.indent(state.htmlState, textAfter, line);
         else if (state.localMode.indent)
-          return state.localMode.indent(state.localState, textAfter);
+          return state.localMode.indent(state.localState, textAfter, line);
         else
           return CodeMirror.Pass;
       },
 
       innerMode: function (state) {
         return {state: state.localState || state.htmlState, mode: state.localMode || htmlMode};
       }
     };
   }, "xml", "javascript", "css");
 
   CodeMirror.defineMIME("text/html", "htmlmixed");
 });

rhodecode/public/js/mode/http/http.js

@@ -1,113 +1,113 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("http", function() {
   function failFirstLine(stream, state) {
     stream.skipToEnd();
     state.cur = header;
     return "error";
   }
 
   function start(stream, state) {
     if (stream.match(/^HTTP\/\d\.\d/)) {
       state.cur = responseStatusCode;
       return "keyword";
     } else if (stream.match(/^[A-Z]+/) && /[ \t]/.test(stream.peek())) {
       state.cur = requestPath;
       return "keyword";
     } else {
       return failFirstLine(stream, state);
     }
   }
 
   function responseStatusCode(stream, state) {
     var code = stream.match(/^\d+/);
     if (!code) return failFirstLine(stream, state);
 
     state.cur = responseStatusText;
     var status = Number(code[0]);
     if (status >= 100 && status < 200) {
       return "positive informational";
     } else if (status >= 200 && status < 300) {
       return "positive success";
     } else if (status >= 300 && status < 400) {
       return "positive redirect";
     } else if (status >= 400 && status < 500) {
       return "negative client-error";
     } else if (status >= 500 && status < 600) {
       return "negative server-error";
     } else {
       return "error";
     }
   }
 
   function responseStatusText(stream, state) {
     stream.skipToEnd();
     state.cur = header;
     return null;
   }
 
   function requestPath(stream, state) {
     stream.eatWhile(/\S/);
     state.cur = requestProtocol;
     return "string-2";
   }
 
   function requestProtocol(stream, state) {
     if (stream.match(/^HTTP\/\d\.\d$/)) {
       state.cur = header;
       return "keyword";
     } else {
       return failFirstLine(stream, state);
     }
   }
 
   function header(stream) {
     if (stream.sol() && !stream.eat(/[ \t]/)) {
       if (stream.match(/^.*?:/)) {
         return "atom";
       } else {
         stream.skipToEnd();
         return "error";
       }
     } else {
       stream.skipToEnd();
       return "string";
     }
   }
 
   function body(stream) {
     stream.skipToEnd();
     return null;
   }
 
   return {
     token: function(stream, state) {
       var cur = state.cur;
       if (cur != header && cur != body && stream.eatSpace()) return null;
       return cur(stream, state);
     },
 
     blankLine: function(state) {
       state.cur = body;
     },
 
     startState: function() {
       return {cur: start};
     }
   };
 });
 
 CodeMirror.defineMIME("message/http", "http");
 
 });

rhodecode/public/js/mode/idl/idl.js

@@ -1,290 +1,290 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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";
 
   function wordRegexp(words) {
     return new RegExp('^((' + words.join(')|(') + '))\\b', 'i');
   };
 
   var builtinArray = [
     'a_correlate', 'abs', 'acos', 'adapt_hist_equal', 'alog',
     'alog2', 'alog10', 'amoeba', 'annotate', 'app_user_dir',
     'app_user_dir_query', 'arg_present', 'array_equal', 'array_indices',
     'arrow', 'ascii_template', 'asin', 'assoc', 'atan',
     'axis', 'axis', 'bandpass_filter', 'bandreject_filter', 'barplot',
     'bar_plot', 'beseli', 'beselj', 'beselk', 'besely',
     'beta', 'biginteger', 'bilinear', 'bin_date', 'binary_template',
     'bindgen', 'binomial', 'bit_ffs', 'bit_population', 'blas_axpy',
     'blk_con', 'boolarr', 'boolean', 'boxplot', 'box_cursor',
     'breakpoint', 'broyden', 'bubbleplot', 'butterworth', 'bytarr',
     'byte', 'byteorder', 'bytscl', 'c_correlate', 'calendar',
     'caldat', 'call_external', 'call_function', 'call_method',
     'call_procedure', 'canny', 'catch', 'cd', 'cdf', 'ceil',
     'chebyshev', 'check_math', 'chisqr_cvf', 'chisqr_pdf', 'choldc',
     'cholsol', 'cindgen', 'cir_3pnt', 'clipboard', 'close',
     'clust_wts', 'cluster', 'cluster_tree', 'cmyk_convert', 'code_coverage',
     'color_convert', 'color_exchange', 'color_quan', 'color_range_map',
     'colorbar', 'colorize_sample', 'colormap_applicable',
     'colormap_gradient', 'colormap_rotation', 'colortable',
     'comfit', 'command_line_args', 'common', 'compile_opt', 'complex',
     'complexarr', 'complexround', 'compute_mesh_normals', 'cond', 'congrid',
     'conj', 'constrained_min', 'contour', 'contour', 'convert_coord',
     'convol', 'convol_fft', 'coord2to3', 'copy_lun', 'correlate',
     'cos', 'cosh', 'cpu', 'cramer', 'createboxplotdata',
     'create_cursor', 'create_struct', 'create_view', 'crossp', 'crvlength',
     'ct_luminance', 'cti_test', 'cursor', 'curvefit', 'cv_coord',
     'cvttobm', 'cw_animate', 'cw_animate_getp', 'cw_animate_load',
     'cw_animate_run', 'cw_arcball', 'cw_bgroup', 'cw_clr_index',
     'cw_colorsel', 'cw_defroi', 'cw_field', 'cw_filesel', 'cw_form',
     'cw_fslider', 'cw_light_editor', 'cw_light_editor_get',
     'cw_light_editor_set', 'cw_orient', 'cw_palette_editor',
     'cw_palette_editor_get', 'cw_palette_editor_set', 'cw_pdmenu',
     'cw_rgbslider', 'cw_tmpl', 'cw_zoom', 'db_exists',
     'dblarr', 'dcindgen', 'dcomplex', 'dcomplexarr', 'define_key',
     'define_msgblk', 'define_msgblk_from_file', 'defroi', 'defsysv',
     'delvar', 'dendro_plot', 'dendrogram', 'deriv', 'derivsig',
     'determ', 'device', 'dfpmin', 'diag_matrix', 'dialog_dbconnect',
     'dialog_message', 'dialog_pickfile', 'dialog_printersetup',
     'dialog_printjob', 'dialog_read_image',
     'dialog_write_image', 'dictionary', 'digital_filter', 'dilate', 'dindgen',
     'dissolve', 'dist', 'distance_measure', 'dlm_load', 'dlm_register',
     'doc_library', 'double', 'draw_roi', 'edge_dog', 'efont',
     'eigenql', 'eigenvec', 'ellipse', 'elmhes', 'emboss',
     'empty', 'enable_sysrtn', 'eof', 'eos', 'erase',
     'erf', 'erfc', 'erfcx', 'erode', 'errorplot',
     'errplot', 'estimator_filter', 'execute', 'exit', 'exp',
     'expand', 'expand_path', 'expint', 'extrac', 'extract_slice',
     'f_cvf', 'f_pdf', 'factorial', 'fft', 'file_basename',
     'file_chmod', 'file_copy', 'file_delete', 'file_dirname',
     'file_expand_path', 'file_gunzip', 'file_gzip', 'file_info',
     'file_lines', 'file_link', 'file_mkdir', 'file_move',
     'file_poll_input', 'file_readlink', 'file_same',
     'file_search', 'file_tar', 'file_test', 'file_untar', 'file_unzip',
     'file_which', 'file_zip', 'filepath', 'findgen', 'finite',
     'fix', 'flick', 'float', 'floor', 'flow3',
     'fltarr', 'flush', 'format_axis_values', 'forward_function', 'free_lun',
     'fstat', 'fulstr', 'funct', 'function', 'fv_test',
     'fx_root', 'fz_roots', 'gamma', 'gamma_ct', 'gauss_cvf',
     'gauss_pdf', 'gauss_smooth', 'gauss2dfit', 'gaussfit',
     'gaussian_function', 'gaussint', 'get_drive_list', 'get_dxf_objects',
     'get_kbrd', 'get_login_info',
     'get_lun', 'get_screen_size', 'getenv', 'getwindows', 'greg2jul',
     'grib', 'grid_input', 'grid_tps', 'grid3', 'griddata',
     'gs_iter', 'h_eq_ct', 'h_eq_int', 'hanning', 'hash',
     'hdf', 'hdf5', 'heap_free', 'heap_gc', 'heap_nosave',
     'heap_refcount', 'heap_save', 'help', 'hilbert', 'hist_2d',
     'hist_equal', 'histogram', 'hls', 'hough', 'hqr',
     'hsv', 'i18n_multibytetoutf8',
     'i18n_multibytetowidechar', 'i18n_utf8tomultibyte',
     'i18n_widechartomultibyte',
     'ibeta', 'icontour', 'iconvertcoord', 'idelete', 'identity',
     'idl_base64', 'idl_container', 'idl_validname',
     'idlexbr_assistant', 'idlitsys_createtool',
     'idlunit', 'iellipse', 'igamma', 'igetcurrent', 'igetdata',
     'igetid', 'igetproperty', 'iimage', 'image', 'image_cont',
     'image_statistics', 'image_threshold', 'imaginary', 'imap', 'indgen',
     'int_2d', 'int_3d', 'int_tabulated', 'intarr', 'interpol',
     'interpolate', 'interval_volume', 'invert', 'ioctl', 'iopen',
     'ir_filter', 'iplot', 'ipolygon', 'ipolyline', 'iputdata',
     'iregister', 'ireset', 'iresolve', 'irotate', 'isa',
     'isave', 'iscale', 'isetcurrent', 'isetproperty', 'ishft',
     'isocontour', 'isosurface', 'isurface', 'itext', 'itranslate',
     'ivector', 'ivolume', 'izoom', 'journal', 'json_parse',
     'json_serialize', 'jul2greg', 'julday', 'keyword_set', 'krig2d',
     'kurtosis', 'kw_test', 'l64indgen', 'la_choldc', 'la_cholmprove',
     'la_cholsol', 'la_determ', 'la_eigenproblem', 'la_eigenql', 'la_eigenvec',
     'la_elmhes', 'la_gm_linear_model', 'la_hqr', 'la_invert',
     'la_least_square_equality', 'la_least_squares', 'la_linear_equation',
     'la_ludc', 'la_lumprove', 'la_lusol',
     'la_svd', 'la_tridc', 'la_trimprove', 'la_triql', 'la_trired',
     'la_trisol', 'label_date', 'label_region', 'ladfit', 'laguerre',
     'lambda', 'lambdap', 'lambertw', 'laplacian', 'least_squares_filter',
     'leefilt', 'legend', 'legendre', 'linbcg', 'lindgen',
     'linfit', 'linkimage', 'list', 'll_arc_distance', 'lmfit',
     'lmgr', 'lngamma', 'lnp_test', 'loadct', 'locale_get',
     'logical_and', 'logical_or', 'logical_true', 'lon64arr', 'lonarr',
     'long', 'long64', 'lsode', 'lu_complex', 'ludc',
     'lumprove', 'lusol', 'm_correlate', 'machar', 'make_array',
     'make_dll', 'make_rt', 'map', 'mapcontinents', 'mapgrid',
     'map_2points', 'map_continents', 'map_grid', 'map_image', 'map_patch',
     'map_proj_forward', 'map_proj_image', 'map_proj_info',
     'map_proj_init', 'map_proj_inverse',
     'map_set', 'matrix_multiply', 'matrix_power', 'max', 'md_test',
     'mean', 'meanabsdev', 'mean_filter', 'median', 'memory',
     'mesh_clip', 'mesh_decimate', 'mesh_issolid',
     'mesh_merge', 'mesh_numtriangles',
     'mesh_obj', 'mesh_smooth', 'mesh_surfacearea',
     'mesh_validate', 'mesh_volume',
     'message', 'min', 'min_curve_surf', 'mk_html_help', 'modifyct',
     'moment', 'morph_close', 'morph_distance',
     'morph_gradient', 'morph_hitormiss',
     'morph_open', 'morph_thin', 'morph_tophat', 'multi', 'n_elements',
     'n_params', 'n_tags', 'ncdf', 'newton', 'noise_hurl',
     'noise_pick', 'noise_scatter', 'noise_slur', 'norm', 'obj_class',
     'obj_destroy', 'obj_hasmethod', 'obj_isa', 'obj_new', 'obj_valid',
     'objarr', 'on_error', 'on_ioerror', 'online_help', 'openr',
     'openu', 'openw', 'oplot', 'oploterr', 'orderedhash',
     'p_correlate', 'parse_url', 'particle_trace', 'path_cache', 'path_sep',
     'pcomp', 'plot', 'plot3d', 'plot', 'plot_3dbox',
     'plot_field', 'ploterr', 'plots', 'polar_contour', 'polar_surface',
     'polyfill', 'polyshade', 'pnt_line', 'point_lun', 'polarplot',
     'poly', 'poly_2d', 'poly_area', 'poly_fit', 'polyfillv',
     'polygon', 'polyline', 'polywarp', 'popd', 'powell',
     'pref_commit', 'pref_get', 'pref_set', 'prewitt', 'primes',
     'print', 'printf', 'printd', 'pro', 'product',
     'profile', 'profiler', 'profiles', 'project_vol', 'ps_show_fonts',
     'psafm', 'pseudo', 'ptr_free', 'ptr_new', 'ptr_valid',
     'ptrarr', 'pushd', 'qgrid3', 'qhull', 'qromb',
     'qromo', 'qsimp', 'query_*', 'query_ascii', 'query_bmp',
     'query_csv', 'query_dicom', 'query_gif', 'query_image', 'query_jpeg',
     'query_jpeg2000', 'query_mrsid', 'query_pict', 'query_png', 'query_ppm',
     'query_srf', 'query_tiff', 'query_video', 'query_wav', 'r_correlate',
     'r_test', 'radon', 'randomn', 'randomu', 'ranks',
     'rdpix', 'read', 'readf', 'read_ascii', 'read_binary',
     'read_bmp', 'read_csv', 'read_dicom', 'read_gif', 'read_image',
     'read_interfile', 'read_jpeg', 'read_jpeg2000', 'read_mrsid', 'read_pict',
     'read_png', 'read_ppm', 'read_spr', 'read_srf', 'read_sylk',
     'read_tiff', 'read_video', 'read_wav', 'read_wave', 'read_x11_bitmap',
     'read_xwd', 'reads', 'readu', 'real_part', 'rebin',
     'recall_commands', 'recon3', 'reduce_colors', 'reform', 'region_grow',
     'register_cursor', 'regress', 'replicate',
     'replicate_inplace', 'resolve_all',
     'resolve_routine', 'restore', 'retall', 'return', 'reverse',
     'rk4', 'roberts', 'rot', 'rotate', 'round',
     'routine_filepath', 'routine_info', 'rs_test', 's_test', 'save',
     'savgol', 'scale3', 'scale3d', 'scatterplot', 'scatterplot3d',
     'scope_level', 'scope_traceback', 'scope_varfetch',
     'scope_varname', 'search2d',
     'search3d', 'sem_create', 'sem_delete', 'sem_lock', 'sem_release',
     'set_plot', 'set_shading', 'setenv', 'sfit', 'shade_surf',
     'shade_surf_irr', 'shade_volume', 'shift', 'shift_diff', 'shmdebug',
     'shmmap', 'shmunmap', 'shmvar', 'show3', 'showfont',
     'signum', 'simplex', 'sin', 'sindgen', 'sinh',
     'size', 'skewness', 'skip_lun', 'slicer3', 'slide_image',
     'smooth', 'sobel', 'socket', 'sort', 'spawn',
     'sph_4pnt', 'sph_scat', 'spher_harm', 'spl_init', 'spl_interp',
     'spline', 'spline_p', 'sprsab', 'sprsax', 'sprsin',
     'sprstp', 'sqrt', 'standardize', 'stddev', 'stop',
     'strarr', 'strcmp', 'strcompress', 'streamline', 'streamline',
     'stregex', 'stretch', 'string', 'strjoin', 'strlen',
     'strlowcase', 'strmatch', 'strmessage', 'strmid', 'strpos',
     'strput', 'strsplit', 'strtrim', 'struct_assign', 'struct_hide',
     'strupcase', 'surface', 'surface', 'surfr', 'svdc',
     'svdfit', 'svsol', 'swap_endian', 'swap_endian_inplace', 'symbol',
     'systime', 't_cvf', 't_pdf', 't3d', 'tag_names',
     'tan', 'tanh', 'tek_color', 'temporary', 'terminal_size',
     'tetra_clip', 'tetra_surface', 'tetra_volume', 'text', 'thin',
     'thread', 'threed', 'tic', 'time_test2', 'timegen',
     'timer', 'timestamp', 'timestamptovalues', 'tm_test', 'toc',
     'total', 'trace', 'transpose', 'tri_surf', 'triangulate',
     'trigrid', 'triql', 'trired', 'trisol', 'truncate_lun',
     'ts_coef', 'ts_diff', 'ts_fcast', 'ts_smooth', 'tv',
     'tvcrs', 'tvlct', 'tvrd', 'tvscl', 'typename',
     'uindgen', 'uint', 'uintarr', 'ul64indgen', 'ulindgen',
     'ulon64arr', 'ulonarr', 'ulong', 'ulong64', 'uniq',
     'unsharp_mask', 'usersym', 'value_locate', 'variance', 'vector',
     'vector_field', 'vel', 'velovect', 'vert_t3d', 'voigt',
     'volume', 'voronoi', 'voxel_proj', 'wait', 'warp_tri',
     'watershed', 'wdelete', 'wf_draw', 'where', 'widget_base',
     'widget_button', 'widget_combobox', 'widget_control',
     'widget_displaycontextmenu', 'widget_draw',
     'widget_droplist', 'widget_event', 'widget_info',
     'widget_label', 'widget_list',
     'widget_propertysheet', 'widget_slider', 'widget_tab',
     'widget_table', 'widget_text',
     'widget_tree', 'widget_tree_move', 'widget_window',
     'wiener_filter', 'window',
     'window', 'write_bmp', 'write_csv', 'write_gif', 'write_image',
     'write_jpeg', 'write_jpeg2000', 'write_nrif', 'write_pict', 'write_png',
     'write_ppm', 'write_spr', 'write_srf', 'write_sylk', 'write_tiff',
     'write_video', 'write_wav', 'write_wave', 'writeu', 'wset',
     'wshow', 'wtn', 'wv_applet', 'wv_cwt', 'wv_cw_wavelet',
     'wv_denoise', 'wv_dwt', 'wv_fn_coiflet',
     'wv_fn_daubechies', 'wv_fn_gaussian',
     'wv_fn_haar', 'wv_fn_morlet', 'wv_fn_paul',
     'wv_fn_symlet', 'wv_import_data',
     'wv_import_wavelet', 'wv_plot3d_wps', 'wv_plot_multires',
     'wv_pwt', 'wv_tool_denoise',
     'xbm_edit', 'xdisplayfile', 'xdxf', 'xfont', 'xinteranimate',
     'xloadct', 'xmanager', 'xmng_tmpl', 'xmtool', 'xobjview',
     'xobjview_rotate', 'xobjview_write_image',
     'xpalette', 'xpcolor', 'xplot3d',
     'xregistered', 'xroi', 'xsq_test', 'xsurface', 'xvaredit',
     'xvolume', 'xvolume_rotate', 'xvolume_write_image',
     'xyouts', 'zlib_compress', 'zlib_uncompress', 'zoom', 'zoom_24'
   ];
   var builtins = wordRegexp(builtinArray);
 
   var keywordArray = [
     'begin', 'end', 'endcase', 'endfor',
     'endwhile', 'endif', 'endrep', 'endforeach',
     'break', 'case', 'continue', 'for',
     'foreach', 'goto', 'if', 'then', 'else',
     'repeat', 'until', 'switch', 'while',
     'do', 'pro', 'function'
   ];
   var keywords = wordRegexp(keywordArray);
 
   CodeMirror.registerHelper("hintWords", "idl", builtinArray.concat(keywordArray));
 
   var identifiers = new RegExp('^[_a-z\xa1-\uffff][_a-z0-9\xa1-\uffff]*', 'i');
 
   var singleOperators = /[+\-*&=<>\/@#~$]/;
   var boolOperators = new RegExp('(and|or|eq|lt|le|gt|ge|ne|not)', 'i');
 
   function tokenBase(stream) {
     // whitespaces
     if (stream.eatSpace()) return null;
 
     // Handle one line Comments
     if (stream.match(';')) {
       stream.skipToEnd();
       return 'comment';
     }
 
     // Handle Number Literals
     if (stream.match(/^[0-9\.+-]/, false)) {
       if (stream.match(/^[+-]?0x[0-9a-fA-F]+/))
         return 'number';
       if (stream.match(/^[+-]?\d*\.\d+([EeDd][+-]?\d+)?/))
         return 'number';
       if (stream.match(/^[+-]?\d+([EeDd][+-]?\d+)?/))
         return 'number';
     }
 
     // Handle Strings
     if (stream.match(/^"([^"]|(""))*"/)) { return 'string'; }
     if (stream.match(/^'([^']|(''))*'/)) { return 'string'; }
 
     // Handle words
     if (stream.match(keywords)) { return 'keyword'; }
     if (stream.match(builtins)) { return 'builtin'; }
     if (stream.match(identifiers)) { return 'variable'; }
 
     if (stream.match(singleOperators) || stream.match(boolOperators)) {
       return 'operator'; }
 
     // Handle non-detected items
     stream.next();
     return null;
   };
 
   CodeMirror.defineMode('idl', function() {
     return {
       token: function(stream) {
         return tokenBase(stream);
       }
     };
   });
 
   CodeMirror.defineMIME('text/x-idl', 'idl');
 });

rhodecode/public/js/mode/javascript/javascript.js

@@ -1,742 +1,930 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
-
-// TODO actually recognize syntax of TypeScript constructs
+// Distributed under an MIT license: https://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";
 
-function expressionAllowed(stream, state, backUp) {
-  return /^(?:operator|sof|keyword c|case|new|[\[{}\(,;:]|=>)$/.test(state.lastType) ||
-    (state.lastType == "quasi" && /\{\s*$/.test(stream.string.slice(0, stream.pos - (backUp || 0))))
-}
-
 CodeMirror.defineMode("javascript", function(config, parserConfig) {
   var indentUnit = config.indentUnit;
   var statementIndent = parserConfig.statementIndent;
   var jsonldMode = parserConfig.jsonld;
   var jsonMode = parserConfig.json || jsonldMode;
   var isTS = parserConfig.typescript;
   var wordRE = parserConfig.wordCharacters || /[\w$\xa1-\uffff]/;
 
   // Tokenizer
 
   var keywords = function(){
     function kw(type) {return {type: type, style: "keyword"};}
-    var A = kw("keyword a"), B = kw("keyword b"), C = kw("keyword c");
+    var A = kw("keyword a"), B = kw("keyword b"), C = kw("keyword c"), D = kw("keyword d");
     var operator = kw("operator"), atom = {type: "atom", style: "atom"};
 
-    var jsKeywords = {
+    return {
       "if": kw("if"), "while": A, "with": A, "else": B, "do": B, "try": B, "finally": B,
-      "return": C, "break": C, "continue": C, "new": kw("new"), "delete": C, "throw": C, "debugger": C,
-      "var": kw("var"), "const": kw("var"), "let": kw("var"),
+      "return": D, "break": D, "continue": D, "new": kw("new"), "delete": C, "void": C, "throw": C,
+      "debugger": kw("debugger"), "var": kw("var"), "const": kw("var"), "let": kw("var"),
       "function": kw("function"), "catch": kw("catch"),
       "for": kw("for"), "switch": kw("switch"), "case": kw("case"), "default": kw("default"),
       "in": operator, "typeof": operator, "instanceof": operator,
       "true": atom, "false": atom, "null": atom, "undefined": atom, "NaN": atom, "Infinity": atom,
       "this": kw("this"), "class": kw("class"), "super": kw("atom"),
-      "yield": C, "export": kw("export"), "import": kw("import"), "extends": C
+      "yield": C, "export": kw("export"), "import": kw("import"), "extends": C,
+      "await": C
     };
-
-    // 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("class"),
-        "implements": C,
-        "namespace": C,
-        "module": kw("module"),
-        "enum": kw("module"),
-
-        // scope modifiers
-        "public": kw("modifier"),
-        "private": kw("modifier"),
-        "protected": kw("modifier"),
-        "abstract": kw("modifier"),
-
-        // operators
-        "as": operator,
-
-        // types
-        "string": type, "number": type, "boolean": type, "any": type
-      };
-
-      for (var attr in tsKeywords) {
-        jsKeywords[attr] = tsKeywords[attr];
-      }
-    }
-
-    return jsKeywords;
   }();
 
-  var isOperatorChar = /[+\-*&%=<>!?|~^]/;
+  var isOperatorChar = /[+\-*&%=<>!?|~^@]/;
   var isJsonldKeyword = /^@(context|id|value|language|type|container|list|set|reverse|index|base|vocab|graph)"/;
 
   function readRegexp(stream) {
     var escaped = false, next, inSet = false;
     while ((next = stream.next()) != null) {
       if (!escaped) {
         if (next == "/" && !inSet) return;
         if (next == "[") inSet = true;
         else if (inSet && next == "]") inSet = false;
       }
       escaped = !escaped && next == "\\";
     }
   }
 
   // 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 tokenBase(stream, state) {
     var ch = stream.next();
     if (ch == '"' || ch == "'") {
       state.tokenize = tokenString(ch);
       return state.tokenize(stream, state);
-    } else if (ch == "." && stream.match(/^\d+(?:[eE][+\-]?\d+)?/)) {
+    } else if (ch == "." && stream.match(/^\d[\d_]*(?:[eE][+\-]?[\d_]+)?/)) {
       return ret("number", "number");
     } else if (ch == "." && stream.match("..")) {
       return ret("spread", "meta");
     } else if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
       return ret(ch);
     } else if (ch == "=" && stream.eat(">")) {
       return ret("=>", "operator");
-    } else if (ch == "0" && stream.eat(/x/i)) {
-      stream.eatWhile(/[\da-f]/i);
-      return ret("number", "number");
-    } else if (ch == "0" && stream.eat(/o/i)) {
-      stream.eatWhile(/[0-7]/i);
-      return ret("number", "number");
-    } else if (ch == "0" && stream.eat(/b/i)) {
-      stream.eatWhile(/[01]/i);
+    } else if (ch == "0" && stream.match(/^(?:x[\dA-Fa-f_]+|o[0-7_]+|b[01_]+)n?/)) {
       return ret("number", "number");
     } else if (/\d/.test(ch)) {
-      stream.match(/^\d*(?:\.\d*)?(?:[eE][+\-]?\d+)?/);
+      stream.match(/^[\d_]*(?:n|(?:\.[\d_]*)?(?:[eE][+\-]?[\d_]+)?)?/);
       return ret("number", "number");
     } else if (ch == "/") {
       if (stream.eat("*")) {
         state.tokenize = tokenComment;
         return tokenComment(stream, state);
       } else if (stream.eat("/")) {
         stream.skipToEnd();
         return ret("comment", "comment");
       } else if (expressionAllowed(stream, state, 1)) {
         readRegexp(stream);
-        stream.match(/^\b(([gimyu])(?![gimyu]*\2))+\b/);
+        stream.match(/^\b(([gimyus])(?![gimyus]*\2))+\b/);
         return ret("regexp", "string-2");
       } else {
-        stream.eatWhile(isOperatorChar);
+        stream.eat("=");
         return ret("operator", "operator", stream.current());
       }
     } else if (ch == "`") {
       state.tokenize = tokenQuasi;
       return tokenQuasi(stream, state);
     } else if (ch == "#") {
       stream.skipToEnd();
       return ret("error", "error");
+    } else if (ch == "<" && stream.match("!--") || ch == "-" && stream.match("->")) {
+      stream.skipToEnd()
+      return ret("comment", "comment")
     } else if (isOperatorChar.test(ch)) {
-      stream.eatWhile(isOperatorChar);
+      if (ch != ">" || !state.lexical || state.lexical.type != ">") {
+        if (stream.eat("=")) {
+          if (ch == "!" || ch == "=") stream.eat("=")
+        } else if (/[<>*+\-]/.test(ch)) {
+          stream.eat(ch)
+          if (ch == ">") stream.eat(ch)
+        }
+      }
       return ret("operator", "operator", stream.current());
     } else if (wordRE.test(ch)) {
       stream.eatWhile(wordRE);
-      var word = stream.current(), known = keywords.propertyIsEnumerable(word) && keywords[word];
-      return (known && state.lastType != ".") ? ret(known.type, known.style, word) :
-                     ret("variable", "variable", word);
+      var word = stream.current()
+      if (state.lastType != ".") {
+        if (keywords.propertyIsEnumerable(word)) {
+          var kw = keywords[word]
+          return ret(kw.type, kw.style, word)
+        }
+        if (word == "async" && stream.match(/^(\s|\/\*.*?\*\/)*[\[\(\w]/, false))
+          return ret("async", "keyword", word)
+      }
+      return ret("variable", "variable", word)
     }
   }
 
   function tokenString(quote) {
     return function(stream, state) {
       var escaped = false, next;
       if (jsonldMode && stream.peek() == "@" && stream.match(isJsonldKeyword)){
         state.tokenize = tokenBase;
         return ret("jsonld-keyword", "meta");
       }
       while ((next = stream.next()) != null) {
         if (next == quote && !escaped) break;
         escaped = !escaped && next == "\\";
       }
       if (!escaped) state.tokenize = tokenBase;
       return ret("string", "string");
     };
   }
 
   function tokenComment(stream, state) {
     var maybeEnd = false, ch;
     while (ch = stream.next()) {
       if (ch == "/" && maybeEnd) {
         state.tokenize = tokenBase;
         break;
       }
       maybeEnd = (ch == "*");
     }
     return ret("comment", "comment");
   }
 
   function tokenQuasi(stream, state) {
     var escaped = false, next;
     while ((next = stream.next()) != null) {
       if (!escaped && (next == "`" || next == "$" && stream.eat("{"))) {
         state.tokenize = tokenBase;
         break;
       }
       escaped = !escaped && next == "\\";
     }
     return ret("quasi", "string-2", stream.current());
   }
 
   var brackets = "([{}])";
   // This is a crude lookahead trick to try and notice that we're
   // parsing the argument patterns for a fat-arrow function before we
   // actually hit the arrow token. It only works if the arrow is on
   // the same line as the arguments and there's no strange noise
   // (comments) in between. Fallback is to only notice when we hit the
   // arrow, and not declare the arguments as locals for the arrow
   // body.
   function findFatArrow(stream, state) {
     if (state.fatArrowAt) state.fatArrowAt = null;
     var arrow = stream.string.indexOf("=>", stream.start);
     if (arrow < 0) return;
 
+    if (isTS) { // Try to skip TypeScript return type declarations after the arguments
+      var m = /:\s*(?:\w+(?:<[^>]*>|\[\])?|\{[^}]*\})\s*$/.exec(stream.string.slice(stream.start, arrow))
+      if (m) arrow = m.index
+    }
+
     var depth = 0, sawSomething = false;
     for (var pos = arrow - 1; pos >= 0; --pos) {
       var ch = stream.string.charAt(pos);
       var bracket = brackets.indexOf(ch);
       if (bracket >= 0 && bracket < 3) {
         if (!depth) { ++pos; break; }
-        if (--depth == 0) break;
+        if (--depth == 0) { if (ch == "(") sawSomething = true; break; }
       } else if (bracket >= 3 && bracket < 6) {
         ++depth;
       } else if (wordRE.test(ch)) {
         sawSomething = true;
-      } else if (/["'\/]/.test(ch)) {
-        return;
+      } else if (/["'\/`]/.test(ch)) {
+        for (;; --pos) {
+          if (pos == 0) return
+          var next = stream.string.charAt(pos - 1)
+          if (next == ch && stream.string.charAt(pos - 2) != "\\") { pos--; break }
+        }
       } else if (sawSomething && !depth) {
         ++pos;
         break;
       }
     }
     if (sawSomething && !depth) state.fatArrowAt = pos;
   }
 
   // Parser
 
   var atomicTypes = {"atom": true, "number": true, "variable": true, "string": true, "regexp": true, "this": true, "jsonld-keyword": true};
 
   function JSLexical(indented, column, type, align, prev, info) {
     this.indented = indented;
     this.column = column;
     this.type = type;
     this.prev = prev;
     this.info = info;
     if (align != null) this.align = align;
   }
 
   function inScope(state, varname) {
     for (var v = state.localVars; v; v = v.next)
       if (v.name == varname) return true;
     for (var cx = state.context; cx; cx = cx.prev) {
       for (var v = cx.vars; v; v = v.next)
         if (v.name == varname) return true;
     }
   }
 
   function parseJS(state, style, type, content, stream) {
     var cc = state.cc;
     // Communicate our context to the combinators.
     // (Less wasteful than consing up a hundred closures on every call.)
     cx.state = state; cx.stream = stream; cx.marked = null, cx.cc = cc; cx.style = style;
 
     if (!state.lexical.hasOwnProperty("align"))
       state.lexical.align = true;
 
     while(true) {
       var combinator = cc.length ? cc.pop() : jsonMode ? expression : statement;
       if (combinator(type, content)) {
         while(cc.length && cc[cc.length - 1].lex)
           cc.pop()();
         if (cx.marked) return cx.marked;
         if (type == "variable" && inScope(state, content)) return "variable-2";
         return style;
       }
     }
   }
 
   // Combinator utils
 
   var cx = {state: null, column: null, marked: null, cc: null};
   function pass() {
     for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]);
   }
   function cont() {
     pass.apply(null, arguments);
     return true;
   }
+  function inList(name, list) {
+    for (var v = list; v; v = v.next) if (v.name == name) return true
+    return false;
+  }
   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;
     cx.marked = "def";
     if (state.context) {
-      if (inList(state.localVars)) return;
-      state.localVars = {name: varname, next: state.localVars};
+      if (state.lexical.info == "var" && state.context && state.context.block) {
+        // FIXME function decls are also not block scoped
+        var newContext = registerVarScoped(varname, state.context)
+        if (newContext != null) {
+          state.context = newContext
+          return
+        }
+      } else if (!inList(varname, state.localVars)) {
+        state.localVars = new Var(varname, state.localVars)
+        return
+      }
+    }
+    // Fall through means this is global
+    if (parserConfig.globalVars && !inList(varname, state.globalVars))
+      state.globalVars = new Var(varname, state.globalVars)
+  }
+  function registerVarScoped(varname, context) {
+    if (!context) {
+      return null
+    } else if (context.block) {
+      var inner = registerVarScoped(varname, context.prev)
+      if (!inner) return null
+      if (inner == context.prev) return context
+      return new Context(inner, context.vars, true)
+    } else if (inList(varname, context.vars)) {
+      return context
     } else {
-      if (inList(state.globalVars)) return;
-      if (parserConfig.globalVars)
-        state.globalVars = {name: varname, next: state.globalVars};
+      return new Context(context.prev, new Var(varname, context.vars), false)
     }
   }
 
+  function isModifier(name) {
+    return name == "public" || name == "private" || name == "protected" || name == "abstract" || name == "readonly"
+  }
+
   // Combinators
 
-  var defaultVars = {name: "this", next: {name: "arguments"}};
+  function Context(prev, vars, block) { this.prev = prev; this.vars = vars; this.block = block }
+  function Var(name, next) { this.name = name; this.next = next }
+
+  var defaultVars = new Var("this", new Var("arguments", null))
   function pushcontext() {
-    cx.state.context = {prev: cx.state.context, vars: cx.state.localVars};
-    cx.state.localVars = defaultVars;
+    cx.state.context = new Context(cx.state.context, cx.state.localVars, false)
+    cx.state.localVars = defaultVars
+  }
+  function pushblockcontext() {
+    cx.state.context = new Context(cx.state.context, cx.state.localVars, true)
+    cx.state.localVars = null
   }
   function popcontext() {
-    cx.state.localVars = cx.state.context.vars;
-    cx.state.context = cx.state.context.prev;
+    cx.state.localVars = cx.state.context.vars
+    cx.state.context = cx.state.context.prev
   }
+  popcontext.lex = true
   function pushlex(type, info) {
     var result = function() {
       var state = cx.state, indent = state.indented;
       if (state.lexical.type == "stat") indent = state.lexical.indented;
       else for (var outer = state.lexical; outer && outer.type == ")" && outer.align; outer = outer.prev)
         indent = outer.indented;
       state.lexical = new JSLexical(indent, cx.stream.column(), type, null, state.lexical, info);
     };
     result.lex = true;
     return result;
   }
   function poplex() {
     var state = cx.state;
     if (state.lexical.prev) {
       if (state.lexical.type == ")")
         state.indented = state.lexical.indented;
       state.lexical = state.lexical.prev;
     }
   }
   poplex.lex = true;
 
   function expect(wanted) {
     function exp(type) {
       if (type == wanted) return cont();
-      else if (wanted == ";") return pass();
+      else if (wanted == ";" || type == "}" || type == ")" || type == "]") return pass();
       else return cont(exp);
     };
     return exp;
   }
 
   function statement(type, value) {
-    if (type == "var") return cont(pushlex("vardef", value.length), vardef, expect(";"), poplex);
-    if (type == "keyword a") return cont(pushlex("form"), expression, statement, poplex);
+    if (type == "var") return cont(pushlex("vardef", value), vardef, expect(";"), poplex);
+    if (type == "keyword a") return cont(pushlex("form"), parenExpr, statement, poplex);
     if (type == "keyword b") return cont(pushlex("form"), statement, poplex);
-    if (type == "{") return cont(pushlex("}"), block, poplex);
+    if (type == "keyword d") return cx.stream.match(/^\s*$/, false) ? cont() : cont(pushlex("stat"), maybeexpression, expect(";"), poplex);
+    if (type == "debugger") return cont(expect(";"));
+    if (type == "{") return cont(pushlex("}"), pushblockcontext, block, poplex, popcontext);
     if (type == ";") return cont();
     if (type == "if") {
       if (cx.state.lexical.info == "else" && cx.state.cc[cx.state.cc.length - 1] == poplex)
         cx.state.cc.pop()();
-      return cont(pushlex("form"), expression, statement, poplex, maybeelse);
+      return cont(pushlex("form"), parenExpr, statement, poplex, maybeelse);
     }
     if (type == "function") return cont(functiondef);
     if (type == "for") return cont(pushlex("form"), forspec, statement, poplex);
-    if (type == "variable") return cont(pushlex("stat"), maybelabel);
-    if (type == "switch") return cont(pushlex("form"), expression, pushlex("}", "switch"), expect("{"),
-                                      block, poplex, poplex);
+    if (type == "class" || (isTS && value == "interface")) {
+      cx.marked = "keyword"
+      return cont(pushlex("form", type == "class" ? type : value), className, poplex)
+    }
+    if (type == "variable") {
+      if (isTS && value == "declare") {
+        cx.marked = "keyword"
+        return cont(statement)
+      } else if (isTS && (value == "module" || value == "enum" || value == "type") && cx.stream.match(/^\s*\w/, false)) {
+        cx.marked = "keyword"
+        if (value == "enum") return cont(enumdef);
+        else if (value == "type") return cont(typename, expect("operator"), typeexpr, expect(";"));
+        else return cont(pushlex("form"), pattern, expect("{"), pushlex("}"), block, poplex, poplex)
+      } else if (isTS && value == "namespace") {
+        cx.marked = "keyword"
+        return cont(pushlex("form"), expression, statement, poplex)
+      } else if (isTS && value == "abstract") {
+        cx.marked = "keyword"
+        return cont(statement)
+      } else {
+        return cont(pushlex("stat"), maybelabel);
+      }
+    }
+    if (type == "switch") return cont(pushlex("form"), parenExpr, expect("{"), pushlex("}", "switch"), pushblockcontext,
+                                      block, poplex, poplex, popcontext);
     if (type == "case") return cont(expression, expect(":"));
     if (type == "default") return cont(expect(":"));
-    if (type == "catch") return cont(pushlex("form"), pushcontext, expect("("), funarg, expect(")"),
-                                     statement, poplex, popcontext);
-    if (type == "class") return cont(pushlex("form"), className, poplex);
+    if (type == "catch") return cont(pushlex("form"), pushcontext, maybeCatchBinding, statement, poplex, popcontext);
     if (type == "export") return cont(pushlex("stat"), afterExport, poplex);
     if (type == "import") return cont(pushlex("stat"), afterImport, poplex);
-    if (type == "module") return cont(pushlex("form"), pattern, pushlex("}"), expect("{"), block, poplex, poplex)
+    if (type == "async") return cont(statement)
+    if (value == "@") return cont(expression, statement)
     return pass(pushlex("stat"), expression, expect(";"), poplex);
   }
-  function expression(type) {
-    return expressionInner(type, false);
+  function maybeCatchBinding(type) {
+    if (type == "(") return cont(funarg, expect(")"))
+  }
+  function expression(type, value) {
+    return expressionInner(type, value, false);
   }
-  function expressionNoComma(type) {
-    return expressionInner(type, true);
+  function expressionNoComma(type, value) {
+    return expressionInner(type, value, true);
   }
-  function expressionInner(type, noComma) {
+  function parenExpr(type) {
+    if (type != "(") return pass()
+    return cont(pushlex(")"), expression, expect(")"), poplex)
+  }
+  function expressionInner(type, value, noComma) {
     if (cx.state.fatArrowAt == cx.stream.start) {
       var body = noComma ? arrowBodyNoComma : arrowBody;
-      if (type == "(") return cont(pushcontext, pushlex(")"), commasep(pattern, ")"), poplex, expect("=>"), body, popcontext);
+      if (type == "(") return cont(pushcontext, pushlex(")"), commasep(funarg, ")"), poplex, expect("=>"), body, popcontext);
       else if (type == "variable") return pass(pushcontext, pattern, expect("=>"), body, popcontext);
     }
 
     var maybeop = noComma ? maybeoperatorNoComma : maybeoperatorComma;
     if (atomicTypes.hasOwnProperty(type)) return cont(maybeop);
     if (type == "function") return cont(functiondef, maybeop);
-    if (type == "keyword c") return cont(noComma ? maybeexpressionNoComma : maybeexpression);
-    if (type == "(") return cont(pushlex(")"), maybeexpression, comprehension, expect(")"), poplex, maybeop);
+    if (type == "class" || (isTS && value == "interface")) { cx.marked = "keyword"; return cont(pushlex("form"), classExpression, poplex); }
+    if (type == "keyword c" || type == "async") return cont(noComma ? expressionNoComma : expression);
+    if (type == "(") return cont(pushlex(")"), maybeexpression, expect(")"), poplex, maybeop);
     if (type == "operator" || type == "spread") return cont(noComma ? expressionNoComma : expression);
     if (type == "[") return cont(pushlex("]"), arrayLiteral, poplex, maybeop);
     if (type == "{") return contCommasep(objprop, "}", null, maybeop);
     if (type == "quasi") return pass(quasi, maybeop);
     if (type == "new") return cont(maybeTarget(noComma));
+    if (type == "import") return cont(expression);
     return cont();
   }
   function maybeexpression(type) {
     if (type.match(/[;\}\)\],]/)) return pass();
     return pass(expression);
   }
-  function maybeexpressionNoComma(type) {
-    if (type.match(/[;\}\)\],]/)) return pass();
-    return pass(expressionNoComma);
-  }
 
   function maybeoperatorComma(type, value) {
     if (type == ",") return cont(expression);
     return maybeoperatorNoComma(type, value, false);
   }
   function maybeoperatorNoComma(type, value, noComma) {
     var me = noComma == false ? maybeoperatorComma : maybeoperatorNoComma;
     var expr = noComma == false ? expression : expressionNoComma;
     if (type == "=>") return cont(pushcontext, noComma ? arrowBodyNoComma : arrowBody, popcontext);
     if (type == "operator") {
-      if (/\+\+|--/.test(value)) return cont(me);
+      if (/\+\+|--/.test(value) || isTS && value == "!") return cont(me);
+      if (isTS && value == "<" && cx.stream.match(/^([^>]|<.*?>)*>\s*\(/, false))
+        return cont(pushlex(">"), commasep(typeexpr, ">"), poplex, me);
       if (value == "?") return cont(expression, expect(":"), expr);
       return cont(expr);
     }
     if (type == "quasi") { return pass(quasi, me); }
     if (type == ";") return;
     if (type == "(") return contCommasep(expressionNoComma, ")", "call", me);
     if (type == ".") return cont(property, me);
     if (type == "[") return cont(pushlex("]"), maybeexpression, expect("]"), poplex, me);
+    if (isTS && value == "as") { cx.marked = "keyword"; return cont(typeexpr, me) }
+    if (type == "regexp") {
+      cx.state.lastType = cx.marked = "operator"
+      cx.stream.backUp(cx.stream.pos - cx.stream.start - 1)
+      return cont(expr)
+    }
   }
   function quasi(type, value) {
     if (type != "quasi") return pass();
     if (value.slice(value.length - 2) != "${") return cont(quasi);
     return cont(expression, continueQuasi);
   }
   function continueQuasi(type) {
     if (type == "}") {
       cx.marked = "string-2";
       cx.state.tokenize = tokenQuasi;
       return cont(quasi);
     }
   }
   function arrowBody(type) {
     findFatArrow(cx.stream, cx.state);
     return pass(type == "{" ? statement : expression);
   }
   function arrowBodyNoComma(type) {
     findFatArrow(cx.stream, cx.state);
     return pass(type == "{" ? statement : expressionNoComma);
   }
   function maybeTarget(noComma) {
     return function(type) {
       if (type == ".") return cont(noComma ? targetNoComma : target);
+      else if (type == "variable" && isTS) return cont(maybeTypeArgs, noComma ? maybeoperatorNoComma : maybeoperatorComma)
       else return pass(noComma ? expressionNoComma : expression);
     };
   }
   function target(_, value) {
     if (value == "target") { cx.marked = "keyword"; return cont(maybeoperatorComma); }
   }
   function targetNoComma(_, value) {
     if (value == "target") { cx.marked = "keyword"; return cont(maybeoperatorNoComma); }
   }
   function maybelabel(type) {
     if (type == ":") return cont(poplex, statement);
     return pass(maybeoperatorComma, expect(";"), poplex);
   }
   function property(type) {
     if (type == "variable") {cx.marked = "property"; return cont();}
   }
   function objprop(type, value) {
-    if (type == "variable" || cx.style == "keyword") {
+    if (type == "async") {
+      cx.marked = "property";
+      return cont(objprop);
+    } else if (type == "variable" || cx.style == "keyword") {
       cx.marked = "property";
       if (value == "get" || value == "set") return cont(getterSetter);
+      var m // Work around fat-arrow-detection complication for detecting typescript typed arrow params
+      if (isTS && cx.state.fatArrowAt == cx.stream.start && (m = cx.stream.match(/^\s*:\s*/, false)))
+        cx.state.fatArrowAt = cx.stream.pos + m[0].length
       return cont(afterprop);
     } else if (type == "number" || type == "string") {
       cx.marked = jsonldMode ? "property" : (cx.style + " property");
       return cont(afterprop);
     } else if (type == "jsonld-keyword") {
       return cont(afterprop);
-    } else if (type == "modifier") {
+    } else if (isTS && isModifier(value)) {
+      cx.marked = "keyword"
       return cont(objprop)
     } else if (type == "[") {
-      return cont(expression, expect("]"), afterprop);
+      return cont(expression, maybetype, expect("]"), afterprop);
     } else if (type == "spread") {
-      return cont(expression);
+      return cont(expressionNoComma, afterprop);
+    } else if (value == "*") {
+      cx.marked = "keyword";
+      return cont(objprop);
+    } else if (type == ":") {
+      return pass(afterprop)
     }
   }
   function getterSetter(type) {
     if (type != "variable") return pass(afterprop);
     cx.marked = "property";
     return cont(functiondef);
   }
   function afterprop(type) {
     if (type == ":") return cont(expressionNoComma);
     if (type == "(") return pass(functiondef);
   }
-  function commasep(what, end) {
-    function proceed(type) {
-      if (type == ",") {
+  function commasep(what, end, sep) {
+    function proceed(type, value) {
+      if (sep ? sep.indexOf(type) > -1 : type == ",") {
         var lex = cx.state.lexical;
         if (lex.info == "call") lex.pos = (lex.pos || 0) + 1;
-        return cont(what, proceed);
+        return cont(function(type, value) {
+          if (type == end || value == end) return pass()
+          return pass(what)
+        }, proceed);
       }
-      if (type == end) return cont();
+      if (type == end || value == end) return cont();
+      if (sep && sep.indexOf(";") > -1) return pass(what)
       return cont(expect(end));
     }
-    return function(type) {
-      if (type == end) return cont();
+    return function(type, value) {
+      if (type == end || value == end) return cont();
       return pass(what, proceed);
     };
   }
   function contCommasep(what, end, info) {
     for (var i = 3; i < arguments.length; i++)
       cx.cc.push(arguments[i]);
     return cont(pushlex(end, info), commasep(what, end), poplex);
   }
   function block(type) {
     if (type == "}") return cont();
     return pass(statement, block);
   }
-  function maybetype(type) {
-    if (isTS && type == ":") return cont(typedef);
+  function maybetype(type, value) {
+    if (isTS) {
+      if (type == ":") return cont(typeexpr);
+      if (value == "?") return cont(maybetype);
+    }
+  }
+  function maybetypeOrIn(type, value) {
+    if (isTS && (type == ":" || value == "in")) return cont(typeexpr)
+  }
+  function mayberettype(type) {
+    if (isTS && type == ":") {
+      if (cx.stream.match(/^\s*\w+\s+is\b/, false)) return cont(expression, isKW, typeexpr)
+      else return cont(typeexpr)
+    }
+  }
+  function isKW(_, value) {
+    if (value == "is") {
+      cx.marked = "keyword"
+      return cont()
+    }
+  }
+  function typeexpr(type, value) {
+    if (value == "keyof" || value == "typeof" || value == "infer") {
+      cx.marked = "keyword"
+      return cont(value == "typeof" ? expressionNoComma : typeexpr)
+    }
+    if (type == "variable" || value == "void") {
+      cx.marked = "type"
+      return cont(afterType)
+    }
+    if (value == "|" || value == "&") return cont(typeexpr)
+    if (type == "string" || type == "number" || type == "atom") return cont(afterType);
+    if (type == "[") return cont(pushlex("]"), commasep(typeexpr, "]", ","), poplex, afterType)
+    if (type == "{") return cont(pushlex("}"), commasep(typeprop, "}", ",;"), poplex, afterType)
+    if (type == "(") return cont(commasep(typearg, ")"), maybeReturnType, afterType)
+    if (type == "<") return cont(commasep(typeexpr, ">"), typeexpr)
   }
-  function maybedefault(_, value) {
-    if (value == "=") return cont(expressionNoComma);
+  function maybeReturnType(type) {
+    if (type == "=>") return cont(typeexpr)
+  }
+  function typeprop(type, value) {
+    if (type == "variable" || cx.style == "keyword") {
+      cx.marked = "property"
+      return cont(typeprop)
+    } else if (value == "?" || type == "number" || type == "string") {
+      return cont(typeprop)
+    } else if (type == ":") {
+      return cont(typeexpr)
+    } else if (type == "[") {
+      return cont(expect("variable"), maybetypeOrIn, expect("]"), typeprop)
+    } else if (type == "(") {
+      return pass(functiondecl, typeprop)
+    }
   }
-  function typedef(type) {
-    if (type == "variable") {cx.marked = "variable-3"; return cont();}
+  function typearg(type, value) {
+    if (type == "variable" && cx.stream.match(/^\s*[?:]/, false) || value == "?") return cont(typearg)
+    if (type == ":") return cont(typeexpr)
+    if (type == "spread") return cont(typearg)
+    return pass(typeexpr)
   }
-  function vardef() {
+  function afterType(type, value) {
+    if (value == "<") return cont(pushlex(">"), commasep(typeexpr, ">"), poplex, afterType)
+    if (value == "|" || type == "." || value == "&") return cont(typeexpr)
+    if (type == "[") return cont(typeexpr, expect("]"), afterType)
+    if (value == "extends" || value == "implements") { cx.marked = "keyword"; return cont(typeexpr) }
+    if (value == "?") return cont(typeexpr, expect(":"), typeexpr)
+  }
+  function maybeTypeArgs(_, value) {
+    if (value == "<") return cont(pushlex(">"), commasep(typeexpr, ">"), poplex, afterType)
+  }
+  function typeparam() {
+    return pass(typeexpr, maybeTypeDefault)
+  }
+  function maybeTypeDefault(_, value) {
+    if (value == "=") return cont(typeexpr)
+  }
+  function vardef(_, value) {
+    if (value == "enum") {cx.marked = "keyword"; return cont(enumdef)}
     return pass(pattern, maybetype, maybeAssign, vardefCont);
   }
   function pattern(type, value) {
-    if (type == "modifier") return cont(pattern)
+    if (isTS && isModifier(value)) { cx.marked = "keyword"; return cont(pattern) }
     if (type == "variable") { register(value); return cont(); }
     if (type == "spread") return cont(pattern);
-    if (type == "[") return contCommasep(pattern, "]");
+    if (type == "[") return contCommasep(eltpattern, "]");
     if (type == "{") return contCommasep(proppattern, "}");
   }
   function proppattern(type, value) {
     if (type == "variable" && !cx.stream.match(/^\s*:/, false)) {
       register(value);
       return cont(maybeAssign);
     }
     if (type == "variable") cx.marked = "property";
     if (type == "spread") return cont(pattern);
     if (type == "}") return pass();
+    if (type == "[") return cont(expression, expect(']'), expect(':'), proppattern);
     return cont(expect(":"), pattern, maybeAssign);
   }
+  function eltpattern() {
+    return pass(pattern, maybeAssign)
+  }
   function maybeAssign(_type, value) {
     if (value == "=") return cont(expressionNoComma);
   }
   function vardefCont(type) {
     if (type == ",") return cont(vardef);
   }
   function maybeelse(type, value) {
     if (type == "keyword b" && value == "else") return cont(pushlex("form", "else"), statement, poplex);
   }
-  function forspec(type) {
-    if (type == "(") return cont(pushlex(")"), forspec1, expect(")"), poplex);
+  function forspec(type, value) {
+    if (value == "await") return cont(forspec);
+    if (type == "(") return cont(pushlex(")"), forspec1, poplex);
   }
   function forspec1(type) {
-    if (type == "var") return cont(vardef, expect(";"), forspec2);
-    if (type == ";") return cont(forspec2);
-    if (type == "variable") return cont(formaybeinof);
-    return pass(expression, expect(";"), forspec2);
-  }
-  function formaybeinof(_type, value) {
-    if (value == "in" || value == "of") { cx.marked = "keyword"; return cont(expression); }
-    return cont(maybeoperatorComma, forspec2);
+    if (type == "var") return cont(vardef, forspec2);
+    if (type == "variable") return cont(forspec2);
+    return pass(forspec2)
   }
   function forspec2(type, value) {
-    if (type == ";") return cont(forspec3);
-    if (value == "in" || value == "of") { cx.marked = "keyword"; return cont(expression); }
-    return pass(expression, expect(";"), forspec3);
-  }
-  function forspec3(type) {
-    if (type != ")") cont(expression);
+    if (type == ")") return cont()
+    if (type == ";") return cont(forspec2)
+    if (value == "in" || value == "of") { cx.marked = "keyword"; return cont(expression, forspec2) }
+    return pass(expression, forspec2)
   }
   function functiondef(type, value) {
     if (value == "*") {cx.marked = "keyword"; return cont(functiondef);}
     if (type == "variable") {register(value); return cont(functiondef);}
-    if (type == "(") return cont(pushcontext, pushlex(")"), commasep(funarg, ")"), poplex, statement, popcontext);
+    if (type == "(") return cont(pushcontext, pushlex(")"), commasep(funarg, ")"), poplex, mayberettype, statement, popcontext);
+    if (isTS && value == "<") return cont(pushlex(">"), commasep(typeparam, ">"), poplex, functiondef)
+  }
+  function functiondecl(type, value) {
+    if (value == "*") {cx.marked = "keyword"; return cont(functiondecl);}
+    if (type == "variable") {register(value); return cont(functiondecl);}
+    if (type == "(") return cont(pushcontext, pushlex(")"), commasep(funarg, ")"), poplex, mayberettype, popcontext);
+    if (isTS && value == "<") return cont(pushlex(">"), commasep(typeparam, ">"), poplex, functiondecl)
   }
-  function funarg(type) {
+  function typename(type, value) {
+    if (type == "keyword" || type == "variable") {
+      cx.marked = "type"
+      return cont(typename)
+    } else if (value == "<") {
+      return cont(pushlex(">"), commasep(typeparam, ">"), poplex)
+    }
+  }
+  function funarg(type, value) {
+    if (value == "@") cont(expression, funarg)
     if (type == "spread") return cont(funarg);
-    return pass(pattern, maybetype, maybedefault);
+    if (isTS && isModifier(value)) { cx.marked = "keyword"; return cont(funarg); }
+    if (isTS && type == "this") return cont(maybetype, maybeAssign)
+    return pass(pattern, maybetype, maybeAssign);
+  }
+  function classExpression(type, value) {
+    // Class expressions may have an optional name.
+    if (type == "variable") return className(type, value);
+    return classNameAfter(type, value);
   }
   function className(type, value) {
     if (type == "variable") {register(value); return cont(classNameAfter);}
   }
   function classNameAfter(type, value) {
-    if (value == "extends") return cont(expression, classNameAfter);
+    if (value == "<") return cont(pushlex(">"), commasep(typeparam, ">"), poplex, classNameAfter)
+    if (value == "extends" || value == "implements" || (isTS && type == ",")) {
+      if (value == "implements") cx.marked = "keyword";
+      return cont(isTS ? typeexpr : expression, classNameAfter);
+    }
     if (type == "{") return cont(pushlex("}"), classBody, poplex);
   }
   function classBody(type, value) {
+    if (type == "async" ||
+        (type == "variable" &&
+         (value == "static" || value == "get" || value == "set" || (isTS && isModifier(value))) &&
+         cx.stream.match(/^\s+[\w$\xa1-\uffff]/, false))) {
+      cx.marked = "keyword";
+      return cont(classBody);
+    }
     if (type == "variable" || cx.style == "keyword") {
-      if (value == "static") {
-        cx.marked = "keyword";
-        return cont(classBody);
-      }
       cx.marked = "property";
-      if (value == "get" || value == "set") return cont(classGetterSetter, functiondef, classBody);
-      return cont(functiondef, classBody);
+      return cont(isTS ? classfield : functiondef, classBody);
     }
+    if (type == "number" || type == "string") return cont(isTS ? classfield : functiondef, classBody);
+    if (type == "[")
+      return cont(expression, maybetype, expect("]"), isTS ? classfield : functiondef, classBody)
     if (value == "*") {
       cx.marked = "keyword";
       return cont(classBody);
     }
-    if (type == ";") return cont(classBody);
+    if (isTS && type == "(") return pass(functiondecl, classBody)
+    if (type == ";" || type == ",") return cont(classBody);
     if (type == "}") return cont();
+    if (value == "@") return cont(expression, classBody)
   }
-  function classGetterSetter(type) {
-    if (type != "variable") return pass();
-    cx.marked = "property";
-    return cont();
+  function classfield(type, value) {
+    if (value == "?") return cont(classfield)
+    if (type == ":") return cont(typeexpr, maybeAssign)
+    if (value == "=") return cont(expressionNoComma)
+    var context = cx.state.lexical.prev, isInterface = context && context.info == "interface"
+    return pass(isInterface ? functiondecl : functiondef)
   }
-  function afterExport(_type, value) {
+  function afterExport(type, value) {
     if (value == "*") { cx.marked = "keyword"; return cont(maybeFrom, expect(";")); }
     if (value == "default") { cx.marked = "keyword"; return cont(expression, expect(";")); }
+    if (type == "{") return cont(commasep(exportField, "}"), maybeFrom, expect(";"));
     return pass(statement);
   }
+  function exportField(type, value) {
+    if (value == "as") { cx.marked = "keyword"; return cont(expect("variable")); }
+    if (type == "variable") return pass(expressionNoComma, exportField);
+  }
   function afterImport(type) {
     if (type == "string") return cont();
-    return pass(importSpec, maybeFrom);
+    if (type == "(") return pass(expression);
+    return pass(importSpec, maybeMoreImports, maybeFrom);
   }
   function importSpec(type, value) {
     if (type == "{") return contCommasep(importSpec, "}");
     if (type == "variable") register(value);
     if (value == "*") cx.marked = "keyword";
     return cont(maybeAs);
   }
+  function maybeMoreImports(type) {
+    if (type == ",") return cont(importSpec, maybeMoreImports)
+  }
   function maybeAs(_type, value) {
     if (value == "as") { cx.marked = "keyword"; return cont(importSpec); }
   }
   function maybeFrom(_type, value) {
     if (value == "from") { cx.marked = "keyword"; return cont(expression); }
   }
   function arrayLiteral(type) {
     if (type == "]") return cont();
-    return pass(expressionNoComma, maybeArrayComprehension);
-  }
-  function maybeArrayComprehension(type) {
-    if (type == "for") return pass(comprehension, expect("]"));
-    if (type == ",") return cont(commasep(maybeexpressionNoComma, "]"));
     return pass(commasep(expressionNoComma, "]"));
   }
-  function comprehension(type) {
-    if (type == "for") return cont(forspec, comprehension);
-    if (type == "if") return cont(expression, comprehension);
+  function enumdef() {
+    return pass(pushlex("form"), pattern, expect("{"), pushlex("}"), commasep(enummember, "}"), poplex, poplex)
+  }
+  function enummember() {
+    return pass(pattern, maybeAssign);
   }
 
   function isContinuedStatement(state, textAfter) {
     return state.lastType == "operator" || state.lastType == "," ||
       isOperatorChar.test(textAfter.charAt(0)) ||
       /[,.]/.test(textAfter.charAt(0));
   }
 
+  function expressionAllowed(stream, state, backUp) {
+    return state.tokenize == tokenBase &&
+      /^(?:operator|sof|keyword [bcd]|case|new|export|default|spread|[\[{}\(,;:]|=>)$/.test(state.lastType) ||
+      (state.lastType == "quasi" && /\{\s*$/.test(stream.string.slice(0, stream.pos - (backUp || 0))))
+  }
+
   // Interface
 
   return {
     startState: function(basecolumn) {
       var state = {
         tokenize: tokenBase,
         lastType: "sof",
         cc: [],
         lexical: new JSLexical((basecolumn || 0) - indentUnit, 0, "block", false),
         localVars: parserConfig.localVars,
-        context: parserConfig.localVars && {vars: parserConfig.localVars},
+        context: parserConfig.localVars && new Context(null, null, false),
         indented: basecolumn || 0
       };
       if (parserConfig.globalVars && typeof parserConfig.globalVars == "object")
         state.globalVars = parserConfig.globalVars;
       return state;
     },
 
     token: function(stream, state) {
       if (stream.sol()) {
         if (!state.lexical.hasOwnProperty("align"))
           state.lexical.align = false;
         state.indented = stream.indentation();
         findFatArrow(stream, state);
       }
       if (state.tokenize != tokenComment && stream.eatSpace()) return null;
       var style = state.tokenize(stream, state);
       if (type == "comment") return style;
       state.lastType = type == "operator" && (content == "++" || content == "--") ? "incdec" : type;
       return parseJS(state, style, type, content, stream);
     },
 
     indent: function(state, textAfter) {
       if (state.tokenize == tokenComment) return CodeMirror.Pass;
       if (state.tokenize != tokenBase) return 0;
-      var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical;
+      var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical, top
       // Kludge to prevent 'maybelse' from blocking lexical scope pops
       if (!/^\s*else\b/.test(textAfter)) for (var i = state.cc.length - 1; i >= 0; --i) {
         var c = state.cc[i];
         if (c == poplex) lexical = lexical.prev;
         else if (c != maybeelse) break;
       }
-      if (lexical.type == "stat" && firstChar == "}") lexical = lexical.prev;
+      while ((lexical.type == "stat" || lexical.type == "form") &&
+             (firstChar == "}" || ((top = state.cc[state.cc.length - 1]) &&
+                                   (top == maybeoperatorComma || top == maybeoperatorNoComma) &&
+                                   !/^[,\.=+\-*:?[\(]/.test(textAfter))))
+        lexical = lexical.prev;
       if (statementIndent && lexical.type == ")" && lexical.prev.type == "stat")
         lexical = lexical.prev;
       var type = lexical.type, closing = firstChar == type;
 
-      if (type == "vardef") return lexical.indented + (state.lastType == "operator" || state.lastType == "," ? lexical.info + 1 : 0);
+      if (type == "vardef") return lexical.indented + (state.lastType == "operator" || state.lastType == "," ? lexical.info.length + 1 : 0);
       else if (type == "form" && firstChar == "{") return lexical.indented;
       else if (type == "form") return lexical.indented + indentUnit;
       else if (type == "stat")
         return lexical.indented + (isContinuedStatement(state, textAfter) ? statementIndent || indentUnit : 0);
       else if (lexical.info == "switch" && !closing && parserConfig.doubleIndentSwitch != false)
         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);
     },
 
     electricInput: /^\s*(?:case .*?:|default:|\{|\})$/,
     blockCommentStart: jsonMode ? null : "/*",
     blockCommentEnd: jsonMode ? null : "*/",
+    blockCommentContinue: jsonMode ? null : " * ",
     lineComment: jsonMode ? null : "//",
     fold: "brace",
     closeBrackets: "()[]{}''\"\"``",
 
     helperType: jsonMode ? "json" : "javascript",
     jsonldMode: jsonldMode,
     jsonMode: jsonMode,
 
     expressionAllowed: expressionAllowed,
+
     skipExpression: function(state) {
       var top = state.cc[state.cc.length - 1]
       if (top == expression || top == expressionNoComma) state.cc.pop()
     }
   };
 });
 
 CodeMirror.registerHelper("wordChars", "javascript", /[\w$]/);
 
 CodeMirror.defineMIME("text/javascript", "javascript");
 CodeMirror.defineMIME("text/ecmascript", "javascript");
 CodeMirror.defineMIME("application/javascript", "javascript");
 CodeMirror.defineMIME("application/x-javascript", "javascript");
 CodeMirror.defineMIME("application/ecmascript", "javascript");
 CodeMirror.defineMIME("application/json", {name: "javascript", json: true});
 CodeMirror.defineMIME("application/x-json", {name: "javascript", json: true});
 CodeMirror.defineMIME("application/ld+json", {name: "javascript", jsonld: true});
 CodeMirror.defineMIME("text/typescript", { name: "javascript", typescript: true });
 CodeMirror.defineMIME("application/typescript", { name: "javascript", typescript: true });
 
 });

rhodecode/public/js/mode/jinja2/jinja2.js

@@ -1,142 +1,146 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://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("jinja2", function() {
     var keywords = ["and", "as", "block", "endblock", "by", "cycle", "debug", "else", "elif",
       "extends", "filter", "endfilter", "firstof", "for",
       "endfor", "if", "endif", "ifchanged", "endifchanged",
       "ifequal", "endifequal", "ifnotequal",
       "endifnotequal", "in", "include", "load", "not", "now", "or",
       "parsed", "regroup", "reversed", "spaceless",
       "endspaceless", "ssi", "templatetag", "openblock",
       "closeblock", "openvariable", "closevariable",
       "openbrace", "closebrace", "opencomment",
       "closecomment", "widthratio", "url", "with", "endwith",
       "get_current_language", "trans", "endtrans", "noop", "blocktrans",
       "endblocktrans", "get_available_languages",
       "get_current_language_bidi", "plural"],
     operator = /^[+\-*&%=<>!?|~^]/,
     sign = /^[:\[\(\{]/,
     atom = ["true", "false"],
     number = /^(\d[+\-\*\/])?\d+(\.\d+)?/;
 
     keywords = new RegExp("((" + keywords.join(")|(") + "))\\b");
     atom = new RegExp("((" + atom.join(")|(") + "))\\b");
 
     function tokenBase (stream, state) {
       var ch = stream.peek();
 
       //Comment
       if (state.incomment) {
         if(!stream.skipTo("#}")) {
           stream.skipToEnd();
         } else {
           stream.eatWhile(/\#|}/);
           state.incomment = false;
         }
         return "comment";
       //Tag
       } else if (state.intag) {
         //After operator
         if(state.operator) {
           state.operator = false;
           if(stream.match(atom)) {
             return "atom";
           }
           if(stream.match(number)) {
             return "number";
           }
         }
         //After sign
         if(state.sign) {
           state.sign = false;
           if(stream.match(atom)) {
             return "atom";
           }
           if(stream.match(number)) {
             return "number";
           }
         }
 
         if(state.instring) {
           if(ch == state.instring) {
             state.instring = false;
           }
           stream.next();
           return "string";
         } else if(ch == "'" || ch == '"') {
           state.instring = ch;
           stream.next();
           return "string";
         } else if(stream.match(state.intag + "}") || stream.eat("-") && stream.match(state.intag + "}")) {
           state.intag = false;
           return "tag";
         } else if(stream.match(operator)) {
           state.operator = true;
           return "operator";
         } else if(stream.match(sign)) {
           state.sign = true;
         } else {
           if(stream.eat(" ") || stream.sol()) {
             if(stream.match(keywords)) {
               return "keyword";
             }
             if(stream.match(atom)) {
               return "atom";
             }
             if(stream.match(number)) {
               return "number";
             }
             if(stream.sol()) {
               stream.next();
             }
           } else {
             stream.next();
           }
 
         }
         return "variable";
       } else if (stream.eat("{")) {
-        if (ch = stream.eat("#")) {
+        if (stream.eat("#")) {
           state.incomment = true;
           if(!stream.skipTo("#}")) {
             stream.skipToEnd();
           } else {
             stream.eatWhile(/\#|}/);
             state.incomment = false;
           }
           return "comment";
         //Open tag
         } else if (ch = stream.eat(/\{|%/)) {
           //Cache close tag
           state.intag = ch;
           if(ch == "{") {
             state.intag = "}";
           }
           stream.eat("-");
           return "tag";
         }
       }
       stream.next();
     };
 
     return {
       startState: function () {
         return {tokenize: tokenBase};
       },
       token: function (stream, state) {
         return state.tokenize(stream, state);
-      }
+      },
+      blockCommentStart: "{#",
+      blockCommentEnd: "#}"
     };
   });
+
+  CodeMirror.defineMIME("text/jinja2", "jinja2");
 });

rhodecode/public/js/mode/jsx/jsx.js

@@ -1,147 +1,148 b''
 // CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: http://codemirror.net/LICENSE
+// Distributed under an MIT license: https://codemirror.net/LICENSE
 
 (function(mod) {
   if (typeof exports == "object" && typeof module == "object") // CommonJS
     mod(require("../../lib/codemirror"), require("../xml/xml"), require("../javascript/javascript"))
   else if (typeof define == "function" && define.amd) // AMD
     define(["../../lib/codemirror", "../xml/xml", "../javascript/javascript"], mod)
   else // Plain browser env
     mod(CodeMirror)
 })(function(CodeMirror) {
   "use strict"
 
   // Depth means the amount of open braces in JS context, in XML
   // context 0 means not in tag, 1 means in tag, and 2 means in tag
   // and js block comment.
   function Context(state, mode, depth, prev) {
     this.state = state; this.mode = mode; this.depth = depth; this.prev = prev
   }
 
   function copyContext(context) {
     return new Context(CodeMirror.copyState(context.mode, context.state),
                        context.mode,
                        context.depth,
                        context.prev && copyContext(context.prev))
   }
 
-  CodeMirror.defineMode("jsx", function(config) {
-    var xmlMode = CodeMirror.getMode(config, {name: "xml", allowMissing: true, multilineTagIndentPastTag: false})
-    var jsMode = CodeMirror.getMode(config, "javascript")
+  CodeMirror.defineMode("jsx", function(config, modeConfig) {
+    var xmlMode = CodeMirror.getMode(config, {name: "xml", allowMissing: true, multilineTagIndentPastTag: false, allowMissingTagName: true})
+    var jsMode = CodeMirror.getMode(config, modeConfig && modeConfig.base || "javascript")
 
     function flatXMLIndent(state) {
       var tagName = state.tagName
       state.tagName = null
-      var result = xmlMode.indent(state, "")
+      var result = xmlMode.indent(state, "", "")
       state.tagName = tagName
       return result
     }
 
     function token(stream, state) {
       if (state.context.mode == xmlMode)
         return xmlToken(stream, state, state.context)
       else
         return jsToken(stream, state, state.context)
     }
 
     function xmlToken(stream, state, cx) {
       if (cx.depth == 2) { // Inside a JS /* */ comment
         if (stream.match(/^.*?\*\//)) cx.depth = 1
         else stream.skipToEnd()
         return "comment"
       }
 
       if (stream.peek() == "{") {
         xmlMode.skipAttribute(cx.state)
 
         var indent = flatXMLIndent(cx.state), xmlContext = cx.state.context
         // If JS starts on same line as tag
         if (xmlContext && stream.match(/^[^>]*>\s*$/, false)) {
           while (xmlContext.prev && !xmlContext.startOfLine)
             xmlContext = xmlContext.prev
           // If tag starts the line, use XML indentation level
           if (xmlContext.startOfLine) indent -= config.indentUnit
           // Else use JS indentation level
           else if (cx.prev.state.lexical) indent = cx.prev.state.lexical.indented
         // Else if inside of tag
         } else if (cx.depth == 1) {
           indent += config.indentUnit
         }
 
         state.context = new Context(CodeMirror.startState(jsMode, indent),
                                     jsMode, 0, state.context)
         return null
       }
 
       if (cx.depth == 1) { // Inside of tag
         if (stream.peek() == "<") { // Tag inside of tag
           xmlMode.skipAttribute(cx.state)
           state.context = new Context(CodeMirror.startState(xmlMode, flatXMLIndent(cx.state)),
                                       xmlMode, 0, state.context)
           return null
         } else if (stream.match("//")) {
           stream.skipToEnd()
           return "comment"
         } else if (stream.match("/*")) {
           cx.depth = 2
           return token(stream, state)
         }
       }
 
       var style = xmlMode.token(stream, cx.state), cur = stream.current(), stop
       if (/\btag\b/.test(style)) {
         if (/>$/.test(cur)) {
           if (cx.state.context) cx.depth = 0
           else state.context = state.context.prev
         } else if (/^</.test(cur)) {
           cx.depth = 1
         }
       } else if (!style && (stop = cur.indexOf("{")) > -1) {
         stream.backUp(cur.length - stop)
       }
       return style
     }
 
     function jsToken(stream, state, cx) {
       if (stream.peek() == "<" && jsMode.expressionAllowed(stream, cx.state)) {
         jsMode.skipExpression(cx.state)
-        state.context = new Context(CodeMirror.startState(xmlMode, jsMode.indent(cx.state, "")),
+        state.context = new Context(CodeMirror.startState(xmlMode, jsMode.indent(cx.state, "", "")),
                                     xmlMode, 0, state.context)
         return null
       }
 
       var style = jsMode.token(stream, cx.state)
       if (!style && cx.depth != null) {
         var cur = stream.current()
         if (cur == "{") {
           cx.depth++
         } else if (cur == "}") {
           if (--cx.depth == 0) state.context = state.context.prev
         }
       }
       return style
     }
 
     return {
       startState: function() {
         return {context: new Context(CodeMirror.startState(jsMode), jsMode)}
       },
 
       copyState: function(state) {
         return {context: copyContext(state.context)}
       },
 
       token: token,
 
       indent: function(state, textAfter, fullLine) {
         return state.context.mode.indent(state.context.state, textAfter, fullLine)
       },
 
       innerMode: function(state) {
         return state.context
       }
     }
   }, "xml", "javascript")
 
   CodeMirror.defineMIME("text/jsx", "jsx")
-})
+  CodeMirror.defineMIME("text/typescript-jsx", {name: "jsx", base: {name: "javascript", typescript: true}})
+});