@vc-shell/framework 1.1.1 → 1.1.2

package/dist/assets/livescript-Dci8HnOi.js

@@ -0,0 +1,259 @@
+var tokenBase = function(stream, state) {
+  var next_rule = state.next || "start";
+  {
+    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 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: 'docComment',
+      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: 'atom',
+      regex: '(?:true|false|yes|no|on|off|null|void|undefined)' + keywordend
+    }, {
+      token: 'invalid',
+      regex: '(?:p(?:ackage|r(?:ivate|otected)|ublic)|i(?:mplements|nterface)|enum|static|yield)' + keywordend
+    }, {
+      token: 'className.standard',
+      regex: '(?:R(?:e(?:gExp|ferenceError)|angeError)|S(?:tring|yntaxError)|E(?:rror|valError)|Array|Boolean|Date|Function|Number|Object|TypeError|URIError)' + keywordend
+    }, {
+      token: 'variableName.function.standard',
+      regex: '(?:is(?:NaN|Finite)|parse(?:Int|Float)|Math|JSON|(?:en|de)codeURI(?:Component)?)' + keywordend
+    }, {
+      token: 'variableName.standard',
+      regex: '(?:t(?:hat|il|o)|f(?:rom|allthrough)|it|by|e)' + keywordend
+    }, {
+      token: 'variableName',
+      regex: identifier + '\\s*:(?![:=])'
+    }, {
+      token: 'variableName',
+      regex: identifier
+    }, {
+      token: 'operatorKeyword',
+      regex: '(?:\\.{3}|\\s+\\?)'
+    }, {
+      token: 'keyword',
+      regex: '(?:@+|::|\\.\\.)',
+      next: 'key'
+    }, {
+      token: 'operatorKeyword',
+      regex: '\\.\\s*',
+      next: 'key'
+    }, {
+      token: 'string',
+      regex: '\\\\\\S[^\\s,;)}\\]]*'
+    }, {
+      token: 'docString',
+      regex: '\'\'\'',
+      next: 'qdoc'
+    }, {
+      token: 'docString',
+      regex: '"""',
+      next: 'qqdoc'
+    }, {
+      token: 'string',
+      regex: '\'',
+      next: 'qstring'
+    }, {
+      token: 'string',
+      regex: '"',
+      next: 'qqstring'
+    }, {
+      token: 'string',
+      regex: '`',
+      next: 'js'
+    }, {
+      token: 'string',
+      regex: '<\\[',
+      next: 'words'
+    }, {
+      token: 'regexp',
+      regex: '//',
+      next: 'heregex'
+    }, {
+      token: 'regexp',
+      regex: '\\/(?:[^[\\/\\n\\\\]*(?:(?:\\\\.|\\[[^\\]\\n\\\\]*(?:\\\\.[^\\]\\n\\\\]*)*\\])[^[\\/\\n\\\\]*)*)\\/[gimy$]{0,4}',
+      next: 'key'
+    }, {
+      token: 'number',
+      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: 'paren',
+      regex: '[({[]'
+    }, {
+      token: 'paren',
+      regex: '[)}\\]]',
+      next: 'key'
+    }, {
+      token: 'operatorKeyword',
+      regex: '\\S+'
+    }, {
+      token: 'content',
+      regex: '\\s+'
+    }
+  ],
+  heregex: [
+    {
+      token: 'regexp',
+      regex: '.*?//[gimy$?]{0,4}',
+      next: 'start'
+    }, {
+      token: 'regexp',
+      regex: '\\s*#{'
+    }, {
+      token: 'comment',
+      regex: '\\s+(?:#.*)?'
+    }, {
+      token: 'regexp',
+      regex: '\\S+'
+    }
+  ],
+  key: [
+    {
+      token: 'operatorKeyword',
+      regex: '[.?@!]+'
+    }, {
+      token: 'variableName',
+      regex: identifier,
+      next: 'start'
+    }, {
+      token: 'content',
+      regex: '',
+      next: 'start'
+    }
+  ],
+  comment: [
+    {
+      token: 'docComment',
+      regex: '.*?\\*/',
+      next: 'start'
+    }, {
+      token: 'docComment',
+      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);
+  }
+}
+
+const liveScript = {
+  name: "livescript",
+  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;
+  }
+};
+
+export { liveScript };

package/dist/assets/lua-CByQu4v6.js

