research-copilot 0.1.0

package/app/out/renderer/assets/groovy-CpwJiBl7.js

@@ -0,0 +1,223 @@
+function words(str) {
+  var obj = {}, words2 = str.split(" ");
+  for (var i = 0; i < words2.length; ++i) obj[words2[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(stream2, state2) {
+    var escaped = false, next, end = !tripleQuoted;
+    while ((next = stream2.next()) != null) {
+      if (next == quote && !escaped) {
+        if (!tripleQuoted) {
+          break;
+        }
+        if (stream2.match(quote + quote)) {
+          end = true;
+          break;
+        }
+      }
+      if (quote == '"' && next == "$" && !escaped) {
+        if (stream2.eat("{")) {
+          state2.tokenize.push(tokenBaseUntilBrace());
+          return "string";
+        } else if (stream2.match(/^\w/, false)) {
+          state2.tokenize.push(tokenVariableDeref);
+          return "string";
+        }
+      }
+      escaped = !escaped && next == "\\";
+    }
+    if (end) state2.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;
+}
+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;
+      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);
+    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/app/out/renderer/assets/haskell-BlGBCCe3.js

@@ -0,0 +1,459 @@
+function switchState(source, setState, f) {
+  setState(f);
+  return f(source, setState);
+}
+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]/;
+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();
+    } 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);
+        return "integer";
+      }
+      if (source.eat(/[oO]/)) {
+        source.eatWhile(octitRE);
+        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);
+    }
+    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();
+      }
+    }
+  }
+  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
+};