research-copilot 0.1.0

package/app/out/renderer/assets/svgDrawCommon-b86b1483-Bein03PD.js

@@ -0,0 +1,100 @@
+import { G as lineBreakRegex, A as dist } from "./MilkdownMarkdownEditor-bLPxrCVb.js";
+const drawRect = (element, rectData) => {
+  const rectElement = element.append("rect");
+  rectElement.attr("x", rectData.x);
+  rectElement.attr("y", rectData.y);
+  rectElement.attr("fill", rectData.fill);
+  rectElement.attr("stroke", rectData.stroke);
+  rectElement.attr("width", rectData.width);
+  rectElement.attr("height", rectData.height);
+  if (rectData.name) {
+    rectElement.attr("name", rectData.name);
+  }
+  rectData.rx !== void 0 && rectElement.attr("rx", rectData.rx);
+  rectData.ry !== void 0 && rectElement.attr("ry", rectData.ry);
+  if (rectData.attrs !== void 0) {
+    for (const attrKey in rectData.attrs) {
+      rectElement.attr(attrKey, rectData.attrs[attrKey]);
+    }
+  }
+  rectData.class !== void 0 && rectElement.attr("class", rectData.class);
+  return rectElement;
+};
+const drawBackgroundRect = (element, bounds) => {
+  const rectData = {
+    x: bounds.startx,
+    y: bounds.starty,
+    width: bounds.stopx - bounds.startx,
+    height: bounds.stopy - bounds.starty,
+    fill: bounds.fill,
+    stroke: bounds.stroke,
+    class: "rect"
+  };
+  const rectElement = drawRect(element, rectData);
+  rectElement.lower();
+};
+const drawText = (element, textData) => {
+  const nText = textData.text.replace(lineBreakRegex, " ");
+  const textElem = element.append("text");
+  textElem.attr("x", textData.x);
+  textElem.attr("y", textData.y);
+  textElem.attr("class", "legend");
+  textElem.style("text-anchor", textData.anchor);
+  textData.class !== void 0 && textElem.attr("class", textData.class);
+  const tspan = textElem.append("tspan");
+  tspan.attr("x", textData.x + textData.textMargin * 2);
+  tspan.text(nText);
+  return textElem;
+};
+const drawImage = (elem, x, y, link) => {
+  const imageElement = elem.append("image");
+  imageElement.attr("x", x);
+  imageElement.attr("y", y);
+  const sanitizedLink = dist.sanitizeUrl(link);
+  imageElement.attr("xlink:href", sanitizedLink);
+};
+const drawEmbeddedImage = (element, x, y, link) => {
+  const imageElement = element.append("use");
+  imageElement.attr("x", x);
+  imageElement.attr("y", y);
+  const sanitizedLink = dist.sanitizeUrl(link);
+  imageElement.attr("xlink:href", `#${sanitizedLink}`);
+};
+const getNoteRect = () => {
+  const noteRectData = {
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100,
+    fill: "#EDF2AE",
+    stroke: "#666",
+    anchor: "start",
+    rx: 0,
+    ry: 0
+  };
+  return noteRectData;
+};
+const getTextObj = () => {
+  const testObject = {
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100,
+    "text-anchor": "start",
+    style: "#666",
+    textMargin: 0,
+    rx: 0,
+    ry: 0,
+    tspan: true
+  };
+  return testObject;
+};
+export {
+  drawBackgroundRect as a,
+  getTextObj as b,
+  drawEmbeddedImage as c,
+  drawRect as d,
+  drawImage as e,
+  drawText as f,
+  getNoteRect as g
+};

package/app/out/renderer/assets/swift-FRZi1uvB.js

