@muze-nl/simplystore 0.3.6 → 0.4.0

package/www/codemirror/mode/julia/julia.js

@@ -1,390 +0,0 @@
-// CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: https://codemirror.net/5/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("julia", function(config, parserConf) {
-  function wordRegexp(words, end, pre) {
-    if (typeof pre === "undefined") { pre = ""; }
-    if (typeof end === "undefined") { end = "\\b"; }
-    return new RegExp("^" + pre + "((" + words.join(")|(") + "))" + end);
-  }
-
-  var octChar = "\\\\[0-7]{1,3}";
-  var hexChar = "\\\\x[A-Fa-f0-9]{1,2}";
-  var sChar = "\\\\[abefnrtv0%?'\"\\\\]";
-  var uChar = "([^\\u0027\\u005C\\uD800-\\uDFFF]|[\\uD800-\\uDFFF][\\uDC00-\\uDFFF])";
-
-  var asciiOperatorsList = [
-    "[<>]:", "[<>=]=", "<<=?", ">>>?=?", "=>", "--?>", "<--[->]?", "\\/\\/",
-    "\\.{2,3}", "[\\.\\\\%*+\\-<>!\\/^|&]=?", "\\?", "\\$", "~", ":"
-  ];
-  var operators = parserConf.operators || wordRegexp([
-    "[<>]:", "[<>=]=", "[!=]==", "<<=?", ">>>?=?", "=>?", "--?>", "<--[->]?", "\\/\\/",
-    "[\\\\%*+\\-<>!\\/^|&\\u00F7\\u22BB]=?", "\\?", "\\$", "~", ":",
-    "\\u00D7", "\\u2208", "\\u2209", "\\u220B", "\\u220C", "\\u2218",
-    "\\u221A", "\\u221B", "\\u2229", "\\u222A", "\\u2260", "\\u2264",
-    "\\u2265", "\\u2286", "\\u2288", "\\u228A", "\\u22C5",
-    "\\b(in|isa)\\b(?!\.?\\()"
-  ], "");
-  var delimiters = parserConf.delimiters || /^[;,()[\]{}]/;
-  var identifiers = parserConf.identifiers ||
-        /^[_A-Za-z\u00A1-\u2217\u2219-\uFFFF][\w\u00A1-\u2217\u2219-\uFFFF]*!*/;
-
-  var chars = wordRegexp([octChar, hexChar, sChar, uChar], "'");
-
-  var openersList = ["begin", "function", "type", "struct", "immutable", "let",
-        "macro", "for", "while", "quote", "if", "else", "elseif", "try",
-        "finally", "catch", "do"];
-
-  var closersList = ["end", "else", "elseif", "catch", "finally"];
-
-  var keywordsList = ["if", "else", "elseif", "while", "for", "begin", "let",
-        "end", "do", "try", "catch", "finally", "return", "break", "continue",
-        "global", "local", "const", "export", "import", "importall", "using",
-        "function", "where", "macro", "module", "baremodule", "struct", "type",
-        "mutable", "immutable", "quote", "typealias", "abstract", "primitive",
-        "bitstype"];
-
-  var builtinsList = ["true", "false", "nothing", "NaN", "Inf"];
-
-  CodeMirror.registerHelper("hintWords", "julia", keywordsList.concat(builtinsList));
-
-  var openers = wordRegexp(openersList);
-  var closers = wordRegexp(closersList);
-  var keywords = wordRegexp(keywordsList);
-  var builtins = wordRegexp(builtinsList);
-
-  var macro = /^@[_A-Za-z\u00A1-\uFFFF][\w\u00A1-\uFFFF]*!*/;
-  var symbol = /^:[_A-Za-z\u00A1-\uFFFF][\w\u00A1-\uFFFF]*!*/;
-  var stringPrefixes = /^(`|([_A-Za-z\u00A1-\uFFFF]*"("")?))/;
-
-  var macroOperators = wordRegexp(asciiOperatorsList, "", "@");
-  var symbolOperators = wordRegexp(asciiOperatorsList, "", ":");
-
-  function inArray(state) {
-    return (state.nestedArrays > 0);
-  }
-
-  function inGenerator(state) {
-    return (state.nestedGenerators > 0);
-  }
-
-  function currentScope(state, n) {
-    if (typeof(n) === "undefined") { n = 0; }
-    if (state.scopes.length <= n) {
-      return null;
-    }
-    return state.scopes[state.scopes.length - (n + 1)];
-  }
-
-  // tokenizers
-  function tokenBase(stream, state) {
-    // Handle multiline comments
-    if (stream.match('#=', false)) {
-      state.tokenize = tokenComment;
-      return state.tokenize(stream, state);
-    }
-
-    // Handle scope changes
-    var leavingExpr = state.leavingExpr;
-    if (stream.sol()) {
-      leavingExpr = false;
-    }
-    state.leavingExpr = false;
-
-    if (leavingExpr) {
-      if (stream.match(/^'+/)) {
-        return "operator";
-      }
-    }
-
-    if (stream.match(/\.{4,}/)) {
-      return "error";
-    } else if (stream.match(/\.{1,3}/)) {
-      return "operator";
-    }
-
-    if (stream.eatSpace()) {
-      return null;
-    }
-
-    var ch = stream.peek();
-
-    // Handle single line comments
-    if (ch === '#') {
-      stream.skipToEnd();
-      return "comment";
-    }
-
-    if (ch === '[') {
-      state.scopes.push('[');
-      state.nestedArrays++;
-    }
-
-    if (ch === '(') {
-      state.scopes.push('(');
-      state.nestedGenerators++;
-    }
-
-    if (inArray(state) && ch === ']') {
-      while (state.scopes.length && currentScope(state) !== "[") { state.scopes.pop(); }
-      state.scopes.pop();
-      state.nestedArrays--;
-      state.leavingExpr = true;
-    }
-
-    if (inGenerator(state) && ch === ')') {
-      while (state.scopes.length && currentScope(state) !== "(") { state.scopes.pop(); }
-      state.scopes.pop();
-      state.nestedGenerators--;
-      state.leavingExpr = true;
-    }
-
-    if (inArray(state)) {
-      if (state.lastToken == "end" && stream.match(':')) {
-        return "operator";
-      }
-      if (stream.match('end')) {
-        return "number";
-      }
-    }
-
-    var match;
-    if (match = stream.match(openers, false)) {
-      state.scopes.push(match[0]);
-    }
-
-    if (stream.match(closers, false)) {
-      state.scopes.pop();
-    }
-
-    // Handle type annotations
-    if (stream.match(/^::(?![:\$])/)) {
-      state.tokenize = tokenAnnotation;
-      return state.tokenize(stream, state);
-    }
-
-    // Handle symbols
-    if (!leavingExpr && (stream.match(symbol) || stream.match(symbolOperators))) {
-      return "builtin";
-    }
-
-    // Handle parametric types
-    //if (stream.match(/^{[^}]*}(?=\()/)) {
-    //  return "builtin";
-    //}
-
-    // Handle operators and Delimiters
-    if (stream.match(operators)) {
-      return "operator";
-    }
-
-    // Handle Number Literals
-    if (stream.match(/^\.?\d/, false)) {
-      var imMatcher = RegExp(/^im\b/);
-      var numberLiteral = false;
-      if (stream.match(/^0x\.[0-9a-f_]+p[\+\-]?[_\d]+/i)) { numberLiteral = true; }
-      // Integers
-      if (stream.match(/^0x[0-9a-f_]+/i)) { numberLiteral = true; } // Hex
-      if (stream.match(/^0b[01_]+/i)) { numberLiteral = true; } // Binary
-      if (stream.match(/^0o[0-7_]+/i)) { numberLiteral = true; } // Octal
-      // Floats
-      if (stream.match(/^(?:(?:\d[_\d]*)?\.(?!\.)(?:\d[_\d]*)?|\d[_\d]*\.(?!\.)(?:\d[_\d]*))?([Eef][\+\-]?[_\d]+)?/i)) { numberLiteral = true; }
-      if (stream.match(/^\d[_\d]*(e[\+\-]?\d+)?/i)) { numberLiteral = true; } // Decimal
-      if (numberLiteral) {
-          // Integer literals may be "long"
-          stream.match(imMatcher);
-          state.leavingExpr = true;
-          return "number";
-      }
-    }
-
-    // Handle Chars
-    if (stream.match('\'')) {
-      state.tokenize = tokenChar;
-      return state.tokenize(stream, state);
-    }
-
-    // Handle Strings
-    if (stream.match(stringPrefixes)) {
-      state.tokenize = tokenStringFactory(stream.current());
-      return state.tokenize(stream, state);
-    }
-
-    if (stream.match(macro) || stream.match(macroOperators)) {
-      return "meta";
-    }
-
-    if (stream.match(delimiters)) {
-      return null;
-    }
-
-    if (stream.match(keywords)) {
-      return "keyword";
-    }
-
-    if (stream.match(builtins)) {
-      return "builtin";
-    }
-
-    var isDefinition = state.isDefinition || state.lastToken == "function" ||
-                       state.lastToken == "macro" || state.lastToken == "type" ||
-                       state.lastToken == "struct" || state.lastToken == "immutable";
-
-    if (stream.match(identifiers)) {
-      if (isDefinition) {
-        if (stream.peek() === '.') {
-          state.isDefinition = true;
-          return "variable";
-        }
-        state.isDefinition = false;
-        return "def";
-      }
-      state.leavingExpr = true;
-      return "variable";
-    }
-
-    // Handle non-detected items
-    stream.next();
-    return "error";
-  }
-
-  function tokenAnnotation(stream, state) {
-    stream.match(/.*?(?=[,;{}()=\s]|$)/);
-    if (stream.match('{')) {
-      state.nestedParameters++;
-    } else if (stream.match('}') && state.nestedParameters > 0) {
-      state.nestedParameters--;
-    }
-    if (state.nestedParameters > 0) {
-      stream.match(/.*?(?={|})/) || stream.next();
-    } else if (state.nestedParameters == 0) {
-      state.tokenize = tokenBase;
-    }
-    return "builtin";
-  }
-
-  function tokenComment(stream, state) {
-    if (stream.match('#=')) {
-      state.nestedComments++;
-    }
-    if (!stream.match(/.*?(?=(#=|=#))/)) {
-      stream.skipToEnd();
-    }
-    if (stream.match('=#')) {
-      state.nestedComments--;
-      if (state.nestedComments == 0)
-        state.tokenize = tokenBase;
-    }
-    return "comment";
-  }
-
-  function tokenChar(stream, state) {
-    var isChar = false, match;
-    if (stream.match(chars)) {
-      isChar = true;
-    } else if (match = stream.match(/\\u([a-f0-9]{1,4})(?=')/i)) {
-      var value = parseInt(match[1], 16);
-      if (value <= 55295 || value >= 57344) { // (U+0,U+D7FF), (U+E000,U+FFFF)
-        isChar = true;
-        stream.next();
-      }
-    } else if (match = stream.match(/\\U([A-Fa-f0-9]{5,8})(?=')/)) {
-      var value = parseInt(match[1], 16);
-      if (value <= 1114111) { // U+10FFFF
-        isChar = true;
-        stream.next();
-      }
-    }
-    if (isChar) {
-      state.leavingExpr = true;
-      state.tokenize = tokenBase;
-      return "string";
-    }
-    if (!stream.match(/^[^']+(?=')/)) { stream.skipToEnd(); }
-    if (stream.match('\'')) { state.tokenize = tokenBase; }
-    return "error";
-  }
-
-  function tokenStringFactory(delimiter) {
-    if (delimiter.substr(-3) === '"""') {
-      delimiter = '"""';
-    } else if (delimiter.substr(-1) === '"') {
-      delimiter = '"';
-    }
-    function tokenString(stream, state) {
-      if (stream.eat('\\')) {
-        stream.next();
-      } else if (stream.match(delimiter)) {
-        state.tokenize = tokenBase;
-        state.leavingExpr = true;
-        return "string";
-      } else {
-        stream.eat(/[`"]/);
-      }
-      stream.eatWhile(/[^\\`"]/);
-      return "string";
-    }
-    return tokenString;
-  }
-
-  var external = {
-    startState: function() {
-      return {
-        tokenize: tokenBase,
-        scopes: [],
-        lastToken: null,
-        leavingExpr: false,
-        isDefinition: false,
-        nestedArrays: 0,
-        nestedComments: 0,
-        nestedGenerators: 0,
-        nestedParameters: 0,
-        firstParenPos: -1
-      };
-    },
-
-    token: function(stream, state) {
-      var style = state.tokenize(stream, state);
-      var current = stream.current();
-
-      if (current && style) {
-        state.lastToken = current;
-      }
-
-      return style;
-    },
-
-    indent: function(state, textAfter) {
-      var delta = 0;
-      if ( textAfter === ']' || textAfter === ')' || /^end\b/.test(textAfter) ||
-           /^else/.test(textAfter) || /^catch\b/.test(textAfter) || /^elseif\b/.test(textAfter) ||
-           /^finally/.test(textAfter) ) {
-        delta = -1;
-      }
-      return (state.scopes.length + delta) * config.indentUnit;
-    },
-
-    electricInput: /\b(end|else|catch|finally)\b/,
-    blockCommentStart: "#=",
-    blockCommentEnd: "=#",
-    lineComment: "#",
-    closeBrackets: "()[]{}\"\"",
-    fold: "indent"
-  };
-  return external;
-});
-
-
-CodeMirror.defineMIME("text/x-julia", "julia");
-
-});

package/www/codemirror/mode/livescript/livescript.js

@@ -1,280 +0,0 @@
-// CodeMirror, copyright (c) by Marijn Haverbeke and others
-// Distributed under an MIT license: https://codemirror.net/5/LICENSE
-
-/**
- * Link to the project's GitHub page:
- * https://github.com/duralog/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";
-
-  CodeMirror.defineMode('livescript', function(){
-    var tokenBase = function(stream, state) {
-      var next_rule = state.next || "start";
-      if (next_rule) {
-        state.next = state.next;
-        var nr = Rules[next_rule];
-        if (nr.splice) {
-          for (var i$ = 0; i$ < nr.length; ++i$) {
-            var r = nr[i$];
-            if (r.regex && stream.match(r.regex)) {
-              state.next = r.next || state.next;
-              return r.token;
-            }
-          }
-          stream.next();
-          return 'error';
-        }
-        if (stream.match(r = Rules[next_rule])) {
-          if (r.regex && stream.match(r.regex)) {
-            state.next = r.next;
-            return r.token;
-          } else {
-            stream.next();
-            return 'error';
-          }
-        }
-      }
-      stream.next();
-      return 'error';
-    };
-    var external = {
-      startState: function(){
-        return {
-          next: 'start',
-          lastToken: {style: null, indent: 0, content: ""}
-        };
-      },
-      token: function(stream, state){
-        while (stream.pos == stream.start)
-          var style = tokenBase(stream, state);
-        state.lastToken = {
-          style: style,
-          indent: stream.indentation(),
-          content: stream.current()
-        };
-        return style.replace(/\./g, ' ');
-      },
-      indent: function(state){
-        var indentation = state.lastToken.indent;
-        if (state.lastToken.content.match(indenter)) {
-          indentation += 2;
-        }
-        return indentation;
-      }
-    };
-    return external;
-  });
-
-  var identifier = '(?![\\d\\s])[$\\w\\xAA-\\uFFDC](?:(?!\\s)[$\\w\\xAA-\\uFFDC]|-[A-Za-z])*';
-  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*$');
-  var keywordend = '(?![$\\w]|-[A-Za-z]|\\s*:(?![:=]))';
-  var stringfill = {
-    token: 'string',
-    regex: '.+'
-  };
-  var Rules = {
-    start: [
-      {
-        token: 'comment.doc',
-        regex: '/\\*',
-        next: 'comment'
-      }, {
-        token: 'comment',
-        regex: '#.*'
-      }, {
-        token: 'keyword',
-        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
-      }, {
-        token: 'constant.language',
-        regex: '(?:true|false|yes|no|on|off|null|void|undefined)' + keywordend
-      }, {
-        token: 'invalid.illegal',
-        regex: '(?:p(?:ackage|r(?:ivate|otected)|ublic)|i(?:mplements|nterface)|enum|static|yield)' + keywordend
-      }, {
-        token: 'language.support.class',
-        regex: '(?:R(?:e(?:gExp|ferenceError)|angeError)|S(?:tring|yntaxError)|E(?:rror|valError)|Array|Boolean|Date|Function|Number|Object|TypeError|URIError)' + keywordend
-      }, {
-        token: 'language.support.function',
-        regex: '(?:is(?:NaN|Finite)|parse(?:Int|Float)|Math|JSON|(?:en|de)codeURI(?:Component)?)' + keywordend
-      }, {
-        token: 'variable.language',
-        regex: '(?:t(?:hat|il|o)|f(?:rom|allthrough)|it|by|e)' + keywordend
-      }, {
-        token: 'identifier',
-        regex: identifier + '\\s*:(?![:=])'
-      }, {
-        token: 'variable',
-        regex: identifier
-      }, {
-        token: 'keyword.operator',
-        regex: '(?:\\.{3}|\\s+\\?)'
-      }, {
-        token: 'keyword.variable',
-        regex: '(?:@+|::|\\.\\.)',
-        next: 'key'
-      }, {
-        token: 'keyword.operator',
-        regex: '\\.\\s*',
-        next: 'key'
-      }, {
-        token: 'string',
-        regex: '\\\\\\S[^\\s,;)}\\]]*'
-      }, {
-        token: 'string.doc',
-        regex: '\'\'\'',
-        next: 'qdoc'
-      }, {
-        token: 'string.doc',
-        regex: '"""',
-        next: 'qqdoc'
-      }, {
-        token: 'string',
-        regex: '\'',
-        next: 'qstring'
-      }, {
-        token: 'string',
-        regex: '"',
-        next: 'qqstring'
-      }, {
-        token: 'string',
-        regex: '`',
-        next: 'js'
-      }, {
-        token: 'string',
-        regex: '<\\[',
-        next: 'words'
-      }, {
-        token: 'string.regex',
-        regex: '//',
-        next: 'heregex'
-      }, {
-        token: 'string.regex',
-        regex: '\\/(?:[^[\\/\\n\\\\]*(?:(?:\\\\.|\\[[^\\]\\n\\\\]*(?:\\\\.[^\\]\\n\\\\]*)*\\])[^[\\/\\n\\\\]*)*)\\/[gimy$]{0,4}',
-        next: 'key'
-      }, {
-        token: 'constant.numeric',
-        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$]*)'
-      }, {
-        token: 'lparen',
-        regex: '[({[]'
-      }, {
-        token: 'rparen',
-        regex: '[)}\\]]',
-        next: 'key'
-      }, {
-        token: 'keyword.operator',
-        regex: '\\S+'
-      }, {
-        token: 'text',
-        regex: '\\s+'
-      }
-    ],
-    heregex: [
-      {
-        token: 'string.regex',
-        regex: '.*?//[gimy$?]{0,4}',
-        next: 'start'
-      }, {
-        token: 'string.regex',
-        regex: '\\s*#{'
-      }, {
-        token: 'comment.regex',
-        regex: '\\s+(?:#.*)?'
-      }, {
-        token: 'string.regex',
-        regex: '\\S+'
-      }
-    ],
-    key: [
-      {
-        token: 'keyword.operator',
-        regex: '[.?@!]+'
-      }, {
-        token: 'identifier',
-        regex: identifier,
-        next: 'start'
-      }, {
-        token: 'text',
-        regex: '',
-        next: 'start'
-      }
-    ],
-    comment: [
-      {
-        token: 'comment.doc',
-        regex: '.*?\\*/',
-        next: 'start'
-      }, {
-        token: 'comment.doc',
-        regex: '.+'
-      }
-    ],
-    qdoc: [
-      {
-        token: 'string',
-        regex: ".*?'''",
-        next: 'key'
-      }, stringfill
-    ],
-    qqdoc: [
-      {
-        token: 'string',
-        regex: '.*?"""',
-        next: 'key'
-      }, stringfill
-    ],
-    qstring: [
-      {
-        token: 'string',
-        regex: '[^\\\\\']*(?:\\\\.[^\\\\\']*)*\'',
-        next: 'key'
-      }, stringfill
-    ],
-    qqstring: [
-      {
-        token: 'string',
-        regex: '[^\\\\"]*(?:\\\\.[^\\\\"]*)*"',
-        next: 'key'
-      }, stringfill
-    ],
-    js: [
-      {
-        token: 'string',
-        regex: '[^\\\\`]*(?:\\\\.[^\\\\`]*)*`',
-        next: 'key'
-      }, stringfill
-    ],
-    words: [
-      {
-        token: 'string',
-        regex: '.*?\\]>',
-        next: 'key'
-      }, stringfill
-    ]
-  };
-  for (var idx in Rules) {
-    var r = Rules[idx];
-    if (r.splice) {
-      for (var i = 0, len = r.length; i < len; ++i) {
-        var rr = r[i];
-        if (typeof rr.regex === 'string') {
-          Rules[idx][i].regex = new RegExp('^' + rr.regex);
-        }
-      }
-    } else if (typeof rr.regex === 'string') {
-      Rules[idx].regex = new RegExp('^' + r.regex);
-    }
-  }
-
-  CodeMirror.defineMIME('text/x-livescript', 'livescript');
-
-});