@sjcrh/proteinpaint-client 2.182.0 → 2.183.0

package/dist/Disco-6FDT6KRM.js

@@ -0,0 +1,3235 @@
+import {
+  InvalidDataUI,
+  configUiInit,
+  fillbar,
+  getMaxLabelWidth,
+  getNormalRoot,
+  renderTable,
+  svgLegend,
+  table2col
+} from "./chunk-OXJ2TWDO.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-V6DLLX4N.js";
+import {
+  dofetch3
+} from "./chunk-7RN3L2BX.js";
+import {
+  Menu
+} from "./chunk-A6TQGNDQ.js";
+import "./chunk-HYZG6OPC.js";
+import "./chunk-FN5XPUPH.js";
+import "./chunk-LSEFWW72.js";
+import {
+  topBarInit
+} from "./chunk-5EF5U7MX.js";
+import "./chunk-2K5DSRBJ.js";
+import "./chunk-UCLS2SVB.js";
+import {
+  copyMerge,
+  getCompInit,
+  multiInit
+} from "./chunk-MVTCBVSX.js";
+import "./chunk-SEQLC4AD.js";
+import "./chunk-L4QG7XZE.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-KQMEJUWI.js";
+import "./chunk-UJU3Q7QJ.js";
+import "./chunk-WGL6FIUE.js";
+import "./chunk-6ITDJ5UR.js";
+import {
+  bplen,
+  dtcnv,
+  dtfusionrna,
+  dtloh,
+  dtsnvindel,
+  dtsv,
+  mclass
+} from "./chunk-XYFDBYOY.js";
+import "./chunk-TV74I3Y5.js";
+import {
+  arc_default,
+  line_default,
+  pie_default,
+  ribbon_default
+} from "./chunk-IH7ILDJS.js";
+import "./chunk-LOZEKOES.js";
+import "./chunk-TOU7EVFQ.js";
+import {
+  linear,
+  ticks
+} from "./chunk-OAWQ6LOO.js";
+import "./chunk-SEEYV6P2.js";
+import {
+  pointer_default,
+  select_default
+} from "./chunk-NDWTN4U5.js";
+import "./chunk-OMR2DT66.js";
+import "./chunk-HFNDKYVF.js";
+
+// plots/disco/arc/FullArcRenderer.ts
+var FullArcRenderer = class {
+  constructor(radius, width, color) {
+    this.radius = radius;
+    this.width = width;
+    this.color = color;
+  }
+  render(holder) {
+    const donutGenerator = arc_default();
+    const arc = {
+      startAngle: 0,
+      endAngle: Math.PI * 2,
+      innerRadius: this.radius,
+      outerRadius: this.radius + this.width,
+      color: this.color,
+      text: "No label"
+    };
+    const array = [];
+    array.push(arc);
+    const donutArc = holder.append("g");
+    donutArc.selectAll("path").data(array).enter().append("path").attr("d", (d) => donutGenerator(d)).attr("fill", (d) => d.color);
+  }
+};
+
+// plots/disco/menu/MenuProvider.ts
+var MenuProvider = class {
+  static create() {
+    const menu = new Menu({ padding: 5 });
+    menu.d.style("border", "1px solid #FFF").style("position", "absolute").style("z-index", 1001);
+    return menu;
+  }
+};
+
+// plots/disco/fusion/FusionColorProvider.ts
+var FusionColorProvider = class {
+  static getColor(chrA, chrB) {
+    if (chrA != chrB) {
+      return "#6A3D9A" /* Interchromosomal */.valueOf();
+    } else {
+      return "#1B9E77" /* Intrachromosomal */.valueOf();
+    }
+  }
+};
+
+// plots/disco/fusion/FusionRenderer.ts
+var FusionRenderer = class {
+  constructor(genome) {
+    this.genome = genome;
+  }
+  render(holder, fusions, opacity = 1) {
+    let radius = 0;
+    const fusionsWithTarget = fusions.filter((f) => f.target);
+    if (fusionsWithTarget.length > 0) {
+      radius = fusionsWithTarget[0].target.radius;
+      const fullArcRenderer = new FullArcRenderer(radius, 2, "#6464641A");
+      fullArcRenderer.render(holder);
+    } else return;
+    const ribbon = ribbon_default().radius(radius);
+    const ribbons = holder.selectAll(".chord").data(fusions);
+    const menu = MenuProvider.create();
+    const createTooltip = this.createTooltip.bind(this);
+    const genome = this.genome;
+    ribbons.enter().append("path").attr("class", "chord").attr("d", ribbon).attr("fill", (fusion) => {
+      return FusionColorProvider.getColor(
+        fusion.source.positionInChromosome.chromosome,
+        fusion.target.positionInChromosome.chromosome
+      );
+    }).style("opacity", opacity).each(function(d) {
+      const path = select_default(this);
+      const tip = MenuProvider.create();
+      path.on("click", async function(event) {
+        tip.clear().show(event.x, event.y);
+        const div = tip.d.append("div");
+        await makeSvgraph(d, div, genome);
+      });
+    }).on("mouseover", async function(mouseEvent, fusion) {
+      const table = table2col({ holder: menu.d });
+      createTooltip(table, fusion);
+      menu.show(mouseEvent.x, mouseEvent.y);
+    }).on("mouseout", () => {
+      menu.clear();
+      menu.hide();
+    });
+  }
+  createTooltip(table, fusion) {
+    {
+      const [td1, td2] = table.addRow();
+      td1.text("Data type");
+      td2.append("span").style("margin-left", "5px").text("Fusion transcript");
+    }
+    {
+      const positionInChromosomeSource = fusion.source.positionInChromosome;
+      const positionInChromosomeTarget = fusion.target.positionInChromosome;
+      const [td1, td2] = table.addRow();
+      td1.text("Position");
+      td2.append("span").style("margin-left", "5px").text(
+        ` ${fusion.source.gene || ""} ${positionInChromosomeSource.chromosome}:${positionInChromosomeSource.position} ${fusion.source.strand === "+" ? "forward" : "reverse"} >  ${fusion.target.gene || ""} ${positionInChromosomeTarget.chromosome}:${positionInChromosomeTarget.position} ${fusion.target.strand === "+" ? "forward" : "reverse"} `
+      );
+    }
+  }
+};
+async function makeSvgraph(fusion, div, genome) {
+  const wait = div.append("div").text("Loading...");
+  const svpair = {
+    a: {
+      chr: fusion.source.positionInChromosome.chromosome,
+      position: fusion.source.positionInChromosome.position,
+      strand: fusion.source.strand
+    },
+    b: {
+      chr: fusion.target.positionInChromosome.chromosome,
+      position: fusion.target.positionInChromosome.position,
+      strand: fusion.target.strand
+    }
+  };
+  await getGm(svpair.a, genome.name, fusion.source.gene);
+  await getGm(svpair.b, genome.name, fusion.target.gene);
+  wait.remove();
+  const _ = await import("./svgraph-AYR2UPNK.js");
+  _.default({
+    pairlst: [svpair],
+    genome,
+    holder: div
+  });
+}
+async function getGm(p, genome, name) {
+  const d = await dofetch3("isoformbycoord", {
+    body: { genome, chr: p.chr, pos: p.position }
+  });
+  if (d.error) throw d.error;
+  const u = d.lst.find((i) => i.isdefault && name === i.name) || d.lst[0];
+  if (u) {
+    p.name = u.name;
+    p.gm = { isoform: u.isoform };
+  }
+}
+
+// plots/disco/DiscoRenderer.ts
+var DiscoRenderer = class {
+  constructor(renders, legendRenderer, genome) {
+    this.renders = renders;
+    this.legendRenderer = legendRenderer;
+    this.fusionRenderer = new FusionRenderer(genome);
+  }
+  render(holder, viewModel, onCnvSourceSelect) {
+    const svgDiv = holder.append("div").style("display", "inline-block").style("font-family", "Arial");
+    const svg = svgDiv.append("svg").attr("id", "sjpp_disco_plot").attr("data-testid", "sjpp_disco_plot").attr("width", viewModel.width).attr("height", viewModel.height + viewModel.legendHeight);
+    const mainG = svg.append("g").attr("class", "mainG").attr(
+      "transform",
+      `translate(${viewModel.settings.rings.labelLinesInnerRadius + viewModel.settings.rings.labelsToLinesDistance + 100},${viewModel.height / 2})`
+    );
+    for (const [ringType, renderer] of this.renders) {
+      const elements = viewModel.getElements(ringType);
+      const collisions = viewModel.getCollisions(ringType);
+      renderer.render(mainG, elements, collisions);
+    }
+    this.fusionRenderer.render(mainG, viewModel.fusions, viewModel.settings.Disco.fusionOpacity);
+    if (viewModel.settings.Disco.centerText) {
+      const chrRingBbox = mainG.select('[data-testid="sjpp_chromosomes_arc_group"]').node().getBBox();
+      const text = viewModel.settings.Disco.centerText.length > 20 ? viewModel.settings.Disco.centerText.slice(0, 20) + "..." : viewModel.settings.Disco.centerText;
+      const textElem = mainG.append("text").attr("class", "sjpp-disco-center-text").text(text);
+      const textBbox = textElem.node().getBBox();
+      textElem.attr("transform", `translate(${chrRingBbox.x + chrRingBbox.width / 2 - textBbox.width / 2},0)`);
+    }
+    this.legendRenderer.render(
+      mainG,
+      viewModel.legend,
+      -1 * (viewModel.settings.rings.labelLinesInnerRadius + viewModel.settings.rings.labelsToLinesDistance + 75),
+      viewModel.width,
+      viewModel.height / 2,
+      viewModel,
+      onCnvSourceSelect
+    );
+  }
+};
+
+// plots/disco/interactions/DiscoInteractions.ts
+var DiscoInteractions = class {
+  constructor(discoApp) {
+    this.discoApp = discoApp;
+    this.downloadClickListener = (svg) => {
+      const downloadImgName = this.discoApp.state.settings.downloadImgName || "disco.plot";
+      const a = document.createElement("a");
+      document.body.appendChild(a);
+      a.addEventListener(
+        "click",
+        () => {
+          const serializer = new XMLSerializer();
+          const svg_blob = new Blob([serializer.serializeToString(svg)], {
+            type: "image/svg+xml"
+          });
+          a.download = downloadImgName + ".svg";
+          a.href = URL.createObjectURL(svg_blob);
+          document.body.removeChild(a);
+        },
+        false
+      );
+      a.click();
+    };
+    this.geneClickListener = async (gene, mnames) => {
+      const { filter, filter0 } = this.discoApp.app.getState().termfilter;
+      const arg = {
+        holder: this.discoApp.app.opts.holder,
+        genome: this.discoApp.app.opts.state.args.genome,
+        nobox: true,
+        query: gene,
+        tklst: [
+          {
+            type: "mds3",
+            dslabel: this.discoApp.app.opts.state.vocab.dslabel,
+            hlaachange: mnames.join(","),
+            filter0,
+            filterObj: getNormalRoot(filter)
+            // must not pass filter as frozen. pass unfrozen, normalized copy so mds3 code will work
+          }
+        ]
+      };
+      const _ = await import("./block.init-NCNSE3HD.js");
+      await _.default(arg);
+    };
+    this.colorScaleNumericInputsCallback = async (obj) => {
+      const callAppDispatch = (settings) => {
+        this.discoApp.app.dispatch({
+          type: "plot_edit",
+          id: this.discoApp.id,
+          config: { settings: { Disco: Object.assign({ cnvCutoffMode: obj.cutoffMode }, settings) } }
+        });
+      };
+      if (obj.cutoffMode == "auto") {
+        if (obj.min == null || obj.max == null)
+          throw new Error('Color scale must return min and max if cutoffMode "auto"');
+        callAppDispatch({
+          cnvCapping: this.discoApp.state.settings.cnv.capping,
+          cnvPercentile: this.discoApp.state.settings.cnv.percentile
+        });
+      } else if (obj.cutoffMode == "fixed") {
+        if (obj.min == null || obj.max == null)
+          throw new Error('Color scale must return min and max if cutoffMode "fixed"');
+        const diffValue = obj.max !== this.discoApp.state.settings.cnv.capping ? obj.max : Math.abs(obj.min);
+        callAppDispatch({
+          cnvCapping: diffValue
+        });
+      } else if (obj.cutoffMode == "percentile") callAppDispatch({ cnvPercentile: obj.percentile });
+      else throw new Error("Unknown cutoff mode returned from dom/ColorScale");
+    };
+    this.onMutationWaterfallColorChange = (color) => {
+      this.discoApp.app.dispatch({
+        type: "plot_edit",
+        id: this.discoApp.id,
+        config: { settings: { Disco: { mutationWaterfallColor: color } } }
+      });
+    };
+  }
+};
+
+// plots/disco/chromosome/Reference.ts
+var Reference = class {
+  /**
+   * Creates a Reference object that contains information about chromosomes.
+   * @param settings State settings
+   * @param chromosomes Chromosome order. This function formats into an obj with `chr` removed.
+   * @param chromosomeOverride Obj of chromsome keys and sizes. Filtered to remove hidden chromosomes in settings.
+   */
+  constructor(settings, chromosomes, chromosomeOverride) {
+    this.chromosomes = [];
+    this.chromosomesOrder = [];
+    this.keysArray = [];
+    this.totalSizeArray = [];
+    this.chrSizesArray = [];
+    const chrSizes = chromosomeOverride || chromosomes;
+    this.settings = settings;
+    this.chromosomesOrder = [];
+    let totalSize = 0;
+    this.totalPadAngle = Object.keys(chrSizes).length * this.settings.padAngle;
+    this.totalChromosomesAngle = 2 * Math.PI - this.totalPadAngle;
+    for (const chr in chrSizes) {
+      const key = chr.slice(0, 3) === "chr" ? chr.slice(3) : chr;
+      this.chromosomesOrder.push(chr);
+      this.keysArray.push(key);
+      this.totalSizeArray.push(totalSize);
+      this.chrSizesArray.push(chrSizes[chr]);
+      totalSize += chrSizes[chr];
+    }
+    this.totalSize = totalSize;
+    let lastAngle = 0;
+    for (let i = 0; i < this.keysArray.length; i++) {
+      const chromosomeAngle = this.totalChromosomesAngle * (this.chrSizesArray[i] / totalSize);
+      const startAngle = i == 0 ? this.settings.padAngle / 2 : lastAngle + this.settings.padAngle;
+      const endAngle = i == 0 ? this.settings.padAngle / 2 + chromosomeAngle : lastAngle + this.settings.padAngle + chromosomeAngle;
+      const chromosome = {
+        start: this.totalSizeArray[i],
+        size: this.chrSizesArray[i],
+        factor: 1,
+        startAngle,
+        endAngle,
+        angle: (startAngle + endAngle) / 2,
+        innerRadius: this.settings.rings.chromosomeInnerRadius,
+        outerRadius: this.settings.rings.chromosomeInnerRadius + this.settings.rings.chromosomeWidth,
+        color: "#AAA",
+        text: this.keysArray[i]
+      };
+      this.chromosomes.push(chromosome);
+      if (chromosome.endAngle != null) {
+        lastAngle = chromosome.endAngle;
+      }
+    }
+  }
+};
+
+// plots/disco/data/DataObjectMapper.ts
+var DataObjectMapper = class {
+  constructor(sampleName, prioritizedGenes) {
+    this.sampleName = sampleName;
+    this.prioritizedGenes = prioritizedGenes;
+  }
+  map(dObject) {
+    return {
+      dt: dObject.dt,
+      mname: dObject.mname,
+      mClass: dObject.class,
+      gene: dObject.gene,
+      chr: dObject.chr,
+      ref: dObject.ref,
+      alt: dObject.alt,
+      vafs: dObject.vafs,
+      position: dObject.pos ? dObject.pos : dObject.position,
+      poschr: dObject.poschr,
+      posbins: dObject.posbins,
+      poslabel: dObject.poslabel,
+      sampleName: this.sampleName,
+      ssm_id: dObject.ssm_id,
+      start: dObject.start,
+      stop: dObject.stop,
+      value: dObject.value,
+      segmean: dObject.segmean,
+      isPrioritized: this.prioritizedGenes.some((cancerGene) => cancerGene == dObject.gene),
+      chrA: dObject.chrA,
+      chrB: dObject.chrB,
+      geneA: dObject.geneA,
+      geneB: dObject.geneB,
+      posA: dObject.posA,
+      posB: dObject.posB,
+      strandA: dObject.strandA,
+      strandB: dObject.strandB
+    };
+  }
+};
+
+// plots/disco/data/PercentileMapper.ts
+var PercentileMapper = class {
+  map(data, percentile) {
+    return this.calculatePercentileForPositivesAndNegatives(data, percentile);
+  }
+  calculatePercentileForPositivesAndNegatives(data, percentile) {
+    const positives = data.filter((x) => x > 0);
+    const negatives = data.filter((x) => x < 0).map((x) => -1 * x);
+    let positive = NaN;
+    let negative = NaN;
+    if (positives.length > 0) {
+      positive = this.calculatePercentile(positives, percentile);
+    }
+    if (negatives.length > 0) {
+      negative = -1 * this.calculatePercentile(negatives, percentile);
+    }
+    return { positive, negative };
+  }
+  calculatePercentile(data, percentile) {
+    if (data.length === 0) {
+      throw new Error("Array must contain at least one element.");
+    }
+    const sortedValues = data.sort((a, b) => a - b);
+    const index = percentile / 100 * (sortedValues.length - 1);
+    const lowerIndex = Math.floor(index);
+    const upperIndex = Math.ceil(index);
+    const fraction = index - lowerIndex;
+    if (lowerIndex === upperIndex) {
+      return sortedValues[lowerIndex];
+    }
+    return sortedValues[lowerIndex] + fraction * (sortedValues[upperIndex] - sortedValues[lowerIndex]);
+  }
+};
+
+// plots/disco/data/DataMapper.ts
+var DataMapper = class _DataMapper {
+  constructor(settings, reference, sample, prioritizedGenes = []) {
+    // remove fields and extract filters to seperate classes
+    this.labelData = [];
+    this.nonExonicSnvData = [];
+    this.nonExonicInnerRadius = 0;
+    this.snvRingDataMap = /* @__PURE__ */ new Map();
+    this.snvInnerRadius = 0;
+    this.snvData = [];
+    this.bpx = 0;
+    this.onePxArcAngle = 0;
+    this.filteredSnvData = [];
+    this.filteredSnvCountByChr = /* @__PURE__ */ new Map();
+    this.lohData = [];
+    this.lohInnerRadius = 0;
+    this.cnvData = [];
+    this.cnvInnerRadius = 0;
+    this.fusionData = [];
+    this.fusionRadius = 0;
+    this.hasPrioritizedGenes = false;
+    this.hasWaterfallEligibleChromosome = false;
+    this.invalidEntries = [];
+    this.cnvLossMaxValue = 0;
+    this.cnvGainMaxValue = 0;
+    this.percentilePositive = 0;
+    this.percentileNegative = 0;
+    this.cnvMaxPercentileAbs = 0;
+    this.mutationWaterfallData = [];
+    this.mutationWaterfallInnerRadius = 0;
+    this.mutationWaterfallRangeMin = Infinity;
+    this.mutationWaterfallRangeMax = -Infinity;
+    this.lohMaxValue = void 0;
+    this.lohMinValue = void 0;
+    this.snvFilter = (data) => data.dt == dtsnvindel;
+    this.fusionFilter = (data) => data.dt == dtfusionrna || data.dt == dtsv;
+    this.cnvFilter = (data) => data.dt == dtcnv;
+    this.lohFilter = (data) => data.dt == dtloh;
+    this.compareData = (a, b) => {
+      const chrDiff = this.reference.chromosomesOrder.indexOf(a.chr) - this.reference.chromosomesOrder.indexOf(b.chr);
+      if (chrDiff != 0) {
+        return chrDiff;
+      }
+      const aPos = a.pos ? a.pos : a.start;
+      const bPos = b.pos ? b.pos : b.start;
+      return aPos - bPos;
+    };
+    this.settings = settings;
+    this.reference = reference;
+    this.sample = sample;
+    this.excludedChromosomes = this.settings.Disco.hiddenChromosomes;
+    this.lastInnerRadious = this.settings.rings.chromosomeInnerRadius;
+    this.gainCapped = this.settings.Disco.cnvCapping;
+    this.lossCapped = -1 * this.settings.Disco.cnvCapping;
+    this.nonExonicFilter = (data) => {
+      if (prioritizedGenes.length > 0 && this.settings.Disco.prioritizeGeneLabelsByGeneSets) {
+        return prioritizedGenes.includes(data.gene) && settings.rings.nonExonicFilterValues.includes(ViewModelMapper.snvClassLayer[data.mClass]);
+      } else {
+        return settings.rings.nonExonicFilterValues.includes(ViewModelMapper.snvClassLayer[data.mClass]);
+      }
+    };
+    this.snvRingFilter = (data) => {
+      if (prioritizedGenes.length > 0 && this.settings.Disco.prioritizeGeneLabelsByGeneSets) {
+        return prioritizedGenes.includes(data.gene) && settings.rings.snvRingFilters.includes(ViewModelMapper.snvClassLayer[data.mClass]);
+      } else {
+        return settings.rings.snvRingFilters.includes(ViewModelMapper.snvClassLayer[data.mClass]);
+      }
+    };
+    this.dataObjectMapper = new DataObjectMapper(sample, prioritizedGenes);
+  }
+  map(data) {
+    const dataArray = [];
+    this.filteredSnvCountByChr.clear();
+    this.hasWaterfallEligibleChromosome = false;
+    this.mutationWaterfallData = [];
+    this.mutationWaterfallInnerRadius = 0;
+    this.mutationWaterfallRangeMin = Infinity;
+    this.mutationWaterfallRangeMax = -Infinity;
+    data.forEach((dObject) => {
+      const index = this.reference.chromosomesOrder.indexOf(dObject.chr);
+      const indexA = this.reference.chromosomesOrder.indexOf(dObject.chrA);
+      const indexB = this.reference.chromosomesOrder.indexOf(dObject.chrB);
+      if (dObject.dt == dtsnvindel) {
+        if (index != -1 && this.snvData.length < this.settings.snv.maxMutationCount) {
+          const pos = dObject.pos ?? dObject.position;
+          const chrSize = this.reference.chromosomes[index].size;
+          if (Number.isFinite(pos) && pos >= 0 && pos <= chrSize) {
+            this.addData(dObject, dataArray);
+          } else {
+            this.invalidEntries.push({ dataType: "SNV", reason: `Position ${pos} outside of ${dObject.chr}` });
+          }
+        } else if (index == -1) {
+          if (!this.excludedChromosomes.includes(dObject.chr)) {
+            this.invalidEntries.push({ dataType: "SNV", reason: `Unknown chr ${dObject.chr}` });
+          }
+        }
+      } else if (dObject.dt == dtfusionrna || dObject.dt == dtsv) {
+        if (indexA != -1 && indexB != -1) {
+          const posA = dObject.posA;
+          const posB = dObject.posB;
+          const chrSizeA = this.reference.chromosomes[indexA].size;
+          const chrSizeB = this.reference.chromosomes[indexB].size;
+          if (Number.isFinite(posA) && Number.isFinite(posB) && posA >= 0 && posA <= chrSizeA && posB >= 0 && posB <= chrSizeB) {
+            this.addData(dObject, dataArray);
+          } else {
+            const reasonParts = [];
+            if (!(Number.isFinite(posA) && posA >= 0 && posA <= chrSizeA))
+              reasonParts.push(`Position ${posA} outside of ${dObject.chrA}`);
+            if (!(Number.isFinite(posB) && posB >= 0 && posB <= chrSizeB))
+              reasonParts.push(`Position ${posB} outside of ${dObject.chrB}`);
+            this.invalidEntries.push({ dataType: "Fusion", reason: reasonParts.join("; ") });
+          }
+        } else {
+          const missing = [];
+          if (indexA == -1 && !this.excludedChromosomes.includes(dObject.chrA)) missing.push(dObject.chrA);
+          if (indexB == -1 && !this.excludedChromosomes.includes(dObject.chrB)) missing.push(dObject.chrB);
+          if (missing.length) this.invalidEntries.push({ dataType: "Fusion", reason: "Unknown chr in fusion" });
+        }
+      } else if ([dtcnv, dtloh].includes(Number(dObject.dt))) {
+        const idx = this.reference.chromosomesOrder.indexOf(dObject.chr);
+        if (dObject.chr && idx != -1) {
+          const chrSize = this.reference.chromosomes[idx].size;
+          const start = dObject.start;
+          const stop = dObject.stop;
+          if (Number.isFinite(start) && Number.isFinite(stop) && start >= 0 && stop <= chrSize && start <= stop) {
+            this.addData(dObject, dataArray);
+          } else {
+            this.invalidEntries.push({
+              dataType: dObject.dt == dtcnv ? "CNV" : "LOH",
+              reason: `Position ${start}-${stop} outside of ${dObject.chr}`
+            });
+          }
+        } else {
+          if (!this.excludedChromosomes.includes(dObject.chr)) {
+            this.invalidEntries.push({
+              dataType: dObject.dt == dtcnv ? "CNV" : "LOH",
+              reason: `Unknown chr ${dObject.chr}`
+            });
+          }
+        }
+      } else {
+        throw Error("Unknown mutation type!");
+      }
+    });
+    const sortedData = dataArray.sort(this.compareData);
+    if (this.settings.rings.nonExonicRingEnabled) {
+      sortedData.forEach((data2) => {
+        this.filterNonExonicSnvData(data2);
+      });
+    }
+    if (this.nonExonicSnvData.length > 0) {
+      this.nonExonicInnerRadius = this.lastInnerRadious - this.settings.rings.nonExonicRingWidth;
+      this.lastInnerRadious = this.nonExonicInnerRadius;
+    }
+    sortedData.forEach((data2) => {
+      this.filterSnvs(data2);
+    });
+    this.hasWaterfallEligibleChromosome = Array.from(this.filteredSnvCountByChr.values()).some((count) => count >= 2);
+    if (this.settings.Disco.mutationWaterfallPlot && this.hasWaterfallEligibleChromosome) {
+      this.prepareMutationWaterfallData();
+    }
+    sortedData.forEach((data2) => {
+      this.filterLohs(data2);
+    });
+    if (this.lohData.length > 0) {
+      this.lohInnerRadius = this.lastInnerRadious - this.settings.rings.lohRingWidth;
+      this.lastInnerRadious = this.lohInnerRadius;
+    }
+    sortedData.forEach((data2) => {
+      this.filterCnvs(data2);
+    });
+    if (this.cnvData.length > 0) {
+      this.cnvInnerRadius = this.lastInnerRadious - this.settings.rings.cnvRingWidth;
+      this.lastInnerRadious = this.cnvInnerRadius;
+      this.cappedCnvMaxAbsValue = Math.min(
+        this.settings.Disco.cnvCapping,
+        Math.max(
+          Math.abs(_DataMapper.capMaxValue(this.cnvLossMaxValue, this.gainCapped, this.lossCapped)),
+          Math.abs(_DataMapper.capMaxValue(this.cnvGainMaxValue, this.gainCapped, this.lossCapped))
+        )
+      );
+      const percentilePair = new PercentileMapper().map(
+        this.cnvData.map((data2) => data2.value),
+        this.settings.Disco.cnvPercentile
+      );
+      this.percentilePositive = _DataMapper.capMaxValue(percentilePair.positive, this.gainCapped, this.lossCapped);
+      this.percentileNegative = _DataMapper.capMaxValue(percentilePair.negative, this.gainCapped, this.lossCapped);
+      this.cnvMaxPercentileAbs = Math.min(
+        this.settings.Disco.cnvCapping,
+        Math.max(this.percentilePositive, Math.abs(this.percentileNegative))
+      );
+    }
+    sortedData.forEach((data2) => {
+      this.filterFusion(data2);
+    });
+    if (this.fusionData.length > 0) {
+      this.fusionRadius = this.lastInnerRadious;
+    }
+    const dataHolder = {
+      labelData: this.labelData,
+      nonExonicSnvData: this.nonExonicSnvData,
+      nonExonicInnerRadius: this.nonExonicInnerRadius,
+      snvRingDataMap: this.snvRingDataMap,
+      snvInnerRadius: this.snvInnerRadius,
+      snvData: this.snvData,
+      bpx: this.bpx,
+      onePxArcAngle: this.onePxArcAngle,
+      filteredSnvData: this.filteredSnvData,
+      lohData: this.lohData,
+      lohInnerRadius: this.lohInnerRadius,
+      cnvData: this.cnvData,
+      cnvInnerRadius: this.cnvInnerRadius,
+      fusionData: this.fusionData,
+      fusionRadius: this.fusionRadius,
+      hasPrioritizedGenes: this.hasPrioritizedGenes,
+      hasWaterfallEligibleChromosome: this.hasWaterfallEligibleChromosome,
+      cnvGainMaxValue: this.cnvGainMaxValue,
+      cnvLossMaxValue: this.cnvLossMaxValue,
+      cappedCnvMaxAbsValue: this.cappedCnvMaxAbsValue,
+      percentilePositive: this.percentilePositive,
+      percentileNegative: this.percentileNegative,
+      cnvMaxPercentileAbs: this.cnvMaxPercentileAbs,
+      lohMaxValue: this.lohMaxValue,
+      lohMinValue: this.lohMinValue,
+      mutationWaterfallData: this.mutationWaterfallData,
+      mutationWaterfallInnerRadius: this.mutationWaterfallInnerRadius,
+      mutationWaterfallLogRange: this.mutationWaterfallData.length ? { min: this.mutationWaterfallRangeMin, max: this.mutationWaterfallRangeMax } : void 0,
+      invalidDataInfo: {
+        entries: this.invalidEntries,
+        errorMsg: `Entries listed above were skipped due to invalid or unsupported chromosome information.`
+      }
+    };
+    return dataHolder;
+  }
+  addData(dObject, dataArray) {
+    const instance = this.dataObjectMapper.map(dObject);
+    if (instance.isPrioritized) {
+      this.hasPrioritizedGenes = true;
+    }
+    dataArray.push(instance);
+  }
+  filterNonExonicSnvData(data) {
+    if (this.snvFilter(data)) {
+      if (this.settings.rings.nonExonicRingEnabled && this.nonExonicFilter(data)) {
+        this.nonExonicSnvData.push(data);
+      }
+    }
+  }
+  filterSnvs(data) {
+    if (this.snvFilter(data)) {
+      this.snvData.push(data);
+      if (this.snvRingFilter(data)) {
+        if (this.snvInnerRadius == 0) {
+          this.snvInnerRadius = this.lastInnerRadious - this.settings.rings.snvRingWidth;
+          this.lastInnerRadious = this.snvInnerRadius;
+          this.bpx = Math.floor(this.reference.totalSize / (this.reference.totalChromosomesAngle * this.snvInnerRadius));
+          this.onePxArcAngle = 1 / this.snvInnerRadius;
+        }
+        this.filteredSnvData.push(data);
+        this.labelData.push(data);
+        const currentCount = this.filteredSnvCountByChr.get(data.chr) || 0;
+        this.filteredSnvCountByChr.set(data.chr, currentCount + 1);
+        const arcAngle = this.calculateArcAngle(data);
+        let dataArray = this.snvRingDataMap.get(arcAngle);
+        if (!dataArray) {
+          dataArray = new Array();
+        }
+        dataArray.push(data);
+        this.snvRingDataMap.set(arcAngle, dataArray);
+      }
+    }
+  }
+  filterFusion(data) {
+    if (this.fusionFilter(data)) {
+      data.isPrioritized = true;
+      this.fusionData.push(data);
+      this.labelData.push(data);
+    }
+  }
+  filterLohs(data) {
+    if (this.lohFilter(data)) {
+      if (this.lohMaxValue == void 0 || this.lohMaxValue < data.value) {
+        this.lohMaxValue = data.segmean;
+      }
+      if (this.lohMinValue == void 0 || this.lohMinValue > data.value) {
+        this.lohMinValue = data.segmean;
+      }
+      this.lohData.push(data);
+    }
+  }
+  filterCnvs(data) {
+    if (this.cnvFilter(data)) {
+      if (!data.chr || this.reference.chromosomesOrder.indexOf(data.chr) == -1) {
+        return;
+      }
+      if (this.cnvGainMaxValue == void 0 || this.cnvGainMaxValue < data.value) {
+        this.cnvGainMaxValue = data.value;
+      }
+      if (this.cnvLossMaxValue == void 0 || this.cnvLossMaxValue > data.value) {
+        this.cnvLossMaxValue = data.value;
+      }
+      this.cnvData.push(data);
+    }
+  }
+  prepareMutationWaterfallData() {
+    this.mutationWaterfallInnerRadius = this.lastInnerRadious - this.settings.rings.mutationWaterfallRingWidth;
+    this.lastInnerRadious = this.mutationWaterfallInnerRadius;
+    const groupedSnvs = /* @__PURE__ */ new Map();
+    const firstMutationByChr = [];
+    for (const snv of this.filteredSnvData) {
+      const list = groupedSnvs.get(snv.chr) || [];
+      list.push(snv);
+      groupedSnvs.set(snv.chr, list);
+    }
+    for (const [, snvs] of groupedSnvs) {
+      if (snvs.length < 2) continue;
+      snvs.sort((a, b) => a.position - b.position);
+      firstMutationByChr.push({
+        chr: snvs[0].chr,
+        position: snvs[0].position,
+        logDistance: 0
+        // placeholder updated after range computed
+      });
+      for (let i = 1; i < snvs.length; i++) {
+        const prev = snvs[i - 1];
+        const curr = snvs[i];
+        const distance = Math.max(1, Math.abs(curr.position - prev.position));
+        const logDistance = Math.log10(distance);
+        this.mutationWaterfallData.push({
+          chr: curr.chr,
+          position: curr.position,
+          logDistance
+        });
+        if (logDistance < this.mutationWaterfallRangeMin) {
+          this.mutationWaterfallRangeMin = logDistance;
+        }
+        if (logDistance > this.mutationWaterfallRangeMax) {
+          this.mutationWaterfallRangeMax = logDistance;
+        }
+      }
+    }
+    if (!this.mutationWaterfallData.length) {
+      this.mutationWaterfallRangeMin = 0;
+      this.mutationWaterfallRangeMax = 0;
+    }
+    const topLogDistance = this.mutationWaterfallRangeMax;
+    for (const first of firstMutationByChr) {
+      this.mutationWaterfallData.push({
+        ...first,
+        logDistance: topLogDistance
+      });
+    }
+  }
+  calculateArcAngle(data) {
+    const currentChromosome = this.reference.chromosomes[this.reference.chromosomesOrder.findIndex((chromosomeOrder) => data.chr == chromosomeOrder)];
+    const dataAnglePos = Math.floor(data.position / this.bpx);
+    return currentChromosome.startAngle + dataAnglePos * this.onePxArcAngle;
+  }
+  static capMaxValue(value, gainCapped, lossCapped) {
+    if (value && Math.sign(value) == 1) {
+      return value > gainCapped ? gainCapped : value;
+    }
+    if (Math.sign(value) == -1) {
+      return value < lossCapped ? lossCapped : value;
+    }
+    return 0;
+  }
+  static capMinValue(value, capMinValue = 1) {
+    if (Math.sign(value) == 1) {
+      return value > capMinValue ? value : capMinValue;
+    }
+    if (Math.sign(value) == -1) {
+      return value < -1 * capMinValue ? value : -1 * capMinValue;
+    }
+    return 1;
+  }
+};
+
+// plots/disco/legend/Legend.ts
+var Legend = class {
+  constructor(snvTitle, cnvTitle, lohTitle, fusionTitle, cnvPercentile, cnvCutoffmode, snvClassMap, cnvClassMap, cnvRenderingType, fusionLegend, discoInteractions, lohLegend, mutationWaterfallLegend) {
+    this.snvTitle = snvTitle;
+    this.cnvTitle = cnvTitle;
+    this.lohTitle = lohTitle;
+    this.fusionTitle = fusionTitle;
+    this.cnvPercentile = cnvPercentile;
+    this.cnvCutoffMode = cnvCutoffmode;
+    this.snvClassMap = snvClassMap;
+    this.cnvClassMap = cnvClassMap;
+    this.cnvRenderingType = cnvRenderingType;
+    this.lohLegend = lohLegend;
+    this.fusionLegend = fusionLegend;
+    this.discoInteractions = discoInteractions;
+    this.mutationWaterfallLegend = mutationWaterfallLegend;
+  }
+  legendCount() {
+    return (this.snvClassMap.size > 0 ? 1 : 0) + (this.cnvClassMap.size > 0 ? 1 : 0) + (this.lohLegend ? 1 : 0) + (this.fusionLegend ? 1 : 0) + (this.mutationWaterfallLegend ? 1 : 0);
+  }
+};
+
+// plots/disco/fusion/Fusion.ts
+var Fusion = class {
+  constructor(source, target, genes, count, endpts) {
+    this.source = source;
+    this.target = target;
+    this.genes = genes;
+    this.count = count;
+    this.endpts = endpts;
+  }
+};
+
+// plots/disco/fusion/FusionSubgroup.ts
+var FusionSubgroup = class {
+  constructor(startAngle, endAngle, radius, gene, value, genes, positionInChromosome, strand) {
+    this.startAngle = startAngle;
+    this.endAngle = endAngle;
+    this.radius = radius;
+    this.gene = gene;
+    this.value = value;
+    this.genes = genes;
+    this.positionInChromosome = positionInChromosome;
+    this.strand = strand;
+  }
+};
+
+// plots/disco/fusion/FusionMapper.ts
+var FusionMapper = class {
+  constructor(radius, sampleName, reference) {
+    this.radius = radius;
+    this.sampleName = sampleName;
+    this.reference = reference;
+  }
+  map(fusionData) {
+    const fusions = [];
+    fusionData.forEach((data) => {
+      const genes = /* @__PURE__ */ new Set();
+      genes.add(data.geneA);
+      genes.add(data.geneB);
+      const startAngle = this.calculateStartAngle(data.chrA, data.posA);
+      const endAngle = this.calculateEndAngle(data.chrA, data.posA);
+      if (startAngle === null || endAngle === null) return;
+      const source = new FusionSubgroup(
+        startAngle,
+        endAngle,
+        this.radius,
+        data.geneA,
+        data.value,
+        genes,
+        {
+          chromosome: data.chrA,
+          position: data.posA
+        },
+        data.strandA
+      );
+      let target;
+      if (data.chrB && data.posB) {
+        const startAngle2 = this.calculateStartAngle(data.chrB, data.posB);
+        const endAngle2 = this.calculateEndAngle(data.chrB, data.posB);
+        if (startAngle2 === null || endAngle2 === null) return;
+        target = new FusionSubgroup(
+          startAngle2,
+          endAngle2,
+          this.radius,
+          data.geneB,
+          data.value,
+          genes,
+          {
+            chromosome: data.chrB,
+            position: data.posB
+          },
+          data.strandB
+        );
+      }
+      const fusion = new Fusion(source, target, "genes", -1, "Endpoints");
+      fusions.push(fusion);
+    });
+    return fusions;
+  }
+  calculateStartAngle(chr, pos) {
+    const index = this.reference.chromosomesOrder.indexOf(chr);
+    if (index === -1) return null;
+    const chromosome = this.reference.chromosomes[index];
+    return chromosome.startAngle + (chromosome.endAngle - chromosome.startAngle) * (Number(pos) / chromosome.size) - 0.01;
+  }
+  calculateEndAngle(chr, pos) {
+    const index = this.reference.chromosomesOrder.indexOf(chr);
+    if (index === -1) return null;
+    const chromosome = this.reference.chromosomes[index];
+    return 0.01 + chromosome.startAngle + (chromosome.endAngle - chromosome.startAngle) * (Number(pos) / chromosome.size);
+  }
+};
+
+// plots/disco/loh/GradientColorProvider.ts
+var GradientColorProvider = class {
+  static provide(value) {
+    const clampedValue = Math.min(Math.max(value, 0), 1);
+    const colorValue = Math.round(clampedValue * 255);
+    return `rgb(${colorValue}, ${colorValue}, ${colorValue})`;
+  }
+};
+
+// plots/disco/loh/LohLegend.ts
+var LohLegend = class {
+  constructor(minValue, maxValue) {
+    this.minValue = minValue;
+    this.maxValue = maxValue;
+    this.colorStartValue = GradientColorProvider.provide(minValue);
+    this.colorEndValue = GradientColorProvider.provide(maxValue);
+  }
+};
+
+// plots/disco/viewmodel/ViewModel.ts
+var ViewModel = class {
+  constructor(settings, rings, legend, fusions, dataHolder, genesetName, snvDataLengthAll) {
+    this.settings = settings;
+    this.rings = rings;
+    this.legend = legend;
+    this.fusions = fusions;
+    this.genesetName = genesetName;
+    const tempHolder = select_default("body").append("div").style("position", "absolute").style("visibility", "hidden");
+    const tempSvg = tempHolder.append("svg");
+    const labels = rings.labelsRing?.elementsToDisplay?.map((l) => l.text) || [];
+    const maxLabelSpace = getMaxLabelWidth(tempSvg, labels);
+    tempHolder.remove();
+    this.width = 2 * (this.settings.horizontalPadding + this.settings.rings.labelLinesInnerRadius + this.settings.rings.labelsToLinesDistance + maxLabelSpace);
+    this.height = 2 * (this.settings.rings.labelLinesInnerRadius + this.settings.rings.labelsToLinesDistance + this.settings.verticalPadding + this.settings.label.fontSize * 2 + maxLabelSpace);
+    this.legendHeight = this.calculateLegendHeight(legend);
+    this.snvDataLength = dataHolder.snvData.length;
+    this.filteredSnvDataLength = dataHolder.filteredSnvData.length;
+    this.snvDataLengthAll = snvDataLengthAll;
+    this.cnvMaxValue = dataHolder.cnvGainMaxValue;
+    this.cnvMinValue = dataHolder.cnvLossMaxValue;
+    this.cappedCnvMaxAbsValue = dataHolder.cappedCnvMaxAbsValue;
+    this.negativePercentile = dataHolder.percentileNegative;
+    this.positivePercentile = dataHolder.percentilePositive;
+    this.invalidDataInfo = dataHolder.invalidDataInfo;
+    this.canShowMutationWaterfallPlot = dataHolder.hasWaterfallEligibleChromosome;
+  }
+  getElements(ringType) {
+    switch (ringType) {
+      case 0 /* CHROMOSOME */:
+        return this.rings.chromosomesRing ? this.rings.chromosomesRing.elements : [];
+      case 1 /* LABEL */:
+        return this.rings.labelsRing.elementsToDisplay;
+      case 2 /* NONEXONICSNV */:
+        return this.rings.nonExonicArcRing ? this.rings.nonExonicArcRing.elements : [];
+      case 3 /* SNV */:
+        return this.rings.snvArcRing ? this.rings.snvArcRing.elements : [];
+      case 5 /* CNV */:
+        return this.rings.cnvArcRing ? this.rings.cnvArcRing.elements : [];
+      case 6 /* LOH */:
+        return this.rings.lohArcRing ? this.rings.lohArcRing.elements : [];
+      case 4 /* MUTATION_WATERFALL */:
+        return this.rings.mutationWaterfallRing ? this.rings.mutationWaterfallRing.elements : [];
+      default:
+        throw new Error(`ringType ${ringType} not defined`);
+    }
+  }
+  getCollisions(ringType) {
+    if (ringType == 1 /* LABEL */) {
+      return this.rings.labelsRing.collisions;
+    } else {
+      return void 0;
+    }
+  }
+  calculateLegendHeight(legend) {
+    const rawHeight = this.settings.legend.rowHeight;
+    return rawHeight * legend.legendCount();
+  }
+};
+
+// plots/disco/ring/Ring.ts
+var Ring = class {
+  constructor(innerRadius, width, elements) {
+    this.innerRadius = innerRadius;
+    this.outerRadius = innerRadius + width;
+    this.width = width;
+    this.elements = elements;
+  }
+};
+
+// plots/disco/label/MLabel.ts
+var MLabel = class _MLabel {
+  /**
+   * The Singleton's constructor should always be private to prevent direct
+   * construction calls with the `new` operator.
+   */
+  constructor() {
+    const mlabel = {};
+    for (const key in mclass) {
+      mlabel[mclass[key].label] = mclass[key];
+      mlabel[key] = mclass[key];
+    }
+    this.mlabel = mlabel;
+  }
+  /**
+   * The static method that controls the access to the singleton instance.
+   *
+   * This implementation let you subclass the Singleton class while keeping
+   * just one instance of each subclass around.
+   */
+  static getInstance() {
+    if (!_MLabel.instance) {
+      _MLabel.instance = new _MLabel();
+    }
+    return _MLabel.instance;
+  }
+};
+
+// plots/disco/snv/SnvLegendElement.ts
+var SnvLegendElement = class {
+  constructor(snvType, color, count) {
+    this.snvType = snvType;
+    this.color = color;
+    this.count = count;
+  }
+};
+
+// plots/disco/snv/SnvArcsMapper.ts
+var SnvArcsMapper = class {
+  constructor(svnInnerRadius, svnWidth, sampleName, reference) {
+    this.snvClassMap = /* @__PURE__ */ new Map();
+    this.svnInnerRadius = svnInnerRadius;
+    this.svnWidth = svnWidth;
+    this.sampleName = sampleName;
+    this.reference = reference;
+    this.bpx = Math.floor(this.reference.totalSize / (this.reference.totalChromosomesAngle * svnInnerRadius));
+    this.onePxArcAngle = 1 / svnInnerRadius;
+  }
+  map(exonicSnvDataMap) {
+    const snvArray = [];
+    for (const angle of exonicSnvDataMap.keys()) {
+      const array = exonicSnvDataMap.get(angle);
+      if (array) {
+        const arraySize = array.length;
+        for (let i = 0; i < array.length; i++) {
+          const data = array[i];
+          const snvLegendElement = this.snvClassMap.get(data.mClass);
+          if (snvLegendElement) {
+            this.snvClassMap.set(data.mClass, this.createSnvLegend(data.mClass, ++snvLegendElement.count));
+          } else {
+            this.snvClassMap.set(data.mClass, this.createSnvLegend(data.mClass, 1));
+          }
+          const startAngle = angle;
+          const endAngle = angle + this.onePxArcAngle;
+          const mLabel = MLabel.getInstance().mlabel ? MLabel.getInstance().mlabel[data.mClass] : void 0;
+          const arc = {
+            startAngle,
+            endAngle,
+            innerRadius: this.svnInnerRadius + i * this.svnWidth / arraySize,
+            outerRadius: this.svnInnerRadius + (i + 1) * this.svnWidth / arraySize,
+            color: mLabel.color,
+            text: data.gene,
+            dataClass: mLabel.label,
+            mname: data.mname,
+            chr: data.chr,
+            pos: data.position,
+            vafs: data.vafs,
+            sampleName: [data.sampleName]
+          };
+          snvArray.push(arc);
+        }
+      }
+    }
+    return snvArray;
+  }
+  createSnvLegend(dataClass, count) {
+    const mClass = MLabel.getInstance().mlabel[dataClass];
+    return new SnvLegendElement(mClass.label, mClass.color, count);
+  }
+};
+
+// plots/disco/cnv/CnvLegend.ts
+var CnvLegend = class {
+  constructor(text, cnvType, color, value) {
+    this.text = text;
+    this.cnvType = cnvType;
+    this.color = color;
+    this.value = value;
+  }
+};
+
+// plots/disco/cnv/CnvColorProvider.ts
+var CnvColorProvider = class {
+  static getColor(value, settings, cnvMaxPercentileAbs = 0) {
+    const cnv = settings.cnv;
+    const gainCapped = settings.Disco.cnvRenderingType == "heatmap" /* heatmap */ ? settings.Disco.cnvCapping : cnvMaxPercentileAbs;
+    const lossCapped = settings.Disco.cnvRenderingType == "heatmap" /* heatmap */ ? -1 * settings.Disco.cnvCapping : -1 * cnvMaxPercentileAbs;
+    if (value < lossCapped) {
+      return cnv.cappedLossColor;
+    } else if (value >= lossCapped && value <= 0) {
+      return cnv.lossColor;
+    } else if (value > 0 && value <= gainCapped) {
+      return cnv.ampColor;
+    } else {
+      return cnv.cappedAmpColor;
+    }
+  }
+};
+
+// plots/disco/cnv/CnvArcsMapper.ts
+var CnvArcsMapper = class {
+  constructor(cnvInnerRadius, cnvWidth, settings, sampleName, reference, cnvMaxValue = 0, cnvMinValue = 0, cnvMaxAbsValue = 0, cnvAbsPercentile = 0, cnvUnit = "", cnvRenderingType) {
+    this.cnvClassMap = /* @__PURE__ */ new Map();
+    this.cnvInnerRadius = cnvInnerRadius;
+    this.cnvWidth = cnvWidth;
+    this.settings = settings;
+    this.sampleName = sampleName;
+    this.reference = reference;
+    this.cnvMaxValue = cnvMaxValue;
+    this.cnvMinValue = cnvMinValue;
+    this.cnvMaxAbsValue = cnvMaxAbsValue;
+    this.cnvAbsPercentile = cnvAbsPercentile;
+    this.cnvUnit = cnvUnit;
+    this.cnvRenderingType = cnvRenderingType;
+    this.gainCapped = Math.min(cnvAbsPercentile, this.settings.Disco.cnvCapping);
+    this.lossCapped = -1 * Math.min(cnvAbsPercentile, this.settings.Disco.cnvCapping);
+    this.lossOnly = cnvMaxValue <= 0;
+    this.gainOnly = cnvMinValue >= 0;
+    this.onePxArcAngle = 1 / this.cnvInnerRadius;
+    const gain = new CnvLegend(
+      "Max",
+      cnvMaxValue > 0 ? 1 /* Gain */ : 0 /* Loss */,
+      this.getColor(cnvMaxValue),
+      cnvMaxValue
+    );
+    const loss = new CnvLegend(
+      "Min",
+      cnvMinValue > 0 ? 1 /* Gain */ : 0 /* Loss */,
+      this.getColor(cnvMinValue),
+      cnvMinValue
+    );
+    const cap = new CnvLegend(
+      "Capping",
+      0 /* Loss */,
+      this.getColor(cnvMinValue > 0 ? cnvMinValue : cnvMaxValue),
+      this.settings.Disco.cnvCapping
+    );
+    this.cnvClassMap.set(1 /* Gain */, gain);
+    this.cnvClassMap.set(0 /* Loss */, loss);
+    this.cnvClassMap.set(2 /* Cap */, cap);
+  }
+  map(arcData) {
+    const arcs = [];
+    arcData.forEach((data) => {
+      let startAngle = this.calculateStartAngle(data);
+      let endAngle = this.calculateEndAngle(data);
+      if (startAngle === null || endAngle === null) return;
+      if (endAngle - startAngle < this.onePxArcAngle) {
+        const restAngle = this.onePxArcAngle - (endAngle - startAngle);
+        startAngle = startAngle - restAngle / 2;
+        endAngle = startAngle + restAngle / 2;
+      }
+      const innerRadius = this.calculateInnerRadius(data);
+      const outerRadius = this.calculateOuterRadius(data);
+      const color = this.getColor(data.value);
+      const arc = {
+        startAngle,
+        endAngle,
+        innerRadius,
+        outerRadius,
+        color,
+        text: data.gene,
+        chr: data.chr,
+        start: data.start,
+        stop: data.stop,
+        value: data.value,
+        unit: this.cnvUnit,
+        sampleName: [this.sampleName]
+      };
+      arcs.push(arc);
+    });
+    return arcs;
+  }
+  calculateStartAngle(data) {
+    const index = this.reference.chromosomesOrder.indexOf(data.chr);
+    if (index == -1) return null;
+    const chromosome = this.reference.chromosomes[index];
+    return chromosome.startAngle + (chromosome.endAngle - chromosome.startAngle) * (Number(data.start) / chromosome.size);
+  }
+  calculateEndAngle(data) {
+    const index = this.reference.chromosomesOrder.indexOf(data.chr);
+    const chromosome = this.reference.chromosomes[index];
+    return chromosome.startAngle + (chromosome.endAngle - chromosome.startAngle) * (Number(data.stop) / chromosome.size);
+  }
+  getColor(value) {
+    return CnvColorProvider.getColor(value, this.settings, this.cnvAbsPercentile);
+  }
+  calculateInnerRadius(data) {
+    if (this.cnvRenderingType == "heatmap" /* heatmap */) {
+      return this.cnvInnerRadius;
+    }
+    if (this.gainOnly) {
+      return this.cnvInnerRadius;
+    }
+    if (this.lossOnly) {
+      const outerRadius = this.cnvInnerRadius + this.cnvWidth;
+      return outerRadius + DataMapper.capMinValue(
+        this.cnvWidth * DataMapper.capMaxValue(data.value, this.gainCapped, this.lossCapped) / this.cnvAbsPercentile
+      );
+    }
+    const centerRadius = this.cnvInnerRadius + this.cnvWidth / 2;
+    if (Math.sign(data.value) == 1) {
+      return centerRadius;
+    }
+    if (Math.sign(data.value) == -1) {
+      return centerRadius + DataMapper.capMinValue(
+        DataMapper.capMaxValue(data.value, this.gainCapped, this.lossCapped) / this.cnvAbsPercentile * (this.cnvWidth / 2)
+      );
+    }
+    return 1;
+  }
+  calculateOuterRadius(data) {
+    const maxOuterRadius = this.cnvInnerRadius + this.cnvWidth;
+    if (this.cnvRenderingType == "heatmap" /* heatmap */) {
+      return maxOuterRadius;
+    }
+    if (this.gainOnly) {
+      return this.cnvInnerRadius + DataMapper.capMinValue(
+        this.cnvWidth * DataMapper.capMaxValue(data.value, this.gainCapped, this.lossCapped) / this.cnvAbsPercentile
+      );
+    }
+    if (this.lossOnly) {
+      return maxOuterRadius;
+    }
+    const centerRadius = this.cnvInnerRadius + this.cnvWidth / 2;
+    if (Math.sign(data.value) == 1) {
+      return centerRadius + DataMapper.capMinValue(
+        DataMapper.capMaxValue(data.value, this.gainCapped, this.lossCapped) / this.cnvMaxAbsValue * (this.cnvWidth / 2)
+      );
+    }
+    if (Math.sign(data.value) == -1) {
+      return centerRadius;
+    }
+    return 1;
+  }
+};
+
+// plots/disco/label/Line.ts
+var Line = class {
+  constructor(points, color) {
+    this.points = new Array();
+    this.points = points;
+    this.color = color;
+  }
+};
+
+// plots/disco/label/LabelFactory.ts
+var LabelFactory = class {
+  static createLabel(startAngle, endAngle, innerRadius, outerRadius, value, gene, color, dataClass, chr, position, isPrioritized = false, labelsToLinesGap, mutationTooltip, fusionTooltip) {
+    const angle = (startAngle + endAngle) / 2;
+    const ccAngle = angle - Math.PI / 2;
+    const transform = `rotate(${angle * 180 / Math.PI - 90}) translate(${outerRadius})${angle > Math.PI ? "rotate(180)" : ""}`;
+    const textAnchor = angle > Math.PI ? "end" : "";
+    const r0 = innerRadius;
+    const r1 = outerRadius - labelsToLinesGap;
+    const points = [];
+    const point0 = {
+      x: r0 * Math.cos(ccAngle),
+      y: r0 * Math.sin(ccAngle)
+    };
+    const point1 = {
+      x: r1 * Math.cos(ccAngle),
+      y: r1 * Math.sin(ccAngle)
+    };
+    points.push(point0);
+    points.push(point1);
+    const line = new Line(points, color);
+    const label = {
+      startAngle,
+      endAngle,
+      innerRadius,
+      outerRadius,
+      angle,
+      value,
+      text: gene,
+      color,
+      transform,
+      textAnchor,
+      ccAngle,
+      line,
+      isPrioritized,
+      start: position,
+      stop: position,
+      chr,
+      mutationsTooltip: mutationTooltip ? [mutationTooltip] : void 0,
+      fusionTooltip: fusionTooltip ? [fusionTooltip] : void 0
+    };
+    return label;
+  }
+  static createMovedLabel(element, overlap) {
+    const startAngle = element.startAngle + overlap;
+    const endAngle = element.endAngle + overlap;
+    const angle = (startAngle + endAngle) / 2;
+    const ccAngle = angle - Math.PI / 2;
+    const r0 = element.innerRadius;
+    const r1 = element.outerRadius - 2;
+    const dr = (r1 - r0) / 3;
+    const cos0 = Math.cos(element.ccAngle);
+    const sin0 = Math.sin(element.ccAngle);
+    const cos1 = Math.cos(element.ccAngle + overlap);
+    const sin1 = Math.sin(element.ccAngle + overlap);
+    const points = [];
+    const point0 = {
+      x: r0 * cos0,
+      y: r0 * sin0
+    };
+    const point1 = {
+      x: (r0 + dr) * cos0,
+      y: (r0 + dr) * sin0
+    };
+    const point2 = {
+      x: (r0 + 2 * dr) * cos1,
+      y: (r0 + 2 * dr) * sin1
+    };
+    const point3 = {
+      x: (r0 + 3 * dr) * cos1,
+      y: (r0 + 3 * dr) * sin1
+    };
+    points.push(point0);
+    points.push(point1);
+    points.push(point2);
+    points.push(point3);
+    const line = new Line(points, element.color);
+    const transform = "rotate(" + (angle * 180 / Math.PI - 90) + ")translate(" + element.outerRadius + ")" + (angle > Math.PI ? "rotate(180)" : "");
+    const textAnchor = angle > Math.PI ? "end" : "";
+    const color = element.mutationsTooltip ? element.mutationsTooltip[0].color : element.fusionTooltip ? element.fusionTooltip[0].color : void 0;
+    const label = {
+      startAngle,
+      endAngle,
+      innerRadius: element.innerRadius,
+      outerRadius: element.outerRadius,
+      angle,
+      value: element.value,
+      text: element.text,
+      transform,
+      textAnchor,
+      ccAngle,
+      color,
+      line,
+      isPrioritized: element.isPrioritized,
+      start: element.start,
+      stop: element.stop,
+      chr: element.chr,
+      mutationsTooltip: element.mutationsTooltip,
+      fusionTooltip: element.fusionTooltip
+    };
+    return label;
+  }
+};
+
+// plots/disco/label/LabelsMapper.ts
+var LabelsMapper = class {
+  constructor(settings, sampleName, reference, cnvMaxPercentileAbs = 0) {
+    this.labelMap = /* @__PURE__ */ new Map();
+    this.settings = settings;
+    this.sampleName = sampleName;
+    this.reference = reference;
+    this.cnvMaxPercentileAbs = cnvMaxPercentileAbs;
+  }
+  map(data, cnvData = []) {
+    const innerRadius = this.settings.rings.labelLinesInnerRadius;
+    const outerRadius = innerRadius + this.settings.rings.labelsToLinesDistance;
+    data.forEach((data2) => {
+      if (data2.dt == dtsnvindel) {
+        const startAngle = this.calculateStartAngle(data2.chr, data2.position);
+        const endAngle = this.calculateEndAngle(data2.chr, data2.position);
+        if (startAngle === null || endAngle === null) return;
+        const mLabel = MLabel.getInstance().mlabel ? MLabel.getInstance().mlabel[data2.mClass] : void 0;
+        this.addLabelOrMutation(
+          data2,
+          data2.gene,
+          data2.mname,
+          startAngle,
+          endAngle,
+          innerRadius,
+          outerRadius,
+          mLabel.color,
+          mLabel.label
+        );
+      }
+      if (data2.dt == dtfusionrna) {
+        const color = FusionColorProvider.getColor(data2.chrA, data2.chrB);
+        if (data2.geneA) {
+          const startAngleSource = this.calculateStartAngle(data2.chrA, data2.posA);
+          const endAngleSource = this.calculateEndAngle(data2.chrA, data2.posA);
+          if (startAngleSource === null || endAngleSource === null) return;
+          this.addLabelOrFusion(
+            data2,
+            data2.geneA,
+            data2.posA,
+            startAngleSource,
+            endAngleSource,
+            innerRadius,
+            outerRadius,
+            color
+          );
+        }
+        if (data2.geneB && data2.geneA != data2.geneB) {
+          const startAngleTarget = this.calculateStartAngle(data2.chrB, data2.posB);
+          const endAngleTarget = this.calculateEndAngle(data2.chrB, data2.posB);
+          if (startAngleTarget == null || endAngleTarget == null) return;
+          this.addLabelOrFusion(
+            data2,
+            data2.geneB,
+            data2.posB,
+            startAngleTarget,
+            endAngleTarget,
+            innerRadius,
+            outerRadius,
+            color
+          );
+        }
+      }
+    });
+    const labelsArray = Array.from(this.labelMap.values());
+    labelsArray.forEach((label) => {
+      cnvData.forEach((cnv) => {
+        if (label.stop >= cnv.start && cnv.stop >= label.start && label.chr == cnv.chr) {
+          const mutation = {
+            value: cnv.value,
+            color: CnvColorProvider.getColor(cnv.value, this.settings, this.cnvMaxPercentileAbs),
+            chr: cnv.chr,
+            start: cnv.start,
+            stop: cnv.stop
+          };
+          if (label.cnvTooltip) {
+            label.cnvTooltip.push(mutation);
+          } else {
+            label.cnvTooltip = [];
+            label.cnvTooltip.push(mutation);
+          }
+        }
+      });
+    });
+    return Array.from(this.labelMap.values());
+  }
+  addLabelOrMutation(data, gene, mname, startAngle, endAngle, innerRadius, outerRadius, color, dataClass) {
+    const label = this.labelMap.get(gene);
+    const mutation = {
+      mname,
+      color,
+      dataClass,
+      chr: data.chr,
+      position: data.position,
+      vafs: data.vafs
+    };
+    if (!label) {
+      this.labelMap.set(
+        gene,
+        LabelFactory.createLabel(
+          startAngle,
+          endAngle,
+          innerRadius,
+          outerRadius,
+          data.value,
+          gene,
+          color,
+          dataClass,
+          data.chr,
+          data.position,
+          data.isPrioritized,
+          this.settings.rings.labelsToLinesGap,
+          mutation
+        )
+      );
+    } else {
+      if (label.mutationsTooltip) {
+        label.start = Math.min(label.start, data.position);
+        label.stop = Math.max(label.stop, data.position);
+        label.mutationsTooltip.push(mutation);
+      } else {
+        label.mutationsTooltip = [];
+        label.start = Math.min(label.start, data.position);
+        label.stop = Math.max(label.stop, data.position);
+        label.mutationsTooltip.push(mutation);
+      }
+    }
+  }
+  addLabelOrFusion(data, gene, position, startAngle, endAngle, innerRadius, outerRadius, color) {
+    const label = this.labelMap.get(gene);
+    const fusionTooltip = {
+      color,
+      chrA: data.chrA,
+      chrB: data.chrB,
+      posA: data.posA,
+      posB: data.posB,
+      geneA: data.geneA,
+      geneB: data.geneB,
+      strandA: data.strandA,
+      strandB: data.strandB
+    };
+    if (!label) {
+      this.labelMap.set(
+        gene,
+        LabelFactory.createLabel(
+          startAngle,
+          endAngle,
+          innerRadius,
+          outerRadius,
+          data.value,
+          gene,
+          color,
+          "Fusion transcript",
+          data.chr,
+          data.position,
+          data.isPrioritized,
+          this.settings.rings.labelsToLinesGap,
+          void 0,
+          fusionTooltip
+        )
+      );
+    } else {
+      if (label.fusionTooltip) {
+        label.start = Math.min(label.start, position);
+        label.stop = Math.max(label.stop, position);
+        label.fusionTooltip.push(fusionTooltip);
+      } else {
+        label.fusionTooltip = [];
+        label.start = Math.min(label.start, position);
+        label.stop = Math.max(label.stop, position);
+        label.fusionTooltip.push(fusionTooltip);
+      }
+    }
+  }
+  calculateStartAngle(chr, position) {
+    const index = this.reference.chromosomesOrder.findIndex((element) => element == chr);
+    if (index === -1) return null;
+    const chromosome = this.reference.chromosomes[index];
+    return chromosome.startAngle + (chromosome.endAngle - chromosome.startAngle) * (Number(position) / chromosome.size);
+  }
+  calculateEndAngle(chr, position) {
+    const index = this.reference.chromosomesOrder.findIndex((element) => element == chr);
+    if (index === -1) return null;
+    const chromosome = this.reference.chromosomes[index];
+    return chromosome.startAngle + (chromosome.endAngle - chromosome.startAngle) * (Number(position) / chromosome.size);
+  }
+};
+
+// plots/disco/label/Labels.ts
+var Labels = class extends Ring {
+  constructor(settings, elements, hasPrioritizedGenes) {
+    super(
+      settings.rings.labelLinesInnerRadius,
+      settings.rings.labelsToLinesDistance,
+      elements.sort((a, b) => {
+        return a.startAngle < b.startAngle ? -1 : a.startAngle > b.startAngle ? 1 : 0;
+      })
+    );
+    this.elementsToDisplay = [];
+    this.settings = settings;
+    this.hasPrioritizedGenes = hasPrioritizedGenes;
+    const circumference = 2 * Math.PI * (settings.rings.labelLinesInnerRadius + settings.rings.labelsToLinesDistance);
+    this.overlapAngle = this.settings.label.overlapAngleFactor * this.settings.label.fontSize / circumference;
+    this.calculateCollisions();
+  }
+  calculateCollisions() {
+    this.collisions = [];
+    let hasPrioritizedGenesList = [];
+    hasPrioritizedGenesList = this.elements.filter((label) => label.isPrioritized);
+    if (this.settings.label.prioritizeGeneLabelsByGeneSets) {
+      this.elementsToDisplay = this.getLabelsWithPrioritizedGenes(hasPrioritizedGenesList);
+    } else if (this.hasPrioritizedGenes) {
+      const prioritizedGenesList = this.elements.filter((label) => label.isPrioritized);
+      const filteredPrioritizedGenesList = this.getLabelsWithPrioritizedGenes(prioritizedGenesList);
+      const withoutPrioritizedGenesList = this.elements.filter((label) => !label.isPrioritized);
+      const combinedAndSortedList = [...withoutPrioritizedGenesList, ...filteredPrioritizedGenesList].sort(
+        (a, b) => a.startAngle - b.startAngle
+      );
+      this.elementsToDisplay = this.getAllLabels(combinedAndSortedList);
+    } else {
+      this.elementsToDisplay = this.getLabelsWithPrioritizedGenes(this.elements);
+    }
+  }
+  getLabelsWithPrioritizedGenes(elemenets) {
+    const filteredList = [];
+    let prev = { endAngle: 0 };
+    elemenets.forEach((element, index) => {
+      if (index == 0) {
+        filteredList.push(element);
+        prev = element;
+      } else {
+        const overlap = prev.endAngle - element.startAngle + this.overlapAngle;
+        if (overlap > 0 && overlap < this.settings.label.maxDeltaAngle) {
+          const labelCopy = LabelFactory.createMovedLabel(element, overlap);
+          filteredList?.push(labelCopy);
+          prev = labelCopy;
+        }
+        if (overlap <= 0) {
+          filteredList.push(element);
+          prev = element;
+        }
+      }
+    });
+    return filteredList;
+  }
+  getAllLabels(elemenets) {
+    const filteredList = [];
+    let prev = { endAngle: 0 };
+    const elemenetsLength = elemenets.length;
+    let lastCancerGeneLabelIndex = -1;
+    for (let index = 0; index < elemenets.length; index++) {
+      const element = elemenets[index];
+      if (element.isPrioritized) {
+        filteredList.push(element);
+        lastCancerGeneLabelIndex = index;
+        prev = element;
+        continue;
+      }
+      if (index == 0) {
+        if (elemenetsLength > 1) {
+          if (this.isElementOverlappingNextCancerGene(elemenets, lastCancerGeneLabelIndex, element, 0)) {
+            continue;
+          }
+          filteredList.push(element);
+          prev = element;
+        }
+        continue;
+      }
+      const prevOverlap = prev.endAngle - element.startAngle + this.overlapAngle;
+      if (prevOverlap > 0 && prevOverlap < this.settings.label.maxDeltaAngle) {
+        if (index == length - 1) {
+          filteredList.push(element);
+          continue;
+        }
+        if (this.isElementOverlappingNextCancerGene(elemenets, lastCancerGeneLabelIndex, element, prevOverlap)) {
+          continue;
+        }
+        const labelCopy = LabelFactory.createMovedLabel(element, prevOverlap);
+        this.collisions?.push(labelCopy);
+        filteredList.push(element);
+        prev = labelCopy;
+      }
+      if (prevOverlap <= 0) {
+        if (this.isElementOverlappingNextCancerGene(elemenets, lastCancerGeneLabelIndex, element, 0)) {
+          continue;
+        }
+        filteredList.push(element);
+        prev = element;
+      }
+    }
+    return filteredList;
+  }
+  isElementOverlappingNextCancerGene(elemenets, lastCancerGeneLabelIndex, element, prevOverlap) {
+    const nextLabelWithCancerGene = this.getNextLabelWithCancerGene(elemenets, lastCancerGeneLabelIndex);
+    if (nextLabelWithCancerGene) {
+      const nextOverlap = element.endAngle + prevOverlap - nextLabelWithCancerGene.startAngle + this.overlapAngle;
+      if (nextOverlap > 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getNextLabelWithCancerGene(elemenets, lastCancerGeneLabelIndex) {
+    return elemenets.find((label, index) => label.isPrioritized && index > lastCancerGeneLabelIndex);
+  }
+};
+
+// plots/disco/snv/NonExonicSnvArcsMapper.ts
+var NonExonicSnvArcsMapper = class {
+  constructor(nonExonicInnerRadius, nonExonicWidht, sampleName, reference) {
+    this.nonExonicInnerRadius = nonExonicInnerRadius;
+    this.nonExonicWidht = nonExonicWidht;
+    this.sampleName = sampleName;
+    this.reference = reference;
+    this.onePxArcAngle = 1 / nonExonicInnerRadius;
+  }
+  map(arcData) {
+    const innerRadius = this.nonExonicInnerRadius;
+    const outerRadius = innerRadius + this.nonExonicWidht;
+    const arcs = [];
+    arcData.forEach((data) => {
+      const mLabel = MLabel.getInstance().mlabel ? MLabel.getInstance().mlabel[data.mClass] : void 0;
+      const startAngle = this.calculateStartAngle(data);
+      const endAngle = this.calculateEndAngle(data);
+      if (startAngle === null || endAngle === null) return;
+      const arc = {
+        startAngle,
+        endAngle,
+        innerRadius,
+        outerRadius,
+        color: mLabel.color,
+        text: data.gene,
+        dataClass: mLabel.label,
+        mname: data.mname,
+        chr: data.chr,
+        pos: data.position,
+        vafs: data.vafs,
+        sampleName: [data.sampleName]
+      };
+      arcs.push(arc);
+    });
+    return arcs;
+  }
+  calculateStartAngle(data) {
+    const index = this.reference.chromosomesOrder.indexOf(data.chr);
+    if (index === -1) return null;
+    const chromosome = this.reference.chromosomes[index];
+    return chromosome.startAngle + (chromosome.endAngle - chromosome.startAngle) * (Number(data.position) / chromosome.size) - this.onePxArcAngle;
+  }
+  calculateEndAngle(data) {
+    const index = this.reference.chromosomesOrder.indexOf(data.chr);
+    const chromosome = this.reference.chromosomes[index];
+    return this.onePxArcAngle + chromosome.startAngle + (chromosome.endAngle - chromosome.startAngle) * (Number(data.position) / chromosome.size);
+  }
+};
+
+// plots/disco/loh/LohArcMapper.ts
+var LohArcMapper = class {
+  constructor(lohInnerRadius, lohWidth, sampleName, reference) {
+    this.lohInnerRadius = lohInnerRadius;
+    this.lohWidth = lohWidth;
+    this.sampleName = sampleName;
+    this.reference = reference;
+  }
+  map(arcData) {
+    const arcs = [];
+    arcData.forEach((data) => {
+      const startAngle = this.calculateStartAngle(data);
+      const endAngle = this.calculateEndAngle(data);
+      if (startAngle === null || endAngle === null) return;
+      const innerRadius = this.lohInnerRadius;
+      const outerRadius = innerRadius + this.lohWidth;
+      const color = GradientColorProvider.provide(data.segmean);
+      const arc = {
+        startAngle,
+        endAngle,
+        innerRadius,
+        outerRadius,
+        color,
+        text: data.gene,
+        chr: data.chr,
+        start: data.start,
+        stop: data.stop,
+        value: data.segmean
+      };
+      arcs.push(arc);
+    });
+    return arcs;
+  }
+  calculateStartAngle(data) {
+    const index = this.reference.chromosomesOrder.indexOf(data.chr);
+    if (index === -1) return null;
+    const chromosome = this.reference.chromosomes[index];
+    return chromosome.startAngle + (chromosome.endAngle - chromosome.startAngle) * (Number(data.start) / chromosome.size);
+  }
+  calculateEndAngle(data) {
+    const index = this.reference.chromosomesOrder.indexOf(data.chr);
+    const chromosome = this.reference.chromosomes[index];
+    return chromosome.startAngle + (chromosome.endAngle - chromosome.startAngle) * (Number(data.stop) / chromosome.size);
+  }
+};
+
+// plots/disco/ring/Rings.ts
+var Rings = class {
+  constructor(labelsRing, chromosomesRing, nonExonicArcRing, snvArcRing, cnvArcRing, lohArcRing, mutationWaterfallRing) {
+    this.labelsRing = labelsRing;
+    this.chromosomesRing = chromosomesRing;
+    this.nonExonicArcRing = nonExonicArcRing;
+    this.snvArcRing = snvArcRing;
+    this.cnvArcRing = cnvArcRing;
+    this.lohArcRing = lohArcRing;
+    this.mutationWaterfallRing = mutationWaterfallRing;
+  }
+};
+
+// plots/disco/waterfall/MutationWaterfallMapper.ts
+var MutationWaterfallMapper = class {
+  constructor(innerRadius, ringWidth, reference, logRange, color = "#4d4d4d") {
+    this.innerRadius = innerRadius;
+    this.ringWidth = ringWidth;
+    this.reference = reference;
+    this.logRange = logRange;
+    this.color = color;
+  }
+  map(data = []) {
+    if (!data.length) return [];
+    const min = this.logRange?.min ?? 0;
+    const max = this.logRange?.max ?? min + 1;
+    const span = max - min || 1;
+    const points = [];
+    for (const datum of data) {
+      const chrIndex = this.reference.chromosomesOrder.indexOf(datum.chr);
+      if (chrIndex === -1) continue;
+      const chromosome = this.reference.chromosomes[chrIndex];
+      const chrAngleSpan = chromosome.endAngle - chromosome.startAngle;
+      const relPos = chromosome.size > 0 ? datum.position / chromosome.size : 0;
+      const angle = chromosome.startAngle + chrAngleSpan * relPos;
+      const normalized = Math.max(0, Math.min(1, (datum.logDistance - min) / span));
+      const radius = this.innerRadius + this.ringWidth * normalized;
+      points.push({
+        startAngle: angle,
+        endAngle: angle,
+        innerRadius: radius,
+        outerRadius: radius,
+        text: chromosome.text,
+        color: this.color,
+        chr: datum.chr,
+        position: datum.position,
+        logDistance: datum.logDistance,
+        ringInnerRadius: this.innerRadius,
+        ringWidth: this.ringWidth,
+        rangeMin: min,
+        rangeMax: max
+      });
+    }
+    return points;
+  }
+};
+
+// plots/disco/viewmodel/ViewModelProvider.ts
+var ViewModelProvider = class {
+  constructor(settings, dataMapper, reference, sampleName, genesetName, discoInteractions) {
+    this.nonExonicArcRing = void 0;
+    this.settings = settings;
+    this.dataMapper = dataMapper;
+    this.reference = reference;
+    this.sampleName = sampleName;
+    this.genesetName = genesetName;
+    this.discoInteractions = discoInteractions;
+  }
+  map(data) {
+    const dataHolder = this.dataMapper.map(data);
+    let labelsRing;
+    if (this.settings.Disco.showGeneNames) {
+      const labelsMapper = new LabelsMapper(
+        this.settings,
+        this.sampleName,
+        this.reference,
+        dataHolder.cnvMaxPercentileAbs
+      );
+      const labelsData = labelsMapper.map(dataHolder.labelData, dataHolder.cnvData);
+      labelsRing = new Labels(this.settings, labelsData, dataHolder.hasPrioritizedGenes);
+    } else {
+      labelsRing = new Labels(this.settings, [], false);
+    }
+    const chromosomesRing = new Ring(
+      this.settings.rings.chromosomeInnerRadius,
+      this.settings.rings.chromosomeWidth,
+      this.reference.chromosomes
+    );
+    const nonExonicSnvArcsMapper = new NonExonicSnvArcsMapper(
+      dataHolder.nonExonicInnerRadius,
+      this.settings.rings.nonExonicRingWidth,
+      this.sampleName,
+      this.reference
+    );
+    const nonExonicData = nonExonicSnvArcsMapper.map(dataHolder.nonExonicSnvData);
+    if (nonExonicData.length > 0) {
+      this.nonExonicArcRing = new Ring(
+        dataHolder.nonExonicInnerRadius,
+        this.settings.rings.nonExonicRingWidth,
+        nonExonicData
+      );
+    }
+    this.snvArcsMapper = new SnvArcsMapper(
+      dataHolder.snvInnerRadius,
+      this.settings.rings.snvRingWidth,
+      this.sampleName,
+      this.reference
+    );
+    const snvData = this.snvArcsMapper.map(dataHolder.snvRingDataMap);
+    if (snvData.length > 0) {
+      this.snvArcRing = new Ring(dataHolder.snvInnerRadius, this.settings.rings.snvRingWidth, snvData);
+    }
+    const lohMapper = new LohArcMapper(
+      dataHolder.lohInnerRadius,
+      this.settings.rings.lohRingWidth,
+      this.sampleName,
+      this.reference
+    );
+    const lohData = lohMapper.map(dataHolder.lohData);
+    if (lohData.length > 0) {
+      this.lohArcRing = new Ring(dataHolder.lohInnerRadius, this.settings.rings.lohRingWidth, lohData);
+    }
+    this.cnvArcsMapper = new CnvArcsMapper(
+      dataHolder.cnvInnerRadius,
+      this.settings.rings.cnvRingWidth,
+      this.settings,
+      this.sampleName,
+      this.reference,
+      dataHolder.percentilePositive,
+      dataHolder.percentileNegative,
+      dataHolder.cappedCnvMaxAbsValue,
+      dataHolder.cnvMaxPercentileAbs,
+      this.settings.cnv.unit,
+      this.settings.Disco.cnvRenderingType
+    );
+    const cnvData = this.cnvArcsMapper.map(dataHolder.cnvData);
+    if (cnvData.length > 0) {
+      this.cnvArcRing = new Ring(dataHolder.cnvInnerRadius, this.settings.rings.cnvRingWidth, cnvData);
+    }
+    if (this.settings.Disco.mutationWaterfallPlot && dataHolder.mutationWaterfallData?.length && dataHolder.mutationWaterfallInnerRadius !== void 0 && //Added this check to prevent TypeScript error "mutationWaterfallInnerRadius might be undefined"
+    (dataHolder.mutationWaterfallInnerRadius ?? 0) > 0 && dataHolder.mutationWaterfallLogRange) {
+      const mutationWaterfallMapper = new MutationWaterfallMapper(
+        dataHolder.mutationWaterfallInnerRadius,
+        this.settings.rings.mutationWaterfallRingWidth,
+        this.reference,
+        dataHolder.mutationWaterfallLogRange,
+        this.settings.Disco.mutationWaterfallColor || "#4d4d4d"
+      );
+      const waterfallData = mutationWaterfallMapper.map(dataHolder.mutationWaterfallData);
+      if (waterfallData.length > 0) {
+        this.mutationWaterfallRing = new Ring(
+          dataHolder.mutationWaterfallInnerRadius,
+          this.settings.rings.mutationWaterfallRingWidth,
+          waterfallData
+        );
+      }
+    }
+    const fusionMapper = new FusionMapper(dataHolder.fusionRadius, this.sampleName, this.reference);
+    const fusions = fusionMapper.map(dataHolder.fusionData);
+    let lohLegend;
+    if (this.settings.legend.lohLegendEnabled && dataHolder.lohMinValue && dataHolder.lohMaxValue) {
+      lohLegend = new LohLegend(dataHolder.lohMinValue, dataHolder.lohMaxValue);
+    }
+    const legend = new Legend(
+      this.settings.legend.snvTitle,
+      this.settings.legend.cnvTitle,
+      this.settings.legend.lohTitle,
+      this.settings.legend.fusionTitle,
+      this.settings.Disco.cnvPercentile,
+      this.settings.Disco.cnvCutoffMode,
+      this.snvArcsMapper ? this.snvArcsMapper.snvClassMap : /* @__PURE__ */ new Map(),
+      this.cnvArcsMapper ? this.cnvArcsMapper.cnvClassMap : /* @__PURE__ */ new Map(),
+      this.settings.Disco.cnvRenderingType,
+      fusions.length > 0,
+      this.discoInteractions,
+      lohLegend,
+      this.settings.Disco.mutationWaterfallPlot && this.mutationWaterfallRing ? {
+        color: this.settings.Disco.mutationWaterfallColor || "#4d4d4d",
+        onColorChange: this.discoInteractions.onMutationWaterfallColorChange
+      } : void 0
+    );
+    const rings = new Rings(
+      labelsRing,
+      chromosomesRing,
+      this.nonExonicArcRing,
+      this.snvArcRing,
+      this.cnvArcRing,
+      this.lohArcRing,
+      this.mutationWaterfallRing
+    );
+    return new ViewModel(
+      this.settings,
+      rings,
+      legend,
+      fusions,
+      dataHolder,
+      this.genesetName,
+      data.filter((i) => i.dt == dtsnvindel).length
+    );
+  }
+};
+
+// plots/disco/viewmodel/ViewModelMapper.ts
+var ViewModelMapper = class _ViewModelMapper {
+  static {
+    this.snvClassLayer = {
+      M: "exonic",
+      E: "exonic",
+      F: "exonic",
+      N: "exonic",
+      S: "exonic",
+      D: "exonic",
+      I: "exonic",
+      P: "exonic",
+      L: "exonic",
+      Utr3: "exonic",
+      Utr5: "exonic",
+      ProteinAltering: "exonic",
+      mnv: "non-exonic",
+      ITD: "non-exonic",
+      insertion: "non-exonic",
+      deletion: "non-exonic",
+      Intron: "non-exonic",
+      X: "non-exonic",
+      noncoding: "non-exonic"
+    };
+  }
+  constructor(settings, discoInteractions) {
+    this.settings = JSON.parse(JSON.stringify(settings));
+    this.discoInteractions = discoInteractions;
+  }
+  applyRadius() {
+    const radius = this.settings.Disco.radius;
+    if (!radius) return;
+    const scale = radius / this.settings.rings.labelLinesInnerRadius;
+    this.settings.rings.labelLinesInnerRadius *= scale;
+    this.settings.rings.labelsToLinesDistance *= scale;
+    this.settings.rings.chromosomeInnerRadius *= scale;
+    this.settings.rings.chromosomeWidth *= scale;
+    this.settings.rings.nonExonicRingWidth *= scale;
+    this.settings.rings.snvRingWidth *= scale;
+    this.settings.rings.lohRingWidth *= scale;
+    this.settings.rings.cnvRingWidth *= scale;
+    this.settings.rings.mutationWaterfallRingWidth *= scale;
+    this.settings.label.fontSize *= scale;
+    this.settings.legend.fontSize *= scale;
+  }
+  static computeDynamicRadius(data) {
+    let ringCount = 0;
+    if (data.some((d) => d.dt == dtsnvindel)) ringCount++;
+    if (data.some((d) => d.dt == dtcnv)) ringCount++;
+    if (data.some((d) => d.dt == dtloh)) ringCount++;
+    if (ringCount <= 1) return 200;
+    if (ringCount == 2) return 250;
+    return 300;
+  }
+  map(opts) {
+    const chrSizes = opts.args.genome.majorchr;
+    const chromosomesOverride = {};
+    for (const chr of Object.keys(chrSizes)) {
+      if (!this.settings.Disco.hiddenChromosomes.includes(chr)) {
+        chromosomesOverride[chr] = chrSizes[chr];
+      }
+    }
+    const sampleName = opts.args.sampleName;
+    const genome = opts.args.genome;
+    const prioritizedGenes = genome?.geneset?.[0] ? genome.geneset[0].lst : [];
+    const genesetName = genome?.geneset?.[0] ? genome.geneset[0].name : "";
+    const data = opts.args.data;
+    if (this.settings.Disco.autoRadius) {
+      this.settings.Disco.radius = _ViewModelMapper.computeDynamicRadius(data);
+    }
+    this.applyRadius();
+    const reference = new Reference(this.settings, chrSizes, chromosomesOverride);
+    const dataMapper = new DataMapper(this.settings, reference, sampleName, prioritizedGenes);
+    return new ViewModelProvider(
+      this.settings,
+      dataMapper,
+      reference,
+      sampleName,
+      genesetName,
+      this.discoInteractions
+    ).map(data);
+  }
+};
+
+// plots/disco/legend/LegendJSONMapper.ts
+var LegendJSONMapper = class {
+  constructor(cappedCnvMaxAbsValue) {
+    this.cappedCnvMaxAbsValue = cappedCnvMaxAbsValue;
+  }
+  map(legend) {
+    const legendJSON = [];
+    let order = 0;
+    if (legend.snvClassMap) {
+      this.mapSnv(legend, legendJSON, order++);
+    }
+    if (legend.cnvRenderingType == "heatmap" /* heatmap */) {
+      this.mapCnvHeatmap(legend, legendJSON, order++);
+    } else if (legend.cnvRenderingType == "bar" /* bar */) {
+      if (legend.cnvClassMap) {
+        this.mapCnvBar(legend, legendJSON, order++);
+      }
+    }
+    if (legend.lohLegend) {
+      this.mapLoh(legend, legendJSON, order++);
+    }
+    if (legend.fusionLegend) {
+      this.mapFusion(legend, legendJSON, order++);
+    }
+    if (legend.mutationWaterfallLegend) {
+      this.mapMutationWaterfall(legend, legendJSON, order++);
+    }
+    return legendJSON;
+  }
+  mapSnv(legend, legendJSON, order) {
+    const snvItems = [];
+    let snvOrder = 0;
+    for (const [snvKey, snvLegendElement] of legend.snvClassMap) {
+      snvItems.push({
+        termid: legend.snvTitle,
+        key: snvKey,
+        text: `${snvLegendElement.snvType} (${snvLegendElement.count})`,
+        color: snvLegendElement.color,
+        order: snvOrder++,
+        border: "1px solid #ccc"
+      });
+    }
+    legendJSON.push({
+      name: legend.snvTitle,
+      order,
+      items: snvItems
+    });
+  }
+  mapCnvBar(legend, legendJSON, order) {
+    if (!legend.cnvClassMap) return;
+    const gain = legend.cnvClassMap.get(1 /* Gain */);
+    const loss = legend.cnvClassMap.get(0 /* Loss */);
+    const cap = legend.cnvClassMap.get(2 /* Cap */);
+    if (gain && loss && cap) {
+      let cnvOrder = 0;
+      const cnvItems = [];
+      if (gain.value > 0) {
+        cnvItems.push({
+          termid: legend.cnvTitle,
+          key: 1 /* Gain */,
+          text: `Max: ${gain.value}`,
+          color: gain.color,
+          order: cnvOrder++,
+          border: "1px solid #ccc"
+        });
+      }
+      if (loss.value < 0) {
+        cnvItems.push({
+          termid: legend.cnvTitle,
+          key: 0 /* Loss */,
+          text: `Min: ${loss.value}`,
+          color: loss.color,
+          order: cnvOrder++,
+          border: "1px solid #ccc"
+        });
+      }
+      cnvItems.push({
+        termid: legend.cnvTitle,
+        key: 2 /* Cap */,
+        text: `Capping: ${cap.value}`,
+        color: cap.color,
+        order: cnvOrder++,
+        border: "1px solid #ccc"
+        // ,
+        // onClickCallback: this.onClickCallback
+      });
+      legendJSON.push({
+        name: legend.cnvTitle,
+        id: "sjpp-disco-cnv-legend",
+        order,
+        items: cnvItems
+      });
+    }
+  }
+  mapCnvHeatmap(legend, legendJSON, order) {
+    if (!legend.cnvClassMap) return;
+    const gain = legend.cnvClassMap.get(1 /* Gain */);
+    const loss = legend.cnvClassMap.get(0 /* Loss */);
+    const cap = legend.cnvClassMap.get(2 /* Cap */);
+    if (gain && loss && cap) {
+      let cnvOrder = 0;
+      const cnvItems = [];
+      const base = {
+        termid: legend.cnvTitle,
+        width: 100,
+        order: cnvOrder++,
+        isLegendItem: true,
+        dt: 4
+      };
+      if (gain.value > 0 && loss.value < 0) {
+        const maxValue = Math.max(Math.abs(loss.value), gain.value);
+        const domain = [-maxValue, 0, maxValue];
+        cnvItems.push(
+          Object.assign(
+            {
+              key: 3 /* LossGain */,
+              domain,
+              scale: linear([-1, 0, 1], [loss.color, "white", gain.color]),
+              labels: { left: "Loss", right: "Gain" },
+              numericInputs: {
+                cutoffMode: legend.cnvCutoffMode,
+                defaultPercentile: legend.cnvPercentile,
+                callback: (obj) => legend.discoInteractions.colorScaleNumericInputsCallback(obj)
+              }
+            },
+            base
+          )
+        );
+      } else {
+        if (gain.value > 0) {
+          cnvItems.push(
+            Object.assign(
+              {
+                key: 1 /* Gain */,
+                text: "Copy number gain",
+                domain: [0, gain.value],
+                scale: linear([0, 1], ["white", gain.color])
+              },
+              base
+            )
+          );
+        }
+        if (loss.value < 0) {
+          cnvItems.push(
+            Object.assign(
+              {
+                key: 0 /* Loss */,
+                text: "Copy number loss",
+                domain: [loss.value, 0],
+                scale: linear([0, 1], [loss.color, "white"])
+              },
+              base
+            )
+          );
+        }
+      }
+      legendJSON.push({
+        name: legend.cnvTitle,
+        order,
+        id: "sjpp-disco-cnv-legend",
+        items: cnvItems
+      });
+    }
+  }
+  mapLoh(legend, legendJSON, order) {
+    if (!legend.lohLegend) return;
+    const lohItems = [];
+    lohItems.push({
+      termid: legend.lohTitle,
+      key: "min",
+      text: "min",
+      color: legend.lohLegend.colorStartValue,
+      order: 0,
+      border: "1px solid #ccc"
+    });
+    lohItems.push({
+      termid: legend.lohTitle,
+      key: "max",
+      text: "max",
+      color: legend.lohLegend.colorEndValue,
+      order: 1,
+      border: "1px solid #ccc"
+    });
+    legendJSON.push({
+      name: legend.lohTitle,
+      order,
+      items: lohItems
+    });
+  }
+  mapFusion(legend, legendJSON, order) {
+    const fusionItems = [];
+    fusionItems.push({
+      termid: legend.fusionTitle,
+      key: "#6A3D9A" /* Interchromosomal */,
+      text: "Interchromosomal",
+      color: "#6A3D9A" /* Interchromosomal */.valueOf(),
+      order: 0,
+      border: "1px solid #ccc"
+    });
+    fusionItems.push({
+      termid: legend.fusionTitle,
+      key: "#1B9E77" /* Intrachromosomal */,
+      text: "Intrachromosomal",
+      color: "#1B9E77" /* Intrachromosomal */.valueOf(),
+      order: 1,
+      border: "1px solid #ccc"
+    });
+    legendJSON.push({
+      name: legend.fusionTitle,
+      order,
+      items: fusionItems
+    });
+  }
+  mapMutationWaterfall(legend, legendJSON, order) {
+    if (!legend.mutationWaterfallLegend) return;
+    const waterfallItems = [];
+    waterfallItems.push({
+      termid: "Mutation Waterfall Plot",
+      key: "mutation-waterfall-color",
+      text: "Dot color",
+      color: legend.mutationWaterfallLegend.color,
+      order: 0,
+      colorPicker: true,
+      inputWidth: 28,
+      width: 0,
+      onColorChange: legend.mutationWaterfallLegend.onColorChange
+    });
+    waterfallItems.push({
+      termid: "Mutation Waterfall Plot",
+      key: "mutation-waterfall-axis",
+      text: "Axis: log10 intermutation distance",
+      order: 1,
+      skipIcon: true,
+      width: 0
+    });
+    legendJSON.push({
+      name: "Mutation Waterfall Plot",
+      order,
+      items: waterfallItems
+    });
+  }
+};
+
+// plots/disco/cnv/renderCnvSourceLegend.ts
+function parseSetLabel(set, index) {
+  let text = set.name || `Set ${index + 1}`;
+  let href;
+  let target = "_blank";
+  if (set.nameHtml) {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(set.nameHtml, "text/html");
+    const anchor = doc.querySelector("a");
+    if (anchor) {
+      href = anchor.getAttribute("href") || void 0;
+      target = anchor.getAttribute("target") || "_blank";
+      text = anchor.textContent?.trim() || text;
+    } else {
+      text = doc.body.textContent?.trim() || text;
+    }
+  }
+  return { text, href, target };
+}
+function renderCnvSourceLegend(legendG, datasets, fontSize, onChange) {
+  if (!legendG || legendG.empty()) throw new Error("legendG is required");
+  if (!datasets || datasets.length === 0) throw new Error("at least one dataset is required");
+  legendG.select("g.sjpp-cnv-source").remove();
+  const gBBox = legendG.node().getBBox();
+  const cnvSrcWrapper = legendG.append("g").attr("class", "sjpp-cnv-source").attr("transform", `translate(${gBBox.width},${gBBox.y + fontSize})`);
+  const btnPaddingX = Math.round(fontSize * 0.8);
+  const btnHgt = Math.round(fontSize * 1.8);
+  const btnWrapper = cnvSrcWrapper.append("g").attr("transform", `translate(${fontSize},${-btnHgt / 2})`).style("cursor", "pointer").on("click", function(event) {
+    event.stopPropagation();
+    showCnvMenu(this);
+  });
+  const btnText = btnWrapper.append("text").attr("x", 0).attr("y", btnHgt / 2).attr("font-size", fontSize).attr("text-anchor", "start").attr("dominant-baseline", "middle").text("Select source \u25B2".toUpperCase());
+  const textW = btnText.node() ? Math.ceil(btnText.node().getBBox().width) : 0;
+  const btnWdt = textW + btnPaddingX * 2;
+  btnWrapper.insert("rect", ":first-child").attr("width", btnWdt).attr("height", btnHgt).attr("rx", 10).attr("ry", 10).style("fill", "#f2f2f2");
+  btnText.attr("x", btnWdt / 2).attr("text-anchor", "middle");
+  const cnvMenu = new Menu({
+    onHide: () => {
+      btnText.text("Select source \u25B2".toUpperCase());
+    }
+  });
+  function showCnvMenu(dom) {
+    btnText.text("Select source \u25BC".toUpperCase());
+    cnvMenu.clear().showunder(dom);
+    cnvMenu.d.append("div").text("Choose data source for CNV:").style("margin", "5px 5px 0 5px");
+    const tableHolder = cnvMenu.d.append("div").style("padding", "5px");
+    const { columns, rows } = buildTableData(datasets);
+    const [, activeIndex] = getActiveDataset(datasets);
+    renderTable({
+      columns,
+      rows,
+      div: tableHolder,
+      singleMode: true,
+      maxWidth: "70vw",
+      maxHeight: "60vh",
+      selectedRows: [activeIndex],
+      header: { allowSort: false },
+      noButtonCallback: (rowIndex, node) => {
+        const inputIndex = Number(node?.value);
+        const selectedIndex = Number.isNaN(inputIndex) ? rowIndex : inputIndex;
+        if (!Number.isNaN(selectedIndex)) onChange(selectedIndex);
+        cnvMenu.hide();
+      }
+    });
+  }
+}
+function getActiveDataset(datasets) {
+  let currentIndex = datasets.findIndex((d) => d.inuse);
+  if (currentIndex == -1) currentIndex = 0;
+  return [datasets[currentIndex], currentIndex];
+}
+function buildTableData(datasets) {
+  const attrKeys = [];
+  for (const set of datasets) {
+    if (!set.attrs) continue;
+    for (const key of Object.keys(set.attrs)) {
+      if (!attrKeys.includes(key)) attrKeys.push(key);
+    }
+  }
+  const columns = [{ label: "Source" }];
+  for (const key of attrKeys) columns.push({ label: key });
+  const rows = datasets.map((set, index) => {
+    const sourceInfo = parseSetLabel(set, index);
+    const cells = [];
+    if (set.nameHtml) cells.push({ html: set.nameHtml });
+    else if (sourceInfo.href) cells.push({ value: sourceInfo.text, url: sourceInfo.href });
+    else cells.push({ value: sourceInfo.text });
+    for (const key of attrKeys) {
+      const value = set.attrs?.[key];
+      cells.push({ value: value ?? "" });
+    }
+    return cells;
+  });
+  return { columns, rows };
+}
+
+// plots/disco/legend/LegendRenderer.ts
+var LegendRenderer = class {
+  constructor(cappedCnvMaxAbsValue = 0, fontSize) {
+    this.fontSize = fontSize;
+    this.legendJSONMapper = new LegendJSONMapper(cappedCnvMaxAbsValue);
+  }
+  render(holder, legend, xOffset, svgw, svgh, viewModel, onCnvSourceSelect) {
+    const svgLegendRenderer = svgLegend({
+      holder: holder.append("g").attr("data-testid", "sjpp_disco_plot_legend"),
+      rectFillFxn: (d2) => d2.color,
+      iconStroke: "#aaa"
+    });
+    const data = this.legendJSONMapper.map(legend);
+    const legendTitles = data.map((d2) => d2.name.trim());
+    const maxLabelWidth = getMaxLabelWidth(holder, legendTitles);
+    const d = {
+      xOffset: maxLabelWidth + xOffset
+    };
+    svgLegendRenderer(data, {
+      settings: Object.assign(
+        {},
+        {
+          svgw,
+          svgh,
+          dimensions: d,
+          fontsize: this.fontSize
+        }
+      )
+    });
+    const altCnv = viewModel.appState.args.alternativeDataByDt?.[dtcnv];
+    if (altCnv && altCnv.length > 0) {
+      const legendG = holder.select('g[data-testid="sjpp_disco_plot_legend"]');
+      const cnvLegendG = legendG.select("#sjpp-disco-cnv-legend");
+      if (!legendG.empty()) {
+        const add2G = cnvLegendG.empty() ? legendG : cnvLegendG;
+        renderCnvSourceLegend(add2G, altCnv, this.fontSize, onCnvSourceSelect);
+      }
+    }
+  }
+};
+
+// plots/disco/chromosome/ChromosomesRenderer.ts
+var ChromosomesRenderer = class {
+  constructor(padAngle, innerRadius, outerRadius, fontSize) {
+    this.padAngle = padAngle;
+    this.innerRadius = innerRadius;
+    this.outerRadius = outerRadius;
+    this.fontSize = fontSize;
+  }
+  render(holder, elements) {
+    const pie = pie_default().padAngle(this.padAngle).value((d) => d.size).sort(null);
+    const arcData = pie(elements);
+    const arc = arc_default().innerRadius(this.innerRadius).outerRadius(this.outerRadius);
+    const arcs = holder.append("g").attr("data-testid", "sjpp_chromosomes_arc_group");
+    const menu = MenuProvider.create();
+    arcs.selectAll("path").data(arcData).enter().append("path").attr("d", arc).attr("fill", "black").on("mousemove", (event, d) => {
+      const [x, y] = pointer_default(event, arcs.node());
+      let angle = Math.atan2(y, x) + Math.PI / 2;
+      if (angle < 0) angle += 2 * Math.PI;
+      const frac = Math.max(0, Math.min(1, (angle - d.data.startAngle) / (d.data.endAngle - d.data.startAngle)));
+      const pos = Math.round(frac * d.data.size);
+      menu.d.html(`<span style="font-size:.8em">chr${d.data.text}</span> ${bplen(pos)}`).style("padding", "5px");
+      menu.show(event.x, event.y);
+    }).on("mouseenter", (event) => {
+      select_default(event.currentTarget).attr("stroke", "orange").attr("stroke-width", 1);
+    }).on("mouseleave", (event) => {
+      select_default(event.currentTarget).attr("stroke", null).attr("stroke-width", null);
+      menu.hide();
+    });
+    arcs.selectAll("text").data(arcData).enter().append("text").attr("transform", (d) => {
+      return `translate(${arc.centroid(d)}) rotate(${d.data.angle * 180 / Math.PI - 90})${d.data.angle > Math.PI ? "rotate(180)" : ""}`;
+    }).attr("dy", "0.35em").attr("text-anchor", "middle").text((d) => d.data.text).style("fill", "white").style("font-size", `${this.fontSize}px`).style("padding", "500px").style("pointer-events", "none").style("padding", "500px");
+  }
+};
+
+// plots/disco/snv/vafTooltip.ts
+function getIntegerCount(v) {
+  if (Number.isInteger(v)) return v;
+  if (typeof v == "string" && /^-?\d+$/.test(v)) {
+    const n = Number(v);
+    if (Number.isInteger(n)) return n;
+  }
+  return null;
+}
+function hasValidReadCounts(refCountValue, altCountValue) {
+  const refCount = getIntegerCount(refCountValue);
+  const altCount = getIntegerCount(altCountValue);
+  return refCount != null && altCount != null && refCount >= 0 && altCount >= 0 && refCount + altCount > 0;
+}
+function getVafEntries(vafs) {
+  const entries = [];
+  if (Array.isArray(vafs)) {
+    for (const vaf of vafs) {
+      const label = vaf?.id || vaf?.name;
+      const refCount = vaf?.refCount;
+      const altCount = vaf?.altCount;
+      if (!label || refCount == null || altCount == null) continue;
+      entries.push({ label, refCount, altCount });
+    }
+  }
+  return entries;
+}
+function hasAnyValidVafEntry(vafs) {
+  return getVafEntries(vafs).some((vaf) => hasValidReadCounts(vaf.refCount, vaf.altCount));
+}
+function appendVafBar(td2, refCountValue, altCountValue, label = "VAF") {
+  const refCount = getIntegerCount(refCountValue);
+  const altCount = getIntegerCount(altCountValue);
+  if (refCount == null || altCount == null) return;
+  const totalCount = refCount + altCount;
+  const fraction = altCount / totalCount;
+  const div = td2.append("div").style("margin-left", "5px").style("margin-top", "4px").style("display", "flex").style("align-items", "center").style("gap", "6px");
+  div.append("span").style("font-size", "0.8em").style("color", "#555").text(label);
+  fillbar(div, { f: fraction, v1: altCount, v2: totalCount });
+}
+function appendVafBars(td2, vafs) {
+  for (const vaf of getVafEntries(vafs)) {
+    if (!hasValidReadCounts(vaf.refCount, vaf.altCount)) continue;
+    appendVafBar(td2, vaf.refCount, vaf.altCount, vaf.label);
+  }
+}
+
+// plots/disco/label/LabelsRenderer.ts
+var LabelsRenderer = class {
+  constructor(animationDuration, fontSize, geneClickListener) {
+    this.animationDuration = animationDuration;
+    this.fontSize = fontSize;
+    this.geneClickListener = geneClickListener;
+  }
+  render(holder, elements, collisions) {
+    const labelsG = holder.append("g");
+    const lineFunction = line_default().x((point) => point.x).y((point) => point.y);
+    const menu = MenuProvider.create();
+    labelsG.selectAll(".group").data(elements).enter().append("g").attr("class", "group").each((label, i, nodes) => {
+      const g = select_default(nodes[i]);
+      g.append("text").attr("class", "chord-text").attr("dy", ".35em").attr("transform", label.transform).style("text-anchor", label.textAnchor).style("font-size", `${this.fontSize}px`).style("fill", label.color).style("cursor", "pointer").text(label.text).on("click", () => {
+        if (label.mutationsTooltip) {
+          this.geneClickListener(
+            label.text,
+            label.mutationsTooltip.map((value) => value.mname)
+          );
+        }
+      }).on("mouseover", (mouseEvent) => {
+        const table = table2col({ holder: menu.d });
+        this.createTooltip(table, label);
+        menu.show(mouseEvent.x, mouseEvent.y);
+      }).on("mouseout", () => {
+        menu.clear();
+        menu.hide();
+      });
+      g.append("path").attr("class", "chord-tick").datum(label.line.points).style("stroke", label.color).style("fill", "none").attr("d", lineFunction);
+    });
+    labelsG.selectAll(".group").each((label, i, nodes) => {
+      const collision = collisions ? collisions.find((l) => l.text === label.text) : void 0;
+      if (collision) {
+        const g = select_default(nodes[i]);
+        g.selectAll(".chord-text").datum(collision).transition().duration(this.animationDuration).attr("transform", collision.transform).style("text-anchor", collision.textAnchor);
+        g.selectAll(".chord-tick").datum(collision.line.points).transition().duration(this.animationDuration).style("fill", "none").attr("d", lineFunction);
+      }
+    });
+  }
+  createTooltip(table, label) {
+    if (label.mutationsTooltip) {
+      const [td1, td2] = table.addRow();
+      td1.text("Gene");
+      td2.append("span").style("margin-left", "5px").text(label.text);
+      label.mutationsTooltip.forEach((mutation) => {
+        {
+          const [td12, td22] = table.addRow();
+          td12.text("Mutation");
+          td22.append("span").style("margin-left", "5px").text(mutation.mname).append("span").style("margin-left", "5px").style("color", mutation.color).text(`${mutation.dataClass}`).append("span").style("margin-left", "5px").style("color", "black").style("font-size", "0.8em").text(` ${mutation.chr}:${mutation.position}`);
+          if (hasAnyValidVafEntry(mutation.vafs)) {
+            appendVafBars(td22, mutation.vafs);
+          }
+        }
+      });
+    }
+    if (label.fusionTooltip) {
+      const [td1, td2] = table.addRow();
+      td1.text("Data type");
+      td2.append("span").text("Fusion transcript");
+      label.fusionTooltip.forEach((fusionTooltip) => {
+        const [td12, td22] = table.addRow();
+        td12.text("Position");
+        td22.append("span").text(
+          ` ${fusionTooltip.geneA ? fusionTooltip.geneA : "?"} ${fusionTooltip.chrA}:${fusionTooltip.posA}
+						${fusionTooltip.strandA == "+" ? "forward" : "reverse"} > ${fusionTooltip.geneB ? fusionTooltip.geneB : "?"} ${fusionTooltip.chrB}:${fusionTooltip.posB} ${fusionTooltip.strandB == "+" ? "forward" : "reverse"} `
+        );
+      });
+    }
+    if (label.cnvTooltip) {
+      label.cnvTooltip.forEach((cnv) => {
+        const [td1, td2] = table.addRow();
+        td1.text("CNV");
+        td2.append("span").style("margin-left", "5px").style("background-color", cnv.color).html("&nbsp;&nbsp;");
+        td2.append("span").style("margin-left", "7.5px").text(cnv.value).append("span").style("margin-left", "7.5px").style("font-size", "0.8em").text(`${cnv.chr}:${cnv.start}-${cnv.stop}`);
+      });
+    }
+  }
+};
+
+// plots/disco/defaults.ts
+function discoDefaults(overrides = {}, app) {
+  const hiddenChromosomes = [];
+  if (app?.vocabApi?.termdbConfig?.queries?.singleSampleMutation?.discoPlot?.skipChrM) {
+    hiddenChromosomes.push("chrM");
+  }
+  const defaults = {
+    downloadImgName: "disco.plot",
+    Disco: {
+      centerText: null,
+      cnvCapping: 5,
+      isOpen: false,
+      prioritizeGeneLabelsByGeneSets: false,
+      showPrioritizeGeneLabelsByGeneSets: false,
+      showGeneNames: true,
+      mutationWaterfallPlot: false,
+      mutationWaterfallColor: "#4d4d4d",
+      cnvRenderingType: "heatmap" /* heatmap */,
+      cnvPercentile: 90,
+      // 90th percentile for removing outliers
+      cnvCutoffMode: "percentile",
+      autoRadius: true,
+      radius: 300,
+      fusionOpacity: 1,
+      hiddenChromosomes
+    },
+    rings: {
+      nonExonicRingWidth: 20,
+      snvRingWidth: 20,
+      lohRingWidth: 20,
+      cnvRingWidth: 30,
+      mutationWaterfallRingWidth: 35,
+      snvRingFilters: ["exonic"],
+      chromosomeInnerRadius: 190,
+      chromosomeWidth: 20,
+      labelLinesInnerRadius: 210,
+      labelsToLinesDistance: 30,
+      labelsToLinesGap: 2,
+      nonExonicRingEnabled: true,
+      nonExonicFilterValues: ["non-exonic"]
+    },
+    verticalPadding: 0,
+    horizontalPadding: 50,
+    layerScaler: 1,
+    padAngle: 2e-3,
+    //0.01, //0.04,
+    label: {
+      fontSize: 12,
+      maxDeltaAngle: 0.05,
+      animationDuration: 1e3,
+      overlapAngleFactor: 5
+      // 5 is set by testing, because label height is not known before rendering
+    },
+    cnv: {
+      capping: 5,
+      percentile: 80,
+      ampColor: "#D6683C",
+      lossColor: "#67a9cf",
+      cappedAmpColor: "#8B0000",
+      cappedLossColor: "#00008B",
+      unit: "Unit"
+    },
+    snv: {
+      maxMutationCount: 1e4
+    },
+    legend: {
+      snvTitle: "SNV",
+      cnvTitle: "CNV",
+      lohTitle: "LOH",
+      fusionTitle: "SV",
+      // Structural Variants (color by co-location)
+      lohLegendEnabled: true,
+      fontSize: 12,
+      rowHeight: 48
+    },
+    menu: {
+      padding: 5
+    }
+  };
+  if (overrides?.Disco?.radius != null && (overrides.Disco.radius > 1e3 || overrides.Disco.radius < 200)) {
+    console.log(`${overrides?.Disco?.radius} is greater or lower than the min and max for the radius`);
+  }
+  return copyMerge(defaults, overrides);
+}
+
+// plots/disco/snv/NonExonicSnvRenderer.ts
+var NonExonicSnvRenderer = class {
+  constructor(geneClickListener) {
+    this.geneClickListener = geneClickListener;
+  }
+  render(holder, elements) {
+    const arcGenerator = arc_default();
+    const arcs = holder.append("g");
+    const menu = MenuProvider.create();
+    arcs.selectAll("path").data(elements).enter().append("path").attr("d", (d) => arcGenerator(d)).attr("fill", (d) => d.color).on("mouseover", (mouseEvent, arc) => {
+      const table = table2col({ holder: menu.d });
+      const snv = structuredClone(arc);
+      snv.dt = dtsnvindel;
+      snv.class = arc.dataClass;
+      snv.gene = snv.text;
+      {
+        const [td1, td2] = table.addRow();
+        td1.text("Consequence");
+        td2.append("span").text(snv.mname);
+        td2.append("span").style("margin-left", "5px").style("color", snv.color).style("font-size", ".8em").text(snv.dataClass);
+      }
+      {
+        const [td1, td2] = table.addRow();
+        td1.text(snv.ref && snv.alt ? "Mutation" : "Position");
+        td2.append("span").text(`${snv.chr}:${snv.pos + 1} ${snv.ref && snv.alt ? snv.ref + ">" + snv.alt : ""}`);
+      }
+      if (snv.gene) {
+        const [td1, td2] = table.addRow();
+        td1.text("Gene");
+        td2.text(snv.gene);
+      }
+      if (snv.occurrence > 1) {
+        const [td1, td2] = table.addRow();
+        td1.text("Occurrence");
+        td2.text(snv.occurrence);
+      }
+      if (hasAnyValidVafEntry(arc.vafs)) {
+        const [td1, td2] = table.addRow();
+        td1.text("Read count");
+        appendVafBars(td2, arc.vafs);
+      }
+      menu.show(mouseEvent.x, mouseEvent.y);
+    }).on("mouseout", () => {
+      menu.clear();
+      menu.hide();
+    }).on("click", (mouseEvent, arc) => {
+      this.geneClickListener(arc.text, [arc.mname]);
+    });
+  }
+};
+
+// plots/disco/snv/SnvRenderer.ts
+var SnvRenderer = class {
+  constructor(svnWidth, geneClickListener) {
+    this.svnWidth = svnWidth;
+    this.geneClickListener = geneClickListener;
+  }
+  render(holder, elements) {
+    if (elements.length > 0) {
+      const svnInnerRadius = elements[0].innerRadius;
+      const fullArcRenderer = new FullArcRenderer(svnInnerRadius, this.svnWidth, "#6464641A");
+      fullArcRenderer.render(holder);
+    }
+    const arcGenerator = arc_default();
+    const arcs = holder.append("g");
+    const menu = MenuProvider.create();
+    arcs.selectAll("path").data(elements).enter().append("path").attr("d", (d) => arcGenerator(d)).attr("fill", (d) => d.color).on("mouseover", (mouseEvent, arc) => {
+      const table = table2col({ holder: menu.d });
+      const snv = structuredClone(arc);
+      snv.dt = dtsnvindel;
+      snv.class = arc.dataClass;
+      snv.gene = snv.text;
+      {
+        const [td1, td2] = table.addRow();
+        td1.text("Consequence");
+        td2.append("span").text(snv.mname);
+        td2.append("span").style("margin-left", "5px").style("color", snv.color).style("font-size", ".8em").text(snv.dataClass);
+      }
+      {
+        const [td1, td2] = table.addRow();
+        td1.text(snv.ref && snv.alt ? "Mutation" : "Position");
+        td2.append("span").text(`${snv.chr}:${snv.pos + 1} ${snv.ref && snv.alt ? snv.ref + ">" + snv.alt : ""}`);
+      }
+      if (snv.gene) {
+        const [td1, td2] = table.addRow();
+        td1.text("Gene");
+        td2.text(snv.gene);
+      }
+      if (snv.occurrence > 1) {
+        const [td1, td2] = table.addRow();
+        td1.text("Occurrence");
+        td2.text(snv.occurrence);
+      }
+      if (hasAnyValidVafEntry(arc.vafs)) {
+        const [td1, td2] = table.addRow();
+        td1.text("Read count");
+        appendVafBars(td2, arc.vafs);
+      }
+      menu.show(mouseEvent.x, mouseEvent.y);
+    }).on("mouseout", () => {
+      menu.clear();
+      menu.hide();
+    }).on("click", (mouseEvent, arc) => {
+      this.geneClickListener(arc.text, [arc.mname]);
+    });
+  }
+};
+
+// plots/disco/loh/LohRenderer.ts
+var LohRenderer = class {
+  render(holder, elements) {
+    const arcGenerator = arc_default();
+    const arcs = holder.append("g");
+    const menu = MenuProvider.create();
+    arcs.selectAll("path").data(elements).enter().append("path").attr("d", (d) => arcGenerator(d)).attr("fill", (d) => d.color).on("mouseover", (mouseEvent, arc) => {
+      const table = table2col({ holder: menu.d });
+      const loh = structuredClone(arc);
+      loh.dt = dtloh;
+      loh.gene = loh.text;
+      {
+        const [td12, td22] = table.addRow();
+        td12.text("Data type");
+        td22.append("span").style("margin-left", "5px").text("Loss of Heterozygosity");
+      }
+      const [td1, td2] = table.addRow();
+      td1.text("Position");
+      td2.append("span").text(`${arc.chr}:${arc.start}-${arc.stop}`);
+      menu.show(mouseEvent.x, mouseEvent.y);
+    }).on("mouseout", () => {
+      menu.clear();
+      menu.hide();
+    });
+  }
+};
+
+// plots/disco/cnv/CnvBarRenderer.ts
+var CnvBarRenderer = class {
+  render(holder, elements) {
+    const arcGenerator = arc_default();
+    const arcs = holder.append("g");
+    const hoverOverlay = holder.append("g").attr("class", "hover-overlay").style("pointer-events", "none");
+    const menu = MenuProvider.create();
+    arcs.selectAll("path").data(elements).enter().append("path").attr("d", (d) => arcGenerator(d)).attr("fill", (d) => d.color).on("mouseover", (mouseEvent, arc) => {
+      hoverOverlay.selectAll("*").remove();
+      hoverOverlay.append("path").datum(arc).attr("d", arcGenerator(arc)).attr("fill", "none").attr("stroke", "black").attr("stroke-width", 1);
+      const cnv = structuredClone(arc);
+      cnv.dt = dtcnv;
+      cnv.samples = [{ sample_id: arc.sampleName }];
+      cnv.gene = cnv.text;
+      const table = table2col({ holder: menu.d });
+      {
+        const [c1, c2] = table.addRow();
+        c1.text("CNV");
+        c2.html(`<span style="background:${cnv.color}">&nbsp;&nbsp;</span> ${cnv.value}`);
+      }
+      {
+        const [c1, c2] = table.addRow();
+        c1.text("Position");
+        c2.text(cnv.chr + ":" + cnv.start + "-" + cnv.stop);
+      }
+      {
+        const [c1, c2] = table.addRow();
+        c1.text("Unit");
+        c2.text(cnv.value);
+      }
+      menu.show(mouseEvent.x, mouseEvent.y);
+    }).on("mouseout", () => {
+      hoverOverlay.selectAll("*").remove();
+      menu.clear();
+      menu.hide();
+    });
+  }
+};
+
+// plots/disco/cnv/CnvHeatmapRenderer.ts
+var CnvHeatmapRenderer = class {
+  constructor(positivePercentile = 0, negativePercentile = 0) {
+    this.positivePercentile = positivePercentile;
+    this.negativePercentile = negativePercentile;
+  }
+  render(holder, elements) {
+    const arcGenerator = arc_default();
+    const arcs = holder.append("g");
+    const hoverOverlay = holder.append("g").attr("class", "hover-overlay").style("pointer-events", "none");
+    const menu = MenuProvider.create();
+    arcs.selectAll("path").data(elements).enter().append("path").attr("d", (d) => arcGenerator(d)).attr("fill", (d) => this.getColor(d.color, d.value)).on("mouseenter", (mouseEvent, arc) => {
+      hoverOverlay.append("path").datum(arc).attr("d", arcGenerator(arc)).attr("fill", "none").attr("stroke", "black").attr("stroke-width", 1);
+      const table = table2col({ holder: menu.d });
+      const cnv = structuredClone(arc);
+      cnv.dt = dtcnv;
+      cnv.samples = [{ sample_id: arc.sampleName }];
+      cnv.gene = cnv.text;
+      {
+        const [c1, c2] = table.addRow();
+        c1.text("CNV");
+        c2.html(
+          `<span style="background:${this.getColor(
+            cnv.color,
+            cnv.value
+          )}; border:solid lightgrey 0.1px;">&nbsp;&nbsp;</span> ${cnv.value}`
+        );
+      }
+      {
+        const [c1, c2] = table.addRow();
+        c1.text("Position");
+        c2.text(cnv.chr + ":" + cnv.start + "-" + cnv.stop);
+      }
+      menu.show(mouseEvent.x, mouseEvent.y);
+    }).on("mouseleave", () => {
+      hoverOverlay.selectAll("*").remove();
+      menu.clear();
+      menu.hide();
+    });
+  }
+  // Computes fill color using linear scale between -P80, 0, and +P80
+  getColor(color, value) {
+    const maxValue = Math.max(this.positivePercentile, Math.abs(this.negativePercentile));
+    return linear(
+      [-maxValue, 0, maxValue],
+      [color, "white", color]
+      // transitions to white in the middle
+    ).clamp(true)(value);
+  }
+};
+
+// plots/disco/waterfall/MutationWaterfallRenderer.ts
+var MutationWaterfallRenderer = class {
+  constructor(dotRadius = 1.5) {
+    this.dotRadius = dotRadius;
+  }
+  render(holder, elements) {
+    if (!elements.length) return;
+    const ringGroup = holder.append("g").attr("data-testid", "sjpp_mutation_waterfall_ring");
+    const menu = MenuProvider.create();
+    ringGroup.append("g").selectAll("circle").data(elements).enter().append("circle").attr("cx", (d) => Math.cos(d.startAngle - Math.PI / 2) * d.innerRadius).attr("cy", (d) => Math.sin(d.startAngle - Math.PI / 2) * d.innerRadius).attr("r", this.dotRadius).attr("fill", (d) => d.color).attr("opacity", 0.9).on("mouseover", (event, d) => {
+      const distance = Math.round(Math.pow(10, d.logDistance));
+      menu.clear();
+      const table = table2col({ holder: menu.d });
+      {
+        const [td1, td2] = table.addRow();
+        td1.text("Intermutation distance");
+        td2.text(`${bplen(distance)}`);
+      }
+      menu.show(event.x, event.y);
+    }).on("mouseout", () => {
+      menu.clear();
+      menu.hide();
+    });
+    this.renderAxis(ringGroup, elements[0]);
+  }
+  renderAxis(holder, referencePoint) {
+    const { ringInnerRadius, ringWidth, rangeMin, rangeMax } = referencePoint;
+    const axisGroup = holder.append("g").attr("class", "sjpp-waterfall-axis");
+    const topRadius = ringInnerRadius + ringWidth;
+    axisGroup.append("line").attr("x1", 0).attr("y1", -topRadius).attr("x2", 0).attr("y2", -ringInnerRadius).attr("stroke", "#6e6e6e").attr("stroke-width", 1);
+    const span = rangeMax - rangeMin || 1;
+    const tickValues = rangeMax === rangeMin ? [rangeMin] : ticks(rangeMin, rangeMax, 4);
+    tickValues.forEach((value) => {
+      const ratio = (value - rangeMin) / span;
+      const radius = ringInnerRadius + ringWidth * ratio;
+      const y = -radius;
+      axisGroup.append("line").attr("x1", -4).attr("x2", 4).attr("y1", y).attr("y2", y).attr("stroke", "#6e6e6e");
+      const exponent = Math.round(value * 10) / 10;
+      const formatted = Number.isInteger(exponent) ? `${exponent}` : exponent.toFixed(1);
+      axisGroup.append("text").attr("x", 6).attr("y", y + 3).style("font-size", "10px").style("fill", "#4d4d4d").text(`10^${formatted} bp`);
+    });
+  }
+};
+
+// plots/disco/Disco.ts
+var Disco = class {
+  constructor(opts) {
+    this.recreateViewModel = false;
+    this.onCnvSourceSelect = (index) => {
+      const state = this.app.getState();
+      const args = state.args;
+      const alt = args.alternativeDataByDt?.[dtcnv];
+      if (!alt) return;
+      const altClone = structuredClone(args.alternativeDataByDt);
+      altClone[dtcnv].forEach((d, i) => d.inuse = i === index);
+      const selected = altClone[dtcnv][index];
+      selected.mlst.forEach((d) => d.position = d.pos);
+      const baseData = args.data.filter((d) => d.dt != dtcnv && d.dt != dtloh);
+      const newData = baseData.concat(selected.mlst);
+      this.app.dispatch({
+        type: "app_refresh",
+        state: { args: { ...args, data: newData, alternativeDataByDt: altClone } }
+      });
+    };
+    this.type = "Disco";
+    this.opts = opts;
+    this.isOpen = false;
+    this.discoInteractions = new DiscoInteractions(this);
+  }
+  static {
+    this.type = "Disco";
+  }
+  async init() {
+    const state = this.app.getState();
+    const settings = state.plots.find((p) => p.id === this.id).settings;
+    this.stateViewModelMapper = new ViewModelMapper(settings, this.discoInteractions);
+    this.viewModel = this.stateViewModelMapper.map(state);
+    const holder = this.opts.holder;
+    const controlsHolder = holder.append("div").style("display", "inline-block").style("vertical-align", "top");
+    const mainDiv = holder.append("div").style("display", "inline-block");
+    const topbar = controlsHolder.append("div");
+    const config_div = controlsHolder.append("div");
+    const configInputsOptions = this.getConfigInputsOptions(this.viewModel);
+    this.features = await multiInit({
+      topbar: topBarInit({
+        app: this.app,
+        id: this.id,
+        // TODO change the way svg is selected
+        downloadHandler: () => this.discoInteractions.downloadClickListener(holder.select('svg[id="sjpp_disco_plot"]').node()),
+        callback: () => this.toggleVisibility(this.isOpen),
+        isOpen: () => this.isOpen,
+        holder: topbar
+      }),
+      config: configUiInit({
+        app: this.app,
+        id: this.id,
+        holder: config_div,
+        isOpen: () => this.isOpen,
+        inputs: configInputsOptions
+      })
+    });
+    this.errorDiv = mainDiv.append("div").attr("data-testid", "sjpp-disco-errorDiv");
+    this.svgDiv = mainDiv.append("div").attr("data-testid", "sjpp-disco-svgDiv");
+  }
+  getConfigInputsOptions(viewModel) {
+    const configInputsOptions = [];
+    if (viewModel.settings.Disco.showPrioritizeGeneLabelsByGeneSets) {
+      const filterMutationsGenesCheckbox = [
+        {
+          boxLabel: viewModel.genesetName,
+          label: `Filter mutations`,
+          type: "checkbox",
+          chartType: "Disco",
+          settingsKey: "prioritizeGeneLabelsByGeneSets",
+          title: `Only show mutations for ${viewModel.genesetName} genes`
+        }
+      ];
+      configInputsOptions.push(...filterMutationsGenesCheckbox);
+    }
+    if (viewModel.cnvMaxValue !== 0 || viewModel.cnvMinValue !== 0) {
+      const cnvConfigInputOptions = [
+        {
+          boxLabel: "",
+          label: "CNV rendering type",
+          type: "radio",
+          chartType: "Disco",
+          settingsKey: "cnvRenderingType",
+          title: "CNV rendering type",
+          options: [
+            { label: "Heatmap", value: "heatmap" /* heatmap */ },
+            { label: "Bar", value: "bar" /* bar */ }
+          ]
+        }
+      ];
+      configInputsOptions.push(...cnvConfigInputOptions);
+    }
+    configInputsOptions.push({
+      boxLabel: "",
+      label: "Show gene names",
+      type: "checkbox",
+      chartType: "Disco",
+      settingsKey: "showGeneNames",
+      title: "Show gene name labels on the outside of the plot"
+    });
+    const genomeChr = this.app.opts.state.args.genome.majorchr;
+    const chromosomeConfigOption = {
+      label: "Chromosomes",
+      title: "Chromosomes shown in the plot",
+      type: "multiCheckbox",
+      chartType: "Disco",
+      settingsKey: "hiddenChromosomes",
+      style: {
+        colNum: 4
+      },
+      options: Object.keys(genomeChr).map((c) => ({ label: c, value: c })),
+      processInput: (values = []) => {
+        const reverse = Object.keys(genomeChr).filter((c) => !values.includes(c));
+        return reverse;
+      }
+    };
+    configInputsOptions.push(chromosomeConfigOption);
+    configInputsOptions.push({
+      boxLabel: "",
+      label: "Auto radius",
+      type: "checkbox",
+      chartType: "Disco",
+      settingsKey: "autoRadius",
+      title: "Automatically set the radius based on the number of data rings"
+    });
+    const dimensionOptions = [
+      {
+        label: "Radius",
+        title: "Set the radius of the entire plot, between 200 and 1000 pixels.",
+        type: "number",
+        chartType: "Disco",
+        settingsKey: "radius",
+        debounceInterval: 500,
+        step: 25,
+        min: 200,
+        max: 1e3,
+        getDisplayStyle: (plot) => plot.settings.Disco.autoRadius ? "none" : "table-row"
+      },
+      {
+        label: "Fusion opacity",
+        title: "Adjust opacity of fusion arcs, between 0 and 1",
+        type: "number",
+        chartType: "Disco",
+        settingsKey: "fusionOpacity",
+        step: 0.01,
+        min: 0,
+        max: 1,
+        debounceInterval: 500
+      }
+    ];
+    configInputsOptions.push(...dimensionOptions);
+    if (viewModel.canShowMutationWaterfallPlot && viewModel.snvDataLength > 0) {
+      configInputsOptions.push({
+        boxLabel: "",
+        label: "Mutation Waterfall Plot",
+        type: "checkbox",
+        chartType: "Disco",
+        settingsKey: "mutationWaterfallPlot",
+        title: "Render log10 intermutation distance ring for SNV/indel data"
+      });
+    }
+    return configInputsOptions;
+  }
+  async main() {
+    const settings = this.state.settings;
+    this.isOpen = settings.Disco.isOpen;
+    if (this.recreateViewModel) {
+      this.stateViewModelMapper = new ViewModelMapper(settings, this.discoInteractions);
+      this.viewModel = this.stateViewModelMapper.map(this.app.getState());
+    }
+    this.recreateViewModel = true;
+    if (this.viewModel) {
+      this.svgDiv.selectAll("*").remove();
+      const appState = this.app.getState();
+      this.viewModel.svgDiv = this.svgDiv;
+      this.viewModel.appState = appState;
+      for (const name in this.features) {
+        this.features[name].update({ state: this.state, appState });
+      }
+      const legendRenderer = new LegendRenderer(this.viewModel.cappedCnvMaxAbsValue, settings.label.fontSize);
+      const discoRenderer = new DiscoRenderer(
+        this.getRingRenderers(this.viewModel.settings, this.viewModel, this.discoInteractions.geneClickListener),
+        legendRenderer,
+        this.app.opts.state.args.genome
+      );
+      discoRenderer.render(this.svgDiv, this.viewModel, this.onCnvSourceSelect);
+      if (this.viewModel.invalidDataInfo?.entries?.length) {
+        InvalidDataUI.render(this.errorDiv, this.viewModel.invalidDataInfo);
+      }
+    }
+  }
+  getState(appState) {
+    const config = appState.plots.find((p) => p.id === this.id);
+    if (!config) return config;
+    return { ...config, mlst: appState.args.data };
+  }
+  getRingRenderers(settings, viewModel, geneClickListener) {
+    const chromosomesRenderer = new ChromosomesRenderer(
+      settings.padAngle,
+      settings.rings.chromosomeInnerRadius,
+      settings.rings.chromosomeInnerRadius + settings.rings.chromosomeWidth,
+      settings.label.fontSize
+    );
+    const labelsRenderer = new LabelsRenderer(
+      settings.label.animationDuration,
+      settings.label.fontSize,
+      geneClickListener
+    );
+    const nonExonicSnvRenderer = new NonExonicSnvRenderer(geneClickListener);
+    const snvRenderer = new SnvRenderer(settings.rings.snvRingWidth, geneClickListener);
+    const cnvRenderer = settings.Disco.cnvRenderingType === "heatmap" /* heatmap */ ? new CnvHeatmapRenderer(viewModel.positivePercentile, viewModel.negativePercentile) : new CnvBarRenderer();
+    const lohRenderer = new LohRenderer();
+    const mutationWaterfallRenderer = new MutationWaterfallRenderer();
+    const renderersMap = /* @__PURE__ */ new Map();
+    renderersMap.set(0 /* CHROMOSOME */, chromosomesRenderer);
+    renderersMap.set(1 /* LABEL */, labelsRenderer);
+    renderersMap.set(2 /* NONEXONICSNV */, nonExonicSnvRenderer);
+    renderersMap.set(3 /* SNV */, snvRenderer);
+    renderersMap.set(4 /* MUTATION_WATERFALL */, mutationWaterfallRenderer);
+    renderersMap.set(5 /* CNV */, cnvRenderer);
+    renderersMap.set(6 /* LOH */, lohRenderer);
+    return renderersMap;
+  }
+  toggleVisibility(isOpen) {
+    this.app.dispatch({
+      type: "plot_edit",
+      id: this.opts.id,
+      config: {
+        settings: {
+          Disco: { isOpen: !isOpen }
+        }
+      }
+    });
+  }
+};
+var discoInit = getCompInit(Disco);
+var componentInit = discoInit;
+async function getPlotConfig(opts, app) {
+  return {
+    chartType: "Disco",
+    subfolder: "disco",
+    extension: "ts",
+    settings: discoDefaults(opts.overrides, app)
+  };
+}
+export {
+  componentInit,
+  Disco as default,
+  discoInit,
+  getPlotConfig
+};
+//# sourceMappingURL=Disco-6FDT6KRM.js.map