@sjcrh/proteinpaint-client 2.210.0 → 2.210.1

package/dist/singlecell-PEIEFXVU.js

@@ -0,0 +1,81 @@
+import {
+  appInit
+} from "./chunk-DH74ZT37.js";
+import "./chunk-BSWPONNA.js";
+import "./chunk-X46YA4CB.js";
+import "./chunk-SKMFMGCD.js";
+import "./chunk-CSAS3PVJ.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-T4RYLTR3.js";
+import "./chunk-ELJX3QIQ.js";
+import "./chunk-Y3SDMRDX.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-VTHZGUSZ.js";
+import "./chunk-3TV5WWUN.js";
+import "./chunk-4Y5W26UF.js";
+import "./chunk-UYKJOBRO.js";
+import {
+  copyMerge
+} from "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-7X6NF7NI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-Z2ZITHT4.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-FXQXCOII.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// gdc/singlecell.ts
+var gdcGenome = "hg38";
+var gdcDslabel = "GDC";
+async function init(arg, holder, genomes) {
+  const plotAppApi = await appInit({
+    holder,
+    state: {
+      genome: gdcGenome,
+      dslabel: gdcDslabel,
+      termfilter: { filter0: arg.filter0 },
+      plots: arg.state?.plots || [{ chartType: "singleCellPlot" }]
+    },
+    genome: genomes[gdcGenome],
+    app: copyMerge({}, arg.opts?.app || {}),
+    opts: {
+      singleCellPlot: arg.opts?.singleCellPlot || {}
+    }
+  });
+  const api = {
+    update: async (updateArg) => {
+      if (!plotAppApi) return;
+      if ("filter0" in updateArg) {
+        plotAppApi.dispatch({
+          type: "app_refresh",
+          subactions: [
+            {
+              type: "filter_replace",
+              filter0: updateArg.filter0
+            }
+          ]
+        });
+      } else {
+        plotAppApi.dispatch({
+          type: "plot_edit",
+          id: plotAppApi.getState().plots[0].id,
+          config: updateArg
+        });
+      }
+    }
+  };
+  return api;
+}
+export {
+  init
+};
+//# sourceMappingURL=singlecell-PEIEFXVU.js.map

package/dist/snp-G55JGINX.js

@@ -0,0 +1,33 @@
+import {
+  SearchHandler
+} from "./chunk-FW3ME75U.js";
+import "./chunk-CSAS3PVJ.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-T4RYLTR3.js";
+import "./chunk-ELJX3QIQ.js";
+import "./chunk-Y3SDMRDX.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-VTHZGUSZ.js";
+import "./chunk-3TV5WWUN.js";
+import "./chunk-4Y5W26UF.js";
+import "./chunk-UYKJOBRO.js";
+import "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-7X6NF7NI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-Z2ZITHT4.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-FXQXCOII.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-HS5PO5ZQ.js";
+export {
+  SearchHandler
+};
+//# sourceMappingURL=snp-G55JGINX.js.map

package/dist/snp.unit.spec-47CCZKJO.js