@@ -0,0 +1,291 @@
+function wordSet(words) {
+  var set = {};
+  for (var i = 0; i < words.length; i++) set[words[i]] = true;
+  return set;
+}
+var keywords = wordSet([
+  "_",
+  "var",
+  "let",
+  "actor",
+  "class",
+  "enum",
+  "extension",
+  "import",
+  "protocol",
+  "struct",
+  "func",
+  "typealias",
+  "associatedtype",
+  "open",
+  "public",
+  "internal",
+  "fileprivate",
+  "private",
+  "deinit",
+  "init",
+  "new",
+  "override",
+  "self",
+  "subscript",
+  "super",
+  "convenience",
+  "dynamic",
+  "final",
+  "indirect",
+  "lazy",
+  "required",
+  "static",
+  "unowned",
+  "unowned(safe)",
+  "unowned(unsafe)",
+  "weak",
+  "as",
+  "is",
+  "break",
+  "case",
+  "continue",
+  "default",
+  "else",
+  "fallthrough",
+  "for",
+  "guard",
+  "if",
+  "in",
+  "repeat",
+  "switch",
+  "where",
+  "while",
+  "defer",
+  "return",
+  "inout",
+  "mutating",
+  "nonmutating",
+  "isolated",
+  "nonisolated",
+  "catch",
+  "do",
+  "rethrows",
+  "throw",
+  "throws",
+  "async",
+  "await",
+  "try",
+  "didSet",
+  "get",
+  "set",
+  "willSet",
+  "assignment",
+  "associativity",
+  "infix",
+  "left",
+  "none",
+  "operator",
+  "postfix",
+  "precedence",
+  "precedencegroup",
+  "prefix",
+  "right",
+  "Any",
+  "AnyObject",
+  "Type",
+  "dynamicType",
+  "Self",
+  "Protocol",
+  "__COLUMN__",
+  "__FILE__",
+  "__FUNCTION__",
+  "__LINE__"
+]);
+var definingKeywords = wordSet(["var", "let", "actor", "class", "enum", "extension", "import", "protocol", "struct", "func", "typealias", "associatedtype", "for"]);
+var atoms = wordSet(["true", "false", "nil", "self", "super", "_"]);
+var types = wordSet([
+  "Array",
+  "Bool",
+  "Character",
+  "Dictionary",
+  "Double",
+  "Float",
+  "Int",
+  "Int8",
+  "Int16",
+  "Int32",
+  "Int64",
+  "Never",
+  "Optional",
+  "Set",
+  "String",
+  "UInt8",
+  "UInt16",
+  "UInt32",
+  "UInt64",
+  "Void"
+]);
+var operators = "+-/*%=|&<>~^?!";
+var punc = ":;,.(){}[]";
+var binary = /^\-?0b[01][01_]*/;
+var octal = /^\-?0o[0-7][0-7_]*/;
+var hexadecimal = /^\-?0x[\dA-Fa-f][\dA-Fa-f_]*(?:(?:\.[\dA-Fa-f][\dA-Fa-f_]*)?[Pp]\-?\d[\d_]*)?/;
+var decimal = /^\-?\d[\d_]*(?:\.\d[\d_]*)?(?:[Ee]\-?\d[\d_]*)?/;
+var identifier = /^\$\d+|(`?)[_A-Za-z][_A-Za-z$0-9]*\1/;
+var property = /^\.(?:\$\d+|(`?)[_A-Za-z][_A-Za-z$0-9]*\1)/;
+var instruction = /^\#[A-Za-z]+/;
+var attribute = /^@(?:\$\d+|(`?)[_A-Za-z][_A-Za-z$0-9]*\1)/;
+function tokenBase(stream, state, prev) {
+  if (stream.sol()) state.indented = stream.indentation();
+  if (stream.eatSpace()) return null;
+  var ch = stream.peek();
+  if (ch == "/") {
+    if (stream.match("//")) {
+      stream.skipToEnd();
+      return "comment";
+    }
+    if (stream.match("/*")) {
+      state.tokenize.push(tokenComment);
+      return tokenComment(stream, state);
+    }
+  }
+  if (stream.match(instruction)) return "builtin";
+  if (stream.match(attribute)) return "attribute";
+  if (stream.match(binary)) return "number";
+  if (stream.match(octal)) return "number";
+  if (stream.match(hexadecimal)) return "number";
+  if (stream.match(decimal)) return "number";
+  if (stream.match(property)) return "property";
+  if (operators.indexOf(ch) > -1) {
+    stream.next();
+    return "operator";
+  }
+  if (punc.indexOf(ch) > -1) {
+    stream.next();
+    stream.match("..");
+    return "punctuation";
+  }
+  var stringMatch;
+  if (stringMatch = stream.match(/("""|"|')/)) {
+    var tokenize = tokenString.bind(null, stringMatch[0]);
+    state.tokenize.push(tokenize);
+    return tokenize(stream, state);
+  }
+  if (stream.match(identifier)) {
+    var ident = stream.current();
+    if (types.hasOwnProperty(ident)) return "type";
+    if (atoms.hasOwnProperty(ident)) return "atom";
+    if (keywords.hasOwnProperty(ident)) {
+      if (definingKeywords.hasOwnProperty(ident))
+        state.prev = "define";
+      return "keyword";
+    }
+    if (prev == "define") return "def";
+    return "variable";
+  }
+  stream.next();
+  return null;
+}
+function tokenUntilClosingParen() {
+  var depth = 0;
+  return function(stream, state, prev) {
+    var inner = tokenBase(stream, state, prev);
+    if (inner == "punctuation") {
+      if (stream.current() == "(") ++depth;
+      else if (stream.current() == ")") {
+        if (depth == 0) {
+          stream.backUp(1);
+          state.tokenize.pop();
+          return state.tokenize[state.tokenize.length - 1](stream, state);
+        } else --depth;
+      }
+    }
+    return inner;
+  };
+}
+function tokenString(openQuote, stream, state) {
+  var singleLine = openQuote.length == 1;
+  var ch, escaped = false;
+  while (ch = stream.peek()) {
+    if (escaped) {
+      stream.next();
+      if (ch == "(") {
+        state.tokenize.push(tokenUntilClosingParen());
+        return "string";
+      }
+      escaped = false;
+    } else if (stream.match(openQuote)) {
+      state.tokenize.pop();
+      return "string";
+    } else {
+      stream.next();
+      escaped = ch == "\\";
+    }
+  }
+  if (singleLine) {
+    state.tokenize.pop();
+  }
+  return "string";
+}
+function tokenComment(stream, state) {
+  var ch;
+  while (ch = stream.next()) {
+    if (ch === "/" && stream.eat("*")) {
+      state.tokenize.push(tokenComment);
+    } else if (ch === "*" && stream.eat("/")) {
+      state.tokenize.pop();
+      break;
+    }
+  }
+  return "comment";
+}
+function Context(prev, align, indented) {
+  this.prev = prev;
+  this.align = align;
+  this.indented = indented;
+}
+function pushContext(state, stream) {
+  var align = stream.match(/^\s*($|\/[\/\*]|[)}\]])/, false) ? null : stream.column() + 1;
+  state.context = new Context(state.context, align, state.indented);
+}
+function popContext(state) {
+  if (state.context) {
+    state.indented = state.context.indented;
+    state.context = state.context.prev;
+  }
+}
+const swift = {
+  name: "swift",
+  startState: function() {
+    return {
+      prev: null,
+      context: null,
+      indented: 0,
+      tokenize: []
+    };
+  },
+  token: function(stream, state) {
+    var prev = state.prev;
+    state.prev = null;
+    var tokenize = state.tokenize[state.tokenize.length - 1] || tokenBase;
+    var style = tokenize(stream, state, prev);
+    if (!style || style == "comment") state.prev = prev;
+    else if (!state.prev) state.prev = style;
+    if (style == "punctuation") {
+      var bracket = /[\(\[\{]|([\]\)\}])/.exec(stream.current());
+      if (bracket) (bracket[1] ? popContext : pushContext)(state, stream);
+    }
+    return style;
+  },
+  indent: function(state, textAfter, iCx) {
+    var cx = state.context;
+    if (!cx) return 0;
+    var closing = /^[\]\}\)]/.test(textAfter);
+    if (cx.align != null) return cx.align - (closing ? 1 : 0);
+    return cx.indented + (closing ? 0 : iCx.unit);
+  },
+  languageData: {
+    indentOnInput: /^\s*[\)\}\]]$/,
+    commentTokens: { line: "//", block: { open: "/*", close: "*/" } },
+    closeBrackets: { brackets: ["(", "[", "{", "'", '"', "`"] }
+  }
+};
+export {
+  swift
+};

