research-copilot 0.1.0

package/app/out/renderer/assets/livescript-DmzgM3Yt.js

@@ -0,0 +1,296 @@
+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,
+      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/app/out/renderer/assets/lua-8cJgIlqe.js

@@ -0,0 +1,256 @@
+function prefixRE(words) {
+  return new RegExp("^(?:" + words.join("|") + ")", "i");
+}
+function wordRE(words) {
+  return new RegExp("^(?:" + words.join("|") + ")$", "i");
+}
+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
+};

package/app/out/renderer/assets/mathematica-DNLOL9PQ.js

@@ -0,0 +1,110 @@
+var Identifier = "[a-zA-Z\\$][a-zA-Z0-9\\$]*";
+var pBase = "(?:\\d+)";
+var pFloat = "(?:\\.\\d+|\\d+\\.\\d*|\\d+)";
+var pFloatBase = "(?:\\.\\w+|\\w+\\.\\w*|\\w+)";
+var pPrecision = "(?:`(?:`?" + pFloat + ")?)";
+var reBaseForm = new RegExp("(?:" + pBase + "(?:\\^\\^" + pFloatBase + pPrecision + "?(?:\\*\\^[+-]?\\d+)?))");
+var reFloatForm = new RegExp("(?:" + pFloat + pPrecision + "?(?:\\*\\^[+-]?\\d+)?)");
+var reIdInContext = new RegExp("(?:`?)(?:" + Identifier + ")(?:`(?:" + Identifier + "))*(?:`?)");
+function tokenBase(stream, state) {
+  var ch;
+  ch = stream.next();
+  if (ch === '"') {
+    state.tokenize = tokenString;
+    return state.tokenize(stream, state);
+  }
+  if (ch === "(") {
+    if (stream.eat("*")) {
+      state.commentLevel++;
+      state.tokenize = tokenComment;
+      return state.tokenize(stream, state);
+    }
+  }
+  stream.backUp(1);
+  if (stream.match(reBaseForm, true, false)) {
+    return "number";
+  }
+  if (stream.match(reFloatForm, true, false)) {
+    return "number";
+  }
+  if (stream.match(/(?:In|Out)\[[0-9]*\]/, true, false)) {
+    return "atom";
+  }
+  if (stream.match(/([a-zA-Z\$][a-zA-Z0-9\$]*(?:`[a-zA-Z0-9\$]+)*::usage)/, true, false)) {
+    return "meta";
+  }
+  if (stream.match(/([a-zA-Z\$][a-zA-Z0-9\$]*(?:`[a-zA-Z0-9\$]+)*::[a-zA-Z\$][a-zA-Z0-9\$]*):?/, true, false)) {
+    return "string.special";
+  }
+  if (stream.match(/([a-zA-Z\$][a-zA-Z0-9\$]*\s*:)(?:(?:[a-zA-Z\$][a-zA-Z0-9\$]*)|(?:[^:=>~@\^\&\*\)\[\]'\?,\|])).*/, true, false)) {
+    return "variableName.special";
+  }
+  if (stream.match(/[a-zA-Z\$][a-zA-Z0-9\$]*_+[a-zA-Z\$][a-zA-Z0-9\$]*/, true, false)) {
+    return "variableName.special";
+  }
+  if (stream.match(/[a-zA-Z\$][a-zA-Z0-9\$]*_+/, true, false)) {
+    return "variableName.special";
+  }
+  if (stream.match(/_+[a-zA-Z\$][a-zA-Z0-9\$]*/, true, false)) {
+    return "variableName.special";
+  }
+  if (stream.match(/\\\[[a-zA-Z\$][a-zA-Z0-9\$]*\]/, true, false)) {
+    return "character";
+  }
+  if (stream.match(/(?:\[|\]|{|}|\(|\))/, true, false)) {
+    return "bracket";
+  }
+  if (stream.match(/(?:#[a-zA-Z\$][a-zA-Z0-9\$]*|#+[0-9]?)/, true, false)) {
+    return "variableName.constant";
+  }
+  if (stream.match(reIdInContext, true, false)) {
+    return "keyword";
+  }
+  if (stream.match(/(?:\\|\+|\-|\*|\/|,|;|\.|:|@|~|=|>|<|&|\||_|`|'|\^|\?|!|%)/, true, false)) {
+    return "operator";
+  }
+  stream.next();
+  return "error";
+}
+function tokenString(stream, state) {
+  var next, end = false, escaped = false;
+  while ((next = stream.next()) != null) {
+    if (next === '"' && !escaped) {
+      end = true;
+      break;
+    }
+    escaped = !escaped && next === "\\";
+  }
+  if (end && !escaped) {
+    state.tokenize = tokenBase;
+  }
+  return "string";
+}
+function tokenComment(stream, state) {
+  var prev, next;
+  while (state.commentLevel > 0 && (next = stream.next()) != null) {
+    if (prev === "(" && next === "*") state.commentLevel++;
+    if (prev === "*" && next === ")") state.commentLevel--;
+    prev = next;
+  }
+  if (state.commentLevel <= 0) {
+    state.tokenize = tokenBase;
+  }
+  return "comment";
+}
+const mathematica = {
+  name: "mathematica",
+  startState: function() {
+    return { tokenize: tokenBase, commentLevel: 0 };
+  },
+  token: function(stream, state) {
+    if (stream.eatSpace()) return null;
+    return state.tokenize(stream, state);
+  },
+  languageData: {
+    commentTokens: { block: { open: "(*", close: "*)" } }
+  }
+};
+export {
+  mathematica
+};