@@ -0,0 +1,171 @@
+import {
+  SearchHandler
+} from "./chunk-FW3ME75U.js";
+import {
+  require_tape
+} from "./chunk-PJYCTAMC.js";
+import "./chunk-CSAS3PVJ.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-T4RYLTR3.js";
+import "./chunk-ELJX3QIQ.js";
+import "./chunk-Y3SDMRDX.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-VTHZGUSZ.js";
+import "./chunk-3TV5WWUN.js";
+import "./chunk-4Y5W26UF.js";
+import "./chunk-UYKJOBRO.js";
+import "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-7X6NF7NI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-Z2ZITHT4.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-FXQXCOII.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import {
+  __toESM
+} from "./chunk-HS5PO5ZQ.js";
+
+// termdb/handlers/test/snp.unit.spec.ts
+var import_tape = __toESM(require_tape(), 1);
+function getGeneSearchWithCoordinates(overrides = {}) {
+  return {
+    chr: "chr17",
+    ref: "G",
+    alt: "A",
+    fromWhat: "rs1234567",
+    start: 7670618,
+    stop: 7670619,
+    ...overrides
+  };
+}
+function getGeneSearchWithPos(overrides = {}) {
+  return {
+    chr: "chr13",
+    ref: "T",
+    alt: "C",
+    fromWhat: "BRCA2:c.68_69delAA",
+    pos: 32889612,
+    ...overrides
+  };
+}
+(0, import_tape.default)("\n", function(test) {
+  test.comment("-***- termdb/handlers/snp -***-");
+  test.end();
+});
+(0, import_tape.default)("selectSnp() should throw when required fields are missing", async (test) => {
+  const handler = new SearchHandler();
+  handler.callback = () => {
+  };
+  try {
+    await handler.selectSnp({ chr: "chr1", ref: "A", alt: "T" });
+    test.fail("Should throw when fromWhat is missing");
+  } catch (e) {
+    test.match(String(e), /missing chr, ref, alt, or fromWhat/, "Should throw when fromWhat is missing");
+  }
+  try {
+    await handler.selectSnp({ ref: "A", alt: "T", fromWhat: "rs123" });
+    test.fail("Should throw when chr is missing");
+  } catch (e) {
+    test.match(String(e), /missing chr, ref, alt, or fromWhat/, "Should throw when chr is missing");
+  }
+  try {
+    await handler.selectSnp({ chr: "chr1", alt: "T", fromWhat: "rs123" });
+    test.fail("Should throw when ref is missing");
+  } catch (e) {
+    test.match(String(e), /missing chr, ref, alt, or fromWhat/, "Should throw when ref is missing");
+  }
+  try {
+    await handler.selectSnp({ chr: "chr1", ref: "A", fromWhat: "rs123" });
+    test.fail("Should throw when alt is missing");
+  } catch (e) {
+    test.match(String(e), /missing chr, ref, alt, or fromWhat/, "Should throw when alt is missing");
+  }
+  test.end();
+});
+(0, import_tape.default)("selectSnp() should throw when coordinate is missing", async (test) => {
+  const handler = new SearchHandler();
+  handler.callback = () => {
+  };
+  try {
+    await handler.selectSnp({
+      chr: "chr17",
+      ref: "G",
+      alt: "A",
+      fromWhat: "rs1234567"
+    });
+    test.fail("Should throw when coordinate is missing");
+  } catch (e) {
+    test.match(String(e), /missing coordinate of snp/, "Should throw expected message for missing coordinate");
+  }
+  test.end();
+});
+(0, import_tape.default)("selectSnp() should call callback with term object using start/stop coordinates", async (test) => {
+  const handler = new SearchHandler();
+  let selected;
+  handler.callback = (t) => {
+    selected = t;
+  };
+  const geneSearch = getGeneSearchWithCoordinates();
+  await handler.selectSnp(geneSearch);
+  test.equal(selected?.id, "rs1234567", "Should set id to fromWhat");
+  test.equal(selected?.chr, "chr17", "Should pass chr");
+  test.equal(selected?.start, 7670618, "Should pass start coordinate");
+  test.equal(selected?.stop, 7670619, "Should pass stop coordinate");
+  test.equal(selected?.ref, "G", "Should pass ref");
+  test.deepEqual(selected?.alt, ["A"], "Should convert alt string to array");
+  test.equal(selected?.name, "rs1234567", "Should set name to fromWhat");
+  test.equal(selected?.type, "snp", "Should set type to snp");
+  test.end();
+});
+(0, import_tape.default)("selectSnp() should call callback with term object using pos coordinate", async (test) => {
+  const handler = new SearchHandler();
+  let selected;
+  handler.callback = (t) => {
+    selected = t;
+  };
+  const geneSearch = getGeneSearchWithPos();
+  await handler.selectSnp(geneSearch);
+  test.equal(selected?.id, "BRCA2:c.68_69delAA", "Should set id to fromWhat");
+  test.equal(selected?.chr, "chr13", "Should pass chr");
+  test.equal(selected?.start, 32889611, "Should convert pos-1 to start");
+  test.equal(selected?.stop, 32889612, "Should set stop to pos");
+  test.equal(selected?.ref, "T", "Should pass ref");
+  test.deepEqual(selected?.alt, ["C"], "Should convert alt string to array");
+  test.equal(selected?.name, "BRCA2:c.68_69delAA", "Should set name to fromWhat");
+  test.equal(selected?.type, "snp", "Should set type to snp");
+  test.end();
+});
+(0, import_tape.default)("selectSnp() should handle alt as array when already in array format", async (test) => {
+  const handler = new SearchHandler();
+  let selected;
+  handler.callback = (t) => {
+    selected = t;
+  };
+  const geneSearch = getGeneSearchWithCoordinates({ alt: ["A", "T"] });
+  await handler.selectSnp(geneSearch);
+  test.deepEqual(selected?.alt, ["A", "T"], "Should preserve alt array when provided as array");
+  test.end();
+});
+(0, import_tape.default)("selectSnp() should handle various chromosome formats", async (test) => {
+  const handler = new SearchHandler();
+  const chromosomes = ["chr1", "chr22", "chrX", "chrY", "chrM"];
+  for (const chr of chromosomes) {
+    let selected;
+    handler.callback = (t) => {
+      selected = t;
+    };
+    const geneSearch = getGeneSearchWithCoordinates({ chr });
+    await handler.selectSnp(geneSearch);
+    test.equal(selected?.chr, chr, `Should handle chromosome ${chr}`);
+  }
+  test.end();
+});
+//# sourceMappingURL=snp.unit.spec-47CCZKJO.js.map

