research-copilot 0.1.0

package/app/out/renderer/assets/stateDiagram-v2-c2b004d7-BgRoffou.js

@@ -0,0 +1,326 @@
+import { s as styles, d as db, p as parser$1, D as DEFAULT_NESTED_DOC_DIR, a as DEFAULT_STATE_TYPE, b as DIVIDER_TYPE, S as STMT_RELATION, c as STMT_STATE } from "./styles-ca3715f6-DgbNw99p.js";
+import { G as Graph } from "./graph-DpC13d95.js";
+import { v as log$1, r as getConfig, u as select, O as utils, w as configureSvgSize, C as common$1 } from "./MilkdownMarkdownEditor-bLPxrCVb.js";
+import { r as render } from "./index-5325376f-Bbs7Fbqr.js";
+import "./layout-ZeuHE_aY.js";
+import "./index-BqDyyRCx.js";
+import "./clone-CsnzsYXQ.js";
+import "./edges-96097737-CD0EvAZQ.js";
+import "./createText-1719965b-Cji7KN4K.js";
+import "./line-CAgaGl-S.js";
+import "./array-DgktLKBx.js";
+import "./path-Cp2qmpkd.js";
+const SHAPE_STATE = "rect";
+const SHAPE_STATE_WITH_DESC = "rectWithTitle";
+const SHAPE_START = "start";
+const SHAPE_END = "end";
+const SHAPE_DIVIDER = "divider";
+const SHAPE_GROUP = "roundedWithTitle";
+const SHAPE_NOTE = "note";
+const SHAPE_NOTEGROUP = "noteGroup";
+const CSS_DIAGRAM = "statediagram";
+const CSS_STATE = "state";
+const CSS_DIAGRAM_STATE = `${CSS_DIAGRAM}-${CSS_STATE}`;
+const CSS_EDGE = "transition";
+const CSS_NOTE = "note";
+const CSS_NOTE_EDGE = "note-edge";
+const CSS_EDGE_NOTE_EDGE = `${CSS_EDGE} ${CSS_NOTE_EDGE}`;
+const CSS_DIAGRAM_NOTE = `${CSS_DIAGRAM}-${CSS_NOTE}`;
+const CSS_CLUSTER = "cluster";
+const CSS_DIAGRAM_CLUSTER = `${CSS_DIAGRAM}-${CSS_CLUSTER}`;
+const CSS_CLUSTER_ALT = "cluster-alt";
+const CSS_DIAGRAM_CLUSTER_ALT = `${CSS_DIAGRAM}-${CSS_CLUSTER_ALT}`;
+const PARENT = "parent";
+const NOTE = "note";
+const DOMID_STATE = "state";
+const DOMID_TYPE_SPACER = "----";
+const NOTE_ID = `${DOMID_TYPE_SPACER}${NOTE}`;
+const PARENT_ID = `${DOMID_TYPE_SPACER}${PARENT}`;
+const G_EDGE_STYLE = "fill:none";
+const G_EDGE_ARROWHEADSTYLE = "fill: #333";
+const G_EDGE_LABELPOS = "c";
+const G_EDGE_LABELTYPE = "text";
+const G_EDGE_THICKNESS = "normal";
+let nodeDb = {};
+let graphItemCount = 0;
+const setConf = function(cnf) {
+  const keys = Object.keys(cnf);
+  for (const key of keys) {
+    cnf[key];
+  }
+};
+const getClasses = function(text, diagramObj) {
+  diagramObj.db.extract(diagramObj.db.getRootDocV2());
+  return diagramObj.db.getClasses();
+};
+function getClassesFromDbInfo(dbInfoItem) {
+  if (dbInfoItem === void 0 || dbInfoItem === null) {
+    return "";
+  } else {
+    if (dbInfoItem.classes) {
+      return dbInfoItem.classes.join(" ");
+    } else {
+      return "";
+    }
+  }
+}
+function stateDomId(itemId = "", counter = 0, type = "", typeSpacer = DOMID_TYPE_SPACER) {
+  const typeStr = type !== null && type.length > 0 ? `${typeSpacer}${type}` : "";
+  return `${DOMID_STATE}-${itemId}${typeStr}-${counter}`;
+}
+const setupNode = (g, parent, parsedItem, diagramStates, diagramDb, altFlag) => {
+  const itemId = parsedItem.id;
+  const classStr = getClassesFromDbInfo(diagramStates[itemId]);
+  if (itemId !== "root") {
+    let shape = SHAPE_STATE;
+    if (parsedItem.start === true) {
+      shape = SHAPE_START;
+    }
+    if (parsedItem.start === false) {
+      shape = SHAPE_END;
+    }
+    if (parsedItem.type !== DEFAULT_STATE_TYPE) {
+      shape = parsedItem.type;
+    }
+    if (!nodeDb[itemId]) {
+      nodeDb[itemId] = {
+        id: itemId,
+        shape,
+        description: common$1.sanitizeText(itemId, getConfig()),
+        classes: `${classStr} ${CSS_DIAGRAM_STATE}`
+      };
+    }
+    const newNode = nodeDb[itemId];
+    if (parsedItem.description) {
+      if (Array.isArray(newNode.description)) {
+        newNode.shape = SHAPE_STATE_WITH_DESC;
+        newNode.description.push(parsedItem.description);
+      } else {
+        if (newNode.description.length > 0) {
+          newNode.shape = SHAPE_STATE_WITH_DESC;
+          if (newNode.description === itemId) {
+            newNode.description = [parsedItem.description];
+          } else {
+            newNode.description = [newNode.description, parsedItem.description];
+          }
+        } else {
+          newNode.shape = SHAPE_STATE;
+          newNode.description = parsedItem.description;
+        }
+      }
+      newNode.description = common$1.sanitizeTextOrArray(newNode.description, getConfig());
+    }
+    if (newNode.description.length === 1 && newNode.shape === SHAPE_STATE_WITH_DESC) {
+      newNode.shape = SHAPE_STATE;
+    }
+    if (!newNode.type && parsedItem.doc) {
+      log$1.info("Setting cluster for ", itemId, getDir(parsedItem));
+      newNode.type = "group";
+      newNode.dir = getDir(parsedItem);
+      newNode.shape = parsedItem.type === DIVIDER_TYPE ? SHAPE_DIVIDER : SHAPE_GROUP;
+      newNode.classes = newNode.classes + " " + CSS_DIAGRAM_CLUSTER + " " + (altFlag ? CSS_DIAGRAM_CLUSTER_ALT : "");
+    }
+    const nodeData = {
+      labelStyle: "",
+      shape: newNode.shape,
+      labelText: newNode.description,
+      // typeof newNode.description === 'object'
+      //   ? newNode.description[0]
+      //   : newNode.description,
+      classes: newNode.classes,
+      style: "",
+      //styles.style,
+      id: itemId,
+      dir: newNode.dir,
+      domId: stateDomId(itemId, graphItemCount),
+      type: newNode.type,
+      padding: 15
+      //getConfig().flowchart.padding
+    };
+    nodeData.centerLabel = true;
+    if (parsedItem.note) {
+      const noteData = {
+        labelStyle: "",
+        shape: SHAPE_NOTE,
+        labelText: parsedItem.note.text,
+        classes: CSS_DIAGRAM_NOTE,
+        // useHtmlLabels: false,
+        style: "",
+        // styles.style,
+        id: itemId + NOTE_ID + "-" + graphItemCount,
+        domId: stateDomId(itemId, graphItemCount, NOTE),
+        type: newNode.type,
+        padding: 15
+        //getConfig().flowchart.padding
+      };
+      const groupData = {
+        labelStyle: "",
+        shape: SHAPE_NOTEGROUP,
+        labelText: parsedItem.note.text,
+        classes: newNode.classes,
+        style: "",
+        // styles.style,
+        id: itemId + PARENT_ID,
+        domId: stateDomId(itemId, graphItemCount, PARENT),
+        type: "group",
+        padding: 0
+        //getConfig().flowchart.padding
+      };
+      graphItemCount++;
+      const parentNodeId = itemId + PARENT_ID;
+      g.setNode(parentNodeId, groupData);
+      g.setNode(noteData.id, noteData);
+      g.setNode(itemId, nodeData);
+      g.setParent(itemId, parentNodeId);
+      g.setParent(noteData.id, parentNodeId);
+      let from = itemId;
+      let to = noteData.id;
+      if (parsedItem.note.position === "left of") {
+        from = noteData.id;
+        to = itemId;
+      }
+      g.setEdge(from, to, {
+        arrowhead: "none",
+        arrowType: "",
+        style: G_EDGE_STYLE,
+        labelStyle: "",
+        classes: CSS_EDGE_NOTE_EDGE,
+        arrowheadStyle: G_EDGE_ARROWHEADSTYLE,
+        labelpos: G_EDGE_LABELPOS,
+        labelType: G_EDGE_LABELTYPE,
+        thickness: G_EDGE_THICKNESS
+      });
+    } else {
+      g.setNode(itemId, nodeData);
+    }
+  }
+  if (parent && parent.id !== "root") {
+    log$1.trace("Setting node ", itemId, " to be child of its parent ", parent.id);
+    g.setParent(itemId, parent.id);
+  }
+  if (parsedItem.doc) {
+    log$1.trace("Adding nodes children ");
+    setupDoc(g, parsedItem, parsedItem.doc, diagramStates, diagramDb, !altFlag);
+  }
+};
+const setupDoc = (g, parentParsedItem, doc, diagramStates, diagramDb, altFlag) => {
+  log$1.trace("items", doc);
+  doc.forEach((item) => {
+    switch (item.stmt) {
+      case STMT_STATE:
+        setupNode(g, parentParsedItem, item, diagramStates, diagramDb, altFlag);
+        break;
+      case DEFAULT_STATE_TYPE:
+        setupNode(g, parentParsedItem, item, diagramStates, diagramDb, altFlag);
+        break;
+      case STMT_RELATION:
+        {
+          setupNode(g, parentParsedItem, item.state1, diagramStates, diagramDb, altFlag);
+          setupNode(g, parentParsedItem, item.state2, diagramStates, diagramDb, altFlag);
+          const edgeData = {
+            id: "edge" + graphItemCount,
+            arrowhead: "normal",
+            arrowTypeEnd: "arrow_barb",
+            style: G_EDGE_STYLE,
+            labelStyle: "",
+            label: common$1.sanitizeText(item.description, getConfig()),
+            arrowheadStyle: G_EDGE_ARROWHEADSTYLE,
+            labelpos: G_EDGE_LABELPOS,
+            labelType: G_EDGE_LABELTYPE,
+            thickness: G_EDGE_THICKNESS,
+            classes: CSS_EDGE
+          };
+          g.setEdge(item.state1.id, item.state2.id, edgeData, graphItemCount);
+          graphItemCount++;
+        }
+        break;
+    }
+  });
+};
+const getDir = (parsedItem, defaultDir = DEFAULT_NESTED_DOC_DIR) => {
+  let dir = defaultDir;
+  if (parsedItem.doc) {
+    for (let i = 0; i < parsedItem.doc.length; i++) {
+      const parsedItemDoc = parsedItem.doc[i];
+      if (parsedItemDoc.stmt === "dir") {
+        dir = parsedItemDoc.value;
+      }
+    }
+  }
+  return dir;
+};
+const draw = async function(text, id, _version, diag) {
+  log$1.info("Drawing state diagram (v2)", id);
+  nodeDb = {};
+  diag.db.getDirection();
+  const { securityLevel, state: conf } = getConfig();
+  const nodeSpacing = conf.nodeSpacing || 50;
+  const rankSpacing = conf.rankSpacing || 50;
+  log$1.info(diag.db.getRootDocV2());
+  diag.db.extract(diag.db.getRootDocV2());
+  log$1.info(diag.db.getRootDocV2());
+  const diagramStates = diag.db.getStates();
+  const g = new Graph({
+    multigraph: true,
+    compound: true
+  }).setGraph({
+    rankdir: getDir(diag.db.getRootDocV2()),
+    nodesep: nodeSpacing,
+    ranksep: rankSpacing,
+    marginx: 8,
+    marginy: 8
+  }).setDefaultEdgeLabel(function() {
+    return {};
+  });
+  setupNode(g, void 0, diag.db.getRootDocV2(), diagramStates, diag.db, true);
+  let sandboxElement;
+  if (securityLevel === "sandbox") {
+    sandboxElement = select("#i" + id);
+  }
+  const root = securityLevel === "sandbox" ? select(sandboxElement.nodes()[0].contentDocument.body) : select("body");
+  const svg = root.select(`[id="${id}"]`);
+  const element = root.select("#" + id + " g");
+  await render(element, g, ["barb"], CSS_DIAGRAM, id);
+  const padding = 8;
+  utils.insertTitle(svg, "statediagramTitleText", conf.titleTopMargin, diag.db.getDiagramTitle());
+  const bounds = svg.node().getBBox();
+  const width = bounds.width + padding * 2;
+  const height = bounds.height + padding * 2;
+  svg.attr("class", CSS_DIAGRAM);
+  const svgBounds = svg.node().getBBox();
+  configureSvgSize(svg, height, width, conf.useMaxWidth);
+  const vBox = `${svgBounds.x - padding} ${svgBounds.y - padding} ${width} ${height}`;
+  log$1.debug(`viewBox ${vBox}`);
+  svg.attr("viewBox", vBox);
+  const labels = document.querySelectorAll('[id="' + id + '"] .edgeLabel .label');
+  for (const label of labels) {
+    const dim = label.getBBox();
+    const rect = document.createElementNS("http://www.w3.org/2000/svg", SHAPE_STATE);
+    rect.setAttribute("rx", 0);
+    rect.setAttribute("ry", 0);
+    rect.setAttribute("width", dim.width);
+    rect.setAttribute("height", dim.height);
+    label.insertBefore(rect, label.firstChild);
+  }
+};
+const renderer = {
+  setConf,
+  getClasses,
+  draw
+};
+const diagram = {
+  parser: parser$1,
+  db,
+  renderer,
+  styles,
+  init: (cnf) => {
+    if (!cnf.state) {
+      cnf.state = {};
+    }
+    cnf.state.arrowMarkerAbsolute = cnf.arrowMarkerAbsolute;
+    db.clear();
+  }
+};
+export {
+  diagram
+};

