openrat-cms

Unnamed repository; edit this file 'description' to name the repository.
Log | Files | Refs | README

livescript.js (7668B)


      1 // CodeMirror, copyright (c) by Marijn Haverbeke and others
      2 // Distributed under an MIT license: http://codemirror.net/LICENSE
      3 
      4 /**
      5  * Link to the project's GitHub page:
      6  * https://github.com/duralog/CodeMirror
      7  */
      8 
      9 (function(mod) {
     10   if (typeof exports == "object" && typeof module == "object") // CommonJS
     11     mod(require("../../lib/codemirror"));
     12   else if (typeof define == "function" && define.amd) // AMD
     13     define(["../../lib/codemirror"], mod);
     14   else // Plain browser env
     15     mod(CodeMirror);
     16 })(function(CodeMirror) {
     17   "use strict";
     18 
     19   CodeMirror.defineMode('livescript', function(){
     20     var tokenBase = function(stream, state) {
     21       var next_rule = state.next || "start";
     22       if (next_rule) {
     23         state.next = state.next;
     24         var nr = Rules[next_rule];
     25         if (nr.splice) {
     26           for (var i$ = 0; i$ < nr.length; ++i$) {
     27             var r = nr[i$];
     28             if (r.regex && stream.match(r.regex)) {
     29               state.next = r.next || state.next;
     30               return r.token;
     31             }
     32           }
     33           stream.next();
     34           return 'error';
     35         }
     36         if (stream.match(r = Rules[next_rule])) {
     37           if (r.regex && stream.match(r.regex)) {
     38             state.next = r.next;
     39             return r.token;
     40           } else {
     41             stream.next();
     42             return 'error';
     43           }
     44         }
     45       }
     46       stream.next();
     47       return 'error';
     48     };
     49     var external = {
     50       startState: function(){
     51         return {
     52           next: 'start',
     53           lastToken: {style: null, indent: 0, content: ""}
     54         };
     55       },
     56       token: function(stream, state){
     57         while (stream.pos == stream.start)
     58           var style = tokenBase(stream, state);
     59         state.lastToken = {
     60           style: style,
     61           indent: stream.indentation(),
     62           content: stream.current()
     63         };
     64         return style.replace(/\./g, ' ');
     65       },
     66       indent: function(state){
     67         var indentation = state.lastToken.indent;
     68         if (state.lastToken.content.match(indenter)) {
     69           indentation += 2;
     70         }
     71         return indentation;
     72       }
     73     };
     74     return external;
     75   });
     76 
     77   var identifier = '(?![\\d\\s])[$\\w\\xAA-\\uFFDC](?:(?!\\s)[$\\w\\xAA-\\uFFDC]|-[A-Za-z])*';
     78   var indenter = RegExp('(?:[({[=:]|[-~]>|\\b(?:e(?:lse|xport)|d(?:o|efault)|t(?:ry|hen)|finally|import(?:\\s*all)?|const|var|let|new|catch(?:\\s*' + identifier + ')?))\\s*$');
     79   var keywordend = '(?![$\\w]|-[A-Za-z]|\\s*:(?![:=]))';
     80   var stringfill = {
     81     token: 'string',
     82     regex: '.+'
     83   };
     84   var Rules = {
     85     start: [
     86       {
     87         token: 'comment.doc',
     88         regex: '/\\*',
     89         next: 'comment'
     90       }, {
     91         token: 'comment',
     92         regex: '#.*'
     93       }, {
     94         token: 'keyword',
     95         regex: '(?:t(?:h(?:is|row|en)|ry|ypeof!?)|c(?:on(?:tinue|st)|a(?:se|tch)|lass)|i(?:n(?:stanceof)?|mp(?:ort(?:\\s+all)?|lements)|[fs])|d(?:e(?:fault|lete|bugger)|o)|f(?:or(?:\\s+own)?|inally|unction)|s(?:uper|witch)|e(?:lse|x(?:tends|port)|val)|a(?:nd|rguments)|n(?:ew|ot)|un(?:less|til)|w(?:hile|ith)|o[fr]|return|break|let|var|loop)' + keywordend
     96       }, {
     97         token: 'constant.language',
     98         regex: '(?:true|false|yes|no|on|off|null|void|undefined)' + keywordend
     99       }, {
    100         token: 'invalid.illegal',
    101         regex: '(?:p(?:ackage|r(?:ivate|otected)|ublic)|i(?:mplements|nterface)|enum|static|yield)' + keywordend
    102       }, {
    103         token: 'language.support.class',
    104         regex: '(?:R(?:e(?:gExp|ferenceError)|angeError)|S(?:tring|yntaxError)|E(?:rror|valError)|Array|Boolean|Date|Function|Number|Object|TypeError|URIError)' + keywordend
    105       }, {
    106         token: 'language.support.function',
    107         regex: '(?:is(?:NaN|Finite)|parse(?:Int|Float)|Math|JSON|(?:en|de)codeURI(?:Component)?)' + keywordend
    108       }, {
    109         token: 'variable.language',
    110         regex: '(?:t(?:hat|il|o)|f(?:rom|allthrough)|it|by|e)' + keywordend
    111       }, {
    112         token: 'identifier',
    113         regex: identifier + '\\s*:(?![:=])'
    114       }, {
    115         token: 'variable',
    116         regex: identifier
    117       }, {
    118         token: 'keyword.operator',
    119         regex: '(?:\\.{3}|\\s+\\?)'
    120       }, {
    121         token: 'keyword.variable',
    122         regex: '(?:@+|::|\\.\\.)',
    123         next: 'key'
    124       }, {
    125         token: 'keyword.operator',
    126         regex: '\\.\\s*',
    127         next: 'key'
    128       }, {
    129         token: 'string',
    130         regex: '\\\\\\S[^\\s,;)}\\]]*'
    131       }, {
    132         token: 'string.doc',
    133         regex: '\'\'\'',
    134         next: 'qdoc'
    135       }, {
    136         token: 'string.doc',
    137         regex: '"""',
    138         next: 'qqdoc'
    139       }, {
    140         token: 'string',
    141         regex: '\'',
    142         next: 'qstring'
    143       }, {
    144         token: 'string',
    145         regex: '"',
    146         next: 'qqstring'
    147       }, {
    148         token: 'string',
    149         regex: '`',
    150         next: 'js'
    151       }, {
    152         token: 'string',
    153         regex: '<\\[',
    154         next: 'words'
    155       }, {
    156         token: 'string.regex',
    157         regex: '//',
    158         next: 'heregex'
    159       }, {
    160         token: 'string.regex',
    161         regex: '\\/(?:[^[\\/\\n\\\\]*(?:(?:\\\\.|\\[[^\\]\\n\\\\]*(?:\\\\.[^\\]\\n\\\\]*)*\\])[^[\\/\\n\\\\]*)*)\\/[gimy$]{0,4}',
    162         next: 'key'
    163       }, {
    164         token: 'constant.numeric',
    165         regex: '(?:0x[\\da-fA-F][\\da-fA-F_]*|(?:[2-9]|[12]\\d|3[0-6])r[\\da-zA-Z][\\da-zA-Z_]*|(?:\\d[\\d_]*(?:\\.\\d[\\d_]*)?|\\.\\d[\\d_]*)(?:e[+-]?\\d[\\d_]*)?[\\w$]*)'
    166       }, {
    167         token: 'lparen',
    168         regex: '[({[]'
    169       }, {
    170         token: 'rparen',
    171         regex: '[)}\\]]',
    172         next: 'key'
    173       }, {
    174         token: 'keyword.operator',
    175         regex: '\\S+'
    176       }, {
    177         token: 'text',
    178         regex: '\\s+'
    179       }
    180     ],
    181     heregex: [
    182       {
    183         token: 'string.regex',
    184         regex: '.*?//[gimy$?]{0,4}',
    185         next: 'start'
    186       }, {
    187         token: 'string.regex',
    188         regex: '\\s*#{'
    189       }, {
    190         token: 'comment.regex',
    191         regex: '\\s+(?:#.*)?'
    192       }, {
    193         token: 'string.regex',
    194         regex: '\\S+'
    195       }
    196     ],
    197     key: [
    198       {
    199         token: 'keyword.operator',
    200         regex: '[.?@!]+'
    201       }, {
    202         token: 'identifier',
    203         regex: identifier,
    204         next: 'start'
    205       }, {
    206         token: 'text',
    207         regex: '',
    208         next: 'start'
    209       }
    210     ],
    211     comment: [
    212       {
    213         token: 'comment.doc',
    214         regex: '.*?\\*/',
    215         next: 'start'
    216       }, {
    217         token: 'comment.doc',
    218         regex: '.+'
    219       }
    220     ],
    221     qdoc: [
    222       {
    223         token: 'string',
    224         regex: ".*?'''",
    225         next: 'key'
    226       }, stringfill
    227     ],
    228     qqdoc: [
    229       {
    230         token: 'string',
    231         regex: '.*?"""',
    232         next: 'key'
    233       }, stringfill
    234     ],
    235     qstring: [
    236       {
    237         token: 'string',
    238         regex: '[^\\\\\']*(?:\\\\.[^\\\\\']*)*\'',
    239         next: 'key'
    240       }, stringfill
    241     ],
    242     qqstring: [
    243       {
    244         token: 'string',
    245         regex: '[^\\\\"]*(?:\\\\.[^\\\\"]*)*"',
    246         next: 'key'
    247       }, stringfill
    248     ],
    249     js: [
    250       {
    251         token: 'string',
    252         regex: '[^\\\\`]*(?:\\\\.[^\\\\`]*)*`',
    253         next: 'key'
    254       }, stringfill
    255     ],
    256     words: [
    257       {
    258         token: 'string',
    259         regex: '.*?\\]>',
    260         next: 'key'
    261       }, stringfill
    262     ]
    263   };
    264   for (var idx in Rules) {
    265     var r = Rules[idx];
    266     if (r.splice) {
    267       for (var i = 0, len = r.length; i < len; ++i) {
    268         var rr = r[i];
    269         if (typeof rr.regex === 'string') {
    270           Rules[idx][i].regex = new RegExp('^' + rr.regex);
    271         }
    272       }
    273     } else if (typeof rr.regex === 'string') {
    274       Rules[idx].regex = new RegExp('^' + r.regex);
    275     }
    276   }
    277 
    278   CodeMirror.defineMIME('text/x-livescript', 'livescript');
    279 
    280 });