@@ -0,0 +1,137 @@
+function prefixRE(words) {
+  return new RegExp("^(?:" + words.join("|") + ")", "i");
+}
+function wordRE(words) {
+  return new RegExp("^(?:" + words.join("|") + ")$", "i");
+}
+
+// long list of standard functions from lua manual
+var builtins = wordRE([
+  "_G","_VERSION","assert","collectgarbage","dofile","error","getfenv","getmetatable","ipairs","load",
+  "loadfile","loadstring","module","next","pairs","pcall","print","rawequal","rawget","rawset","require",
+  "select","setfenv","setmetatable","tonumber","tostring","type","unpack","xpcall",
+
+  "coroutine.create","coroutine.resume","coroutine.running","coroutine.status","coroutine.wrap","coroutine.yield",
+
+  "debug.debug","debug.getfenv","debug.gethook","debug.getinfo","debug.getlocal","debug.getmetatable",
+  "debug.getregistry","debug.getupvalue","debug.setfenv","debug.sethook","debug.setlocal","debug.setmetatable",
+  "debug.setupvalue","debug.traceback",
+
+  "close","flush","lines","read","seek","setvbuf","write",
+
+  "io.close","io.flush","io.input","io.lines","io.open","io.output","io.popen","io.read","io.stderr","io.stdin",
+  "io.stdout","io.tmpfile","io.type","io.write",
+
+  "math.abs","math.acos","math.asin","math.atan","math.atan2","math.ceil","math.cos","math.cosh","math.deg",
+  "math.exp","math.floor","math.fmod","math.frexp","math.huge","math.ldexp","math.log","math.log10","math.max",
+  "math.min","math.modf","math.pi","math.pow","math.rad","math.random","math.randomseed","math.sin","math.sinh",
+  "math.sqrt","math.tan","math.tanh",
+
+  "os.clock","os.date","os.difftime","os.execute","os.exit","os.getenv","os.remove","os.rename","os.setlocale",
+  "os.time","os.tmpname",
+
+  "package.cpath","package.loaded","package.loaders","package.loadlib","package.path","package.preload",
+  "package.seeall",
+
+  "string.byte","string.char","string.dump","string.find","string.format","string.gmatch","string.gsub",
+  "string.len","string.lower","string.match","string.rep","string.reverse","string.sub","string.upper",
+
+  "table.concat","table.insert","table.maxn","table.remove","table.sort"
+]);
+var keywords = wordRE(["and","break","elseif","false","nil","not","or","return",
+                       "true","function", "end", "if", "then", "else", "do",
+                       "while", "repeat", "until", "for", "in", "local" ]);
+
+var indentTokens = wordRE(["function", "if","repeat","do", "\\(", "{"]);
+var dedentTokens = wordRE(["end", "until", "\\)", "}"]);
+var dedentPartial = prefixRE(["end", "until", "\\)", "}", "else", "elseif"]);
+
+function readBracket(stream) {
+  var level = 0;
+  while (stream.eat("=")) ++level;
+  stream.eat("[");
+  return level;
+}
+
+function normal(stream, state) {
+  var ch = stream.next();
+  if (ch == "-" && stream.eat("-")) {
+    if (stream.eat("[") && stream.eat("["))
+      return (state.cur = bracketed(readBracket(stream), "comment"))(stream, state);
+    stream.skipToEnd();
+    return "comment";
+  }
+  if (ch == "\"" || ch == "'")
+    return (state.cur = string(ch))(stream, state);
+  if (ch == "[" && /[\[=]/.test(stream.peek()))
+    return (state.cur = bracketed(readBracket(stream), "string"))(stream, state);
+  if (/\d/.test(ch)) {
+    stream.eatWhile(/[\w.%]/);
+    return "number";
+  }
+  if (/[\w_]/.test(ch)) {
+    stream.eatWhile(/[\w\\\-_.]/);
+    return "variable";
+  }
+  return null;
+}
+
+function bracketed(level, style) {
+  return function(stream, state) {
+    var curlev = null, ch;
+    while ((ch = stream.next()) != null) {
+      if (curlev == null) {if (ch == "]") curlev = 0;}
+      else if (ch == "=") ++curlev;
+      else if (ch == "]" && curlev == level) { state.cur = normal; break; }
+      else curlev = null;
+    }
+    return style;
+  };
+}
+
+function string(quote) {
+  return function(stream, state) {
+    var escaped = false, ch;
+    while ((ch = stream.next()) != null) {
+      if (ch == quote && !escaped) break;
+      escaped = !escaped && ch == "\\";
+    }
+    if (!escaped) state.cur = normal;
+    return "string";
+  };
+}
+
+const lua = {
+  name: "lua",
+
+  startState: function() {
+    return {basecol: 0, indentDepth: 0, cur: normal};
+  },
+
+  token: function(stream, state) {
+    if (stream.eatSpace()) return null;
+    var style = state.cur(stream, state);
+    var word = stream.current();
+    if (style == "variable") {
+      if (keywords.test(word)) style = "keyword";
+      else if (builtins.test(word)) style = "builtin";
+    }
+    if ((style != "comment") && (style != "string")){
+      if (indentTokens.test(word)) ++state.indentDepth;
+      else if (dedentTokens.test(word)) --state.indentDepth;
+    }
+    return style;
+  },
+
+  indent: function(state, textAfter, cx) {
+    var closing = dedentPartial.test(textAfter);
+    return state.basecol + cx.unit * (state.indentDepth - (closing ? 1 : 0));
+  },
+
+  languageData: {
+    indentOnInput: /^\s*(?:end|until|else|\)|\})$/,
+    commentTokens: {line: "--", block: {open: "--[[", close: "]]--"}}
+  }
+};
+
+export { lua };