package/app/out/renderer/assets/stex-B6LNC55o.js

@@ -0,0 +1,231 @@
+function mkStex(mathMode) {
+  function pushCommand(state, command) {
+    state.cmdState.push(command);
+  }
+  function peekCommand(state) {
+    if (state.cmdState.length > 0) {
+      return state.cmdState[state.cmdState.length - 1];
+    } else {
+      return null;
+    }
+  }
+  function popCommand(state) {
+    var plug = state.cmdState.pop();
+    if (plug) {
+      plug.closeBracket();
+    }
+  }
+  function getMostPowerful(state) {
+    var context = state.cmdState;
+    for (var i = context.length - 1; i >= 0; i--) {
+      var plug = context[i];
+      if (plug.name == "DEFAULT") {
+        continue;
+      }
+      return plug;
+    }
+    return { styleIdentifier: function() {
+      return null;
+    } };
+  }
+  function addPluginPattern(pluginName, cmdStyle, styles) {
+    return function() {
+      this.name = pluginName;
+      this.bracketNo = 0;
+      this.style = cmdStyle;
+      this.styles = styles;
+      this.argument = null;
+      this.styleIdentifier = function() {
+        return this.styles[this.bracketNo - 1] || null;
+      };
+      this.openBracket = function() {
+        this.bracketNo++;
+        return "bracket";
+      };
+      this.closeBracket = function() {
+      };
+    };
+  }
+  var plugins = {};
+  plugins["importmodule"] = addPluginPattern("importmodule", "tag", ["string", "builtin"]);
+  plugins["documentclass"] = addPluginPattern("documentclass", "tag", ["", "atom"]);
+  plugins["usepackage"] = addPluginPattern("usepackage", "tag", ["atom"]);
+  plugins["begin"] = addPluginPattern("begin", "tag", ["atom"]);
+  plugins["end"] = addPluginPattern("end", "tag", ["atom"]);
+  plugins["label"] = addPluginPattern("label", "tag", ["atom"]);
+  plugins["ref"] = addPluginPattern("ref", "tag", ["atom"]);
+  plugins["eqref"] = addPluginPattern("eqref", "tag", ["atom"]);
+  plugins["cite"] = addPluginPattern("cite", "tag", ["atom"]);
+  plugins["bibitem"] = addPluginPattern("bibitem", "tag", ["atom"]);
+  plugins["Bibitem"] = addPluginPattern("Bibitem", "tag", ["atom"]);
+  plugins["RBibitem"] = addPluginPattern("RBibitem", "tag", ["atom"]);
+  plugins["DEFAULT"] = function() {
+    this.name = "DEFAULT";
+    this.style = "tag";
+    this.styleIdentifier = this.openBracket = this.closeBracket = function() {
+    };
+  };
+  function setState(state, f) {
+    state.f = f;
+  }
+  function normal(source, state) {
+    var plug;
+    if (source.match(/^\\[a-zA-Z@\xc0-\u1fff\u2060-\uffff]+/)) {
+      var cmdName = source.current().slice(1);
+      plug = plugins.hasOwnProperty(cmdName) ? plugins[cmdName] : plugins["DEFAULT"];
+      plug = new plug();
+      pushCommand(state, plug);
+      setState(state, beginParams);
+      return plug.style;
+    }
+    if (source.match(/^\\[$&%#{}_]/)) {
+      return "tag";
+    }
+    if (source.match(/^\\[,;!\/\\]/)) {
+      return "tag";
+    }
+    if (source.match("\\[")) {
+      setState(state, function(source2, state2) {
+        return inMathMode(source2, state2, "\\]");
+      });
+      return "keyword";
+    }
+    if (source.match("\\(")) {
+      setState(state, function(source2, state2) {
+        return inMathMode(source2, state2, "\\)");
+      });
+      return "keyword";
+    }
+    if (source.match("$$")) {
+      setState(state, function(source2, state2) {
+        return inMathMode(source2, state2, "$$");
+      });
+      return "keyword";
+    }
+    if (source.match("$")) {
+      setState(state, function(source2, state2) {
+        return inMathMode(source2, state2, "$");
+      });
+      return "keyword";
+    }
+    var ch = source.next();
+    if (ch == "%") {
+      source.skipToEnd();
+      return "comment";
+    } else if (ch == "}" || ch == "]") {
+      plug = peekCommand(state);
+      if (plug) {
+        plug.closeBracket(ch);
+        setState(state, beginParams);
+      } else {
+        return "error";
+      }
+      return "bracket";
+    } else if (ch == "{" || ch == "[") {
+      plug = plugins["DEFAULT"];
+      plug = new plug();
+      pushCommand(state, plug);
+      return "bracket";
+    } else if (/\d/.test(ch)) {
+      source.eatWhile(/[\w.%]/);
+      return "atom";
+    } else {
+      source.eatWhile(/[\w\-_]/);
+      plug = getMostPowerful(state);
+      if (plug.name == "begin") {
+        plug.argument = source.current();
+      }
+      return plug.styleIdentifier();
+    }
+  }
+  function inMathMode(source, state, endModeSeq) {
+    if (source.eatSpace()) {
+      return null;
+    }
+    if (endModeSeq && source.match(endModeSeq)) {
+      setState(state, normal);
+      return "keyword";
+    }
+    if (source.match(/^\\[a-zA-Z@]+/)) {
+      return "tag";
+    }
+    if (source.match(/^[a-zA-Z]+/)) {
+      return "variableName.special";
+    }
+    if (source.match(/^\\[$&%#{}_]/)) {
+      return "tag";
+    }
+    if (source.match(/^\\[,;!\/]/)) {
+      return "tag";
+    }
+    if (source.match(/^[\^_&]/)) {
+      return "tag";
+    }
+    if (source.match(/^[+\-<>|=,\/@!*:;'"`~#?]/)) {
+      return null;
+    }
+    if (source.match(/^(\d+\.\d*|\d*\.\d+|\d+)/)) {
+      return "number";
+    }
+    var ch = source.next();
+    if (ch == "{" || ch == "}" || ch == "[" || ch == "]" || ch == "(" || ch == ")") {
+      return "bracket";
+    }
+    if (ch == "%") {
+      source.skipToEnd();
+      return "comment";
+    }
+    return "error";
+  }
+  function beginParams(source, state) {
+    var ch = source.peek(), lastPlug;
+    if (ch == "{" || ch == "[") {
+      lastPlug = peekCommand(state);
+      lastPlug.openBracket(ch);
+      source.eat(ch);
+      setState(state, normal);
+      return "bracket";
+    }
+    if (/[ \t\r]/.test(ch)) {
+      source.eat(ch);
+      return null;
+    }
+    setState(state, normal);
+    popCommand(state);
+    return normal(source, state);
+  }
+  return {
+    name: "stex",
+    startState: function() {
+      var f = mathMode ? function(source, state) {
+        return inMathMode(source, state);
+      } : normal;
+      return {
+        cmdState: [],
+        f
+      };
+    },
+    copyState: function(s) {
+      return {
+        cmdState: s.cmdState.slice(),
+        f: s.f
+      };
+    },
+    token: function(stream, state) {
+      return state.f(stream, state);
+    },
+    blankLine: function(state) {
+      state.f = normal;
+      state.cmdState.length = 0;
+    },
+    languageData: {
+      commentTokens: { line: "%" }
+    }
+  };
+}
+const stex = mkStex(false);
+const stexMath = mkStex(true);
+export {
+  stex,
+  stexMath
+};