package/app/out/renderer/assets/tcl-CUcaCdmq.js

@@ -0,0 +1,114 @@
+function parseWords(str) {
+  var obj = {}, words = str.split(" ");
+  for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+  return obj;
+}
+var keywords = parseWords("Tcl safe after append array auto_execok auto_import auto_load auto_mkindex auto_mkindex_old auto_qualify auto_reset bgerror binary break catch cd close concat continue dde eof encoding error eval exec exit expr fblocked fconfigure fcopy file fileevent filename filename flush for foreach format gets glob global history http if incr info interp join lappend lindex linsert list llength load lrange lreplace lsearch lset lsort memory msgcat namespace open package parray pid pkg::create pkg_mkIndex proc puts pwd re_syntax read regex regexp registry regsub rename resource return scan seek set socket source split string subst switch tcl_endOfWord tcl_findLibrary tcl_startOfNextWord tcl_wordBreakAfter tcl_startOfPreviousWord tcl_wordBreakBefore tcltest tclvars tell time trace unknown unset update uplevel upvar variable vwait");
+var functions = parseWords("if elseif else and not or eq ne in ni for foreach while switch");
+var isOperatorChar = /[+\-*&%=<>!?^\/\|]/;
+function chain(stream, state, f) {
+  state.tokenize = f;
+  return f(stream, state);
+}
+function tokenBase(stream, state) {
+  var beforeParams = state.beforeParams;
+  state.beforeParams = false;
+  var ch = stream.next();
+  if ((ch == '"' || ch == "'") && state.inParams) {
+    return chain(stream, state, tokenString(ch));
+  } else if (/[\[\]{}\(\),;\.]/.test(ch)) {
+    if (ch == "(" && beforeParams) state.inParams = true;
+    else if (ch == ")") state.inParams = false;
+    return null;
+  } else if (/\d/.test(ch)) {
+    stream.eatWhile(/[\w\.]/);
+    return "number";
+  } else if (ch == "#") {
+    if (stream.eat("*"))
+      return chain(stream, state, tokenComment);
+    if (ch == "#" && stream.match(/ *\[ *\[/))
+      return chain(stream, state, tokenUnparsed);
+    stream.skipToEnd();
+    return "comment";
+  } else if (ch == '"') {
+    stream.skipTo(/"/);
+    return "comment";
+  } else if (ch == "$") {
+    stream.eatWhile(/[$_a-z0-9A-Z\.{:]/);
+    stream.eatWhile(/}/);
+    state.beforeParams = true;
+    return "builtin";
+  } else if (isOperatorChar.test(ch)) {
+    stream.eatWhile(isOperatorChar);
+    return "comment";
+  } else {
+    stream.eatWhile(/[\w\$_{}\xa1-\uffff]/);
+    var word = stream.current().toLowerCase();
+    if (keywords && keywords.propertyIsEnumerable(word))
+      return "keyword";
+    if (functions && functions.propertyIsEnumerable(word)) {
+      state.beforeParams = true;
+      return "keyword";
+    }
+    return null;
+  }
+}
+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) state.tokenize = tokenBase;
+    return "string";
+  };
+}
+function tokenComment(stream, state) {
+  var maybeEnd = false, ch;
+  while (ch = stream.next()) {
+    if (ch == "#" && maybeEnd) {
+      state.tokenize = tokenBase;
+      break;
+    }
+    maybeEnd = ch == "*";
+  }
+  return "comment";
+}
+function tokenUnparsed(stream, state) {
+  var maybeEnd = 0, ch;
+  while (ch = stream.next()) {
+    if (ch == "#" && maybeEnd == 2) {
+      state.tokenize = tokenBase;
+      break;
+    }
+    if (ch == "]")
+      maybeEnd++;
+    else if (ch != " ")
+      maybeEnd = 0;
+  }
+  return "meta";
+}
+const tcl = {
+  name: "tcl",
+  startState: function() {
+    return {
+      tokenize: tokenBase,
+      beforeParams: false,
+      inParams: false
+    };
+  },
+  token: function(stream, state) {
+    if (stream.eatSpace()) return null;
+    return state.tokenize(stream, state);
+  },
+  languageData: {
+    commentTokens: { line: "#" }
+  }
+};
+export {
+  tcl
+};