@vc-shell/framework 1.1.0 → 1.1.2

package/dist/assets/oz-CEUnktiQ.js

@@ -0,0 +1,235 @@
+function wordRegexp(words) {
+  return new RegExp("^((" + words.join(")|(") + "))\\b");
+}
+
+var singleOperators = /[\^@!\|<>#~\.\*\-\+\\/,=]/;
+var doubleOperators = /(<-)|(:=)|(=<)|(>=)|(<=)|(<:)|(>:)|(=:)|(\\=)|(\\=:)|(!!)|(==)|(::)/;
+var tripleOperators = /(:::)|(\.\.\.)|(=<:)|(>=:)/;
+
+var middle = ["in", "then", "else", "of", "elseof", "elsecase", "elseif", "catch",
+              "finally", "with", "require", "prepare", "import", "export", "define", "do"];
+var end = ["end"];
+
+var atoms = wordRegexp(["true", "false", "nil", "unit"]);
+var commonKeywords = wordRegexp(["andthen", "at", "attr", "declare", "feat", "from", "lex",
+                                 "mod", "div", "mode", "orelse", "parser", "prod", "prop", "scanner", "self", "syn", "token"]);
+var openingKeywords = wordRegexp(["local", "proc", "fun", "case", "class", "if", "cond", "or", "dis",
+                                  "choice", "not", "thread", "try", "raise", "lock", "for", "suchthat", "meth", "functor"]);
+var middleKeywords = wordRegexp(middle);
+var endKeywords = wordRegexp(end);
+
+// Tokenizers
+function tokenBase(stream, state) {
+  if (stream.eatSpace()) {
+    return null;
+  }
+
+  // Brackets
+  if(stream.match(/[{}]/)) {
+    return "bracket";
+  }
+
+  // Special [] keyword
+  if (stream.match('[]')) {
+    return "keyword"
+  }
+
+  // Operators
+  if (stream.match(tripleOperators) || stream.match(doubleOperators)) {
+    return "operator";
+  }
+
+  // Atoms
+  if(stream.match(atoms)) {
+    return 'atom';
+  }
+
+  // Opening keywords
+  var matched = stream.match(openingKeywords);
+  if (matched) {
+    if (!state.doInCurrentLine)
+      state.currentIndent++;
+    else
+      state.doInCurrentLine = false;
+
+    // Special matching for signatures
+    if(matched[0] == "proc" || matched[0] == "fun")
+      state.tokenize = tokenFunProc;
+    else if(matched[0] == "class")
+      state.tokenize = tokenClass;
+    else if(matched[0] == "meth")
+      state.tokenize = tokenMeth;
+
+    return 'keyword';
+  }
+
+  // Middle and other keywords
+  if (stream.match(middleKeywords) || stream.match(commonKeywords)) {
+    return "keyword"
+  }
+
+  // End keywords
+  if (stream.match(endKeywords)) {
+    state.currentIndent--;
+    return 'keyword';
+  }
+
+  // Eat the next char for next comparisons
+  var ch = stream.next();
+
+  // Strings
+  if (ch == '"' || ch == "'") {
+    state.tokenize = tokenString(ch);
+    return state.tokenize(stream, state);
+  }
+
+  // Numbers
+  if (/[~\d]/.test(ch)) {
+    if (ch == "~") {
+      if(! /^[0-9]/.test(stream.peek()))
+        return null;
+      else if (( stream.next() == "0" && stream.match(/^[xX][0-9a-fA-F]+/)) || stream.match(/^[0-9]*(\.[0-9]+)?([eE][~+]?[0-9]+)?/))
+        return "number";
+    }
+
+    if ((ch == "0" && stream.match(/^[xX][0-9a-fA-F]+/)) || stream.match(/^[0-9]*(\.[0-9]+)?([eE][~+]?[0-9]+)?/))
+      return "number";
+
+    return null;
+  }
+
+  // Comments
+  if (ch == "%") {
+    stream.skipToEnd();
+    return 'comment';
+  }
+  else if (ch == "/") {
+    if (stream.eat("*")) {
+      state.tokenize = tokenComment;
+      return tokenComment(stream, state);
+    }
+  }
+
+  // Single operators
+  if(singleOperators.test(ch)) {
+    return "operator";
+  }
+
+  // If nothing match, we skip the entire alphanumerical block
+  stream.eatWhile(/\w/);
+
+  return "variable";
+}
+
+function tokenClass(stream, state) {
+  if (stream.eatSpace()) {
+    return null;
+  }
+  stream.match(/([A-Z][A-Za-z0-9_]*)|(`.+`)/);
+  state.tokenize = tokenBase;
+  return "type"
+}
+
+function tokenMeth(stream, state) {
+  if (stream.eatSpace()) {
+    return null;
+  }
+  stream.match(/([a-zA-Z][A-Za-z0-9_]*)|(`.+`)/);
+  state.tokenize = tokenBase;
+  return "def"
+}
+
+function tokenFunProc(stream, state) {
+  if (stream.eatSpace()) {
+    return null;
+  }
+
+  if(!state.hasPassedFirstStage && stream.eat("{")) {
+    state.hasPassedFirstStage = true;
+    return "bracket";
+  }
+  else if(state.hasPassedFirstStage) {
+    stream.match(/([A-Z][A-Za-z0-9_]*)|(`.+`)|\$/);
+    state.hasPassedFirstStage = false;
+    state.tokenize = tokenBase;
+    return "def"
+  }
+  else {
+    state.tokenize = tokenBase;
+    return null;
+  }
+}
+
+function tokenComment(stream, state) {
+  var maybeEnd = false, ch;
+  while (ch = stream.next()) {
+    if (ch == "/" && maybeEnd) {
+      state.tokenize = tokenBase;
+      break;
+    }
+    maybeEnd = (ch == "*");
+  }
+  return "comment";
+}
+
+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 buildElectricInputRegEx() {
+  // Reindentation should occur on [] or on a match of any of
+  // the block closing keywords, at the end of a line.
+  var allClosings = middle.concat(end);
+  return new RegExp("[\\[\\]]|(" + allClosings.join("|") + ")$");
+}
+
+const oz = {
+  name: "oz",
+
+  startState: function () {
+    return {
+      tokenize: tokenBase,
+      currentIndent: 0,
+      doInCurrentLine: false,
+      hasPassedFirstStage: false
+    };
+  },
+
+  token: function (stream, state) {
+    if (stream.sol())
+      state.doInCurrentLine = 0;
+
+    return state.tokenize(stream, state);
+  },
+
+  indent: function (state, textAfter, cx) {
+    var trueText = textAfter.replace(/^\s+|\s+$/g, '');
+
+    if (trueText.match(endKeywords) || trueText.match(middleKeywords) || trueText.match(/(\[])/))
+      return cx.unit * (state.currentIndent - 1);
+
+    if (state.currentIndent < 0)
+      return 0;
+
+    return state.currentIndent * cx.unit
+  },
+
+  languageData: {
+    indentOnInut: buildElectricInputRegEx(),
+    commentTokens: {line: "%", block: {open: "/*", close: "*/"}}
+  }
+};
+
+export { oz };

package/dist/assets/pascal-Dksf1EyF.js

@@ -0,0 +1,124 @@
+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(
+  "absolute and array asm begin case const constructor destructor div do " +
+    "downto else end file for function goto if implementation in inherited " +
+    "inline interface label mod nil not object of operator or packed procedure " +
+    "program record reintroduce repeat self set shl shr string then to type " +
+    "unit until uses var while with xor as class dispinterface except exports " +
+    "finalization finally initialization inline is library on out packed " +
+    "property raise resourcestring threadvar try absolute abstract alias " +
+    "assembler bitpacked break cdecl continue cppdecl cvar default deprecated " +
+    "dynamic enumerator experimental export external far far16 forward generic " +
+    "helper implements index interrupt iocheck local message name near " +
+    "nodefault noreturn nostackframe oldfpccall otherwise overload override " +
+    "pascal platform private protected public published read register " +
+    "reintroduce result safecall saveregisters softfloat specialize static " +
+    "stdcall stored strict unaligned unimplemented varargs virtual write");
+var atoms = {"null": true};
+
+var isOperatorChar = /[+\-*&%=<>!?|\/]/;
+
+function tokenBase(stream, state) {
+  var ch = stream.next();
+  if (ch == "#" && state.startOfLine) {
+    stream.skipToEnd();
+    return "meta";
+  }
+  if (ch == '"' || ch == "'") {
+    state.tokenize = tokenString(ch);
+    return state.tokenize(stream, state);
+  }
+  if (ch == "(" && stream.eat("*")) {
+    state.tokenize = tokenComment;
+    return tokenComment(stream, state);
+  }
+  if (ch == "{") {
+    state.tokenize = tokenCommentBraces;
+    return tokenCommentBraces(stream, state);
+  }
+  if (/[\[\]\(\),;\:\.]/.test(ch)) {
+    return null;
+  }
+  if (/\d/.test(ch)) {
+    stream.eatWhile(/[\w\.]/);
+    return "number";
+  }
+  if (ch == "/") {
+    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 (keywords.propertyIsEnumerable(cur)) 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 && next == "\\";
+    }
+    if (end || !escaped) 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 tokenCommentBraces(stream, state) {
+  var ch;
+  while (ch = stream.next()) {
+    if (ch == "}") {
+      state.tokenize = null;
+      break;
+    }
+  }
+  return "comment";
+}
+
+// Interface
+
+const pascal = {
+  name: "pascal",
+
+  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;
+  },
+
+  languageData: {
+    indentOnInput: /^\s*[{}]$/,
+    commentTokens: {block: {open: "(*", close: "*)"}}
+  }
+};
+
+export { pascal };