research-copilot 0.1.0

package/app/out/renderer/assets/octave-DYBj3-tl.js

@@ -0,0 +1,200 @@
+function wordRegexp(words) {
+  return new RegExp("^((" + words.join(")|(") + "))\\b");
+}
+var singleOperators = new RegExp("^[\\+\\-\\*/&|\\^~<>!@'\\\\]");
+var singleDelimiters = new RegExp("^[\\(\\[\\{\\},:=;\\.]");
+var doubleOperators = new RegExp("^((==)|(~=)|(<=)|(>=)|(<<)|(>>)|(\\.[\\+\\-\\*/\\^\\\\]))");
+var doubleDelimiters = new RegExp("^((!=)|(\\+=)|(\\-=)|(\\*=)|(/=)|(&=)|(\\|=)|(\\^=))");
+var tripleDelimiters = new RegExp("^((>>=)|(<<=))");
+var expressionEnd = new RegExp("^[\\]\\)]");
+var identifiers = new RegExp("^[_A-Za-z¡-￿][_A-Za-z0-9¡-￿]*");
+var builtins = wordRegexp([
+  "error",
+  "eval",
+  "function",
+  "abs",
+  "acos",
+  "atan",
+  "asin",
+  "cos",
+  "cosh",
+  "exp",
+  "log",
+  "prod",
+  "sum",
+  "log10",
+  "max",
+  "min",
+  "sign",
+  "sin",
+  "sinh",
+  "sqrt",
+  "tan",
+  "reshape",
+  "break",
+  "zeros",
+  "default",
+  "margin",
+  "round",
+  "ones",
+  "rand",
+  "syn",
+  "ceil",
+  "floor",
+  "size",
+  "clear",
+  "zeros",
+  "eye",
+  "mean",
+  "std",
+  "cov",
+  "det",
+  "eig",
+  "inv",
+  "norm",
+  "rank",
+  "trace",
+  "expm",
+  "logm",
+  "sqrtm",
+  "linspace",
+  "plot",
+  "title",
+  "xlabel",
+  "ylabel",
+  "legend",
+  "text",
+  "grid",
+  "meshgrid",
+  "mesh",
+  "num2str",
+  "fft",
+  "ifft",
+  "arrayfun",
+  "cellfun",
+  "input",
+  "fliplr",
+  "flipud",
+  "ismember"
+]);
+var keywords = wordRegexp([
+  "return",
+  "case",
+  "switch",
+  "else",
+  "elseif",
+  "end",
+  "endif",
+  "endfunction",
+  "if",
+  "otherwise",
+  "do",
+  "for",
+  "while",
+  "try",
+  "catch",
+  "classdef",
+  "properties",
+  "events",
+  "methods",
+  "global",
+  "persistent",
+  "endfor",
+  "endwhile",
+  "printf",
+  "sprintf",
+  "disp",
+  "until",
+  "continue",
+  "pkg"
+]);
+function tokenTranspose(stream, state) {
+  if (!stream.sol() && stream.peek() === "'") {
+    stream.next();
+    state.tokenize = tokenBase;
+    return "operator";
+  }
+  state.tokenize = tokenBase;
+  return tokenBase(stream, state);
+}
+function tokenComment(stream, state) {
+  if (stream.match(/^.*%}/)) {
+    state.tokenize = tokenBase;
+    return "comment";
+  }
+  stream.skipToEnd();
+  return "comment";
+}
+function tokenBase(stream, state) {
+  if (stream.eatSpace()) return null;
+  if (stream.match("%{")) {
+    state.tokenize = tokenComment;
+    stream.skipToEnd();
+    return "comment";
+  }
+  if (stream.match(/^[%#]/)) {
+    stream.skipToEnd();
+    return "comment";
+  }
+  if (stream.match(/^[0-9\.+-]/, false)) {
+    if (stream.match(/^[+-]?0x[0-9a-fA-F]+[ij]?/)) {
+      stream.tokenize = tokenBase;
+      return "number";
+    }
+    if (stream.match(/^[+-]?\d*\.\d+([EeDd][+-]?\d+)?[ij]?/)) {
+      return "number";
+    }
+    if (stream.match(/^[+-]?\d+([EeDd][+-]?\d+)?[ij]?/)) {
+      return "number";
+    }
+  }
+  if (stream.match(wordRegexp(["nan", "NaN", "inf", "Inf"]))) {
+    return "number";
+  }
+  var m = stream.match(/^"(?:[^"]|"")*("|$)/) || stream.match(/^'(?:[^']|'')*('|$)/);
+  if (m) {
+    return m[1] ? "string" : "error";
+  }
+  if (stream.match(keywords)) {
+    return "keyword";
+  }
+  if (stream.match(builtins)) {
+    return "builtin";
+  }
+  if (stream.match(identifiers)) {
+    return "variable";
+  }
+  if (stream.match(singleOperators) || stream.match(doubleOperators)) {
+    return "operator";
+  }
+  if (stream.match(singleDelimiters) || stream.match(doubleDelimiters) || stream.match(tripleDelimiters)) {
+    return null;
+  }
+  if (stream.match(expressionEnd)) {
+    state.tokenize = tokenTranspose;
+    return null;
+  }
+  stream.next();
+  return "error";
+}
+const octave = {
+  name: "octave",
+  startState: function() {
+    return {
+      tokenize: tokenBase
+    };
+  },
+  token: function(stream, state) {
+    var style = state.tokenize(stream, state);
+    if (style === "number" || style === "variable") {
+      state.tokenize = tokenTranspose;
+    }
+    return style;
+  },
+  languageData: {
+    commentTokens: { line: "%" }
+  }
+};
+export {
+  octave
+};

package/app/out/renderer/assets/ordinal-DSZU4PqD.js

@@ -0,0 +1,76 @@
+import { i as initRange } from "./init-ZxktEp_H.js";
+class InternMap extends Map {
+  constructor(entries, key = keyof) {
+    super();
+    Object.defineProperties(this, { _intern: { value: /* @__PURE__ */ new Map() }, _key: { value: key } });
+    if (entries != null) for (const [key2, value] of entries) this.set(key2, value);
+  }
+  get(key) {
+    return super.get(intern_get(this, key));
+  }
+  has(key) {
+    return super.has(intern_get(this, key));
+  }
+  set(key, value) {
+    return super.set(intern_set(this, key), value);
+  }
+  delete(key) {
+    return super.delete(intern_delete(this, key));
+  }
+}
+function intern_get({ _intern, _key }, value) {
+  const key = _key(value);
+  return _intern.has(key) ? _intern.get(key) : value;
+}
+function intern_set({ _intern, _key }, value) {
+  const key = _key(value);
+  if (_intern.has(key)) return _intern.get(key);
+  _intern.set(key, value);
+  return value;
+}
+function intern_delete({ _intern, _key }, value) {
+  const key = _key(value);
+  if (_intern.has(key)) {
+    value = _intern.get(key);
+    _intern.delete(key);
+  }
+  return value;
+}
+function keyof(value) {
+  return value !== null && typeof value === "object" ? value.valueOf() : value;
+}
+const implicit = Symbol("implicit");
+function ordinal() {
+  var index = new InternMap(), domain = [], range = [], unknown = implicit;
+  function scale(d) {
+    let i = index.get(d);
+    if (i === void 0) {
+      if (unknown !== implicit) return unknown;
+      index.set(d, i = domain.push(d) - 1);
+    }
+    return range[i % range.length];
+  }
+  scale.domain = function(_) {
+    if (!arguments.length) return domain.slice();
+    domain = [], index = new InternMap();
+    for (const value of _) {
+      if (index.has(value)) continue;
+      index.set(value, domain.push(value) - 1);
+    }
+    return scale;
+  };
+  scale.range = function(_) {
+    return arguments.length ? (range = Array.from(_), scale) : range.slice();
+  };
+  scale.unknown = function(_) {
+    return arguments.length ? (unknown = _, scale) : unknown;
+  };
+  scale.copy = function() {
+    return ordinal(domain, range).unknown(unknown);
+  };
+  initRange.apply(scale, arguments);
+  return scale;
+}
+export {
+  ordinal as o
+};

package/app/out/renderer/assets/oz-R_e8WMIi.js

@@ -0,0 +1,231 @@
+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);
+function tokenBase(stream, state) {
+  if (stream.eatSpace()) {
+    return null;
+  }
+  if (stream.match(/[{}]/)) {
+    return "bracket";
+  }
+  if (stream.match("[]")) {
+    return "keyword";
+  }
+  if (stream.match(tripleOperators) || stream.match(doubleOperators)) {
+    return "operator";
+  }
+  if (stream.match(atoms)) {
+    return "atom";
+  }
+  var matched = stream.match(openingKeywords);
+  if (matched) {
+    if (!state.doInCurrentLine)
+      state.currentIndent++;
+    else
+      state.doInCurrentLine = false;
+    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";
+  }
+  if (stream.match(middleKeywords) || stream.match(commonKeywords)) {
+    return "keyword";
+  }
+  if (stream.match(endKeywords)) {
+    state.currentIndent--;
+    return "keyword";
+  }
+  var ch = stream.next();
+  if (ch == '"' || ch == "'") {
+    state.tokenize = tokenString(ch);
+    return state.tokenize(stream, state);
+  }
+  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;
+  }
+  if (ch == "%") {
+    stream.skipToEnd();
+    return "comment";
+  } else if (ch == "/") {
+    if (stream.eat("*")) {
+      state.tokenize = tokenComment;
+      return tokenComment(stream, state);
+    }
+  }
+  if (singleOperators.test(ch)) {
+    return "operator";
+  }
+  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, end2 = false;
+    while ((next = stream.next()) != null) {
+      if (next == quote && !escaped) {
+        end2 = true;
+        break;
+      }
+      escaped = !escaped && next == "\\";
+    }
+    if (end2 || !escaped)
+      state.tokenize = tokenBase;
+    return "string";
+  };
+}
+function buildElectricInputRegEx() {
+  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/app/out/renderer/assets/pascal-GD8iposT.js

@@ -0,0 +1,105 @@
+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(
+  "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";
+}
+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
+};