@vc-shell/framework 1.1.2 → 1.1.4

package/dist/assets/groovy-ioGz2WSV.js

@@ -1,228 +0,0 @@
-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 trait transient " +
-    "try void volatile while");
-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) {
-        if (stream.eat("{")) {
-          state.tokenize.push(tokenBaseUntilBrace());
-          return "string";
-        } else if (stream.match(/^\w/, false)) {
-          state.tokenize.push(tokenVariableDeref);
-          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 tokenVariableDeref(stream, state) {
-  var next = stream.match(/^(\.|[\w\$_]+)/);
-  if (!next || !stream.match(next[0] == "." ? /^[\w$_]/ : /^\./)) state.tokenize.pop();
-  if (!next) return state.tokenize[state.tokenize.length-1](stream, state)
-  return next[0] == "." ? null : "variable"
-}
-
-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
-
-const groovy = {
-  name: "groovy",
-  startState: function(indentUnit) {
-    return {
-      tokenize: [tokenBase],
-      context: new Context(-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, cx) {
-    if (!state.tokenize[state.tokenize.length-1].isBase) return null;
-    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 : cx.unit);
-    else if (ctx.align) return ctx.column + (closing ? 0 : 1);
-    else return ctx.indented + (closing ? 0 : cx.unit);
-  },
-
-  languageData: {
-    indentOnInput: /^\s*[{}]$/,
-    commentTokens: {line: "//", block: {open: "/*", close: "*/"}},
-    closeBrackets: {brackets: ["(", "[", "{", "'", '"', "'''", '"""']}
-  }
-};
-
-export { groovy };

package/dist/assets/haskell-BHnm1B83.js

@@ -1,239 +0,0 @@
-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";
-  }
-
-  if (ch == '"') {
-    return switchState(source, setState, stringLiteral);
-  }
-
-  if (largeRE.test(ch)) {
-    source.eatWhile(idRE);
-    if (source.eat('.')) {
-      return "qualifier";
-    }
-    return "type";
-  }
-
-  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";
-      }
-    }
-    source.eatWhile(symbolRE);
-    return "variable"
-  }
-
-  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";
-}
-
-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")(
-    "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", "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");
-
-  return wkw;
-})();
-
-const haskell = {
-  name: "haskell",
-  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;
-  },
-
-  languageData: {
-    commentTokens: {line: "--", block: {open: "{-", close: "-}"}}
-  }
-};
-
-export { haskell };