package/dist/snplocus-TRVAEAPF.js

@@ -0,0 +1,203 @@
+import {
+  makeSnpSelect,
+  mayRestrictAncestry
+} from "./chunk-T5BDYCFO.js";
+import "./chunk-7OYOC7XY.js";
+import {
+  addGeneSearchbox,
+  filterInit,
+  getNormalRoot
+} from "./chunk-CSAS3PVJ.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-T4RYLTR3.js";
+import "./chunk-ELJX3QIQ.js";
+import "./chunk-Y3SDMRDX.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-VTHZGUSZ.js";
+import "./chunk-3TV5WWUN.js";
+import "./chunk-4Y5W26UF.js";
+import "./chunk-UYKJOBRO.js";
+import "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-7X6NF7NI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-Z2ZITHT4.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-FXQXCOII.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// termsetting/handlers/snplocus.ts
+var term_name = "Variants in a locus";
+function getHandler(self) {
+  return {
+    getPillName() {
+      return self.term.name;
+    },
+    getPillStatus() {
+      if (!self.term || !self.q) return;
+      if (!self.term.snps) throw `Missing term.snps [snplocs.ts getPillStatus()]`;
+      let text = `${self.q.chr}:${self.q.start}-${self.q.stop}, ${self.term.snps.length} variant${self.term.snps.length > 1 ? "s" : ""}`;
+      if (self.term.reachedVariantLimit) {
+        text += '<span style="margin-left: 6px; background:#aaa; font-size:1em;font-style: normal; border-radius: 7px;color:white;padding:0px 5px;">&#9888;<span>';
+      }
+      return { text };
+    },
+    validateQ(data) {
+      validateQ(data);
+    },
+    async showEditMenu(div) {
+      await makeEditMenu(self, div);
+    }
+    /* no need for postMain()
+    cache file contains all samples,
+    variants in a cache file is only determined by locus range and info fields
+    thus no need to regenerate cache file upon subcohort or filter change via pill.main()
+    async postMain() {
+    	if (self.q && self.q.chr) {
+    		await validateInput(self)
+    	}
+    }
+    */
+  };
+}
+async function makeEditMenu(self, div0) {
+  const div = div0.append("div").style("margin", "15px");
+  const select_ancestry = await mayRestrictAncestry(self, div);
+  const coordResult = addGeneSearchbox({
+    genome: self.opts.genomeObj,
+    tip: self.dom.tip2,
+    row: div.append("div").style("margin-top", "20px"),
+    defaultCoord: self.q && self.q.chr ? { chr: self.q.chr, start: self.q.start, stop: self.q.stop } : void 0
+  });
+  div.select(".sja_genesearchinput").style("margin", "0px");
+  div.append("span").style("margin", "5px 0px").style("display", "inline-block").style("opacity", 0.4).style("font-size", ".7em").html(
+    '"Gene": Gene name (e.g. AKT1)</br>"Position": chr:start-stop (e.g. chr1:5000-6000)</br>"dbSNP": dbSNP accession (e.g. rs1042522)'
+  );
+  await mayDisplayVariantFilter(self, self.q?.variant_filter, div);
+  const [input_AFcutoff, select_alleleType, select_geneticModel] = makeSnpSelect(
+    div.append("div").attr("class", "sjpp-snp-select").style("margin-top", "15px"),
+    self,
+    "snplocus"
+  );
+  if (self.usecase.target == "dataDownload") div.select(".sjpp-snp-select").style("display", "none");
+  const btnRow = div.append("div").style("margin-top", "15px");
+  btnRow.append("button").style("margin-top", "15px").text("Submit").on("click", async (event) => {
+    if (!coordResult.chr) return window.alert("Invalid coordinate");
+    event.target.disabled = true;
+    event.target.innerHTML = "Validating input...";
+    if (self.term) {
+    } else {
+      self.term = { id: makeId() };
+    }
+    if (!self.q) self.q = {};
+    self.term.type = "snplocus";
+    self.q.chr = coordResult.chr;
+    self.q.start = coordResult.start;
+    self.q.stop = coordResult.stop;
+    self.term.name = term_name;
+    delete self.term.snps;
+    self.q.variant_filter = getNormalRoot(self.variantFilter.active);
+    await validateInput(self);
+    {
+      const v = Number(input_AFcutoff.property("value"));
+      self.q.AFcutoff = v < 0 || v >= 100 ? 5 : v;
+    }
+    self.q.alleleType = select_alleleType.property("selectedIndex");
+    self.q.geneticModel = select_geneticModel.property("selectedIndex");
+    if (select_ancestry) {
+      self.q.restrictAncestry = select_ancestry.node().options[select_ancestry.property("selectedIndex")].__ancestry_obj;
+    }
+    self.api.runCallback();
+  });
+  btnRow.append("span").style("padding-left", "15px").style("opacity", 0.8).style("font-size", ".8em").text(
+    self.usecase.target == "dataDownload" ? "" : "Variants will be treated individually in separate regression models"
+  );
+}
+async function validateInput(self) {
+  const data = await self.vocabApi.validateSnps(self.q);
+  if (data.error) throw data.error;
+  self.q.cacheid = data.cacheid;
+  self.term.snps = data.snps;
+  self.term.reachedVariantLimit = data.reachedVariantLimit;
+}
+function validateQ(data) {
+  const q = data.q;
+  if (!Number.isFinite(q.AFcutoff)) throw "AFcutoff is not number";
+  if (q.AFcutoff < 0 || q.AFcutoff > 100) throw "AFcutoff is not within 0 to 100";
+  if (![0, 1].includes(q.alleleType)) throw "alleleType value is not one of 0/1";
+  if (![0, 1, 2, 3].includes(q.geneticModel)) throw "geneticModel value is not one of 0/1";
+  if (!q.chr) throw "chr missing";
+  if (!Number.isInteger(q.start)) throw "start coordinate is not integer";
+  if (!Number.isInteger(q.stop)) throw "stop coordinate is not integer";
+  if (q.start < 0) throw "start < 0";
+  if (q.stop <= q.start) throw "stop <= start";
+}
+async function fillTW(tw, vocabApi) {
+  try {
+    validateQ(tw);
+  } catch (e) {
+    throw "snplocus validateQ(): " + e;
+  }
+  if (!tw.term.name) tw.term.name = term_name;
+  if (tw.id == void 0 || tw.id == "") {
+    if (tw.term.id == void 0 || tw.term.id == "") {
+      tw.term.id = makeId();
+    }
+    tw.id = tw.term.id;
+  } else {
+    if (tw.term.id == void 0 || tw.term.id == "") {
+      tw.term.id = tw.id;
+    }
+  }
+  await validateInput({
+    term: tw.term,
+    q: tw.q,
+    vocabApi
+  });
+}
+function makeId() {
+  return "snplocus" + Math.random();
+}
+async function mayDisplayVariantFilter(self, filterInState, holder, callback2) {
+  if (!self.variantFilter) {
+    self.variantFilter = await self.vocabApi.get_variantFilter();
+  }
+  if (!self.variantFilter.terms) {
+    return;
+  }
+  if (!self.variantFilter.opts) throw "variantFilter.opts{} missing";
+  if (!self.variantFilter.filter) throw ".filter missing from variantFilter{}";
+  if (!Array.isArray(self.variantFilter.terms) || self.variantFilter.terms.length == 0)
+    throw "variantFilter.terms[] is not non-empty array";
+  if (filterInState) {
+    self.variantFilter.active = JSON.parse(JSON.stringify(filterInState));
+  } else {
+    self.variantFilter.active = JSON.parse(JSON.stringify(self.variantFilter.filter));
+  }
+  const div = holder.append("div").style("margin-top", "15px");
+  div.append("span").text("VARIANT FILTERS").style("font-size", ".8em").style("opacity", 0.5);
+  const filterBody = div.append("div");
+  filterInit({
+    joinWith: self.variantFilter.opts.joinWith,
+    emptyLabel: "+Variant Filter",
+    holder: filterBody,
+    vocab: { terms: self.variantFilter.terms },
+    callback: async (filter) => {
+      self.variantFilter.active = filter;
+      if (callback2) await callback2();
+    }
+  }).main(self.variantFilter.active);
+}
+export {
+  fillTW,
+  getHandler
+};
+//# sourceMappingURL=snplocus-TRVAEAPF.js.map

package/dist/spliceevent.a53ss.diagram-FL2R6F22.js

@@ -0,0 +1,146 @@
+import {
+  font
+} from "./chunk-CSAS3PVJ.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-T4RYLTR3.js";
+import "./chunk-ELJX3QIQ.js";
+import "./chunk-Y3SDMRDX.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-VTHZGUSZ.js";
+import "./chunk-3TV5WWUN.js";
+import "./chunk-4Y5W26UF.js";
+import {
+  IN_frame,
+  exoncolor
+} from "./chunk-UYKJOBRO.js";
+import "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-7X6NF7NI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-Z2ZITHT4.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-FXQXCOII.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// src/spliceevent.a53ss.diagram.js
+var junctionBcolor = "#990000";
+var color_truncateexon = "#00A352";
+function spliceevent_a53ss_diagram_default(arg) {
+  const evt = arg.event;
+  if (!evt) {
+    arg.holder.text(".event missing");
+    return;
+  }
+  if (evt.a5ss == void 0 && evt.a3ss == void 0) {
+    arg.holder.text("not a5ss or a3ss");
+    return;
+  }
+  const exonwidth = 30;
+  const intronwidth = 30;
+  const exonheight = 20;
+  const distfontsize = exonheight - 5;
+  const junctionheight = 20;
+  const xpad = 30;
+  const ypad = 20;
+  const svg = arg.holder.append("svg");
+  const g = svg.append("g").attr("transform", "translate(" + xpad + "," + ypad + ")");
+  const distlabel = evt.sitedist + " nt";
+  let distlabelw;
+  g.append("text").text(distlabel).attr("font-size", distfontsize).attr("font-family", font).each(function() {
+    distlabelw = this.getBBox().width;
+  }).remove();
+  const distlabelpad = 5;
+  let leftinexon = false;
+  let rightinexon = false;
+  let leftinintron = false;
+  let rightinintron = false;
+  if (evt.a5ss) {
+    if (evt.altinexon) leftinexon = true;
+    else leftinintron = true;
+  } else {
+    if (evt.altinexon) rightinexon = true;
+    else rightinintron = true;
+  }
+  let x = 0;
+  let intronstart;
+  let intronstop;
+  g.append("rect").attr("fill", exoncolor).attr("stroke", exoncolor).attr("x", x).attr("y", junctionheight).attr("width", exonwidth).attr("height", exonheight).attr("shape-rendering", "crispEdges");
+  g.append("text").text("e" + (evt.exon5idx + 1)).attr("text-anchor", "middle").attr("x", x + exonwidth / 2).attr("y", junctionheight + exonheight / 2).attr("fill", "white").attr("dominant-baseline", "central").attr("font-size", distfontsize).attr("font-family", font);
+  x += exonwidth;
+  if (leftinexon) {
+    g.append("rect").attr("fill", color_truncateexon).attr("stroke", color_truncateexon).attr("x", x).attr("y", junctionheight).attr("width", distlabelw + distlabelpad * 2).attr("height", exonheight).attr("shape-rendering", "crispEdges");
+    g.append("text").text(distlabel).attr("text-anchor", "middle").attr("x", x + distlabelw / 2 + distlabelpad).attr("y", junctionheight + exonheight / 2).attr("fill", "white").attr("dominant-baseline", "central").attr("font-size", distfontsize).attr("font-family", font);
+    x += distlabelw + distlabelpad * 2;
+  }
+  intronstart = x;
+  if (leftinintron || rightinintron) {
+    if (leftinintron) {
+    } else {
+      x += intronwidth;
+    }
+    g.append("rect").attr("fill", "none").attr("stroke", exoncolor).attr("x", x).attr("y", junctionheight).attr("width", distlabelw + distlabelpad * 2).attr("height", exonheight).attr("shape-rendering", "crispEdges");
+    g.append("text").text(distlabel).attr("text-anchor", "middle").attr("x", x + distlabelw / 2 + distlabelpad).attr("y", junctionheight + exonheight / 2).attr("font-size", distfontsize).attr("font-family", font).attr("dominant-baseline", "central");
+    x += distlabelw + distlabelpad * 2;
+    if (leftinintron) {
+      x += intronwidth;
+    }
+  } else {
+    x += intronwidth;
+  }
+  intronstop = x;
+  g.append("line").attr("x1", intronstart + (leftinintron ? distlabelw + distlabelpad * 2 : 0)).attr("y1", junctionheight + exonheight / 2).attr("x2", intronstop - (rightinintron ? distlabelw + distlabelpad * 2 : 0)).attr("y2", junctionheight + exonheight / 2).attr("stroke", exoncolor).attr("shape-rendering", "crispEdges");
+  if (rightinexon) {
+    g.append("rect").attr("fill", color_truncateexon).attr("stroke", color_truncateexon).attr("x", x).attr("y", junctionheight).attr("width", distlabelw + distlabelpad * 2).attr("height", exonheight).attr("shape-rendering", "crispEdges");
+    g.append("text").text(distlabel).attr("text-anchor", "middle").attr("x", x + distlabelw / 2 + distlabelpad).attr("y", junctionheight + exonheight / 2).attr("fill", "white").attr("dominant-baseline", "central").attr("font-size", distfontsize).attr("font-family", font);
+    x += distlabelw + distlabelpad * 2;
+  }
+  g.append("rect").attr("fill", exoncolor).attr("stroke", exoncolor).attr("x", x).attr("y", junctionheight).attr("width", exonwidth).attr("height", exonheight).attr("shape-rendering", "crispEdges");
+  g.append("text").text("e" + (evt.exon5idx + 1 + 1)).attr("text-anchor", "middle").attr("x", x + exonwidth / 2).attr("y", junctionheight + exonheight / 2).attr("fill", "white").attr("dominant-baseline", "central").attr("font-size", distfontsize).attr("font-family", font);
+  {
+    let x1, x2;
+    if (leftinexon || leftinintron) {
+      x2 = intronstop;
+      if (leftinexon) {
+        x1 = intronstart - distlabelw - distlabelpad * 2;
+      } else {
+        x1 = intronstart + distlabelw + distlabelpad * 2;
+      }
+    } else {
+      x1 = intronstart;
+      if (rightinintron) {
+        x2 = intronstop - distlabelw - distlabelpad * 2;
+      } else {
+        x2 = intronstop + distlabelw + distlabelpad * 2;
+      }
+    }
+    g.append("path").attr("d", "M" + x1 + "," + junctionheight + "L" + (x1 + x2) / 2 + ",0L" + x2 + "," + junctionheight).attr("stroke", junctionBcolor).attr("fill", "none");
+    g.append("text").text(evt.junctionB.v + (evt.frame != void 0 ? evt.frame == IN_frame ? ", in frame" : ",out of frame" : "")).attr("x", (x1 + x2) / 2).attr("y", -1).attr("text-anchor", "middle").attr("font-size", distfontsize).attr("fill", junctionBcolor);
+  }
+  let jAreadcounttext;
+  {
+    const line = g.append("path").attr(
+      "d",
+      "M" + intronstart + "," + (junctionheight + exonheight) + "L" + (intronstart + intronstop) / 2 + "," + (junctionheight * 2 + exonheight) + "L" + intronstop + "," + (junctionheight + exonheight)
+    ).attr("stroke", exoncolor).attr("fill", "none");
+    const nj = evt.junctionA;
+    if (nj) {
+      jAreadcounttext = g.append("text").text(nj.v).attr("x", (intronstart + intronstop) / 2).attr("y", junctionheight * 2 + exonheight + 1).attr("text-anchor", "middle").attr("font-size", distfontsize).attr("dominant-baseline", "hanging");
+    } else {
+      line.attr("stroke-dasharray", "3,3");
+    }
+  }
+  svg.attr("width", xpad * 2 + exonwidth * 2 + intronwidth + distlabelw + distlabelpad * 2).attr("height", ypad * 2 + junctionheight * 2 + exonheight);
+  return jAreadcounttext;
+}
+export {
+  spliceevent_a53ss_diagram_default as default
+};
+//# sourceMappingURL=spliceevent.a53ss.diagram-FL2R6F22.js.map